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

Definición

Inicia una operación de lectura asincrónica que lee los datos de la secuencia y los almacena en la 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);
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[]

Matriz Byte que recibe los bytes leídos de la secuencia.

offset
Int32

Posición de base cero de buffer donde se comienzan a almacenar los datos leídos de esta secuencia.

count
Int32

Número máximo de bytes que se van a leer de la secuencia.

asyncCallback
AsyncCallback

Delegado de AsyncCallback que hace referencia al método que se va a invocar una vez finalizada la operación de lectura.

asyncState
Object

Objeto definido por el usuario que contiene información sobre la operación de lectura. Este objeto se pasa al delegado de asyncCallback cuando la operación ha terminado.

Devoluciones

Objeto IAsyncResult que indica el estado de la operación asincrónica.

Excepciones

buffer es null.

offset es menor que 0.

O bien

offset es mayor que la longitud de buffer.

O bien

offset más count es mayor que la longitud de buffer.

Se ha producido un error en la operación de lectura.

O bien

El cifrado está en uso, pero los datos no se pudieron descifrar.

Ya hay una operación de lectura en curso.

Este objeto se ha cerrado.

No se ha producido la autenticación.

Ejemplos

En el ejemplo de código siguiente se muestra cómo iniciar una operación de lectura asincrónica. Este ejemplo de código es parte de un ejemplo más grande proporcionado para la clase NegotiateStream.

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();
}

Comentarios

Si se habilitan el cifrado, la firma o el cifrado y la firma, la operación de lectura lee los datos de la secuencia subyacente, comprueba la integridad de los datos y la descifra. Si no se usan servicios de seguridad como el cifrado de datos o la firma, este método inicia una operación de lectura asincrónica en la secuencia subyacente.

Este método es asincrónico y no se bloquea mientras se completa la operación. Para bloquear hasta que se complete la operación, use el Read método .

La operación de lectura asincrónica debe completarse llamando al EndRead método . Normalmente, el delegado invoca el asyncCallback método . Para obtener información detallada sobre cómo usar el modelo de programación asincrónica, vea Llamar a métodos sincrónicos de forma asincrónica.

La NegotiateStream clase no admite varias operaciones de lectura simultáneas. Si intenta iniciar una operación de lectura mientras otra operación de lectura ya se está ejecutando en la misma secuencia, se producirá una NotSupportedException excepción.

No puede llamar a este método hasta que se haya autenticado correctamente. Para autenticarse, llame a uno de los AuthenticateAsClientmétodos , AuthenticateAsClientAsync, BeginAuthenticateAsClient, AuthenticateAsServer, AuthenticateAsServerAsynco BeginAuthenticateAsServer .

Se aplica a