PipeStream.Read Método

Definição

Sobrecargas

Read(Span<Byte>)

Lê uma sequência de bytes do fluxo em buffer atual, grava-os em uma matriz de bytes e avança a posição no fluxo até o número de bytes lidos.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)

Lê um bloco de bytes de um fluxo e grava os dados em um buffer especificado, começando em uma posição especificada para um tamanho especificado.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>)

Lê uma sequência de bytes do fluxo em buffer atual, grava-os em uma matriz de bytes e avança a posição no fluxo até o número de bytes lidos.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

Parâmetros

buffer
Span<Byte>

Uma região da memória.A region of memory. Quando este método retorna, o conteúdo desta região é substituído pelos bytes lidos da fonte atual.When this method returns, the contents of this region are replaced by the bytes read from the current source.

Retornos

Int32

O número total de bytes de leitura para o buffer.The total number of bytes read into the buffer. Isso pode ser menor que o número de bytes alocados em buffer se esses muitos bytes não estão disponíveis no momento ou pode ser zero (0) caso o final do fluxo seja atingido.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.

Exceções

O número de bytes lidos foi maior que o tamanho do buffer.The number of bytes read was longer than the buffer length.

Não há suporte para leitura no fluxo.The stream does not support reading.

Não é possível acessar um pipe fechado.Cannot access a closed pipe.

O pipe ainda não foi conectado.The pipe hasn't been connected yet.

- ou --or-

O pipe está em um estado desconectado.The pipe is in a disconnected state.

- ou --or-

O identificador de pipe não foi definido.The pipe handle has not been set. (A implementação de PipeStream chamou InitializeHandle(SafePipeHandle, Boolean, Boolean)?)(Did your PipeStream implementation call InitializeHandle(SafePipeHandle, Boolean, Boolean)?

Comentários

Use a CanRead propriedade para determinar se o PipeStream objeto atual oferece suporte a operações de leitura.Use the CanRead property to determine whether the current PipeStream object supports read operations.

Use o ReadAsync método para ler de forma assíncrona o fluxo atual.Use the ReadAsync method to read asynchronously from the current stream.

Esse método lê um máximo de buffer.Length bytes do fluxo atual e os armazena em buffer .This method reads a maximum of buffer.Length bytes from the current stream and stores them in buffer. A posição atual dentro do fluxo é avançada pelo número de bytes lidos; no entanto, se ocorrer uma exceção, a posição atual dentro do fluxo permanecerá inalterada.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.

Esse método será bloqueado até que pelo menos um byte de dados possa ser lido, caso nenhum dado esteja disponível.This method will block until at least one byte of data can be read, in the event that no data is available.

Esse método retorna 0 somente quando não há mais dados no fluxo e não é mais esperado (como um soquete ou fim de arquivo fechado).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).

Esse método é livre para retornar menos bytes do que o solicitado, mesmo que o final do fluxo não tenha sido atingido.This method is free to return fewer bytes than requested even if the end of the stream has not been reached.

Use BinaryReader para ler tipos de dados primitivos.Use BinaryReader for reading primitive data types.

Aplica-se a

Read(Byte[], Int32, Int32)

Lê um bloco de bytes de um fluxo e grava os dados em um buffer especificado, começando em uma posição especificada para um tamanho especificado.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);
public override int Read (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
[<System.Security.SecurityCritical>]
override this.Read : byte[] * int * int -> int
Public Overrides Function Read (buffer As Byte(), offset As Integer, count As Integer) As Integer

Parâmetros

buffer
Byte[]

Quando este método retorna, ele contém a matriz de bytes especificada com os valores entre offset e (offset + count -1) substituídos pelos bytes lidos da fonte atual.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

O deslocamento de bytes na matriz de buffer no qual os bytes que são lidos serão colocados.The byte offset in the buffer array at which the bytes that are read will be placed.

count
Int32

O número máximo de bytes a serem lidos.The maximum number of bytes to read.

Retornos

Int32

O número total de bytes lidos no buffer.The total number of bytes that are read into buffer. Poderá ser menor que o número de bytes solicitado se esse número de bytes não estiver disponível no momento ou 0 se o fim do fluxo for atingido.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.

Atributos

Exceções

buffer é null.buffer is null.

offset é menor que 0.offset is less than 0.

- ou --or- count é menor que 0.count is less than 0.

count é maior que o número de bytes disponível no buffer.count is greater than the number of bytes available in buffer.

O pipe está fechado.The pipe is closed.

O pipe não dá suporte a operações de leitura.The pipe does not support read operations.

O pipe está desconectado, esperando para conectar-se ou o identificador não foi definido.The pipe is disconnected, waiting to connect, or the handle has not been set.

Ocorreu um erro de E/S.Any I/O error occurred.

Exemplos

O exemplo a seguir cria um cliente de pipe anônimo e um servidor de pipe.The following example creates an anonymous pipe client and pipe server. O servidor de pipe usa o Read método para ler uma série de bytes do cliente de pipe como um código de validação.The pipe server uses the Read method to read a series of bytes from the pipe client as a validation code. O cliente de pipe e o servidor de pipe fazem parte do mesmo exemplo.Both the pipe client and the pipe server are part of the same example. A parte do servidor do exemplo cria um processo de cliente e passa um identificador de pipe anônimo como um argumento.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

Comentários

Use a CanRead propriedade para determinar se o PipeStream objeto atual oferece suporte a operações de leitura.Use the CanRead property to determine whether the current PipeStream object supports read operations.

Chamar o Read método é bloqueado até que os count bytes sejam lidos ou o fim do fluxo seja atingido.Calling the Read method blocks until count bytes are read or the end of the stream is reached. Para operações de leitura assíncronas, consulte BeginRead e EndRead .For asynchronous read operations, see BeginRead and EndRead.

Aplica-se a