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

Definice

Obor názvů:

System.Net.Security

Sestavení:

netstandard.dll, System.Net.Security.dll

Zdroj:

SslStream.cs

Začíná asynchronní operace zápisu, která zapisuje Bytez zadané vyrovnávací paměti do datového proudu.

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

Parametry

buffer

Byte[]

Pole Byte , které poskytuje bajty, které mají být zapsány do datového proudu.

offset

Int32

Umístění založené na nule, ve buffer kterém se mají začít číst bajty, které se mají zapisovat do datového proudu.

count

Int32

Hodnota Int32 , která určuje počet bajtů ke čtení z buffer.

asyncCallback

AsyncCallback

AsyncCallback Delegát, který odkazuje na metodu vyvolat při dokončení operace zápisu.

asyncState

Object

Uživatelem definovaný objekt, který obsahuje informace o operaci zápisu. Tento objekt se předá delegátu asyncCallback po dokončení operace.

Návraty

IAsyncResult

Objekt IAsyncResult označující stav asynchronní operace.

Výjimky

ArgumentNullException

buffer je null.

ArgumentException

Hodnota offset je menší než nula.

nebo

offset je větší než délka buffer.

nebo

offset + počet je větší než délka buffer.

IOException

Operace zápisu se nezdařila.

NotSupportedException

Právě probíhá operace zápisu.

ObjectDisposedException

Tento objekt byl uzavřen.

InvalidOperationException

K ověřování nedošlo.

Příklady

Následující příklad kódu ukazuje volání této metody.

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