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

Definição

Espaço de Nomes:
System.Net.Security
Assemblagem:
System.dll
Assemblagem:
netstandard.dll

Inicia uma operação de escrita assíncrona que escreve Bytes do buffer especificado para o 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[]

Um Byte array que fornece os bytes a serem escritos no fluxo.

offset
Int32

A localização em base zero onde buffer começar a ler bytes a serem escritos no fluxo.

count
Int32

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

asyncCallback
AsyncCallback

Um AsyncCallback delegado que faz referência ao método a invocar quando a operação de escrita está concluída.

asyncState
Object

Um objeto definido pelo utilizador que contém informação sobre a operação de escrita. Este objeto é passado para o asyncCallback delegado quando a operação termina.

Devoluções

IAsyncResult

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

Exceções

ArgumentNullException

buffer é null.

ArgumentException

offset é inferior a zero.

-ou-

offset é maior do que o comprimento de buffer.

-ou-

offset + contagem é maior que o comprimento de buffer.

IOException

A operação de escrita falhou.

NotSupportedException

Já está em curso uma operação de escrita.

ObjectDisposedException

Este objeto foi encerrado.

InvalidOperationException

A autenticação não ocorreu.

Exemplos

O exemplo de código seguinte demonstra como chamar este 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