SslStream.BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) Metódus

Definíció

Névtér:

System.Net.Security

Szerelvény:

System.dll

Elindít egy aszinkron írási műveletet, amely a megadott pufferből a streambe írja Byteaz s-t.

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

Paraméterek

buffer

Byte[]

A Byte streambe írandó bájtokat tartalmazó tömb.

offset

Int32

Az a nulla alapú hely buffer , ahol a streambe írandó bájtok olvasása elkezdhető.

count

Int32

Az Int32 olvasási bájtok bufferszámát meghatározó érték.

asyncCallback

AsyncCallback

Egy AsyncCallback meghatalmazott, aki az írási művelet befejezésekor meghívandó metódusra hivatkozik.

asyncState

Object

Egy felhasználó által definiált objektum, amely az írási művelettel kapcsolatos információkat tartalmazza. Ezt az objektumot a asyncCallback rendszer a művelet befejezésekor továbbítja a meghatalmazottnak.

Válaszok

IAsyncResult

Az IAsyncResult aszinkron művelet állapotát jelző objektum.

Kivételek

ArgumentNullException

buffer az null.

ArgumentException

offset kisebb, mint nulla.

-vagy-

offset nagyobb, mint a hossza buffer.

-vagy-

offset + a szám nagyobb, mint a hossza buffer.

IOException

Az írási művelet nem sikerült.

NotSupportedException

Már folyamatban van egy írási művelet.

ObjectDisposedException

Ezt az objektumot bezárták.

InvalidOperationException

A hitelesítés nem történt meg.

Példák

Az alábbi példakód bemutatja a metódus meghívását.

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