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

Definición

Espacio de nombres:

System.Net.Security

Ensamblado:

System.Net.Security.dll

Ensamblado:

System.dll

Ensamblado:

netstandard.dll

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

IAsyncResult

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

Excepciones

ArgumentNullException

buffer es null.

ArgumentException

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.

IOException

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.

NotSupportedException

Ya hay una operación de lectura en curso.

ObjectDisposedException

Este objeto se ha cerrado.

InvalidOperationException

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 forma parte de un ejemplo más grande proporcionado para la NegotiateStream clase .

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 el inicio de sesión, 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 finalice 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 el uso del 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, BeginAuthenticateAsClientAuthenticateAsServer, , AuthenticateAsServerAsynco BeginAuthenticateAsServer .