AnonymousPipeServerStream Klasse

Referenz

Definition

Namespace:: System.IO.Pipes

Assembly:: System.IO.Pipes.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Quelle:: AnonymousPipeServerStream.cs

Quelle:: AnonymousPipeServerStream.cs

Quelle:: AnonymousPipeServerStream.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Macht einen Stream um eine anonyme Pipe verfügbar, der synchrone und asynchrone Lese- und Schreibvorgänge unterstützt.

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

Vererbung: Object

Stream

PipeStream
AnonymousPipeServerStream

Vererbung: Object

MarshalByRefObject

Stream

PipeStream
AnonymousPipeServerStream

Beispiele

Im folgenden Beispiel wird eine Zeichenfolge von einem übergeordneten Prozess mithilfe anonymer Pipes an einen untergeordneten Prozess gesendet. In diesem Beispiel wird ein AnonymousPipeServerStream -Objekt in einem übergeordneten Prozess mit dem PipeDirection Wert erstellt PipeDirection.Out. Außerdem wird ein AnonymousPipeClientStream -Objekt in einem untergeordneten Prozess mit dem PipeDirection Wert erstellt PipeDirection.In. Der übergeordnete Prozess sendet daraufhin eine vom Benutzer bereitgestellte Zeichenfolge an den untergeordneten Prozess. Die Zeichenfolge wird in der Konsole angezeigt.

Dieses Beispiel gilt für den Serverprozess, der die AnonymousPipeServerStream -Klasse verwendet. Das gesamte Codebeispiel, einschließlich des Codes für den Pipeclient und den Server, finden Sie unter Vorgehensweise: Verwenden von anonymen Pipes für die lokale prozessübergreifende Kommunikation.

//<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>

Hinweise

Anonyme Pipes helfen dabei, eine sichere und prozessübergreifende Kommunikation zwischen untergeordneten und übergeordneten Prozessen zu ermöglichen. Die AnonymousPipeServerStream -Klasse ermöglicht es einem übergeordneten Prozess, Informationen von einem untergeordneten Prozess zu senden oder zu empfangen.

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

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

Die Clientseite einer anonymen Pipe muss aus einem Pipehandle erstellt werden, das vom Server durch Aufrufen der GetClientHandleAsString -Methode bereitgestellt wird. Die Zeichenfolge wird dann beim Erstellen des Clientprozesses als Parameter übergeben. Vom Clientprozess wird er dann als Parameter an den AnonymousPipeClientStreampipeHandleAsString Konstruktor übergeben.

Das AnonymousPipeServerStream -Objekt muss das Clienthandle mithilfe der DisposeLocalCopyOfClientHandle -Methode verwerfen, um benachrichtigt zu werden, wenn der Client beendet wird.

Konstruktoren

AnonymousPipeServerStream()	Initialisiert eine neue Instanz der AnonymousPipeServerStream-Klasse.
AnonymousPipeServerStream(PipeDirection)	Initialisiert eine neue Instanz der AnonymousPipeServerStream-Klasse mit der angegebenen Piperichtung.
AnonymousPipeServerStream(PipeDirection, HandleInheritability)	Initialisiert eine neue Instanz der AnonymousPipeServerStream-Klasse mit der angegebenen Piperichtung und dem angegebenen Vererbbarkeitsmodus.
AnonymousPipeServerStream(PipeDirection, HandleInheritability, Int32)	Initialisiert eine neue Instanz der AnonymousPipeServerStream-Klasse mit der angegebenen Piperichtung, dem angegebenen Vererbbarkeitsmodus und der angegebenen Puffergröße.
AnonymousPipeServerStream(PipeDirection, HandleInheritability, Int32, PipeSecurity)	Initialisiert eine neue Instanz der AnonymousPipeServerStream-Klasse mit der angegebenen Piperichtung, dem angegebenen Vererbbarkeitsmodus, der angegebenen Puffergröße und der angegebenen Pipesicherheit.
AnonymousPipeServerStream(PipeDirection, SafePipeHandle, SafePipeHandle)	Initialisiert eine neue Instanz der AnonymousPipeServerStream-Klasse aus den angegebenen Pipehandles.

Eigenschaften

CanRead	Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. (Geerbt von PipeStream)
CanSeek	Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. (Geerbt von PipeStream)
CanTimeout	Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. (Geerbt von Stream)
CanWrite	Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. (Geerbt von PipeStream)
ClientSafePipeHandle	Ruft das sichere Handle für das AnonymousPipeClientStream-Objekt ab, das gegenwärtig mit dem AnonymousPipeServerStream-Objekt verbunden ist.
InBufferSize	Ruft die Größe des Eingangspuffers 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	Ruft einen Wert ab, der angibt, ob ein PipeStream-Objekt verbunden ist, oder legt diesen fest. (Geerbt von PipeStream)
IsHandleExposed	Ruft einen Wert ab, der angibt, ob ein Handle für ein PipeStream-Objekt verfügbar gemacht wurde. (Geerbt von PipeStream)
IsMessageComplete	Ruft einen Wert ab, der angibt, ob in der vom letzten Lesevorgang zurückgegebenen Meldung weitere Daten vorhanden sind. (Geerbt von PipeStream)
Length	Ruft die Länge eines Streams in Bytes ab. (Geerbt von PipeStream)
OutBufferSize	Ruft die Größe des Ausgangspuffers für eine Pipe in Bytes ab. (Geerbt von PipeStream)
Position	Ruft die aktuelle Position des aktuellen Streams ab oder legt diese fest. (Geerbt von PipeStream)
ReadMode	Legt den Lesemodus für das AnonymousPipeServerStream-Objekt fest. Für anonyme Pipes muss der Übertragungsmodus Byte sein.
ReadTimeout	Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. (Geerbt von Stream)
SafePipeHandle	Ruft das sichere Handle für das lokale Ende der Pipe ab, die vom aktuellen PipeStream-Objekt gekapselt wird. (Geerbt von PipeStream)
TransmissionMode	Ruft den von der aktuellen Pipe unterstützten Pipeübertragungsmodus ab.
WriteTimeout	Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. (Geerbt von Stream)

Methoden

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Beginnt einen asynchronen Lesevorgang. (Geerbt von PipeStream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Beginnt einen asynchronen Schreibvorgang. (Geerbt von PipeStream)
CheckPipePropertyOperations()	Überprüft, ob sich die Pipe in einem ordnungsgemäßen Zustand zum Abrufen oder Festlegen von Eigenschaften befindet. (Geerbt von PipeStream)
CheckReadOperations()	Überprüft, ob die Pipe verbunden ist, um Lesevorgänge auszuführen. (Geerbt von PipeStream)
CheckWriteOperations()	Überprüft, ob die Pipe verbunden ist, um Schreibvorgänge auszuführen. (Geerbt von PipeStream)
Close()	Schließt den aktuellen Stream und gibt alle dem aktuellen Stream zugeordneten Ressourcen frei (z. B. Sockets und Dateihandles). Anstatt diese Methode aufzurufen, stellen Sie sicher, dass der Stream ordnungsgemäß freigegeben wird. (Geerbt von Stream)
CopyTo(Stream)	Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. Beide Datenstrompositionen werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyTo(Stream, Int32)	Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. Beide Datenstrompositionen werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream)	Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. Beide Datenstrompositionen werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, CancellationToken)	Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung eines angegebenen Abbruchtokens in einen anderen Stream. Beide Datenstrompositionen werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, Int32)	Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. Beide Datenstrompositionen werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. Beide Datenstrompositionen werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
CreateWaitHandle()	Veraltet. Veraltet. Veraltet. Reserviert ein WaitHandle-Objekt. (Geerbt von Stream)
Dispose()	Gibt alle vom Stream verwendeten Ressourcen frei. (Geerbt von Stream)
Dispose(Boolean)	Gibt die von der PipeStream-Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. (Geerbt von PipeStream)
DisposeAsync()	Gibt die nicht verwalteten Ressourcen, die von der Stream verwendet werden, asynchron frei. (Geerbt von Stream)
DisposeLocalCopyOfClientHandle()	Schließt die lokale Kopie des Handles für das AnonymousPipeClientStream-Objekt.
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 gleich dem aktuellen Objekt ist. (Geerbt von Object)
Finalize()	Gibt nicht verwaltete Ressourcen frei, und führt andere Bereinigungsvorgänge durch, bevor die AnonymousPipeServerStream-Instanz von der Garbage Collection freigegeben wird.
Flush()	Löscht den Puffer für den aktuellen Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. (Geerbt von PipeStream)
FlushAsync()	Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. (Geerbt von Stream)
FlushAsync(CancellationToken)	Löscht den Puffer für den aktuellen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. (Geerbt von PipeStream)
GetAccessControl()	Ruft ein PipeSecurity-Objekt ab, das die Einträge in der Zugriffssteuerungsliste für die Pipe kapselt, die vom aktuellen PipeStream-Objekt beschrieben wird. (Geerbt von PipeStream)
GetClientHandleAsString()	Ruft das Handle des verbundenen AnonymousPipeClientStream-Objekts als Zeichenfolge ab.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft den 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 zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des 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 einen Contract. (Geerbt von Stream)
Read(Byte[], Int32, Int32)	Liest einen Block von Bytes aus einem Stream und schreibt die Daten ab einer angegebenen Position für eine angegebene Länge in einen angegebenen Puffer. (Geerbt von PipeStream)
Read(Span<Byte>)	Liest eine Folge von Bytes aus dem aktuellen Stream, schreibt sie in ein Bytearray und erhöht die Position innerhalb des Streams um die Anzahl der gelesenen Bytes. (Geerbt von PipeStream)
ReadAsync(Byte[], Int32, Int32)	Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn. (Geerbt von Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Liest eine Folge von Bytes asynchron aus dem aktuellen Stream in ein Bytearray an die angegebene Position für eine angegebene Anzahl von Bytes, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. (Geerbt von PipeStream)
ReadAsync(Memory<Byte>, CancellationToken)	Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, schreibt diese in einen Bytespeicherbereich, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. (Geerbt von PipeStream)
ReadAtLeast(Span<Byte>, Int32, Boolean)	Liest mindestens eine Mindestanzahl von Bytes aus dem aktuellen Stream und erhöht 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 Stream, erhöht die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes und überwacht Abbruchanforderungen. (Geerbt von Stream)
ReadByte()	Liest ein Byte aus einer Pipe. (Geerbt von PipeStream)
ReadExactly(Byte[], Int32, Int32)	`count` Liest die Anzahl von Bytes aus dem aktuellen Stream und verschiebt die Position innerhalb des Datenstroms. (Geerbt von Stream)
ReadExactly(Span<Byte>)	Liest Bytes aus dem aktuellen Stream und verschiebt die Position innerhalb des Datenstroms, bis der `buffer` gefüllt ist. (Geerbt von Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Liest `count` asynchron die Anzahl von Bytes aus dem aktuellen Stream, erhöht die Position innerhalb des Datenstroms und überwacht Abbruchanforderungen. (Geerbt von Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Liest Bytes asynchron aus dem aktuellen Stream, verschiekt die Position innerhalb des Datenstroms, bis der `buffer` gefüllt ist, und überwacht Abbruchanforderungen. (Geerbt von Stream)
Seek(Int64, SeekOrigin)	Legt die aktuelle Position des aktuellen Streams auf den angegebenen Wert fest. (Geerbt von PipeStream)
SetAccessControl(PipeSecurity)	Wendet von einem PipeSecurity-Objekt angegebene Einträge in Zugriffssteuerungslisten auf die vom aktuellen PipeStream-Objekt angegebene Pipe an. (Geerbt von PipeStream)
SetLength(Int64)	Legt die Länge des aktuellen Streams auf den angegebenen Wert fest. (Geerbt von PipeStream)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
WaitForPipeDrain()	Wartet, bis das andere Ende der Pipe alle gesendeten Bytes gelesen hat. (Geerbt von PipeStream)
Write(Byte[], Int32, Int32)	Schreibt einen Byteblock mit den Daten aus einem Puffer in den aktuellen Stream. (Geerbt von PipeStream)
Write(ReadOnlySpan<Byte>)	Schreibt eine Bytesequenz in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn. (Geerbt von PipeStream)
WriteAsync(Byte[], Int32, Int32)	Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn. (Geerbt von Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Schreibt eine angegebene Anzahl von Bytes aus einem Bytearray ab einer angegebenen Position, erhöht die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. (Geerbt von PipeStream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. (Geerbt von PipeStream)
WriteByte(Byte)	Schreibt ein Byte in den aktuellen Stream. (Geerbt von PipeStream)

Erweiterungsmethoden

GetAccessControl(PipeStream)	Gibt die Sicherheitsinformationen eines Pipestreams zurück
SetAccessControl(PipeStream, PipeSecurity)	Ändert die Sicherheitsattribute eines vorhandenen Pipestreams
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguriert, wie Wartezeiten auf die Aufgaben angewandt werden, die von einem asynchronen verwerfbaren Element zurückgegeben werden.

Gilt für: