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

Definitie

Naamruimte:
System.Net.Security
Assembly:
System.dll
Assembly:
netstandard.dll

Hiermee wordt een asynchrone schrijfbewerking gestart die s van de opgegeven buffer naar de stream schrijft 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);
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

Parameters

buffer
Byte[]

Een Byte matrix die de bytes levert die naar de stream moeten worden geschreven.

offset
Int32

De locatie buffer op basis van nul waarop bytes moeten worden gelezen die naar de stream moeten worden geschreven.

count
Int32

Een Int32 waarde die het aantal bytes aangeeft waaruit moet worden gelezen buffer.

asyncCallback
AsyncCallback

Een AsyncCallback gemachtigde die verwijst naar de methode die moet worden aangeroepen wanneer de schrijfbewerking is voltooid.

asyncState
Object

Een door de gebruiker gedefinieerd object met informatie over de schrijfbewerking. Dit object wordt doorgegeven aan de asyncCallback gemachtigde wanneer de bewerking is voltooid.

Retouren

IAsyncResult

Een IAsyncResult object dat de status van de asynchrone bewerking aangeeft.

Uitzonderingen

ArgumentNullException

buffer is null.

ArgumentException

offset is kleiner dan nul.

– of –

offset is groter dan de lengte van buffer.

– of –

offset + count is groter dan de lengte van buffer.

IOException

De schrijfbewerking is mislukt.

NotSupportedException

Er wordt al een schrijfbewerking uitgevoerd.

ObjectDisposedException

Dit object is gesloten.

InvalidOperationException

Er is geen verificatie opgetreden.

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u deze methode aanroept.

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

Van toepassing op