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

Définition

Espace de noms:

System.Net.Security

Assembly:

System.Net.Security.dll

Source:

NegotiateStream.cs

Commence une opération de lecture asynchrone qui lit des données du flux et les stocke dans le tableau spécifié.

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

Paramètres

buffer

Byte[]

Tableau Byte qui reçoit les octets lus dans le flux de données.

offset

Int32

Emplacement de base zéro dans buffer, à partir duquel commencer l'enregistrement des données lues dans ce flux.

count

Int32

Nombre maximal d'octets à lire dans le flux.

asyncCallback

AsyncCallback

Délégué AsyncCallback qui fait référence à la méthode à appeler lorsque l'opération de lecture est terminée.

asyncState

Object

Objet défini par l'utilisateur comportant des informations sur l'opération de lecture. Cet objet est passé au délégué asyncCallback quand l'opération se termine.

Retours

IAsyncResult

Objet IAsyncResult indiquant l'état de l'opération asynchrone.

Exceptions

ArgumentNullException

buffer a la valeur null.

ArgumentException

offset est inférieur à 0.

- ou -

offset est supérieur à la longueur de buffer.

- ou -

offset plus count est supérieur à la longueur d’buffer.

IOException

L'opération de lecture a échoué.

- ou -

Le chiffrement est utilisé, mais les données n'ont pas pu être déchiffrées.

NotSupportedException

Une opération de lecture est déjà en cours.

ObjectDisposedException

L’objet a été fermé.

InvalidOperationException

L'authentification n'a pas été effectuée.

Exemples

L’exemple de code suivant illustre le démarrage d’une opération de lecture asynchrone. Cet exemple de code fait partie d’un exemple plus grand fourni pour 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();
}

Remarques

Si le chiffrement, la signature ou le chiffrement et la signature sont activés, l’opération de lecture lit les données du flux sous-jacent, vérifie l’intégrité des données et les déchiffre. Si aucun service de sécurité tel que le chiffrement des données ou la signature n’est en cours d’utilisation, cette méthode démarre une opération de lecture asynchrone sur le flux sous-jacent.

Cette méthode est asynchrone et ne bloque pas tant que l’opération se termine. Pour bloquer jusqu’à la fin de l’opération, utilisez la Read méthode .

L’opération de lecture asynchrone doit être effectuée en appelant la EndRead méthode . En règle générale, la méthode est appelée par le asyncCallback délégué. Pour plus d’informations sur l’utilisation du modèle de programmation asynchrone, consultez Appel de méthodes synchrones de manière asynchrone

La NegotiateStream classe ne prend pas en charge plusieurs opérations de lecture simultanées. Si vous tentez de démarrer une opération de lecture alors qu’une autre opération de lecture s’exécute déjà sur le même flux, une NotSupportedException exception est levée.

Vous ne pouvez pas appeler cette méthode tant que vous n’avez pas réussi à vous authentifier. Pour vous authentifier, appelez l’une AuthenticateAsClientdes méthodes , AuthenticateAsClientAsync, BeginAuthenticateAsClient, AuthenticateAsServerAuthenticateAsServerAsync, ou BeginAuthenticateAsServer .