PipeStream.Read Metoda

Definicja

Przeciążenia

Read(Span<Byte>)

Odczytuje sekwencję bajtów z bieżącego strumienia, zapisuje je w tablicy bajtów i przesuwa pozycję w strumieniu o liczbę odczytanych bajtów.Reads a sequence of bytes from the current stream, writes them to a byte array, and advances the position within the stream by the number of bytes read.

Read(Byte[], Int32, Int32)

Odczytuje blok bajtów ze strumienia i zapisuje dane w określonym buforze, rozpoczynając od określonego położenia o określonej długości.Reads a block of bytes from a stream and writes the data to a specified buffer starting at a specified position for a specified length.

Read(Span<Byte>)

Odczytuje sekwencję bajtów z bieżącego strumienia, zapisuje je w tablicy bajtów i przesuwa pozycję w strumieniu o liczbę odczytanych bajtów.Reads a sequence of bytes from the current stream, writes them to a byte array, and advances the position within the stream by the number of bytes read.

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

Parametry

buffer
Span<Byte>

Region pamięci.A region of memory. Gdy ta metoda zwraca, zawartość tego regionu jest zastępowana przez Bajty odczytane z bieżącego źródła.When this method returns, the contents of this region are replaced by the bytes read from the current source.

Zwraca

Całkowita liczba bajtów odczytywanych do buffer.The total number of bytes read into the buffer. Może to być mniejsze niż liczba bajtów przydzielono w buffer, jeśli wiele bajtów nie jest aktualnie dostępnych, lub zero (0), jeśli osiągnięto koniec strumienia.This can be less than the number of bytes allocated in buffer if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.

Wyjątki

Liczba odczytanych bajtów była dłuższa niż długość buforu.The number of bytes read was longer than the buffer length.

Strumień nie obsługuje odczytywania.The stream does not support reading.

Nie można uzyskać dostępu do zamkniętego potoku.Cannot access a closed pipe.

Potok nie został jeszcze połączony.The pipe hasn't been connected yet.

lub-or-

Potok jest w stanie odłączonym.The pipe is in a disconnected state.

lub-or-

Dojście potoku nie zostało ustawione.The pipe handle has not been set. (Czy PipeStream InitializeHandle(SafePipeHandle, Boolean, Boolean)wywołania implementacji?(Did your PipeStream implementation call InitializeHandle(SafePipeHandle, Boolean, Boolean)?

Uwagi

Użyj właściwości CanRead, aby określić, czy bieżący obiekt PipeStream obsługuje operacje odczytu.Use the CanRead property to determine whether the current PipeStream object supports read operations.

Użyj metody ReadAsync, aby odczytywać asynchronicznie z bieżącego strumienia.Use the ReadAsync method to read asynchronously from the current stream.

Ta metoda odczytuje maksymalnie buffer.Length bajtów z bieżącego strumienia i zapisuje je w buffer.This method reads a maximum of buffer.Length bytes from the current stream and stores them in buffer. Bieżąca pozycja w strumieniu jest zaawansowana przez liczbę odczytanych bajtów; Jeśli jednak wystąpi wyjątek, bieżąca pozycja w strumieniu pozostaje niezmieniona.The current position within the stream is advanced by the number of bytes read; however, if an exception occurs, the current position within the stream remains unchanged.

Ta metoda zostanie Zablokowani do momentu odczytania co najmniej jednego bajtu danych, w przypadku, gdy żadne dane nie są dostępne.This method will block until at least one byte of data can be read, in the event that no data is available.

Ta metoda zwraca wartość 0 tylko wtedy, gdy nie ma więcej danych w strumieniu i nie jest więcej niż oczekiwano (na przykład zamknięte gniazdo lub koniec pliku).This method returns 0 only when there is no more data in the stream and no more is expected (such as a closed socket or end of file).

Ta metoda jest bezpłatna, aby zwrócić mniejszą liczbę bajtów niż żądana, nawet jeśli nie osiągnięto końca strumienia.This method is free to return fewer bytes than requested even if the end of the stream has not been reached.

Użyj BinaryReader do odczytywania typów danych pierwotnych.Use BinaryReader for reading primitive data types.

Read(Byte[], Int32, Int32)

Odczytuje blok bajtów ze strumienia i zapisuje dane w określonym buforze, rozpoczynając od określonego położenia o określonej długości.Reads a block of bytes from a stream and writes the data to a specified buffer starting at a specified position for a specified length.

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);
override this.Read : byte[] * int * int -> int
Public Overrides Function Read (buffer As Byte(), offset As Integer, count As Integer) As Integer

Parametry

buffer
Byte[]

Gdy ta metoda zwraca, zawiera określoną tablicę bajtową z wartościami między offset i (offset + count-1) zastąpione przez Bajty odczytane z bieżącego źródła.When this method returns, contains the specified byte array with the values between offset and (offset + count - 1) replaced by the bytes read from the current source.

offset
Int32

Przesunięcie bajtu w tablicy buffer, w którym zostaną umieszczone odczytane bajty.The byte offset in the buffer array at which the bytes that are read will be placed.

count
Int32

Maksymalna liczba bajtów do odczytania.The maximum number of bytes to read.

Zwraca

Całkowita liczba bajtów odczytywanych do buffer.The total number of bytes that are read into buffer. Może to być mniejsze niż liczba żądanych bajtów, jeśli liczba bajtów nie jest obecnie dostępna lub wartość 0, jeśli osiągnięto koniec strumienia.This might be less than the number of bytes requested if that number of bytes is not currently available, or 0 if the end of the stream is reached.

Atrybuty

Wyjątki

Parametr buffer ma wartość null.buffer is null.

Parametr offset ma wartość mniejszą niż 0.offset is less than 0.

lub-or- Parametr count ma wartość mniejszą niż 0.count is less than 0.

count jest większa niż liczba bajtów dostępnych w buffer.count is greater than the number of bytes available in buffer.

Potok jest zamknięty.The pipe is closed.

Potok nie obsługuje operacji odczytu.The pipe does not support read operations.

Potok jest odłączony, oczekiwanie na połączenie lub dojście nie zostało ustawione.The pipe is disconnected, waiting to connect, or the handle has not been set.

Wystąpił błąd we/wy.Any I/O error occurred.

Przykłady

W poniższym przykładzie jest tworzony klient z potokiem anonimowym i serwer potoku.The following example creates an anonymous pipe client and pipe server. Serwer potoku używa metody Read, aby odczytać serię bajtów z klienta potoku jako kod weryfikacyjny.The pipe server uses the Read method to read a series of bytes from the pipe client as a validation code. Zarówno klient potoku, jak i serwer potoku są częścią tego samego przykładu.Both the pipe client and the pipe server are part of the same example. Częścią serwera tego przykładu jest tworzenie procesu klienta i przekazanie go do dojścia potoku anonimowego jako argumentu.The server portion of the example creates a client process and passes it an anonymous pipe handle as an argument.

#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

Uwagi

Użyj właściwości CanRead, aby określić, czy bieżący obiekt PipeStream obsługuje operacje odczytu.Use the CanRead property to determine whether the current PipeStream object supports read operations.

Wywoływanie bloków metody Read do momentu odczytania count bajtów lub osiągnięcia końca strumienia.Calling the Read method blocks until count bytes are read or the end of the stream is reached. W przypadku asynchronicznych operacji odczytu Zobacz BeginRead i EndRead.For asynchronous read operations, see BeginRead and EndRead.

Dotyczy