SslStream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) 方法

定義

開始非同步寫入作業,此作業會從指定的緩衝區寫入 Byte 至資料流。

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

參數

buffer
Byte[]

Byte 陣列,提供將要寫入至資料流的位元組。

offset
Int32

buffer 中以零起始的位置,用來開始讀取將要寫入資料流的位元組。

count
Int32

Int32 值,指定從 buffer 中讀取的位元組數。

asyncCallback
AsyncCallback

AsyncCallback 委派,其會參考寫入作業完成時要叫用的方法。

asyncState
Object

包含作業資訊的使用者定義物件。 作業完成時會將這個物件傳遞給 asyncCallback 委派。

傳回

IAsyncResult

IAsyncResult 物件,指出非同步作業的狀態。

例外狀況

buffernull

offset 小於零。

-或- offset 大於 buffer 的長度。

-或- offset + 計數大於 buffer 的長度。

寫入作業失敗。

已經有寫入作業正在進行中。

此物件已關閉。

尚未執行驗證。

範例

下列程式碼範例示範如何呼叫這個方法。

void ReadCallback( IAsyncResult^ ar )
{
   ClientState^ state = dynamic_cast<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( L"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();
      array<Char>^chars = gcnew array<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( L"<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, gcnew AsyncCallback( this, &SslTcpListener::ReadCallback ), state );
      }
      else
      {
         Console::WriteLine( L"Message from the client: {0}", state->readData );
      }
      
      // Encode a test message into a byte array.
      // Signal the end of the message using "<EOF>".
      array<Byte>^message = Encoding::UTF8->GetBytes( L"Hello from the server.<EOF>" );
      
      // Asynchronously send the message to the client.
      stream->BeginWrite( message, 0, message->Length, gcnew AsyncCallback( this, &SslTcpListener::WriteCallback ), state );
   }
   catch ( Exception^ readException ) 
   {
      Console::WriteLine( L"Read error: {0}", readException->Message );
      state->Close();
      return;
   }

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

適用於