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

Definition

Namespace:

System.Net.Security

Assembly:

System.dll

Startet einen asynchronen ByteSchreibvorgang, der s aus dem angegebenen Puffer in den Datenstrom 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);

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 Datenstrom geschrieben werden sollen.

offset

Int32

Der nullbasierte Speicherort, an buffer dem mit dem Lesen von Bytes begonnen werden soll, die in den Datenstrom geschrieben werden sollen.

count

Int32

Ein Int32 Wert, der die Anzahl der Bytes angibt, aus bufferdenen gelesen werden soll.

asyncCallback

AsyncCallback

Ein AsyncCallback Delegat, der auf die Methode verweist, die aufgerufen werden soll, wenn der Schreibvorgang abgeschlossen ist.

asyncState

Object

Ein benutzerdefiniertes Objekt, das Informationen zum Schreibvorgang enthält. Dieses Objekt wird an den asyncCallback Delegaten übergeben, wenn der Vorgang abgeschlossen ist.

Gibt zurück

IAsyncResult

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

Ausnahmen

ArgumentNullException

buffer ist null.

ArgumentException

offset ist kleiner als 0 (null).

-oder-

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

-oder-

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

IOException

Fehler beim Schreibvorgang.

NotSupportedException

Es wird bereits ein Schreibvorgang ausgeführt.

ObjectDisposedException

Dieses Objekt wurde geschlossen.

InvalidOperationException

Die Authentifizierung ist nicht aufgetreten.

Beispiele

Im folgenden Codebeispiel wird das Aufrufen dieser Methode veranschaulicht.

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