AnonymousPipeClientStream Klasse

Definition

Namespace:

System.IO.Pipes

Assembly:

System.IO.Pipes.dll

Quelle:

AnonymousPipeClientStream.cs

Macht die Clientseite eines anonymen Pipestreams verfügbar, der synchrone und asynchrone Lese- und Schreibvorgänge unterstützt (ohne Abbruchunterstützung auf Windows-Plattformen).

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

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

type AnonymousPipeClientStream = class
    inherit PipeStream

Public NotInheritable Class AnonymousPipeClientStream
Inherits PipeStream

Vererbung

Object

MarshalByRefObject

Stream

PipeStream

AnonymousPipeClientStream

Beispiele

Im folgenden Beispiel wird eine Zeichenfolge aus einem übergeordneten Prozess mithilfe von anonymen Rohren an einen untergeordneten Prozess gesendet. In diesem Beispiel wird ein AnonymousPipeServerStream-Objekt in einem übergeordneten Prozess mit einem PipeDirection Wert von Outerstellt. Außerdem wird ein AnonymousPipeClientStream-Objekt in einem untergeordneten Prozess mit einem PipeDirection Wert von Inerstellt. Der übergeordnete Prozess sendet dann eine vom Benutzer bereitgestellte Zeichenfolge an den untergeordneten Prozess. Die Zeichenfolge wird in der Konsole angezeigt.

Dieses Beispiel ist für den Clientprozess vorgesehen, der vom Serverprozess gestartet wird. Benennen Sie die resultierende ausführbare Datei aus dem Clientcode pipeClient.exe, und kopieren Sie sie in dasselbe Verzeichnis wie die ausführbare Serverdatei, wenn Sie dieses Beispiel ausführen. Das gesamte Codebeispiel, einschließlich des Codes für den Pipeclient und den Server, finden Sie unter How to: Use Anonymous Pipes for Local Interprocess Communication.

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

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

ref class PipeClient
{
public:
    static void Main(array<String^>^ args)
    {
        if (args->Length > 1)
        {
            PipeStream^ pipeClient = gcnew AnonymousPipeClientStream(PipeDirection::In, args[1]);

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

            StreamReader^ sr = gcnew StreamReader(pipeClient);

            // Display the read text to the console
            String^ temp;

            // Wait for 'sync message' from the server.
            do
            {
                Console::WriteLine("[CLIENT] Wait for sync...");
                temp = sr->ReadLine();
            }
            while (!temp->StartsWith("SYNC"));

            // Read the server data and echo to the console.
            while ((temp = sr->ReadLine()) != nullptr)
            {
                Console::WriteLine("[CLIENT] Echo: " + temp);
            }
            sr->Close();
            pipeClient->Close();
        }
        Console::Write("[CLIENT] Press Enter to continue...");
        Console::ReadLine();
    }
};

int main()
{
    array<String^>^ args = Environment::GetCommandLineArgs();
    PipeClient::Main(args);
}
//</snippet01>

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

class PipeClient
{
    static void Main(string[] args)
    {
        if (args.Length > 0)
        {
            using (PipeStream pipeClient =
                new AnonymousPipeClientStream(PipeDirection.In, args[0]))
            {
                Console.WriteLine("[CLIENT] Current TransmissionMode: {0}.",
                   pipeClient.TransmissionMode);

                using (StreamReader sr = new StreamReader(pipeClient))
                {
                    // Display the read text to the console
                    string temp;

                    // Wait for 'sync message' from the server.
                    do
                    {
                        Console.WriteLine("[CLIENT] Wait for sync...");
                        temp = sr.ReadLine();
                    }
                    while (!temp.StartsWith("SYNC"));

                    // Read the server data and echo to the console.
                    while ((temp = sr.ReadLine()) != null)
                    {
                        Console.WriteLine("[CLIENT] Echo: " + temp);
                    }
                }
            }
        }
        Console.Write("[CLIENT] Press Enter to continue...");
        Console.ReadLine();
    }
}
//</snippet01>

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

Class PipeClient
    Shared Sub Main(args() as String)
        If args.Length > 0 Then
            Using pipeClient As New AnonymousPipeClientStream(PipeDirection.In, args(0))
                Console.WriteLine("[CLIENT] Current TransmissionMode: {0}.", _
                   pipeClient.TransmissionMode)

                Using sr As New StreamReader(pipeClient)
                    ' Display the read text to the console
                    Dim temp As String

                    ' Wait for 'sync message' from the server.
                    Do
                        Console.WriteLine("[CLIENT] Wait for sync...")
                        temp = sr.ReadLine()
                    Loop While temp.StartsWith("SYNC") = False

                    ' Read the server data and echo to the console.
                    temp = sr.ReadLine()
                    While Not temp = Nothing
                        Console.WriteLine("[CLIENT] Echo: " + temp)
                        temp = sr.ReadLine()
                    End While
                End Using
            End Using
        End If
        Console.Write("[CLIENT] Press Enter to continue...")
        Console.ReadLine()
    End Sub
End Class
'</snippet01>

Hinweise

Anonyme Rohre helfen bei der sicheren und sicheren Interprocess-Kommunikation zwischen untergeordneten und übergeordneten Prozessen. Die AnonymousPipeClientStream-Klasse ermöglicht einem untergeordneten Prozess, eine Verbindung mit einem übergeordneten Prozess herzustellen und Informationen auszutauschen.

Anonyme Rohre sind unbenannte, unidirektionale Rohre, die in der Regel Daten zwischen übergeordneten und untergeordneten Prozessen übertragen. Anonyme Rohre sind immer lokal; sie können nicht über ein Netzwerk verwendet werden. Ein PipeDirection Wert von InOut wird nicht unterstützt, da anonyme Rohre als unidirektional definiert sind.

Anonyme Rohre unterstützen den PipeTransmissionMode.Message Lesemodus nicht.

Die Clientseite einer anonymen Pipe muss über ein vom Server bereitgestelltes Pipehandle erstellt werden, indem die GetClientHandleAsString-Methode aufgerufen wird. Die Zeichenfolge wird dann beim Erstellen des Clientprozesses als Parameter übergeben. Aus dem Clientprozess wird sie als pipeHandleAsString-Parameter an den AnonymousPipeClientStream-Konstruktor übergeben.

Unter Windows werden asynchrone (überlappende) Lese- und Schreibvorgänge von anonymen Rohren nicht unterstützt (siehe Anonyme Pipe-Vorgänge). Die AnonymousPipeClientStream Klasse plant weiterhin Arbeit im Threadpool auf Windows-Plattformen, sodass asynchrone Stream Vorgänge funktionieren, aber der Abbruch dieser Vorgänge wird nicht unterstützt.

Konstruktoren

AnonymousPipeClientStream(PipeDirection, SafePipeHandle)	Initialisiert eine neue Instanz der AnonymousPipeClientStream Klasse aus dem angegebenen Handle.
AnonymousPipeClientStream(PipeDirection, String)	Initialisiert eine neue Instanz der AnonymousPipeClientStream Klasse mit der angegebenen Piperichtung und einer Zeichenfolgendarstellung des Pipehandle.
AnonymousPipeClientStream(String)	Initialisiert eine neue Instanz der AnonymousPipeClientStream Klasse mit der angegebenen Zeichenfolgendarstellung des Pipehandle.

Eigenschaften

CanRead	Ruft einen Wert ab, der angibt, ob der aktuelle Datenstrom Lesevorgänge unterstützt. (Geerbt von PipeStream)
CanSeek	Ruft einen Wert ab, der angibt, ob der aktuelle Datenstrom Suchvorgänge unterstützt. (Geerbt von PipeStream)
CanTimeout	Ruft einen Wert ab, der bestimmt, ob der aktuelle Datenstrom Timeout ausführen kann. (Geerbt von Stream)
CanWrite	Ruft einen Wert ab, der angibt, ob der aktuelle Datenstrom Schreibvorgänge unterstützt. (Geerbt von PipeStream)
InBufferSize	Ruft die Größe des eingehenden Puffers für eine Pipe in Bytes ab. (Geerbt von PipeStream)
IsAsync	Ruft einen Wert ab, der angibt, ob ein PipeStream -Objekt asynchron oder synchron geöffnet wurde. (Geerbt von PipeStream)
IsConnected	Dient zum Abrufen oder Festlegen eines Werts, der angibt, ob ein PipeStream -Objekt verbunden ist. (Geerbt von PipeStream)
IsHandleExposed	Ruft einen Wert ab, der angibt, ob ein Handle für ein PipeStream -Objekt verfügbar gemacht wird. (Geerbt von PipeStream)
IsMessageComplete	Ruft einen Wert ab, der angibt, ob mehr Daten in der Nachricht vorhanden sind, die vom letzten Lesevorgang zurückgegeben wird. (Geerbt von PipeStream)
Length	Ruft die Länge eines Datenstroms in Byte ab. (Geerbt von PipeStream)
OutBufferSize	Ruft die Größe des ausgehenden Puffers für eine Pipe in Bytes ab. (Geerbt von PipeStream)
Position	Dient zum Abrufen oder Festlegen der aktuellen Position des aktuellen Datenstroms. (Geerbt von PipeStream)
ReadMode	Legt den Lesemodus für das AnonymousPipeClientStream-Objekt fest.
ReadTimeout	Dient zum Abrufen oder Festlegen eines Werts in Millisekunden, der bestimmt, wie lange der Datenstrom vor dem Timeout zu lesen versucht. (Geerbt von Stream)
SafePipeHandle	Ruft den sicheren Handle für das lokale Ende der Pipe ab, die das aktuelle PipeStream -Objekt kapselt. (Geerbt von PipeStream)
TransmissionMode	Ruft den vom aktuellen Rohr unterstützten Leitungsübertragungsmodus ab.
WriteTimeout	Dient zum Abrufen oder Festlegen eines Werts in Millisekunden, der bestimmt, wie lange der Datenstrom versucht, vor dem Timeout zu schreiben. (Geerbt von Stream)

Methoden

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Startet einen asynchronen Lesevorgang. (Geerbt von PipeStream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Startet einen asynchronen Schreibvorgang. (Geerbt von PipeStream)
CheckPipePropertyOperations()	Überprüft, ob sich die Pipe in einem ordnungsgemäßen Zustand für das Abrufen oder Festlegen von Eigenschaften befindet. (Geerbt von PipeStream)
CheckReadOperations()	Überprüft, ob sich die Rohre in einem verbundenen Zustand für Lesevorgänge befinden. (Geerbt von PipeStream)
CheckWriteOperations()	Überprüft, ob sich die Pipe in einem verbundenen Zustand für Schreibvorgänge befindet. (Geerbt von PipeStream)
Close()	Schließt den aktuellen Datenstrom und gibt alle Ressourcen (z. B. Sockets und Dateihandles) frei, die dem aktuellen Datenstrom zugeordnet sind. Anstatt diese Methode aufzurufen, stellen Sie sicher, dass der Datenstrom ordnungsgemäß verworfen ist. (Geerbt von Stream)
CopyTo(Stream)	Liest die Bytes aus dem aktuellen Datenstrom und schreibt sie in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyTo(Stream, Int32)	Liest die Bytes aus dem aktuellen Datenstrom und schreibt sie mithilfe einer angegebenen Puffergröße in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream)	Liest die Bytes asynchron aus dem aktuellen Datenstrom und schreibt sie in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, CancellationToken)	Liest die Bytes asynchron aus dem aktuellen Datenstrom und schreibt sie mithilfe eines angegebenen Abbruchtokens in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, Int32)	Liest die Bytes asynchron aus dem aktuellen Datenstrom und schreibt sie mithilfe einer angegebenen Puffergröße in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Liest asynchron die Bytes aus dem aktuellen Datenstrom und schreibt sie in einen anderen Datenstrom, wobei eine angegebene Puffergröße und ein Abbruchtoken verwendet wird. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CreateObjRef(Type)	Erstellt ein Objekt, das alle relevanten Informationen enthält, die zum Generieren eines Proxys erforderlich sind, der für die Kommunikation mit einem Remoteobjekt verwendet wird. (Geerbt von MarshalByRefObject)
CreateWaitHandle()	Veraltet. Weist ein WaitHandle-Objekt zu. (Geerbt von Stream)
Dispose()	Gibt alle vom Streamverwendeten Ressourcen frei. (Geerbt von Stream)
Dispose(Boolean)	Gibt die nicht verwalteten Ressourcen frei, die von der PipeStream Klasse verwendet werden, und gibt optional die verwalteten Ressourcen frei. (Geerbt von PipeStream)
DisposeAsync()	Gibt asynchron die nicht verwalteten Ressourcen frei, die vom Streamverwendet werden. (Geerbt von Stream)
EndRead(IAsyncResult)	Beendet eine ausstehende asynchrone Leseanforderung. (Geerbt von PipeStream)
EndWrite(IAsyncResult)	Beendet eine ausstehende asynchrone Schreibanforderung. (Geerbt von PipeStream)
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
Finalize()	Gibt nicht verwaltete Ressourcen frei und führt weitere Bereinigungsvorgänge aus, bevor die AnonymousPipeClientStream Instanz von der Garbage Collection zurückgefordert wird.
Flush()	Löscht den Puffer für den aktuellen Datenstrom und bewirkt, dass alle gepufferten Daten auf das zugrunde liegende Gerät geschrieben werden. (Geerbt von PipeStream)
FlushAsync()	Löscht asynchron alle Puffer für diesen Datenstrom und bewirkt, dass alle gepufferten Daten auf das zugrunde liegende Gerät geschrieben werden. (Geerbt von Stream)
FlushAsync(CancellationToken)	Löscht den Puffer für den aktuellen Datenstrom asynchron und bewirkt, dass alle gepufferten Daten auf das zugrunde liegende Gerät geschrieben werden. (Geerbt von PipeStream)
GetAccessControl()	Ruft ein PipeSecurity -Objekt ab, das die Zugriffssteuerungslisteneinträge (Access Control List, ACL) für die durch das aktuelle PipeStream -Objekt beschriebene Pipe kapselt. (Geerbt von PipeStream)
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinie für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeHandle(SafePipeHandle, Boolean, Boolean)	Initialisiert ein PipeStream -Objekt aus dem angegebenen SafePipeHandle -Objekt. (Geerbt von PipeStream)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt ab, um die Lebensdauerrichtlinie für diese Instanz zu steuern. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
ObjectInvariant()	Veraltet. Bietet Unterstützung für eine Contract. (Geerbt von Stream)
Read(Byte[], Int32, Int32)	Liest einen Byteblock aus einem Datenstrom und schreibt die Daten an einen angegebenen Puffer, beginnend an einer angegebenen Position für eine angegebene Länge. (Geerbt von PipeStream)
Read(Span<Byte>)	Liest eine Abfolge von Bytes aus dem aktuellen Datenstrom, schreibt sie in ein Bytearray und wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes. (Geerbt von PipeStream)
ReadAsync(Byte[], Int32, Int32)	Liest asynchron eine Abfolge von Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes. (Geerbt von Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Liest asynchron eine Bytesequenz aus dem aktuellen Datenstrom in ein Bytearray ab einer angegebenen Position für eine angegebene Anzahl von Bytes, führt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes durch und überwacht Abbruchanforderungen. (Geerbt von PipeStream)
ReadAsync(Memory<Byte>, CancellationToken)	Liest asynchron eine Abfolge von Bytes aus dem aktuellen Datenstrom, schreibt sie in einen Bytespeicherbereich, wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes und überwacht Abbruchanforderungen. (Geerbt von PipeStream)
ReadAtLeast(Span<Byte>, Int32, Boolean)	Liest mindestens eine Minimale Anzahl von Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes. (Geerbt von Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Liest asynchron mindestens eine Mindestanzahl von Bytes aus dem aktuellen Datenstrom, wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes und überwacht Abbruchanforderungen. (Geerbt von Stream)
ReadByte()	Liest ein Byte aus einer Pfeife. (Geerbt von PipeStream)
ReadExactly(Byte[], Int32, Int32)	Liest count Anzahl von Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms. (Geerbt von Stream)
ReadExactly(Span<Byte>)	Liest Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms, bis die buffer gefüllt ist. (Geerbt von Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Liest asynchron count Anzahl von Bytes aus dem aktuellen Datenstrom, wechselt die Position innerhalb des Datenstroms und überwacht Abbruchanforderungen. (Geerbt von Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Liest asynchron Bytes aus dem aktuellen Datenstrom, wechselt die Position innerhalb des Datenstroms, bis die buffer gefüllt ist, und überwacht Abbruchanforderungen. (Geerbt von Stream)
Seek(Int64, SeekOrigin)	Legt die aktuelle Position des aktuellen Datenstroms auf den angegebenen Wert fest. (Geerbt von PipeStream)
SetAccessControl(PipeSecurity)	Wendet die durch ein PipeSecurity -Objekt angegebenen Zugriffssteuerungslisteneinträge (Access Control List, ACL) auf die durch das aktuelle PipeStream -Objekt angegebene Pipe an. (Geerbt von PipeStream)
SetLength(Int64)	Legt die Länge des aktuellen Datenstroms auf den angegebenen Wert fest. (Geerbt von PipeStream)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
WaitForPipeDrain()	Wartet auf das andere Ende der Pipe, um alle gesendeten Bytes zu lesen. (Geerbt von PipeStream)
Write(Byte[], Int32, Int32)	Schreibt einen Byteblock mithilfe von Daten aus einem Puffer in den aktuellen Datenstrom. (Geerbt von PipeStream)
Write(ReadOnlySpan<Byte>)	Schreibt eine Folge von Bytes in den aktuellen Datenstrom und wechselt die aktuelle Position innerhalb dieses Datenstroms um die Anzahl der geschriebenen Bytes. (Geerbt von PipeStream)
WriteAsync(Byte[], Int32, Int32)	Schreibt asynchron eine Bytesequenz in den aktuellen Datenstrom und wechselt die aktuelle Position innerhalb dieses Datenstroms um die Anzahl der geschriebenen Bytes. (Geerbt von Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Schreibt asynchron eine angegebene Anzahl von Bytes aus einem Bytearray beginnend an einer angegebenen Position, wechselt die aktuelle Position innerhalb dieses Datenstroms um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. (Geerbt von PipeStream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Schreibt asynchron eine Bytesequenz in den aktuellen Datenstrom, wechselt die aktuelle Position innerhalb dieses Datenstroms um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. (Geerbt von PipeStream)
WriteByte(Byte)	Schreibt ein Byte in den aktuellen Datenstrom. (Geerbt von PipeStream)

Erweiterungsmethoden

CopyToAsync(Stream, PipeWriter, CancellationToken)	Liest die Bytes asynchron aus dem Stream und schreibt sie mithilfe eines Abbruchtokens in das angegebene PipeWriter.
GetAccessControl(PipeStream)	Gibt die Sicherheitsinformationen eines Rohrdatenstroms zurück.
SetAccessControl(PipeStream, PipeSecurity)	Ändert die Sicherheitsattribute eines vorhandenen Pipestreams.
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguriert, wie auf die von einem asynchronen Einweg zurückgegebenen Aufgaben gewartet wird.