AnonymousPipeServerStream Classe

Definizione

Spazio dei nomi:

System.IO.Pipes

Assembly:

System.IO.Pipes.dll

Source:

AnonymousPipeServerStream.cs

Espone un flusso di una unnamed pipe, che supporta operazioni di lettura e scrittura sincrone e asincrone.

public ref class AnonymousPipeServerStream sealed : System::IO::Pipes::PipeStream

public sealed class AnonymousPipeServerStream : System.IO.Pipes.PipeStream

type AnonymousPipeServerStream = class
    inherit PipeStream

Public NotInheritable Class AnonymousPipeServerStream
Inherits PipeStream

Ereditarietà

Object

MarshalByRefObject

Stream

PipeStream

AnonymousPipeServerStream

Esempio

Nell'esempio seguente viene inviata una stringa da un processo padre a un processo figlio tramite pipe anonime. In questo esempio viene creato un AnonymousPipeServerStream oggetto in un processo padre con un PipeDirection valore .PipeDirection.Out Crea anche un AnonymousPipeClientStream oggetto in un processo figlio con un PipeDirection valore .PipeDirection.In Il processo padre invia quindi una stringa fornita dall'utente al processo figlio. La stringa viene visualizzata nella console.

Questo esempio è relativo al processo del server, che usa la AnonymousPipeServerStream classe . Per l'intero esempio di codice, incluso il codice sia per il client di pipe che per il server, vedere Procedura: Usare le pipe anonime per la comunicazione interprocesso locale.

//<snippet01>
#using <System.dll>
#using <System.Core.dll>

using namespace System;
using namespace System::IO;
using namespace System::IO::Pipes;
using namespace System::Diagnostics;

ref class PipeServer
{
public:
    static void Main()
    {
        Process^ pipeClient = gcnew Process();

        pipeClient->StartInfo->FileName = "pipeClient.exe";

        AnonymousPipeServerStream^ pipeServer =
            gcnew AnonymousPipeServerStream(PipeDirection::Out,
            HandleInheritability::Inheritable);

        Console::WriteLine("[SERVER] Current TransmissionMode: {0}.",
            pipeServer->TransmissionMode);

        // Pass the client process a handle to the server.
        pipeClient->StartInfo->Arguments =
            pipeServer->GetClientHandleAsString();
        pipeClient->StartInfo->UseShellExecute = false;
        pipeClient->Start();

        pipeServer->DisposeLocalCopyOfClientHandle();

        try
        {
            // Read user input and send that to the client process.
            StreamWriter^ sw = gcnew StreamWriter(pipeServer);

            sw->AutoFlush = true;
            // Send a 'sync message' and wait for client to receive it.
            sw->WriteLine("SYNC");
            pipeServer->WaitForPipeDrain();
            // Send the console input to the client process.
            Console::Write("[SERVER] Enter text: ");
            sw->WriteLine(Console::ReadLine());
            sw->Close();
        }
        // Catch the IOException that is raised if the pipe is broken
        // or disconnected.
        catch (IOException^ e)
        {
            Console::WriteLine("[SERVER] Error: {0}", e->Message);
        }
        pipeServer->Close();
        pipeClient->WaitForExit();
        pipeClient->Close();
        Console::WriteLine("[SERVER] Client quit. Server terminating.");
    }
};

int main()
{
    PipeServer::Main();
}
//</snippet01>

//<snippet01>
using System;
using System.IO;
using System.IO.Pipes;
using System.Diagnostics;

class PipeServer
{
    static void Main()
    {
        Process pipeClient = new Process();

        pipeClient.StartInfo.FileName = "pipeClient.exe";

        using (AnonymousPipeServerStream pipeServer =
            new AnonymousPipeServerStream(PipeDirection.Out,
            HandleInheritability.Inheritable))
        {
            Console.WriteLine("[SERVER] Current TransmissionMode: {0}.",
                pipeServer.TransmissionMode);

            // Pass the client process a handle to the server.
            pipeClient.StartInfo.Arguments =
                pipeServer.GetClientHandleAsString();
            pipeClient.StartInfo.UseShellExecute = false;
            pipeClient.Start();

            pipeServer.DisposeLocalCopyOfClientHandle();

            try
            {
                // Read user input and send that to the client process.
                using (StreamWriter sw = new StreamWriter(pipeServer))
                {
                    sw.AutoFlush = true;
                    // Send a 'sync message' and wait for client to receive it.
                    sw.WriteLine("SYNC");
                    pipeServer.WaitForPipeDrain();
                    // Send the console input to the client process.
                    Console.Write("[SERVER] Enter text: ");
                    sw.WriteLine(Console.ReadLine());
                }
            }
            // Catch the IOException that is raised if the pipe is broken
            // or disconnected.
            catch (IOException e)
            {
                Console.WriteLine("[SERVER] Error: {0}", e.Message);
            }
        }

        pipeClient.WaitForExit();
        pipeClient.Close();
        Console.WriteLine("[SERVER] Client quit. Server terminating.");
    }
}
//</snippet01>

'<snippet01>
Imports System.IO
Imports System.IO.Pipes
Imports System.Diagnostics

Class PipeServer
    Shared Sub Main()
        Dim pipeClient As New Process()

        pipeClient.StartInfo.FileName = "pipeClient.exe"

        Using pipeServer As New AnonymousPipeServerStream(PipeDirection.Out, _
            HandleInheritability.Inheritable)

            Console.WriteLine("[SERVER] Current TransmissionMode: {0}.",
                pipeServer.TransmissionMode)

            ' Pass the client process a handle to the server.
            pipeClient.StartInfo.Arguments = pipeServer.GetClientHandleAsString()
            pipeClient.StartInfo.UseShellExecute = false
            pipeClient.Start()

            pipeServer.DisposeLocalCopyOfClientHandle()

            Try
                ' Read user input and send that to the client process.
                Using sw As New StreamWriter(pipeServer)
                    sw.AutoFlush = true
                    ' Send a 'sync message' and wait for client to receive it.
                    sw.WriteLine("SYNC")
                    pipeServer.WaitForPipeDrain()
                    ' Send the console input to the client process.
                    Console.Write("[SERVER] Enter text: ")
                    sw.WriteLine(Console.ReadLine())
                End Using
            Catch e As IOException
                ' Catch the IOException that is raised if the pipe is broken
                ' or disconnected.
                Console.WriteLine("[SERVER] Error: {0}", e.Message)
            End Try
        End Using

        pipeClient.WaitForExit()
        pipeClient.Close()
        Console.WriteLine("[SERVER] Client quit. Server terminating.")
    End Sub
End Class
'</snippet01>

Commenti

Le pipe anonime consentono di fornire comunicazioni tra processi figlio e padre sicuri e sicuri. La AnonymousPipeServerStream classe consente a un processo padre di inviare o ricevere informazioni da un processo figlio.

Le pipe anonime sono pipe unidirezionale senza nome che in genere trasferiscono dati tra processi padre e figlio. Le pipe anonime sono sempre locali; non possono essere usati in rete. Il PipeDirection valore di InOut non è supportato perché le pipe anonime sono definite come unidirezionale.

Le pipe anonime non supportano la PipeTransmissionMode.Message modalità di lettura.

Il lato client di una pipe anonima deve essere creato da un handle pipe fornito dal lato server chiamando il GetClientHandleAsString metodo . La stringa viene quindi passata come parametro durante la creazione del processo client. Dal processo client, viene quindi passato al AnonymousPipeClientStream costruttore come pipeHandleAsString parametro .

L'oggetto AnonymousPipeServerStream deve eliminare l'handle client usando il DisposeLocalCopyOfClientHandle metodo per ricevere una notifica quando il client viene chiuso.

Costruttori

AnonymousPipeServerStream()	Inizializza una nuova istanza della classe AnonymousPipeServerStream.
AnonymousPipeServerStream(PipeDirection)	Inizializza una nuova istanza della classe AnonymousPipeServerStream con la direzione della pipe specificata.
AnonymousPipeServerStream(PipeDirection, HandleInheritability)	Inizializza una nuova istanza della classe AnonymousPipeServerStream con la direzione della pipe e la modalità di ereditarietà specificate.
AnonymousPipeServerStream(PipeDirection, HandleInheritability, Int32)	Inizializza una nuova istanza della classe AnonymousPipeServerStream con la direzione della pipe, la modalità di ereditarietà e la dimensione di buffer specificate.
AnonymousPipeServerStream(PipeDirection, SafePipeHandle, SafePipeHandle)	Inizializza una nuova istanza della classe AnonymousPipeServerStream dagli handle di pipe specificati.

Proprietà

CanRead	Ottiene un valore che indica se il flusso corrente supporta o meno le operazioni di lettura. (Ereditato da PipeStream)
CanSeek	Ottiene un valore che indica se il flusso corrente supporta o meno le operazioni di ricerca. (Ereditato da PipeStream)
CanTimeout	Ottiene un valore che determina se il flusso corrente prevede il timeout. (Ereditato da Stream)
CanWrite	Ottiene un valore che indica se il flusso corrente supporta o meno le operazioni di scrittura. (Ereditato da PipeStream)
ClientSafePipeHandle	Ottiene l'handle protetto per l'oggetto AnonymousPipeClientStream, attualmente connesso all'oggetto AnonymousPipeServerStream.
InBufferSize	Ottiene la dimensione, in byte, del buffer in ingresso per una pipe. (Ereditato da PipeStream)
IsAsync	Ottiene un valore che indica se un oggetto PipeStream è stato aperto in modalità sincrona o asincrona. (Ereditato da PipeStream)
IsConnected	Ottiene o imposta un valore che indica se un oggetto PipeStream è connesso. (Ereditato da PipeStream)
IsHandleExposed	Ottiene un valore che indica se viene esposto un handle a un oggetto PipeStream. (Ereditato da PipeStream)
IsMessageComplete	Ottiene un valore indica se esistono altri dati nel messaggio restituito dalla più recente operazione di lettura. (Ereditato da PipeStream)
Length	Ottiene la lunghezza di un flusso, in byte. (Ereditato da PipeStream)
OutBufferSize	Ottiene la dimensione, in byte, del buffer in uscita per una pipe. (Ereditato da PipeStream)
Position	Ottiene o imposta la posizione corrente del flusso corrente. (Ereditato da PipeStream)
ReadMode	Imposta la modalità di lettura per l'oggetto AnonymousPipeServerStream. Per gli unnamed pipe, la modalità di trasmissione deve essere Byte.
ReadTimeout	Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout. (Ereditato da Stream)
SafePipeHandle	Ottiene l'handle sicuro per l'estremità locale della pipe incapsulata dall'oggetto PipeStream corrente. (Ereditato da PipeStream)
TransmissionMode	Ottiene la modalità di trasmissione della pipe supportata dalla pipe corrente.
WriteTimeout	Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. (Ereditato da Stream)

Metodi

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Inizia un'operazione di lettura asincrona. (Ereditato da PipeStream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Inizia un'operazione di scrittura asincrona. (Ereditato da PipeStream)
CheckPipePropertyOperations()	Verifica che la pipe si trovi in uno stato appropriato per ottenere o impostare le proprietà. (Ereditato da PipeStream)
CheckReadOperations()	Verifica che la pipe sia connessa per le operazioni di lettura. (Ereditato da PipeStream)
CheckWriteOperations()	Verifica che la pipe sia connessa per le operazioni di scrittura. (Ereditato da PipeStream)
Close()	Chiude il flusso corrente e libera le risorse, come socket e handle di file, ad esso associate. Anziché chiamare questo metodo, assicurarsi che il flusso sia eliminato correttamente. (Ereditato da Stream)
CopyTo(Stream)	Legge i byte dal flusso corrente e li scrive in un altro flusso. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyTo(Stream, Int32)	Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream, CancellationToken)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando un token di annullamento specificato. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream, Int32)	Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, utilizzando una dimensione di buffer specificata. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CreateObjRef(Type)	Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
CreateWaitHandle()	Obsoleti. Alloca un oggetto WaitHandle. (Ereditato da Stream)
Dispose()	Rilascia tutte le risorse usate da Stream. (Ereditato da Stream)
Dispose(Boolean)	Rilascia le risorse non gestite usate dalla classe PipeStream e facoltativamente le risorse gestite. (Ereditato da PipeStream)
DisposeAsync()	Consente di liberare in modo asincrono le risorse non gestite utilizzate da Stream. (Ereditato da Stream)
DisposeLocalCopyOfClientHandle()	Chiude la copia locale dell'handle dell'oggetto AnonymousPipeClientStream.
EndRead(IAsyncResult)	Termina una richiesta di lettura asincrona in sospeso. (Ereditato da PipeStream)
EndWrite(IAsyncResult)	Termina una richiesta di scrittura asincrona in sospeso. (Ereditato da PipeStream)
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Finalize()	Rilascia le risorse non gestite ed esegue altre operazioni di pulizia prima che l'istanza di AnonymousPipeServerStream venga recuperata da Garbage Collection.
Flush()	Cancella i dati del buffer del flusso corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. (Ereditato da PipeStream)
FlushAsync()	Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. (Ereditato da Stream)
FlushAsync(CancellationToken)	Cancella in modo asincrono il buffer del flusso corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. (Ereditato da PipeStream)
GetAccessControl()	Ottiene un oggetto PipeSecurity che incapsula le voci dell'elenco di controllo di accesso (ACL) per la pipe descritta dall'oggetto PipeStream corrente. (Ereditato da PipeStream)
GetClientHandleAsString()	Ottiene l'handle dell'oggetto AnonymousPipeClientStream collegato come stringa.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InitializeHandle(SafePipeHandle, Boolean, Boolean)	Inizializza un oggetto PipeStream dall'oggetto SafePipeHandle specificato. (Ereditato da PipeStream)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
ObjectInvariant()	Obsoleti. Fornisce supporto per un oggetto Contract. (Ereditato da Stream)
Read(Byte[], Int32, Int32)	Legge un blocco di byte da un flusso e scrive i dati in un buffer specificato che inizia in una posizione specificata per una lunghezza specificata. (Ereditato da PipeStream)
Read(Span<Byte>)	Legge una sequenza di byte dal flusso corrente, li scrive in una matrice di byte e fa avanzare la posizione all'interno del flusso in base al numero di byte letti. (Ereditato da PipeStream)
ReadAsync(Byte[], Int32, Int32)	Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti. (Ereditato da Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Legge in modo asincrono una sequenza di byte dal flusso corrente in una matrice di byte che inizia in una posizione specificata per un numero specificato di byte, fa avanzare la posizione all'interno del flusso in base al numero di byte letti e monitora le richieste di annullamento. (Ereditato da PipeStream)
ReadAsync(Memory<Byte>, CancellationToken)	Legge in modo asincrono una sequenza di byte dal flusso corrente, li scrive in un intervallo di memoria di byte, fa avanzare la posizione all'interno del flusso in base al numero di byte letti e monitora le richieste di annullamento. (Ereditato da PipeStream)
ReadAtLeast(Span<Byte>, Int32, Boolean)	Legge almeno un numero minimo di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso in base al numero di byte letti. (Ereditato da Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Legge in modo asincrono almeno un numero minimo di byte dal flusso corrente, sposta in avanti la posizione all'interno del flusso in base al numero di byte letti e monitora le richieste di annullamento. (Ereditato da Stream)
ReadByte()	Legge un byte da una pipe. (Ereditato da PipeStream)
ReadExactly(Byte[], Int32, Int32)	count Legge il numero di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso. (Ereditato da Stream)
ReadExactly(Span<Byte>)	Legge i byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso fino a quando non viene riempito.buffer (Ereditato da Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Legge in modo asincrono count il numero di byte dal flusso corrente, sposta in avanti la posizione all'interno del flusso e monitora le richieste di annullamento. (Ereditato da Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Legge in modo asincrono i byte dal flusso corrente, sposta la posizione all'interno del flusso fino a quando non buffer viene riempita e monitora le richieste di annullamento. (Ereditato da Stream)
Seek(Int64, SeekOrigin)	Imposta la posizione corrente del flusso corrente sul valore specificato. (Ereditato da PipeStream)
SetAccessControl(PipeSecurity)	Applica le voci dell'elenco di controllo di accesso (ACL) specificate da un oggetto PipeSecurity nella pipe specificata dall'oggetto PipeStream corrente. (Ereditato da PipeStream)
SetLength(Int64)	Imposta la lunghezza del flusso corrente sul valore specificato. (Ereditato da PipeStream)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
WaitForPipeDrain()	Aspetta l'altra estremità della pipe per leggere tutti i byte inviati. (Ereditato da PipeStream)
Write(Byte[], Int32, Int32)	Scrive un blocco di byte nel flusso corrente usando dati da un buffer. (Ereditato da PipeStream)
Write(ReadOnlySpan<Byte>)	Scrive una sequenza di byte nel flusso corrente e fa avanzare la posizione corrente nel flusso del numero di byte scritti. (Ereditato da PipeStream)
WriteAsync(Byte[], Int32, Int32)	Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti. (Ereditato da Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Scrive in modo asincrono un numero specificato di byte da una matrice di byte che inizia in una posizione specificata, fa avanzare la posizione corrente all'interno del flusso in base al numero di byte scritti e monitora le richieste di annullamento. (Ereditato da PipeStream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. (Ereditato da PipeStream)
WriteByte(Byte)	Scrive un byte nel flusso corrente. (Ereditato da PipeStream)

Metodi di estensione

GetAccessControl(PipeStream)	Restituisce le informazioni di sicurezza di un flusso di pipe.
SetAccessControl(PipeStream, PipeSecurity)	Modifica gli attributi di sicurezza di un flusso di pipe esistente.
ConfigureAwait(IAsyncDisposable, Boolean)	Consente di configurare la modalità di esecuzione delle espressioni await per le attività restituite da un elemento disposable asincrono.