NegotiateStream.BeginWrite Méthode

Définition

Espace de noms:

System.Net.Security

Assembly:

System.Net.Security.dll

Source:

NegotiateStream.cs

Commence une opération d'écriture asynchrone qui écrit des Bytes de la mémoire tampon spécifiée vers le flux.

public:
 override IAsyncResult ^ BeginWrite(cli::array <System::Byte> ^ buffer, int offset, int count, AsyncCallback ^ asyncCallback, System::Object ^ asyncState);

public override IAsyncResult BeginWrite (byte[] buffer, int offset, int count, AsyncCallback? asyncCallback, object? asyncState);

override this.BeginWrite : byte[] * int * int * AsyncCallback * obj -> IAsyncResult

Public Overrides Function BeginWrite (buffer As Byte(), offset As Integer, count As Integer, asyncCallback As AsyncCallback, asyncState As Object) As IAsyncResult

Paramètres

buffer

Byte[]

Tableau de Byte qui fournit les octets à écrire dans le flux.

offset

Int32

Emplacement de base zéro dans buffer à partir duquel commencer la lecture des octets à écrire dans le flux.

count

Int32

Valeur Int32 qui spécifie le nombre d'octets à lire dans buffer.

asyncCallback

AsyncCallback

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

asyncState

Object

Objet défini par l'utilisateur comportant des informations sur l'opération d'écriture. 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 is less than 0.

- ou -

offset est supérieur à la longueur de buffer.

- ou -

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

IOException

L'opération d'écriture a échoué.

- ou -

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

NotSupportedException

Une opération d'écriture est déjà en cours.

ObjectDisposedException

L’objet a été fermé.

InvalidOperationException

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

Exemples

L’exemple suivant illustre le démarrage d’une opération d’écriture asynchrone.

// Request authentication.
NetworkStream^ clientStream = client->GetStream();
NegotiateStream^ authStream = gcnew NegotiateStream( clientStream,false );

// Pass the NegotiateStream as the AsyncState object 
// so that it is available to the callback delegate.
IAsyncResult^ ar = authStream->BeginAuthenticateAsClient( gcnew AsyncCallback( EndAuthenticateCallback ), authStream );

Console::WriteLine( L"Client waiting for authentication..." );

// Wait until the result is available.
ar->AsyncWaitHandle->WaitOne();

// Display the properties of the authenticated stream.
AuthenticatedStreamReporter::DisplayProperties( authStream );

// Send a message to the server.
// Encode the test data into a byte array.
array<Byte>^message = Encoding::UTF8->GetBytes( L"Hello from the client." );
ar = authStream->BeginWrite( message, 0, message->Length, gcnew AsyncCallback( EndWriteCallback ), authStream );

// Request authentication.
NetworkStream clientStream = client.GetStream();
NegotiateStream authStream = new NegotiateStream(clientStream, false);
// Pass the NegotiateStream as the AsyncState object
// so that it is available to the callback delegate.
Task authenticateTask = authStream
    .AuthenticateAsClientAsync()
    .ContinueWith(task =>
    {
        Console.WriteLine("Client ending authentication...");
        Console.WriteLine("ImpersonationLevel: {0}", authStream.ImpersonationLevel);
    });

Console.WriteLine("Client waiting for authentication...");
// Wait until the result is available.
authenticateTask.Wait();
// Display the properties of the authenticated stream.
AuthenticatedStreamReporter.DisplayProperties(authStream);
// Send a message to the server.
// Encode the test data into a byte array.
byte[] message = Encoding.UTF8.GetBytes("Hello from the client.");
Task writeTask = authStream
    .WriteAsync(message, 0, message.Length)
    .ContinueWith(task =>
    {
        Console.WriteLine("Client ending write operation...");
    });

' Request authentication.
Dim clientStream = client.GetStream()
Dim authStream As New NegotiateStream(clientStream, False)

' Pass the NegotiateStream as the AsyncState object 
' so that it is available to the callback delegate.
Dim ar = authStream.BeginAuthenticateAsClient(
    New AsyncCallback(AddressOf EndAuthenticateCallback), authStream)

Console.WriteLine("Client waiting for authentication...")

' Wait until the result is available.
ar.AsyncWaitHandle.WaitOne()

' Display the properties of the authenticated stream.
AuthenticatedStreamReporter.DisplayProperties(authStream)

' Send a message to the server.
' Encode the test data into a byte array.
Dim message = Encoding.UTF8.GetBytes("Hello from the client.")
ar = authStream.BeginWrite(message, 0, message.Length, 
    New AsyncCallback(AddressOf EndWriteCallback), authStream)

La méthode suivante est appelée lorsque l’opération se termine.

// The following method is called when the write operation completes.
static void EndWriteCallback( IAsyncResult^ ar )
{
   Console::WriteLine( L"Client ending write operation..." );
   NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(ar->AsyncState);
   
   // End the asynchronous operation.
   authStream->EndWrite( ar );
}

' The following method is called when the write operation completes.
Public Shared Sub EndWriteCallback(ar As IAsyncResult)

    Console.WriteLine("Client ending write operation...")
    Dim authStream = CType(ar.AsyncState, NegotiateStream)

    ' End the asynchronous operation.
    authStream.EndWrite(ar)

End Sub

Remarques

Si le chiffrement, la signature ou le chiffrement et la signature sont activés, cette méthode lit les données à partir de la mémoire tampon, les chiffre, les signe ou les chiffre et les signe, puis les transmet à l’aide du flux sous-jacent. Si aucun service de sécurité tel que le chiffrement des données ou la signature n’est utilisé, cette méthode démarre une opération d’écriture asynchrone sur le flux sous-jacent.

Cette méthode est asynchrone et ne se 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 EndWrite 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 d’écriture simultanées. Si vous tentez de démarrer une opération d’écriture alors qu’une autre opération d’écriture est déjà en cours d’exécution 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 , AuthenticateAsClientAsyncBeginAuthenticateAsClient, AuthenticateAsServer, , AuthenticateAsServerAsyncou BeginAuthenticateAsServer .