SslStream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) Método

Definição

Namespace:
System.Net.Security
Assembly:
System.dll
Assembly:
netstandard.dll

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);
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 Byte matriz que fornece os bytes a serem gravados no fluxo.

offset
Int32

O local baseado em zero no buffer qual começar a ler bytes a serem gravados no fluxo.

count
Int32

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

asyncCallback
AsyncCallback

Um AsyncCallback delegado que faz referência ao 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 asyncCallback delegado quando a operação é concluída.

Retornos

IAsyncResult

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

Exceções

ArgumentNullException

buffer é null.

ArgumentException

offset é menor que zero.

-ou-

offset é maior que o comprimento de buffer.

-ou-

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

IOException

Falha na operação de gravação.

NotSupportedException

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

ObjectDisposedException

Este objeto foi fechado.

InvalidOperationException

A autenticação não ocorreu.

Exemplos

O exemplo de código a seguir demonstra a chamada desse método.

void ReadCallback(IAsyncResult ar)
{
    ClientState state = (ClientState) ar.AsyncState;
    SslStream stream = state.stream;
    // Read the  message sent by the client.
    // The end of the message is signaled using the
    // "<EOF>" marker.
    int byteCount = -1;
    try
    {
        Console.WriteLine("Reading data from the client.");
        byteCount = stream.EndRead(ar);
        // Use Decoder class to convert from bytes to UTF8
        // in case a character spans two buffers.
        Decoder decoder = Encoding.UTF8.GetDecoder();
        char[] chars = new char[decoder.GetCharCount(state.buffer,0, byteCount)];
        decoder.GetChars(state.buffer, 0, byteCount, chars,0);
        state.readData.Append (chars);
        // Check for EOF or an empty message.
        if (state.readData.ToString().IndexOf("<EOF>") == -1 && byteCount != 0)
        {
            // We are not finished reading.
            // Asynchronously read more message data from  the client.
            stream.BeginRead(state.buffer, 0, state.buffer.Length,
                new AsyncCallback(ReadCallback),
                state);
        }
        else
        {
            Console.WriteLine("Message from the client: {0}", state.readData.ToString());
        }

        // Encode a test message into a byte array.
        // Signal the end of the message using "<EOF>".
        byte[] message = Encoding.UTF8.GetBytes("Hello from the server.<EOF>");
        // Asynchronously send the message to the client.
        stream.BeginWrite(message, 0, message.Length,
            new AsyncCallback(WriteCallback),
            state);
    }
    catch (Exception readException)
    {
        Console.WriteLine("Read error: {0}", readException.Message);
        state.Close();
        return;
    }
}

Aplica-se a