Freigeben über


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

Definition

Startet einen asynchronen Schreibvorgang, der Byte vom angegebenen Puffer in den Stream schreibt.

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

Parameter

buffer
Byte[]

Ein Byte-Array, das die Bytes bereitstellt, die in den Stream geschrieben werden sollen.

offset
Int32

Der nullbasierte Speicherort in buffer, ab dem das Lesen der in den Stream zu schreibenden Bytes begonnen werden soll.

count
Int32

Ein Int32-Wert, der die Anzahl der vom buffer zu lesenden Bytes angibt.

asyncCallback
AsyncCallback

Ein AsyncCallback-Delegat, der auf die Methode verweist, die aufgerufen wird, wenn der Schreibvorgang beendet wurde.

asyncState
Object

Ein benutzerdefiniertes Objekt, das Informationen über den Schreibvorgang enthält. Dieses Objekt wird bei Abschluss des Vorgangs an den asyncCallback-Delegaten übergeben.

Gibt zurück

Ein IAsyncResult-Objekt, das den Status des asynchronen Vorgangs angibt.

Ausnahmen

buffer ist null.

offset ist kleiner als Null.

- oder -

offset ist größer als die Länge von buffer.

- oder -

offset plus „count“ ist größer als die Länge von buffer.

Fehler beim Schreibvorgang.

Es wird bereits ein Schreibvorgang ausgeführt.

Dieses Objekt wurde geschlossen.

Es ist keine Authentifizierung erfolgt.

Beispiele

Im folgenden Codebeispiel wird das Aufrufen dieser Methode veranschaulicht.

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

Gilt für: