NegotiateStream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) Metodo

Definizione

Spazio dei nomi:

System.Net.Security

Assembly:

System.Net.Security.dll

Origine:

NegotiateStream.cs

Avvia un'operazione di lettura asincrona dei dati del flusso, archiviandoli nella matrice specificata.

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

Parametri

buffer

Byte[]

Matrice Byte che riceve i byte letti dal flusso.

offset

Int32

Posizione in base zero nel buffer da cui iniziare l'archiviazione dei dati letti da questo flusso.

count

Int32

Numero massimo di byte da leggere dal flusso.

asyncCallback

AsyncCallback

Delegato AsyncCallback cui fa riferimento il metodo da richiamare quando l'operazione di lettura è completa.

asyncState

Object

Oggetto definito dall'utente contenente informazioni sull'operazione di lettura. Questo oggetto viene passato al delegato asyncCallback al completamento dell'operazione.

Restituisce

IAsyncResult

Oggetto IAsyncResult che indica lo stato dell'operazione asincrona.

Eccezioni

ArgumentNullException

buffer è null.

ArgumentException

offset è minore di 0.

-oppure-

offset è maggiore della lunghezza di buffer.

-oppure-

La somma di offset e count è maggiore della lunghezza di buffer.

IOException

L'operazione di lettura non è riuscita.

-oppure-

La crittografia è in uso, ma non è stato possibile decrittografare i dati.

NotSupportedException

È già in corso un'operazione di lettura.

ObjectDisposedException

L'oggetto è stato chiuso.

InvalidOperationException

L'autenticazione non è stata effettuata.

Esempio

Nell'esempio di codice seguente viene illustrato l'avvio di un'operazione di lettura asincrona. Questo esempio di codice fa parte di un esempio più grande fornito per la 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();
}

Commenti

Se la crittografia, la firma o la crittografia e la firma sono abilitate, l'operazione di lettura legge i dati dal flusso sottostante, controlla l'integrità dei dati e la decrittografa. Se non vengono usati servizi di sicurezza come crittografia dati o firma, questo metodo avvia un'operazione di lettura asincrona nel flusso sottostante.

Questo metodo è asincrono e non blocca mentre l'operazione viene completata. Per bloccare fino al completamento dell'operazione, usare il Read metodo .

L'operazione di lettura asincrona deve essere completata chiamando il EndRead metodo . In genere, il metodo viene richiamato dal asyncCallback delegato. Per informazioni dettagliate sull'uso del modello di programmazione asincrona, vedere Chiamata di metodi sincroni in modo asincrono

La NegotiateStream classe non supporta più operazioni di lettura simultanee. Se si tenta di avviare un'operazione di lettura mentre un'altra operazione di lettura è già in esecuzione nello stesso flusso, verrà generata un'eccezione NotSupportedException .

Non è possibile chiamare questo metodo fino a quando non è stata eseguita correttamente l'autenticazione. Per eseguire l'autenticazioneAuthenticateAsClient, chiamare uno dei metodi , AuthenticateAsServerAsyncAuthenticateAsServerAuthenticateAsClientAsyncBeginAuthenticateAsCliento .BeginAuthenticateAsServer