NegotiateStream.BeginWrite Metodo

Definizione

Spazio dei nomi:

System.Net.Security

Assembly:

System.Net.Security.dll

Origine:

NegotiateStream.cs

Avvia un'operazione di scrittura asincrona che scrive i Byte dal buffer specificato nel flusso.

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

Parametri

buffer

Byte[]

Matrice di Byte che fornisce i byte che devono essere scritti nel flusso.

offset

Int32

Posizione in base zero in buffer da cui iniziare la lettura dei byte che devono essere scritti nel flusso.

count

Int32

Valore Int32 che specifica il numero di byte da leggere dal buffer.

asyncCallback

AsyncCallback

Delegato AsyncCallback che fa riferimento al metodo da richiamare quando l'operazione di scrittura è completa.

asyncState

Object

Oggetto definito dall'utente contenente informazioni sull'operazione di scrittura. 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 is less than 0.

-oppure-

offset è maggiore della lunghezza di buffer.

-oppure-

la somma di offset e conteggio è maggiore della lunghezza del buffer.

IOException

Operazione di scrittura non riuscita.

-oppure-

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

NotSupportedException

È già in corso un'operazione di scrittura.

ObjectDisposedException

L'oggetto è stato chiuso.

InvalidOperationException

L'autenticazione non è stata effettuata.

Esempio

Nell'esempio seguente viene illustrato l'inizio di un'operazione di scrittura asincrona.

// 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)

Il metodo seguente viene chiamato al termine dell'operazione.

// 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

Commenti

Se la crittografia, la firma o la crittografia e la firma sono abilitate, questo metodo legge i dati dal buffer, crittografa, firma o crittografa e lo trasmette usando il flusso sottostante. Se non sono in uso servizi di sicurezza come la crittografia dei dati o la firma, questo metodo avvia un'operazione di scrittura 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 EndWrite 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 scrittura simultanee. Se si tenta di avviare un'operazione di scrittura mentre un'altra operazione di scrittura è 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