PipeStream.Read Methode

Definition

Namespace:

System.IO.Pipes

Assemblys:

netstandard.dll, System.IO.Pipes.dll

Überlädt

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

Read(Span<Byte>)

Quelle:

PipeStream.Unix.cs

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.

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 Speicherbereich. Wenn diese Methode zurückgegeben wird, werden die Inhalte dieses Bereichs durch die aus der aktuellen Quelle gelesenen Bytes ersetzt.

Gibt zurück

Int32

Die Gesamtanzahl der Bytes, die in die buffer. Dies kann kleiner als die Anzahl der Bytes sein, die zugewiesen buffer werden, wenn viele Bytes derzeit nicht verfügbar sind, oder Null (0), wenn das Ende des Datenstroms erreicht wurde.

Ausnahmen

ArgumentNullException

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

NotSupportedException

Der Datenstrom unterstützt das Lesen nicht.

ObjectDisposedException

Es kann nicht auf eine geschlossene Pfeife zugegriffen werden.

InvalidOperationException

Das Rohr wurde noch nicht verbunden.

- oder -

Das Rohr befindet sich in einem getrennten Zustand.

- oder -

Der Rohrziehpunkt wurde nicht festgelegt. (Haben Sie Ihren PipeStream Implementierungsaufruf aufgerufen InitializeHandle(SafePipeHandle, Boolean, Boolean)?

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 Datenstrom zu lesen.

Diese Methode liest maximal buffer.Length Bytes aus dem aktuellen Datenstrom und speichert sie in buffer. Die aktuelle Position innerhalb des Datenstroms wird um die Anzahl der gelesenen Bytes erweitert; Wenn jedoch eine Ausnahme auftritt, bleibt die aktuelle Position innerhalb des Datenstroms unverändert.

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

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

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

Wird zum Lesen primitiver Datentypen verwendet BinaryReader .

Read(Byte[], Int32, Int32)

Quelle:

PipeStream.Unix.cs

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.

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[]

Wenn diese Methode zurückgegeben wird, enthält das angegebene Bytearray mit den Werten zwischen offset und (offset + count - 1), die durch die aus der aktuellen Quelle gelesenen Bytes ersetzt werden.

offset

Int32

Der 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 Bytes, in die gelesen bufferwird. Dies kann kleiner als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl von Bytes derzeit nicht verfügbar ist, oder 0, wenn das Ende des Datenstroms 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 Anzahl der in buffer.

ObjectDisposedException

Das Rohr ist geschlossen.

NotSupportedException

Die Pipe unterstützt keine Lesevorgänge.

InvalidOperationException

Die Leitung ist getrennt, wartet auf die Verbindung, oder der Ziehpunkt wurde nicht festgelegt.

IOException

Ein E/A-Fehler ist aufgetreten.

Beispiele

Im folgenden Beispiel wird ein anonymer Pipeclient und ein Pipeserver erstellt. Der Pipeserver verwendet die Read Methode, um eine Reihe von Bytes vom Pipeclient als Überprüfungscode 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 an ein anonymes Pipehandle.

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 Methodenblöcke, bis count Bytes gelesen werden oder das Ende des Datenstroms erreicht ist. Informationen zu asynchronen Lesevorgängen finden Sie unter BeginRead und EndRead.