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

Definição

Namespace:

System.Net.Security

Assembly:

System.Net.Security.dll

Origem:

NegotiateStream.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 0.

- ou -

offset é maior que o comprimento do buffer.

- ou -

A soma de offset e count é maior que o tamanho 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. Este exemplo de código faz parte de um exemplo maior fornecido para a NegotiateStream classe .

static void AuthenticateClient( TcpClient^ clientRequest )
{
   NetworkStream^ stream = clientRequest->GetStream();
   
   // Create the NegotiateStream.
   NegotiateStream^ authStream = gcnew NegotiateStream( stream,false );
   
   // Save the current client and NegotiateStream instance 
   // in a ClientState object.
   ClientState^ cState = gcnew ClientState( authStream,clientRequest );
   
   // Listen for the client authentication request.
   authStream->BeginAuthenticateAsServer( gcnew AsyncCallback( EndAuthenticateCallback ), cState );
   
   // Wait until the authentication completes.
   cState->Waiter->WaitOne();
   cState->Waiter->Reset();
   authStream->BeginRead( cState->Buffer, 0, cState->Buffer->Length, gcnew AsyncCallback( EndReadCallback ), cState );
   cState->Waiter->WaitOne();
   
   // Finished with the current client.
   authStream->Close();
   clientRequest->Close();
}

public static void AuthenticateClient(TcpClient clientRequest)
{
    NetworkStream stream = clientRequest.GetStream();
    // Create the NegotiateStream.
    NegotiateStream authStream = new NegotiateStream(stream, false);
    // Save the current client and NegotiateStream instance
    // in a ClientState object.
    ClientState cState = new ClientState(authStream, clientRequest);
    // Listen for the client authentication request.
    Task authTask = authStream
        .AuthenticateAsServerAsync()
        .ContinueWith(task => { EndAuthenticateCallback(cState); });

    // Any exceptions that occurred during authentication are
    // thrown by the EndAuthenticateAsServer method.
    try
    {
        // This call blocks until the authentication is complete.
        authTask.Wait();
    }
    catch (AuthenticationException e)
    {
        Console.WriteLine(e);
        Console.WriteLine("Authentication failed - closing connection.");
        return;
    }
    catch (Exception e)
    {
        Console.WriteLine(e);
        Console.WriteLine("Closing connection.");
        return;
    }

    Task<int> readTask = authStream
        .ReadAsync(cState.Buffer, 0, cState.Buffer.Length);

    readTask
        .ContinueWith((task) => { EndReadCallback(cState, task.Result); })
        .Wait();
    // Finished with the current client.
    authStream.Close();
    clientRequest.Close();
}

Comentários

Se a criptografia, a assinatura ou a criptografia e a assinatura estiverem habilitadas, a operação de leitura lerá os dados do fluxo subjacente, verificará a integridade dos dados e os descriptografa. Se nenhum serviço de segurança, como criptografia de dados ou assinatura, estiver em uso, esse método iniciará uma operação de leitura assíncrona no fluxo subjacente.

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

A operação de leitura assíncrona deve ser concluída chamando o EndRead método . Normalmente, o método é invocado pelo asyncCallback delegado. 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 NegotiateStream classe não dá suporte a várias operações de leitura simultâneas. Se você tentar iniciar uma operação de leitura enquanto outra operação de leitura já estiver em execução no mesmo fluxo, uma NotSupportedException exceção será gerada.

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