Freigeben über


NegotiateStream.BeginWrite Methode

Definition

Startet einen asynchronen Schreibvorgang, der Byte vom angegebenen Puffer in den Stream schreibt.

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

Parameter

buffer
Byte[]

Ein Byte-Array, das die Bytes bereitstellt, die in den Stream geschrieben werden sollen.

offset
Int32

Der nullbasierte Speicherort in buffer, ab dem das Lesen der in den Stream zu schreibenden Bytes begonnen werden soll.

count
Int32

Ein Int32-Wert, der die Anzahl der vom buffer zu lesenden Bytes angibt.

asyncCallback
AsyncCallback

Ein AsyncCallback-Delegat, der auf die Methode verweist, die aufgerufen wird, wenn der Schreibvorgang beendet wurde.

asyncState
Object

Ein benutzerdefiniertes Objekt, das Informationen zum Schreibvorgang enthält. Dieses Objekt wird bei Abschluss des Vorgangs an den asyncCallback-Delegaten übergeben.

Gibt zurück

Ein IAsyncResult-Objekt, das den Status des asynchronen Vorgangs angibt.

Ausnahmen

buffer ist null.

offset is less than 0.

- oder -

offset ist größer als die Länge von buffer.

- oder -

Die Summe von offset und count ist größer als die Länge von buffer.

Fehler beim Schreibvorgang.

- oder -

Die Verschlüsselung wird verwendet, die Daten konnten jedoch nicht verschlüsselt werden.

Es wird bereits ein Schreibvorgang ausgeführt.

Dieses Objekt wurde geschlossen.

Es ist keine Authentifizierung erfolgt.

Beispiele

Im folgenden Beispiel wird der Beginn eines asynchronen Schreibvorgangs veranschaulicht.

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

Die folgende Methode wird aufgerufen, wenn der Vorgang abgeschlossen ist.

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

Hinweise

Wenn verschlüsselung, signieren oder verschlüsselung und signieren aktiviert sind, liest diese Methode die Daten aus dem Puffer, verschlüsselt, signiert oder signiert sie und überträgt sie mithilfe des zugrunde liegenden Datenstroms. Wenn keine Sicherheitsdienste wie Datenverschlüsselung oder Signatur verwendet werden, startet diese Methode einen asynchronen Schreibvorgang für den zugrunde liegenden Stream.

Diese Methode ist asynchron und blockiert nicht, während der Vorgang abgeschlossen ist. Um zu blockieren, bis der Vorgang abgeschlossen ist, verwenden Sie die Read -Methode.

Der asynchrone Lesevorgang muss durch Aufrufen der EndWrite -Methode abgeschlossen werden. In der Regel wird die -Methode vom asyncCallback Delegaten aufgerufen. Ausführliche Informationen zur Verwendung des asynchronen Programmiermodells finden Sie unter Aufrufen synchroner Methoden asynchron.

Mehrere NegotiateStream gleichzeitige Schreibvorgänge werden von der -Klasse nicht unterstützt. Wenn Sie versuchen, einen Schreibvorgang zu starten, während ein anderer Schreibvorgang bereits für denselben Stream ausgeführt wird, wird eine NotSupportedException Ausnahme ausgelöst.

Sie können diese Methode erst aufrufen, wenn Sie sich erfolgreich authentifiziert haben. Rufen Sie zum Authentifizieren eine der AuthenticateAsClientMethoden , AuthenticateAsClientAsync, BeginAuthenticateAsClient, AuthenticateAsServer, oder BeginAuthenticateAsServerAuthenticateAsServerAsyncauf.

Gilt für: