BufferedStream.Read Méthode

Définition

Espace de noms:

System.IO

Assembly:

System.Runtime.dll

Surcharges

Read(Span<Byte>)	Copie les octets depuis le flux mis en mémoire tampon actuel dans une plage d’octets et avance la position dans ce flux du nombre d’octets lus.
Read(Byte[], Int32, Int32)	Copie les octets du flux actuel figurant dans la mémoire tampon dans un tableau.

Read(Span<Byte>)

Source:

BufferedStream.cs

Copie les octets depuis le flux mis en mémoire tampon actuel dans une plage d’octets et avance la position dans ce flux du nombre d’octets lus.

public:
 override int Read(Span<System::Byte> destination);

public override int Read (Span<byte> destination);

override this.Read : Span<byte> -> int

Public Overrides Function Read (destination As Span(Of Byte)) As Integer

Paramètres

destination

Span<Byte>

Région de la mémoire. Quand cette méthode est retournée, le contenu de cette région est remplacé par les octets lus dans la source actuelle.

Retours

Int32

Nombre total d'octets lus dans la mémoire tampon. Le nombre d’octets peut être inférieur au nombre d’octets alloués dans la mémoire tampon si ce nombre d’octets n’est pas actuellement disponible, ou égal à zéro (0) si la fin du flux a été atteinte.

Remarques

Utilisez la CanRead propriété pour déterminer si le instance actuel prend en charge la lecture. Utilisez la ReadAsync méthode pour lire de manière asynchrone à partir du flux actuel.

Les implémentations de cette méthode lisent un maximum d’octets buffer.Length du flux actuel et les stockent dans buffer. La position actuelle dans le flux est avancée par le nombre d’octets lus ; toutefois, si une exception se produit, la position actuelle dans le flux reste inchangée. Les implémentations retournent le nombre d’octets lus. L’implémentation est bloquée jusqu’à ce qu’au moins un octet de données puisse être lu, dans le cas où aucune donnée n’est disponible. Read retourne 0 uniquement lorsqu’il n’y a plus de données dans le flux et qu’aucune autre donnée n’est attendue (par exemple, un socket fermé ou une fin de fichier). Une implémentation est libre de renvoyer moins d’octets que demandé, même si la fin du flux n’a pas été atteinte.

À utiliser BinaryReader pour lire les types de données primitifs.

Read(Byte[], Int32, Int32)

Source:

BufferedStream.cs

Copie les octets du flux actuel figurant dans la mémoire tampon dans un tableau.

public:
 override int Read(cli::array <System::Byte> ^ buffer, int offset, int count);

public override int Read (byte[] buffer, int offset, int count);

override this.Read : byte[] * int * int -> int

Public Overrides Function Read (buffer As Byte(), offset As Integer, count As Integer) As Integer

Paramètres

buffer

Byte[]

Mémoire tampon dans laquelle les octets sont copiés.

offset

Int32

Dans la mémoire tampon, offset d’octet à partir duquel commence la lecture des octets.

count

Int32

Nombre d'octets à lire.

Retours

Int32

Nombre total d’octets lus dans array. Le total peut être inférieur au nombre d’octets demandé si ce nombre n’est pas actuellement disponible, ou il peut être égal à 0 si la fin du flux a été atteinte avant la lecture des données.

Exceptions

ArgumentException

La longueur de array moins offset est inférieure à count.

ArgumentNullException

array a la valeur null.

ArgumentOutOfRangeException

offset ou count est un nombre négatif.

IOException

Le flux n’est pas ouvert ou bien il est null.

NotSupportedException

Le flux ne prend pas en charge la lecture.

ObjectDisposedException

Des méthodes ont été appelées après la fermeture du flux.

Exemples

Cet exemple de code fait partie d’un exemple plus grand fourni pour la BufferedStream classe .

// Receive data using the BufferedStream.
Console::WriteLine(  "Receiving data using BufferedStream." );
bytesReceived = 0;
startTime = DateTime::Now;
while ( bytesReceived < numberOfLoops * receivedData->Length )
{
   bytesReceived += bufStream->Read( receivedData, 0, receivedData->Length );
}

bufferedTime = (DateTime::Now - startTime).TotalSeconds;
Console::WriteLine( "{0} bytes received in {1} seconds.\n", bytesReceived.ToString(), bufferedTime.ToString(  "F1" ) );

// Receive data using the BufferedStream.
Console.WriteLine("Receiving data using BufferedStream.");
bytesReceived = 0;
startTime = DateTime.Now;

int numBytesToRead = receivedData.Length;

while (numBytesToRead > 0)
{
    // Read may return anything from 0 to numBytesToRead.
    int n = bufStream.Read(receivedData,0, receivedData.Length);
    // The end of the file is reached.
    if (n == 0)
        break;
    bytesReceived += n;
    numBytesToRead -= n;
}

bufferedTime = (DateTime.Now - startTime).TotalSeconds;
Console.WriteLine("{0} bytes received in {1} seconds.\n",
    bytesReceived.ToString(),
    bufferedTime.ToString("F1"));

// Receive data using the BufferedStream.
printfn "Receiving data using BufferedStream."
bytesReceived <- 0
let startTime = DateTime.Now

let mutable numBytesToRead = receivedData.Length

let mutable broken = false
while not broken && numBytesToRead > 0 do
    // Read may return anything from 0 to numBytesToRead.
    let n = bufStream.Read(receivedData,0, receivedData.Length)
    // The end of the file is reached.
    if n = 0 then
        broken <- true
    else
        bytesReceived <- bytesReceived + n
        numBytesToRead <- numBytesToRead - n

let bufferedTime = (DateTime.Now - startTime).TotalSeconds
printfn $"{bytesReceived} bytes received in {bufferedTime:F1} seconds.\n"

' Receive data using the BufferedStream.
Console.WriteLine("Receiving data using BufferedStream.")
bytesReceived = 0
startTime = DateTime.Now

Dim numBytesToRead As Integer = receivedData.Length
Dim n As Integer
Do While numBytesToRead > 0

    'Read my return anything from 0 to numBytesToRead
    n = bufStream.Read(receivedData, 0, receivedData.Length)
    'The end of the file is reached.
    If n = 0 Then
        Exit Do
    End If

    bytesReceived += n
    numBytesToRead -= n
Loop

bufferedTime = DateTime.Now.Subtract(startTime).TotalSeconds
Console.WriteLine("{0} bytes received in {1} " & _
    "seconds." & vbCrLf, _
    bytesReceived.ToString(), _
    bufferedTime.ToString("F1"))

Remarques

La Read méthode retourne 0 uniquement si la fin du flux est atteinte. Dans tous les autres cas, Read lit toujours au moins un octet du flux avant de retourner. Par définition, si aucune donnée n’est disponible à partir du flux lors d’un appel à Read, la Read méthode retourne 0 (la fin du flux est atteinte automatiquement). Une implémentation est libre de renvoyer moins d’octets que demandé, même si la fin du flux n’a pas été atteinte.

À utiliser BinaryReader pour lire les types de données primitifs.

Voir aussi

• BlockCopy(Array, Int32, Array, Int32, Int32)
• CanRead
• Write(Byte[], Int32, Int32)
• Fichier et flux de données E/S
• Procédure : lire le texte d’un fichier
• Procédure : écrire du texte dans un fichier