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

Definíció

Névtér:

System.Net.Security

Szerelvény:

System.dll

Elindít egy aszinkron olvasási műveletet, amely beolvassa az adatokat a streamből, és tárolja azokat a megadott tömbben.

public:
 override IAsyncResult ^ BeginRead(cli::array <System::Byte> ^ buffer, int offset, int count, AsyncCallback ^ asyncCallback, System::Object ^ asyncState);

public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback asyncCallback, object asyncState);

override this.BeginRead : byte[] * int * int * AsyncCallback * obj -> IAsyncResult

Public Overrides Function BeginRead (buffer As Byte(), offset As Integer, count As Integer, asyncCallback As AsyncCallback, asyncState As Object) As IAsyncResult

Paraméterek

buffer

Byte[]

Egy Byte tömb, amely fogadja a bájtok olvasását a streamből.

offset

Int32

Az a nulla alapú hely buffer , ahol a streamből beolvasott adatok tárolása megkezdhető.

count

Int32

A streamből beolvasandó bájtok maximális száma.

asyncCallback

AsyncCallback

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

asyncState

Object

Felhasználó által definiált objektum, amely az olvasá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 olvasási művelet nem sikerült.

-vagy-

A titkosítás használatban van, de az adatok visszafejtése nem sikerült.

NotSupportedException

Már folyamatban van egy olvasá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 egy aszinkron olvasási művelet elindítását mutatja be.

// readData and buffer holds the data read from the server.
// They is used by the ReadCallback method.
static StringBuilder readData = new StringBuilder();
static byte [] buffer = new byte[2048];

' readData and buffer holds the data read from the server.
' They is used by the ReadCallback method.
Shared readData As New StringBuilder()
Shared buffer As Byte() = New Byte(2048) {}

static void WriteCallback(IAsyncResult ar)
{
    SslStream stream = (SslStream) ar.AsyncState;
    try
    {
        Console.WriteLine("Writing data to the server.");
        stream.EndWrite(ar);
        // Asynchronously read a message from the server.
        stream.BeginRead(buffer, 0, buffer.Length,
            new AsyncCallback(ReadCallback),
            stream);
    }
    catch (Exception writeException)
    {
        e = writeException;
        complete = true;
        return;
    }
}

Shared Sub WriteCallback(ar As IAsyncResult)
    Dim stream = CType(ar.AsyncState, SslStream)
    Try
        Console.WriteLine("Writing data to the server.")
        stream.EndWrite(ar)
        ' Asynchronously read a message from the server.
        stream.BeginRead(buffer, 0, buffer.Length, New AsyncCallback(AddressOf ReadCallback), stream)
    Catch writeException As Exception
        e = writeException
        complete = True
        Return
    End Try
End Sub

Az olvasás befejeződésekor a következő metódus lesz meghívva.

static void ReadCallback(IAsyncResult ar)
{
    // Read the  message sent by the server.
    // The end of the message is signaled using the
    // "<EOF>" marker.
    SslStream stream = (SslStream) ar.AsyncState;
    int byteCount = -1;
    try
    {
        Console.WriteLine("Reading data from the server.");
        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(buffer,0, byteCount)];
        decoder.GetChars(buffer, 0, byteCount, chars,0);
        readData.Append (chars);
        // Check for EOF or an empty message.
        if (readData.ToString().IndexOf("<EOF>") == -1 && byteCount != 0)
        {
            // We are not finished reading.
            // Asynchronously read more message data from  the server.
            stream.BeginRead(buffer, 0, buffer.Length,
                new AsyncCallback(ReadCallback),
                stream);
        }
        else
        {
            Console.WriteLine("Message from the server: {0}", readData.ToString());
        }
    }
    catch (Exception readException)
    {
        e = readException;
        complete = true;
        return;
    }
    complete = true;
}

Shared Sub ReadCallback(ar As IAsyncResult)
    ' Read the  message sent by the server.
    ' The end of the message is signaled using the
    ' "<EOF>" marker.
    Dim stream = CType(ar.AsyncState, SslStream)
    Dim byteCount As Integer
    Try
        Console.WriteLine("Reading data from the server.")
        byteCount = stream.EndRead(ar)
        ' Use Decoder class to convert from bytes to UTF8
        ' in case a character spans two buffers.
        Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
        Dim chars = New Char(decoder.GetCharCount(buffer, 0, byteCount)) {}
        decoder.GetChars(buffer, 0, byteCount, chars, 0)
        readData.Append(chars)
        ' Check for EOF or an empty message.
        If readData.ToString().IndexOf("<EOF>") = -1 AndAlso byteCount <> 0 Then
            ' We are not finished reading.
            ' Asynchronously read more message data from  the server.
            stream.BeginRead(buffer, 0, buffer.Length, New AsyncCallback(AddressOf ReadCallback), stream)
        Else
            Console.WriteLine("Message from the server: {0}", readData.ToString())
        End If
    Catch readException As Exception
        e = readException
        complete = True
        Return
    End Try
    complete = True
End Sub

Megjegyzések

Ha a titkosítás és az aláírás engedélyezve van, az olvasási művelet beolvassa az adatokat a mögöttes adatfolyamból, ellenőrzi az adatok integritását, és/vagy visszafejti azokat. Az aszinkron olvasási műveletet a EndRead metódus meghívásával kell végrehajtani. A metódust általában a asyncCallback meghatalmazott hívja meg.

Ez a metódus nem blokkolja a művelet befejeződése közben. Ha a művelet befejezéséig szeretné letiltani a műveletet, használja a metódust Read .

Az aszinkron programozási modell használatával kapcsolatos részletes információkért lásd: Szinkron metódusok aszinkron meghívása

Az SslStream osztály nem támogatja több egyidejű olvasási műveletet.

Ezt a metódust csak a sikeres hitelesítés után hívhatja meg. Az egyik metódus BeginAuthenticateAsClientAuthenticateAsServerBeginAuthenticateAsServer meghívásának AuthenticateAsClienthitelesítéséhez.