PipeStream.Read Methode

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

Parameters

Retouren

Het totale aantal bytes dat in de bufferbytes is gelezen. Dit kan kleiner zijn dan het aantal toegewezen bytes als er momenteel niet veel bytes buffer beschikbaar zijn, of nul (0) als het einde van de stream is bereikt.

Uitzonderingen

Opmerkingen

Gebruik de CanRead eigenschap om te bepalen of het huidige PipeStream object leesbewerkingen ondersteunt.

Gebruik de ReadAsync methode om asynchroon te lezen vanuit de huidige stroom.

Met deze methode worden maximaal buffer.Length bytes uit de huidige stroom gelezen en opgeslagen in buffer. De huidige positie in de stream wordt geavanceerd door het aantal gelezen bytes; Als er echter een uitzondering optreedt, blijft de huidige positie binnen de stroom ongewijzigd.

Deze methode wordt geblokkeerd totdat ten minste één byte aan gegevens kan worden gelezen, in het geval dat er geen gegevens beschikbaar zijn.

Deze methode retourneert alleen 0 wanneer er geen gegevens meer in de stream zijn en er niet meer wordt verwacht (zoals een gesloten socket of einde van het bestand).

Deze methode is gratis om minder bytes te retourneren dan is aangevraagd, zelfs als het einde van de stream niet is bereikt.

Gebruiken BinaryReader voor het lezen van primitieve gegevenstypen.

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

[System.Security.SecurityCritical]
public override int Read(byte[] buffer, int offset, int count);

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

[<System.Security.SecurityCritical>]
override this.Read : byte[] * int * int -> int

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

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

Parameters

Retouren

Het totale aantal bytes dat wordt gelezen in buffer. Dit kan minder zijn dan het aantal aangevraagde bytes als dat aantal bytes momenteel niet beschikbaar is of 0 als het einde van de stream is bereikt.

Kenmerken

SecurityCriticalAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt een anonieme pijpclient en pijpserver gemaakt. De pipe-server gebruikt de Read methode om een reeks bytes van de pipe-client te lezen als validatiecode. Zowel de pijpclient als de pijpserver maken deel uit van hetzelfde voorbeeld. Het servergedeelte van het voorbeeld maakt een clientproces en geeft deze als argument een anonieme pijpgreep door.

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

Opmerkingen

Gebruik de CanRead eigenschap om te bepalen of het huidige PipeStream object leesbewerkingen ondersteunt.

Het aanroepen van de Read methodeblokken totdat count bytes worden gelezen of het einde van de stream wordt bereikt. Zie en EndReadvoor asynchrone leesbewerkingenBeginRead.