Partilhar via


NegotiateStream.BeginWrite Método

Definição

Inicia uma operação de gravação assíncrona que grava Bytes do buffer especificado no fluxo.

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

Parâmetros

buffer
Byte[]

Uma matriz Byte que fornece os bytes a serem gravados no fluxo.

offset
Int32

O local baseado em zero em buffer no qual será iniciada a leitura dos bytes a serem gravados no fluxo.

count
Int32

Um valor Int32 que especifica o número de bytes a serem lidos de buffer.

asyncCallback
AsyncCallback

Um delegado AsyncCallback que referencia o método a ser invocado quando a operação de gravação for concluída.

asyncState
Object

Um objeto definido pelo usuário que contém informações sobre a operação de gravação. Esse objeto é passado para o representante asyncCallback quando a operação é concluída.

Retornos

Um objeto IAsyncResult que indica o status da operação assíncrona.

Exceções

buffer é null.

offset is less than 0.

- ou -

offset é maior que o comprimento do buffer.

- ou -

offset mais a contagem é maior que o comprimento de buffer.

A operação de gravação falhou.

- ou -

A criptografia está em uso, mas não foi possível criptografar os dados.

Já existe uma operação de gravação em andamento.

Este objeto foi fechado.

A autenticação não ocorreu.

Exemplos

O exemplo a seguir demonstra o início de uma operação de gravação assíncrona.

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

O método a seguir é chamado quando a operação é concluída.

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

Comentários

Se a criptografia, a assinatura ou a criptografia e a assinatura estiverem habilitadas, esse método lerá os dados do buffer, criptografará, assinará ou criptografará e os assinará e os transmitirá usando o fluxo subjacente. Se nenhum serviço de segurança, como criptografia de dados ou assinatura, estiver em uso, esse método iniciará uma operação de gravação assíncrona no fluxo subjacente.

Esse método é assíncrono e não bloqueia enquanto a operação é concluída. Para bloquear até que a operação seja concluída, use o Read método .

A operação de leitura assíncrona deve ser concluída chamando o EndWrite método . Normalmente, o método é invocado pelo asyncCallback delegado. Para obter informações detalhadas sobre como usar o modelo de programação assíncrona, consulte Chamando métodos síncronos de forma assíncrona

A NegotiateStream classe não dá suporte a várias operações de gravação simultâneas. Se você tentar iniciar uma operação de gravação enquanto outra operação de gravação já estiver em execução no mesmo fluxo, uma NotSupportedException exceção será gerada.

Não é possível chamar esse método até que você tenha se autenticado com êxito. Para autenticar, chame um dos AuthenticateAsClientmétodos , AuthenticateAsClientAsync, AuthenticateAsServerBeginAuthenticateAsClient, , AuthenticateAsServerAsyncou BeginAuthenticateAsServer .

Aplica-se a