PipeStream.Read Methode

Definition

Namespace:

System.IO.Pipes

Assembly:

System.IO.Pipes.dll

Überlädt

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

Read(Span<Byte>)

Quelle:

PipeStream.Unix.cs

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.

public:
 override int Read(Span<System::Byte> buffer);

public override int Read (Span<byte> buffer);

override this.Read : Span<byte> -> int

Public Overrides Function Read (buffer As Span(Of Byte)) As Integer

Parameter

buffer

Span<Byte>

Ein Bereich im Arbeitsspeicher. Bei der Rückgabe dieser Methode werden die Inhalte dieses Bereichs durch die aus der aktuellen Quelle gelesenen Bytes ersetzt.

Gibt zurück

Int32

Die Anzahl der insgesamt in den buffer gelesenen Bytes. Dies kann weniger als die Anzahl der in buffer zugeordneten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder 0 (null), wenn das Ende des Streams erreicht ist.

Ausnahmen

ArgumentNullException

Die Anzahl der gelesenen Bytes war länger als die Pufferlänge.

NotSupportedException

Lesevorgänge werden vom Stream nicht unterstützt.

ObjectDisposedException

Auf eine geschlossene Pipe kann nicht zugegriffen werden.

InvalidOperationException

Die Pipe ist noch nicht verbunden.

- oder -

Die Pipe befindet sich in einem nicht verbundenen Zustand.

- oder -

Das Pipehandle wurde nicht festgelegt. (Hat Ihre PipeStream-Implementierung InitializeHandle(SafePipeHandle, Boolean, Boolean) aufgerufen?

Hinweise

Verwenden Sie die CanRead -Eigenschaft, um zu bestimmen, ob das aktuelle PipeStream Objekt Lesevorgänge unterstützt.

Verwenden Sie die ReadAsync -Methode, um asynchron aus dem aktuellen Stream zu lesen.

Diese Methode liest ein Maximum von buffer.Length Bytes aus dem aktuellen Stream und speichert sie in buffer. Die aktuelle Position im Stream wird um die Anzahl der gelesenen Bytes erweitert. Wenn jedoch eine Ausnahme auftritt, bleibt die aktuelle Position im Stream unverändert.

Diese Methode blockiert, bis mindestens ein Byte Daten gelesen werden kann, falls keine Daten verfügbar sind.

Diese Methode gibt nur dann 0 zurück, wenn keine weiteren Daten im Stream vorhanden sind und keine weiteren (z. B. ein geschlossener Socket oder ein Dateiende) erwartet werden.

Diese Methode kann auch dann weniger Bytes zurückgeben als angefordert, wenn das Ende des Datenstroms nicht erreicht wurde.

Verwenden Sie zum BinaryReader Lesen primitiver Datentypen.

Read(Byte[], Int32, Int32)

Quelle:

PipeStream.Unix.cs

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.

public:
 override int Read(cli::array <System::Byte> ^ buffer, int offset, int count);

public override int Read (byte[] buffer, int offset, int count);

override this.Read : byte[] * int * int -> int

Public Overrides Function Read (buffer As Byte(), offset As Integer, count As Integer) As Integer

Parameter

buffer

Byte[]

Enthält nach dem Beenden dieser Methode das angegebene Bytearray mit den Werten zwischen offset und (offset + count - 1) die durch die aus der aktuellen Quelle gelesenen Bytes ersetzt wurden.

offset

Int32

Das Byteoffset im buffer-Array, an dem die gelesenen Bytes platziert werden.

count

Int32

Die maximale Anzahl der zu lesenden Bytes.

Gibt zurück

Int32

Die Gesamtanzahl der in den buffer gelesenen Bytes. Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder 0, wenn das Streamende erreicht ist.

Ausnahmen

ArgumentNullException

buffer ist null.

ArgumentOutOfRangeException

offset ist kleiner als 0.

- oder -

count ist kleiner als 0.

ArgumentException

count ist größer als die im buffer verfügbare Anzahl von Bytes.

ObjectDisposedException

Die Pipe ist geschlossen.

NotSupportedException

Die Pipe unterstützt keine Lesevorgänge.

InvalidOperationException

Die Verbindung der Pipe ist getrennt, die Pipe wartet auf eine Verbindung, oder das Handle wurde nicht festgelegt.

IOException

Es ist ein E/A-Fehler aufgetreten.

Beispiele

Im folgenden Beispiel werden ein anonymer Pipeclient und ein Pipeserver erstellt. Der Pipeserver verwendet die Read -Methode, um eine Reihe von Bytes aus dem Pipeclient als Validierungscode zu lesen. Sowohl der Pipeclient als auch der Pipeserver sind Teil desselben Beispiels. Der Serverteil des Beispiels erstellt einen Clientprozess und übergibt ihn als Argument ein anonymes Pipehandle.

#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 PipeStreamExample
{
private:
    static array<Byte>^ matchSign = {9, 0, 9, 0};

public:
    static void Main()
    {
        array<String^>^ args = Environment::GetCommandLineArgs();
        if (args->Length < 2)
        {
            Process^ clientProcess = gcnew Process();

            clientProcess->StartInfo->FileName = Environment::CommandLine;

            AnonymousPipeServerStream^ pipeServer =
                gcnew AnonymousPipeServerStream(PipeDirection::In,
                HandleInheritability::Inheritable);
            // Pass the client process a handle to the server.
            clientProcess->StartInfo->Arguments = pipeServer->GetClientHandleAsString();
            clientProcess->StartInfo->UseShellExecute = false;
            Console::WriteLine("[SERVER] Starting client process...");
            clientProcess->Start();

            pipeServer->DisposeLocalCopyOfClientHandle();

            try
            {
                if (WaitForClientSign(pipeServer))
                {
                    Console::WriteLine("[SERVER] Valid sign code received!");
                }
                else
                {
                    Console::WriteLine("[SERVER] Invalid sign code received!");
                }
            }
            catch (IOException^ e)
            {
                 Console::WriteLine("[SERVER] Error: {0}", e->Message);
            }
            clientProcess->WaitForExit();
            clientProcess->Close();
            Console::WriteLine("[SERVER] Client quit. Server terminating.");
        }
        else
        {
            PipeStream^ pipeClient =
                gcnew AnonymousPipeClientStream(PipeDirection::Out, args[1]);
            try
            {
                Console::WriteLine("[CLIENT] Sending sign code...");
                SendClientSign(pipeClient);
            }
            catch (IOException^ e)
            {
                Console::WriteLine("[CLIENT] Error: {0}", e->Message);
            }
            Console::WriteLine("[CLIENT] Terminating.");
        }
    }

private:
    static bool WaitForClientSign(PipeStream^ inStream)
    {
        array<Byte>^ inSign = gcnew array<Byte>(matchSign->Length);
        int len = inStream->Read(inSign, 0, matchSign->Length);
        bool valid = len == matchSign->Length;

        while (valid && len-- > 0)
        {
            valid = valid && (matchSign[len] == inSign[len]);
        }
        return valid;
    }

    static void SendClientSign(PipeStream^ outStream)
    {
        outStream->Write(matchSign, 0, matchSign->Length);
    }
};

int main()
{
    PipeStreamExample::Main();
}

using System;
using System.IO;
using System.IO.Pipes;
using System.Diagnostics;

class PipeStreamExample
{
    private static byte[] matchSign = {9, 0, 9, 0};

    public static void Main()
    {
        string[] args = Environment.GetCommandLineArgs();
        if (args.Length < 2)
        {
            Process clientProcess = new Process();

            clientProcess.StartInfo.FileName = Environment.CommandLine;

            using (AnonymousPipeServerStream pipeServer =
                new AnonymousPipeServerStream(PipeDirection.In,
                HandleInheritability.Inheritable))
            {
                // Pass the client process a handle to the server.
                clientProcess.StartInfo.Arguments = pipeServer.GetClientHandleAsString();
                clientProcess.StartInfo.UseShellExecute = false;
                Console.WriteLine("[SERVER] Starting client process...");
                clientProcess.Start();

                pipeServer.DisposeLocalCopyOfClientHandle();

                try
                {
                    if (WaitForClientSign(pipeServer))
                    {
                        Console.WriteLine("[SERVER] Valid sign code received!");
                    }
                    else
                    {
                        Console.WriteLine("[SERVER] Invalid sign code received!");
                    }
                }
                catch (IOException e)
                {
                    Console.WriteLine("[SERVER] Error: {0}", e.Message);
                }
            }
            clientProcess.WaitForExit();
            clientProcess.Close();
            Console.WriteLine("[SERVER] Client quit. Server terminating.");
        }
        else
        {
            using (PipeStream pipeClient = new AnonymousPipeClientStream(PipeDirection.Out, args[1]))
            {
                try
                {
                    Console.WriteLine("[CLIENT] Sending sign code...");
                    SendClientSign(pipeClient);
                }
                catch (IOException e)
                {
                     Console.WriteLine("[CLIENT] Error: {0}", e.Message);
                }
            }
            Console.WriteLine("[CLIENT] Terminating.");
        }
    }

    private static bool WaitForClientSign(PipeStream inStream)
    {
        byte[] inSign = new byte[matchSign.Length];
        int len = inStream.Read(inSign, 0, matchSign.Length);
        bool valid = len == matchSign.Length;

        while (valid && len-- > 0)
        {
            valid = valid && (matchSign[len] == inSign[len]);
        }
        return valid;
    }

    private static void SendClientSign(PipeStream outStream)
    {
        outStream.Write(matchSign, 0, matchSign.Length);
    }
}

Imports System.IO
Imports System.IO.Pipes
Imports System.Diagnostics

Class PipeStreamExample
    Private Shared matchSign() As Byte = {9, 0, 9, 0}

    Public Shared Sub Main()
        Dim args() As String = Environment.GetCommandLineArgs()
        If args.Length < 2 Then
            Dim clientProcess As New Process()

            clientProcess.StartInfo.FileName = Environment.CommandLine

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

                ' Pass the client process a handle to the server.
                clientProcess.StartInfo.Arguments = pipeServer.GetClientHandleAsString()
                clientProcess.StartInfo.UseShellExecute = false
                Console.WriteLine("[SERVER] Starting client process...")
                clientProcess.Start()

                pipeServer.DisposeLocalCopyOfClientHandle()

                Try
                    If WaitForClientSign(pipeServer) Then
                        Console.WriteLine("[SERVER] Valid sign code received!")
                    Else
                        Console.WriteLine("[SERVER] Invalid sign code received!")
                    End If
                Catch e As IOException
                    Console.WriteLine("[SERVER] Error: {0}", e.Message)
                End Try
            End Using
            clientProcess.WaitForExit()
            clientProcess.Close()
            Console.WriteLine("[SERVER] Client quit. Server terminating.")
        Else
            Using pipeClient As PipeStream = New AnonymousPipeClientStream(PipeDirection.Out, args(1))
                Try
                    Console.WriteLine("[CLIENT] Sending sign code...")
                    SendClientSign(pipeClient)
                Catch e As IOException
                    Console.WriteLine("[CLIENT] Error: {0}", e.Message)
                End Try
            End Using
            Console.WriteLine("[CLIENT] Terminating.")
        End If
    End Sub

    Private Shared Function WaitForClientSign(inStream As PipeStream) As Boolean
        Dim inSign() As Byte = Array.CreateInstance(GetType(Byte), matchSign.Length)
        Dim len As Integer = inStream.Read(inSign, 0, matchSign.Length)
        Dim valid = len.Equals(matchSign.Length)

        While len > 0
            len -= 1
            valid = valid And (matchSign(len).Equals(inSign(len)))
        End While
        Return valid
    End Function

    Private Shared Sub SendClientSign(outStream As PipeStream)
        outStream.Write(matchSign, 0, matchSign.Length)
    End Sub
End Class

Hinweise

Verwenden Sie die CanRead -Eigenschaft, um zu bestimmen, ob das aktuelle PipeStream Objekt Lesevorgänge unterstützt.

Das Aufrufen der Read Methode blockiert, bis count Bytes gelesen werden oder das Ende des Datenstroms erreicht ist. Asynchrone Lesevorgänge finden Sie unter BeginRead und EndRead.