NegotiateStream.BeginWrite Metoda

Definice

Obor názvů:

System.Net.Security

Sestavení:

System.Net.Security.dll

Zdroj:

NegotiateStream.cs

Zahájí asynchronní operaci zápisu, která zapíše Bytes ze zadané vyrovnávací paměti do datového proudu.

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

Parametry

buffer

Byte[]

Pole Byte , které poskytuje bajty, které mají být zapsány do datového proudu.

offset

Int32

Umístění založené na nule, ve buffer kterém se má začít číst bajty, které se mají zapsat do datového proudu.

count

Int32

Hodnota Int32 , která určuje počet bajtů, které se mají číst z buffer.

asyncCallback

AsyncCallback

Delegát AsyncCallback , který odkazuje na metodu k vyvolání po dokončení operace zápisu.

asyncState

Object

Uživatelem definovaný objekt obsahující informace o operaci zápisu. Tento objekt se po dokončení operace předá asyncCallback delegátu.

Návraty

IAsyncResult

Objekt IAsyncResult označující stav asynchronní operace.

Výjimky

ArgumentNullException

buffer je null.

ArgumentException

offset is less than 0.

-nebo-

offsetje větší než délka .buffer

-nebo-

offsetplus count je větší než délka .buffer

IOException

Operace zápisu se nezdařila.

-nebo-

Šifrování se používá, ale data nelze zašifrovat.

NotSupportedException

Operace zápisu již probíhá.

ObjectDisposedException

Tento objekt byl uzavřen.

InvalidOperationException

K ověření nedošlo.

Příklady

Následující příklad ukazuje zahájení asynchronní operace zápisu.

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

Následující metoda je volána po dokončení operace.

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

Poznámky

Pokud je povoleno šifrování, podepisování nebo šifrování a podepisování, tato metoda načte data z vyrovnávací paměti, zašifruje, podepíše nebo zašifruje a podepíše a přenáší je pomocí podkladového datového proudu. Pokud se nepoužívají žádné služby zabezpečení, jako je šifrování dat nebo podepisování, spustí tato metoda asynchronní operaci zápisu do podkladového datového proudu.

Tato metoda je asynchronní a během dokončení operace neblokuje. K blokování do dokončení operace použijte metodu Read .

Asynchronní operace čtení musí být dokončena voláním EndWrite metody . Obvykle je metoda vyvolána delegátem asyncCallback . Podrobné informace o použití asynchronního programovacího modelu najdete v tématu Asynchronní volání synchronních metod.

Třída NegotiateStream nepodporuje více souběžných operací zápisu. Pokud se pokusíte spustit operaci zápisu, zatímco ve stejném datovém proudu se již provádí jiná operace zápisu NotSupportedException , vyvolá se výjimka.

Tuto metodu nelze volat, dokud se úspěšně neověříte. Pokud chcete provést ověření, zavolejte jednu z AuthenticateAsClientmetod , AuthenticateAsClientAsync, BeginAuthenticateAsClient, AuthenticateAsServer, AuthenticateAsServerAsyncnebo BeginAuthenticateAsServer .