SslStream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) Método

Definição

Namespace:

System.Net.Security

Assembly:

System.Net.Security.dll

Origem:

SslStream.cs

Inicia uma operação de leitura assíncrona que lê os dados do fluxo e os armazena na matriz especificada.

public:
 override IAsyncResult ^ BeginRead(cli::array <System::Byte> ^ buffer, int offset, int count, AsyncCallback ^ asyncCallback, System::Object ^ asyncState);

public override IAsyncResult BeginRead (byte[] buffer, int offset, int count, AsyncCallback? asyncCallback, object? asyncState);

override this.BeginRead : byte[] * int * int * AsyncCallback * obj -> IAsyncResult

Public Overrides Function BeginRead (buffer As Byte(), offset As Integer, count As Integer, asyncCallback As AsyncCallback, asyncState As Object) As IAsyncResult

Parâmetros

buffer

Byte[]

Uma matriz Byte que recebe os bytes lidos do fluxo.

offset

Int32

Um local de base zero em buffer no qual inicia o armazenamento dos dados lidos desse fluxo.

count

Int32

O número máximo de bytes a serem lidos do fluxo.

asyncCallback

AsyncCallback

Um delegado AsyncCallback que faz referência ao método a ser invocado quando a operação de leitura é concluída.

asyncState

Object

Um objeto definido pelo usuário que contém informações sobre a operação de leitura. Esse objeto é passado para o representante asyncCallback quando a operação é concluída.

Retornos

IAsyncResult

Um objeto IAsyncResult que indica o status da operação assíncrona.

Exceções

ArgumentNullException

buffer é null.

ArgumentException

offset é menor que zero.

- ou -

offset é maior que o comprimento do buffer.

- ou -

A soma de offset com a contagem é maior que o comprimento de buffer.

IOException

Falha na operação de leitura.

- ou -

A criptografia está sendo utilizada, mas não foi possível descriptografar os dados.

NotSupportedException

Já existe uma operação de leitura em andamento.

ObjectDisposedException

Este objeto foi fechado.

InvalidOperationException

A autenticação não ocorreu.

Exemplos

O exemplo de código a seguir demonstra como iniciar uma operação de leitura assíncrona.

// readData and buffer holds the data read from the server.
// They is used by the ReadCallback method.
static StringBuilder^ readData = gcnew StringBuilder;
static array<Byte>^buffer = gcnew array<Byte>(2048);

// readData and buffer holds the data read from the server.
// They is used by the ReadCallback method.
static StringBuilder readData = new StringBuilder();
static byte [] buffer = new byte[2048];

' readData and buffer holds the data read from the server.
' They is used by the ReadCallback method.
Shared readData As New StringBuilder()
Shared buffer As Byte() = New Byte(2048) {}

static void WriteCallback( IAsyncResult^ ar )
{
   SslStream^ stream = dynamic_cast<SslStream^>(ar->AsyncState);
   try
   {
      Console::WriteLine( L"Writing data to the server." );
      stream->EndWrite( ar );
      
      // Asynchronously read a message from the server.
      stream->BeginRead( buffer, 0, buffer->Length, gcnew AsyncCallback( ReadCallback ), stream );
   }
   catch ( Exception^ writeException ) 
   {
      e = writeException;
      complete = true;
      return;
   }

}

static void WriteCallback(IAsyncResult ar)
{
    SslStream stream = (SslStream) ar.AsyncState;
    try
    {
        Console.WriteLine("Writing data to the server.");
        stream.EndWrite(ar);
        // Asynchronously read a message from the server.
        stream.BeginRead(buffer, 0, buffer.Length,
            new AsyncCallback(ReadCallback),
            stream);
    }
    catch (Exception writeException)
    {
        e = writeException;
        complete = true;
        return;
    }
}

Shared Sub WriteCallback(ar As IAsyncResult)
    Dim stream = CType(ar.AsyncState, SslStream)
    Try
        Console.WriteLine("Writing data to the server.")
        stream.EndWrite(ar)
        ' Asynchronously read a message from the server.
        stream.BeginRead(buffer, 0, buffer.Length, New AsyncCallback(AddressOf ReadCallback), stream)
    Catch writeException As Exception
        e = writeException
        complete = True
        Return
    End Try
End Sub

O método a seguir é chamado quando a leitura é concluída.

static void ReadCallback( IAsyncResult^ ar )
{
   
   // Read the  message sent by the server.
   // The end of the message is signaled using the
   // "<EOF>" marker.
   SslStream^ stream = dynamic_cast<SslStream^>(ar->AsyncState);
   int byteCount = -1;
   try
   {
      Console::WriteLine( L"Reading data from the server." );
      byteCount = stream->EndRead( ar );
      
      // Use Decoder class to convert from bytes to UTF8
      // in case a character spans two buffers.
      Decoder^ decoder = Encoding::UTF8->GetDecoder();
      array<Char>^chars = gcnew array<Char>(decoder->GetCharCount( buffer, 0, byteCount ));
      decoder->GetChars( buffer, 0, byteCount, chars, 0 );
      readData->Append( chars );
      
      // Check for EOF or an empty message.
      if ( readData->ToString()->IndexOf( L"<EOF>" ) == -1 && byteCount != 0 )
      {
         
         // We are not finished reading.
         // Asynchronously read more message data from  the server.
         stream->BeginRead( buffer, 0, buffer->Length, gcnew AsyncCallback( ReadCallback ), stream );
      }
      else
      {
         Console::WriteLine( L"Message from the server: {0}", readData );
      }
   }
   catch ( Exception^ readException ) 
   {
      e = readException;
      complete = true;
      return;
   }

   complete = true;
}

static void ReadCallback(IAsyncResult ar)
{
    // Read the  message sent by the server.
    // The end of the message is signaled using the
    // "<EOF>" marker.
    SslStream stream = (SslStream) ar.AsyncState;
    int byteCount = -1;
    try
    {
        Console.WriteLine("Reading data from the server.");
        byteCount = stream.EndRead(ar);
        // Use Decoder class to convert from bytes to UTF8
        // in case a character spans two buffers.
        Decoder decoder = Encoding.UTF8.GetDecoder();
        char[] chars = new char[decoder.GetCharCount(buffer,0, byteCount)];
        decoder.GetChars(buffer, 0, byteCount, chars,0);
        readData.Append (chars);
        // Check for EOF or an empty message.
        if (readData.ToString().IndexOf("<EOF>") == -1 && byteCount != 0)
        {
            // We are not finished reading.
            // Asynchronously read more message data from  the server.
            stream.BeginRead(buffer, 0, buffer.Length,
                new AsyncCallback(ReadCallback),
                stream);
        }
        else
        {
            Console.WriteLine("Message from the server: {0}", readData.ToString());
        }
    }
    catch (Exception readException)
    {
        e = readException;
        complete = true;
        return;
    }
    complete = true;
}

Shared Sub ReadCallback(ar As IAsyncResult)
    ' Read the  message sent by the server.
    ' The end of the message is signaled using the
    ' "<EOF>" marker.
    Dim stream = CType(ar.AsyncState, SslStream)
    Dim byteCount As Integer
    Try
        Console.WriteLine("Reading data from the server.")
        byteCount = stream.EndRead(ar)
        ' Use Decoder class to convert from bytes to UTF8
        ' in case a character spans two buffers.
        Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
        Dim chars = New Char(decoder.GetCharCount(buffer, 0, byteCount)) {}
        decoder.GetChars(buffer, 0, byteCount, chars, 0)
        readData.Append(chars)
        ' Check for EOF or an empty message.
        If readData.ToString().IndexOf("<EOF>") = -1 AndAlso byteCount <> 0 Then
            ' We are not finished reading.
            ' Asynchronously read more message data from  the server.
            stream.BeginRead(buffer, 0, buffer.Length, New AsyncCallback(AddressOf ReadCallback), stream)
        Else
            Console.WriteLine("Message from the server: {0}", readData.ToString())
        End If
    Catch readException As Exception
        e = readException
        complete = True
        Return
    End Try
    complete = True
End Sub

Comentários

Se a criptografia e ou a assinatura estiverem habilitadas, a operação de leitura lerá os dados do fluxo subjacente, verificará a integridade dos dados e/ou os descriptografa. A operação de leitura assíncrona deve ser concluída chamando o EndRead método . Normalmente, o método é invocado pelo asyncCallback delegado.

Esse método não bloqueia enquanto a operação é concluída. Para bloquear até que a operação seja concluída, use o Read método .

Para obter informações detalhadas sobre como usar o modelo de programação assíncrona, consulte Chamando métodos síncronos de forma assíncrona

A SslStream classe não dá suporte a várias operações de leitura simultâneas.

Não é possível chamar esse método até que você tenha se autenticado com êxito. Para autenticar, chame um dos AuthenticateAsClientmétodos , ou BeginAuthenticateAsClient, AuthenticateAsServerBeginAuthenticateAsServer .