BufferedStream.Read Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
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
- Source:
- BufferedStream.cs
- 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
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
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.
S’applique à
Read(Byte[], Int32, Int32)
- Source:
- BufferedStream.cs
- Source:
- BufferedStream.cs
- 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> ^ array, int offset, int count);
public:
override int Read(cli::array <System::Byte> ^ buffer, int offset, int count);
public override int Read (byte[] array, int offset, int count);
public override int Read (byte[] buffer, int offset, int count);
override this.Read : byte[] * int * int -> int
override this.Read : byte[] * int * int -> int
Public Overrides Function Read (array As Byte(), offset As Integer, count As Integer) As Integer
Public Overrides Function Read (buffer As Byte(), offset As Integer, count As Integer) As Integer
Paramètres
- arraybuffer
- 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
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
La longueur de array
moins offset
est inférieure à count
.
array
a la valeur null
.
offset
ou count
est un nombre négatif.
Le flux n’est pas ouvert ou bien il est null
.
Le flux ne prend pas en charge la lecture.
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