Partager via


FileStream.Read Méthode

Définition

Surcharges

Read(Byte[], Int32, Int32)

Lit un bloc d'octets dans le flux et écrit les données dans une mémoire tampon donnée.

Read(Span<Byte>)

Lit une séquence d’octets dans le flux de fichier actuel et avance la position dans le flux de fichier du nombre d’octets lus.

Read(Byte[], Int32, Int32)

Source:
FileStream.cs
Source:
FileStream.cs
Source:
FileStream.cs

Lit un bloc d'octets dans le flux et écrit les données dans une mémoire tampon donnée.

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[]

Quand cette méthode est retournée, contient le tableau d’octets spécifié dont les valeurs comprises entre offset et (offset + count - 1) sont remplacées par les octets lus dans la source actuelle.

offset
Int32

Dans array, décalage d'octet auquel les octets lus seront placés.

count
Int32

Nombre maximal d'octets à lire.

Retours

Nombre total d'octets lus dans la mémoire tampon. Le total peut être inférieur au nombre d'octets demandé si ce nombre d'octets n'est pas disponible actuellement, ou il peut être égal à zéro si la fin du flux est atteinte.

Exceptions

array a la valeur null.

offset ou count est un nombre négatif.

Le flux ne prend pas en charge la lecture.

Une erreur d'E/S s'est produite.

offset et count décrivent une plage non valide dans array.

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

Exemples

L’exemple suivant lit le contenu d’un FileStream et l’écrit dans un autre FileStream.

using System;
using System.IO;

class Test
{

public static void Main()
{
    // Specify a file to read from and to create.
    string pathSource = @"c:\tests\source.txt";
    string pathNew = @"c:\tests\newfile.txt";

    try
    {

        using (FileStream fsSource = new FileStream(pathSource,
            FileMode.Open, FileAccess.Read))
        {

            // Read the source file into a byte array.
            byte[] bytes = new byte[fsSource.Length];
            int numBytesToRead = (int)fsSource.Length;
            int numBytesRead = 0;
            while (numBytesToRead > 0)
            {
                // Read may return anything from 0 to numBytesToRead.
                int n = fsSource.Read(bytes, numBytesRead, numBytesToRead);

                // Break when the end of the file is reached.
                if (n == 0)
                    break;

                numBytesRead += n;
                numBytesToRead -= n;
            }
             numBytesToRead = bytes.Length;

            // Write the byte array to the other FileStream.
            using (FileStream fsNew = new FileStream(pathNew,
                FileMode.Create, FileAccess.Write))
            {
                fsNew.Write(bytes, 0, numBytesToRead);
            }
        }
    }
    catch (FileNotFoundException ioEx)
    {
        Console.WriteLine(ioEx.Message);
    }
}
}
open System.IO

// Specify a file to read from and to create.
let pathSource = @"c:\tests\source.txt"
let pathNew = @"c:\tests\newfile.txt"

try
    use fsSource = new FileStream(pathSource, FileMode.Open, FileAccess.Read)

    // Read the source file into a byte array.
    let mutable numBytesToRead = int fsSource.Length
    let bytes = numBytesToRead |> Array.zeroCreate
    let mutable numBytesRead = 0

    while numBytesToRead > 0 do
        // Read may return anything from 0 to numBytesToRead.
        let n = fsSource.Read(bytes, numBytesRead, numBytesToRead)

        // Break when the end of the file is reached.
        if n <> 0 then
            numBytesRead <- numBytesRead + n
            numBytesToRead <- numBytesToRead - n

    let numBytesToRead = bytes.Length

    // Write the byte array to the other FileStream.
    use fsNew = new FileStream(pathNew, FileMode.Create, FileAccess.Write)
    fsNew.Write(bytes, 0, numBytesToRead)
with :? FileNotFoundException as ioEx ->
    printfn $"{ioEx.Message}"
Imports System.IO
Class Test
    
Public Shared Sub Main()
    ' Specify a file to read from and to create.
    Dim pathSource As String = "c:\tests\source.txt"
    Dim pathNew As String = "c:\tests\newfile.txt"
    Try 
        Using fsSource As FileStream = New FileStream(pathSource, _
            FileMode.Open, FileAccess.Read)
            ' Read the source file into a byte array.
                Dim bytes() As Byte = New Byte((fsSource.Length) - 1) {}
                Dim numBytesToRead As Integer = CType(fsSource.Length,Integer)
                Dim numBytesRead As Integer = 0

                While (numBytesToRead > 0)
                    ' Read may return anything from 0 to numBytesToRead.
                    Dim n As Integer = fsSource.Read(bytes, numBytesRead, _
                        numBytesToRead)
                    ' Break when the end of the file is reached.
                    If (n = 0) Then
                        Exit While
                    End If
                    numBytesRead = (numBytesRead + n)
                    numBytesToRead = (numBytesToRead - n)

                End While
            numBytesToRead = bytes.Length

            ' Write the byte array to the other FileStream.
            Using fsNew As FileStream = New FileStream(pathNew, _
                FileMode.Create, FileAccess.Write)
                fsNew.Write(bytes, 0, numBytesToRead)
            End Using
        End Using
    Catch ioEx As FileNotFoundException
        Console.WriteLine(ioEx.Message)
    End Try
End Sub
End Class

Remarques

Cette méthode se substitue à Read.

Le offset paramètre donne le décalage de l’octet dans array (l’index de mémoire tampon) auquel commencer la lecture, et le count paramètre donne le nombre maximal d’octets à lire à partir de ce flux. La valeur retournée est le nombre réel d’octets lus, ou zéro si la fin du flux est atteinte. Si l’opération de lecture réussit, la position actuelle du flux est avancée par le nombre d’octets lus. Si une exception se produit, la position actuelle du flux est inchangée.

La Read méthode retourne zéro uniquement après avoir atteint la fin du flux. Sinon, Read lit toujours au moins un octet du flux avant de retourner. Si aucune donnée n’est disponible à partir du flux lors d’un appel à Read, la méthode est bloquée jusqu’à ce qu’au moins un octet de données puisse être retourné. 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.

N’interrompez pas un thread qui effectue une opération de lecture. Bien que l’application puisse sembler s’exécuter correctement après le déblocage du thread, l’interruption peut diminuer les performances et la fiabilité de votre application.

Pour obtenir la liste des opérations courantes de fichiers et de répertoires, consultez Tâches courantes d’E/S.

Voir aussi

S’applique à

Read(Span<Byte>)

Source:
FileStream.cs
Source:
FileStream.cs
Source:
FileStream.cs

Lit une séquence d’octets dans le flux de fichier actuel et avance la position dans le flux de fichier du nombre d’octets lus.

public:
 override int Read(Span<System::Byte> buffer);
public override int Read (Span<byte> buffer);
override this.Read : Span<byte> -> int
Public Overrides Function Read (buffer As Span(Of Byte)) As Integer

Paramètres

buffer
Span<Byte>

Région de la mémoire. Quand cette méthode retourne, le contenu de cette zone est remplacé par les octets lus dans le flux de fichier actuel.

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.

Cette méthode lit un maximum d’octets du flux de buffer.Length fichiers actif et les stocke dans buffer. La position actuelle dans le flux de fichiers est avancée par le nombre d’octets lus ; toutefois, si une exception se produit, la position actuelle dans le flux de fichiers reste inchangée. La méthode 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 de fichiers et qu’aucune autre donnée n’est attendue (par exemple, un socket fermé ou une fin de fichier). La méthode est libre de renvoyer moins d’octets que demandé même si la fin du flux de fichiers n’a pas été atteinte.

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

S’applique à