FileStream Classe

Référence

Définition

Espace de noms:: System.IO

Assemblys:: mscorlib.dll, System.IO.FileSystem.dll

Assembly:: System.Runtime.dll

Assembly:: System.IO.FileSystem.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

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.

Fournit un élément Stream pour un fichier, prenant en charge les opérations en lecture et en écriture aussi bien synchrones qu'asynchrones.

public ref class FileStream : System::IO::Stream

public class FileStream : System.IO.Stream

[System.Runtime.InteropServices.ComVisible(true)]
public class FileStream : System.IO.Stream

type FileStream = class
    inherit Stream

[<System.Runtime.InteropServices.ComVisible(true)>]
type FileStream = class
    inherit Stream

Public Class FileStream
Inherits Stream

Héritage: Object

Stream
FileStream

Héritage: Object

MarshalByRefObject

Stream
FileStream

Dérivé: System.IO.IsolatedStorage.IsolatedStorageFileStream

Attributs: ComVisibleAttribute

Exemples

L’exemple suivant illustre certains des FileStream constructeurs.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void AddText( FileStream^ fs, String^ value )
{
   array<Byte>^info = (gcnew UTF8Encoding( true ))->GetBytes( value );
   fs->Write( info, 0, info->Length );
}

int main()
{
   String^ path = "c:\\temp\\MyTest.txt";
   
   // Delete the file if it exists.
   if ( File::Exists( path ) )
   {
      File::Delete( path );
   }

   //Create the file.
   {
      FileStream^ fs = File::Create( path );
      try
      {
         AddText( fs, "This is some text" );
         AddText( fs, "This is some more text," );
         AddText( fs, "\r\nand this is on a new line" );
         AddText( fs, "\r\n\r\nThe following is a subset of characters:\r\n" );
         for ( int i = 1; i < 120; i++ )
         {
            AddText( fs, Convert::ToChar( i ).ToString() );
            
            //Split the output at every 10th character.
            if ( Math::IEEERemainder( Convert::ToDouble( i ), 10 ) == 0 )
            {
               AddText( fs, "\r\n" );
            }
         }
      }
      finally
      {
         if ( fs )
            delete (IDisposable^)fs;
      }
   }
   
   //Open the stream and read it back.
   {
      FileStream^ fs = File::OpenRead( path );
      try
      {
         array<Byte>^b = gcnew array<Byte>(1024);
         UTF8Encoding^ temp = gcnew UTF8Encoding( true );
         while ( fs->Read( b, 0, b->Length ) > 0 )
         {
            Console::WriteLine( temp->GetString( b ) );
         }
      }
      finally
      {
         if ( fs )
            delete (IDisposable^)fs;
      }
   }
}

using System;
using System.IO;
using System.Text;

class Test
{

    public static void Main()
    {
        string path = @"c:\temp\MyTest.txt";

        // Delete the file if it exists.
        if (File.Exists(path))
        {
            File.Delete(path);
        }

        //Create the file.
        using (FileStream fs = File.Create(path))
        {
            AddText(fs, "This is some text");
            AddText(fs, "This is some more text,");
            AddText(fs, "\r\nand this is on a new line");
            AddText(fs, "\r\n\r\nThe following is a subset of characters:\r\n");

            for (int i=1;i < 120;i++)
            {
                AddText(fs, Convert.ToChar(i).ToString());
            }
        }

        //Open the stream and read it back.
        using (FileStream fs = File.OpenRead(path))
        {
            byte[] b = new byte[1024];
            UTF8Encoding temp = new UTF8Encoding(true);
            int readLen;
            while ((readLen = fs.Read(b,0,b.Length)) > 0)
            {
                Console.WriteLine(temp.GetString(b,0,readLen));
            }
        }
    }

    private static void AddText(FileStream fs, string value)
    {
        byte[] info = new UTF8Encoding(true).GetBytes(value);
        fs.Write(info, 0, info.Length);
    }
}

open System
open System.IO
open System.Text

let addText (fs:FileStream) (value: string) =
    let info = UTF8Encoding(true).GetBytes value
    fs.Write(info, 0, info.Length);

let path = @"c:\temp\MyTest.txt"

// Delete the file if it exists.
if File.Exists path then
    File.Delete path

//Create the file.
do
    use fs = File.Create path

    addText fs "This is some text"
    addText fs "This is some more text,"
    addText fs "\r\nand this is on a new line"
    addText fs "\r\n\r\nThe following is a subset of characters:\r\n"

    for i = 1 to 119 do
        Convert.ToChar i
        |> string
        |> addText fs
    
do
    //Open the stream and read it back.
    use fs = File.OpenRead path
    let b = Array.zeroCreate 1024
    let temp = UTF8Encoding true
    let mutable readLen = fs.Read(b,0,b.Length);
    while readLen> 0 do
        printfn $"{temp.GetString(b,0,readLen)}"
        readLen <- fs.Read(b,0,b.Length)

Imports System.IO
Imports System.Text

Public Class Test

    Public Shared Sub Main()
        Dim path As String = "c:\temp\MyTest.txt"

        ' Delete the file if it exists.
        If File.Exists(path) Then
            File.Delete(path)
        End If

        'Create the file.
        Dim fs As FileStream = File.Create(path)

        AddText(fs, "This is some text")
        AddText(fs, "This is some more text,")
        AddText(fs, Environment.NewLine & "and this is on a new line")
        AddText(fs, Environment.NewLine & Environment.NewLine)
        AddText(fs, "The following is a subset of characters:" & Environment.NewLine)

        Dim i As Integer

        For i = 1 To 120
            AddText(fs, Convert.ToChar(i).ToString())

        Next

        fs.Close()

        'Open the stream and read it back.
        fs = File.OpenRead(path)
        Dim b(1023) As Byte
        Dim temp As UTF8Encoding = New UTF8Encoding(True)

        Do While fs.Read(b, 0, b.Length) > 0
            Console.WriteLine(temp.GetString(b))
        Loop

        fs.Close()
    End Sub

    Private Shared Sub AddText(ByVal fs As FileStream, ByVal value As String)
        Dim info As Byte() = New UTF8Encoding(True).GetBytes(value)
        fs.Write(info, 0, info.Length)
    End Sub
End Class

L’exemple suivant montre comment écrire dans un fichier de manière asynchrone. Ce code s’exécute dans une application WPF qui a un TextBlock nommé UserInput et un bouton connecté à un gestionnaire d’événements Click nommé Button_Click. Le chemin d’accès au fichier doit être remplacé par un fichier qui existe sur l’ordinateur.

using System;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.IO;

namespace WpfApplication1
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            UnicodeEncoding uniencoding = new UnicodeEncoding();
            string filename = @"c:\Users\exampleuser\Documents\userinputlog.txt";

            byte[] result = uniencoding.GetBytes(UserInput.Text);

            using (FileStream SourceStream = File.Open(filename, FileMode.OpenOrCreate))
            {
                SourceStream.Seek(0, SeekOrigin.End);
                await SourceStream.WriteAsync(result, 0, result.Length);
            }
        }
    }
}

Imports System.IO
Imports System.Text

Class MainWindow
    Private Async Sub Button_Click(sender As Object, e As RoutedEventArgs)
        Dim uniencoding As UnicodeEncoding = New UnicodeEncoding()
        Dim filename As String = "c:\Users\exampleuser\Documents\userinputlog.txt"

        Dim result As Byte() = uniencoding.GetBytes(UserInput.Text)

        Using SourceStream As FileStream = File.Open(filename, FileMode.OpenOrCreate)
            SourceStream.Seek(0, SeekOrigin.End)
            Await SourceStream.WriteAsync(result, 0, result.Length)
        End Using
    End Sub
End Class

Remarques

Utilisez la FileStream classe pour lire, écrire dans, ouvrir et fermer des fichiers sur un système de fichiers, et pour manipuler d’autres handles de système d’exploitation liés aux fichiers, notamment les canaux, l’entrée standard et la sortie standard. Vous pouvez utiliser les Readméthodes , Write, CopyToet Flush pour effectuer des opérations synchrones, ou les ReadAsyncméthodes , WriteAsync, CopyToAsyncet FlushAsync pour effectuer des opérations asynchrones. Utilisez les méthodes asynchrones pour effectuer des opérations de fichier gourmandes en ressources sans bloquer le thread principal. Cette considération en matière de performances est particulièrement importante dans une application store Windows 8.x ou une application de bureau où une opération de flux chronophage peut bloquer le thread d’interface utilisateur et faire apparaître votre application comme si elle ne fonctionnait pas. FileStream met en mémoire tampon l’entrée et la sortie pour de meilleures performances.

Important

Ce type implémente l'interface IDisposable. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try/catch. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.

La IsAsync propriété détecte si le handle de fichier a été ouvert de manière asynchrone. Vous spécifiez cette valeur lorsque vous créez une instance de la classe à l’aide FileStream d’un constructeur qui a un isAsyncparamètre , useAsyncou options . Lorsque la propriété a la valeur true, le flux utilise les E/S qui se chevauchent pour effectuer des opérations de fichier de façon asynchrone. Toutefois, la IsAsync propriété n’a pas besoin d’être true pour appeler la ReadAsyncméthode , WriteAsyncou CopyToAsync . Lorsque la IsAsync propriété est false et que vous appelez les opérations de lecture et d’écriture asynchrones, le thread d’interface utilisateur n’est toujours pas bloqué, mais l’opération d’E/S réelle est effectuée de manière synchrone.

La Seek méthode prend en charge l’accès aléatoire aux fichiers. Seek permet de déplacer la position de lecture/écriture vers n’importe quelle position dans le fichier. Cela est effectué avec des paramètres de point de référence de décalage d’octets. Le décalage d’octet est relatif au point de référence de recherche, qui peut être le début, la position actuelle ou la fin du fichier sous-jacent, comme représenté par les trois membres de l’énumération SeekOrigin .

Notes

Les fichiers disque prennent toujours en charge l’accès aléatoire. Au moment de la construction, la valeur de la CanSeek propriété est définie true sur ou false en fonction du type de fichier sous-jacent. Si le type de fichier sous-jacent est FILE_TYPE_DISK, comme défini dans winbase.h, la valeur de la CanSeek propriété est true. Sinon, la valeur de la CanSeek propriété est false.

Si un processus se termine avec une partie d’un fichier verrouillé ou ferme un fichier qui a des verrous en suspens, le comportement n’est pas défini.

Pour les opérations de répertoire et d’autres opérations de fichier, consultez les Fileclasses , Directoryet Path . La File classe est une classe utilitaire qui a des méthodes statiques principalement pour la création d’objets en fonction des chemins d’accès FileStream aux fichiers. La MemoryStream classe crée un flux à partir d’un tableau d’octets et est similaire à la FileStream classe .

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

Détection des modifications de position du flux

Lorsqu’un FileStream objet n’a pas de conservation exclusive sur son handle, un autre thread peut accéder simultanément au handle de fichier et modifier la position du pointeur de fichier du système d’exploitation associé au handle de fichier. Dans ce cas, la position mise en cache dans l’objet FileStream et les données mises en cache dans la mémoire tampon peuvent être compromises. L’objet FileStream effectue régulièrement des vérifications sur les méthodes qui accèdent à la mémoire tampon mise en cache pour s’assurer que la position de handle du système d’exploitation est identique à la position mise en cache utilisée par l’objet FileStream .

Si une modification inattendue de la position du handle est détectée dans un appel à la Read méthode, le .NET Framework abandonne le contenu de la mémoire tampon et lit à nouveau le flux à partir du fichier. Cela peut affecter les performances, en fonction de la taille du fichier et des autres processus susceptibles d’affecter la position du flux de fichiers.

Si une modification inattendue de la position du handle est détectée dans un appel à la Write méthode, le contenu de la mémoire tampon est ignoré et une IOException exception est levée.

Un FileStream objet n’a pas de conservation exclusive sur son handle lorsque la SafeFileHandle propriété est accessible pour exposer le handle ou lorsque l’objet FileStream reçoit la SafeFileHandle propriété dans son constructeur.

Constructeurs

FileStream(IntPtr, FileAccess)	Obsolète. Obsolète. Obsolète. Obsolète. Initialise une nouvelle instance de la classe FileStream pour le handle de fichier spécifié, avec l'autorisation d'accès en lecture/écriture spécifiée.
FileStream(IntPtr, FileAccess, Boolean)	Obsolète. Obsolète. Obsolète. Obsolète. Initialise une nouvelle instance de la classe FileStream pour le handle de fichier spécifié, avec l'autorisation d'accès en lecture/écriture et la propriété d'instance `FileStream` spécifiées.
FileStream(IntPtr, FileAccess, Boolean, Int32)	Obsolète. Obsolète. Obsolète. Obsolète. Initialise une nouvelle instance de la classe FileStream pour le handle de fichier spécifié, avec l'autorisation d'accès en lecture/écriture, la propriété de l'instance `FileStream` et la taille de mémoire tampon spécifiées.
FileStream(IntPtr, FileAccess, Boolean, Int32, Boolean)	Obsolète. Obsolète. Obsolète. Obsolète. Initialise une nouvelle instance de la classe FileStream pour le handle de fichier spécifié, avec l'autorisation d'accès en lecture/écriture, la propriété de l'instance `FileStream`, la taille de mémoire tampon et l'état synchrone ou asynchrone spécifiés.
FileStream(SafeFileHandle, FileAccess)	Initialise une nouvelle instance de la classe FileStream pour le handle de fichier spécifié, avec l'autorisation d'accès en lecture/écriture spécifiée.
FileStream(SafeFileHandle, FileAccess, Int32)	Initialise une nouvelle instance de la classe FileStream pour le handle de fichier spécifié, avec l'autorisation d'accès en lecture/écriture et la taille de mémoire tampon spécifiées.
FileStream(SafeFileHandle, FileAccess, Int32, Boolean)	Initialise une nouvelle instance de la classe FileStream pour le handle de fichier spécifié, avec l'autorisation d'accès en lecture/écriture, la taille de mémoire tampon et l'état synchrone ou asynchrone spécifiés.
FileStream(String, FileMode)	Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès et le mode de création spécifiés.
FileStream(String, FileMode, FileAccess)	Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès, le mode de création et les autorisations de lecture/écriture spécifiés.
FileStream(String, FileMode, FileAccess, FileShare)	Initialise une nouvelle instance de la classe FileStream avec le chemin d’accès, le mode de création, l’autorisation de lecture/écriture et l’autorisation de partage spécifiés.
FileStream(String, FileMode, FileAccess, FileShare, Int32)	Initialise une nouvelle instance de la classe FileStream avec le chemin d’accès, le mode de création, l’autorisation de lecture/écriture, l’autorisation de partage et la taille de mémoire tampon spécifiés.
FileStream(String, FileMode, FileAccess, FileShare, Int32, Boolean)	Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès, le mode de création, l'autorisation de lecture/écriture, l'autorisation de partage, la taille de mémoire tampon et l'état synchrone ou asynchrone spécifiés.
FileStream(String, FileMode, FileAccess, FileShare, Int32, FileOptions)	Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès, le mode de création, l'autorisation d'accès en lecture/écriture et de partage, l'accès que d'autres flux de fichiers peuvent avoir au même fichier, la taille de mémoire tampon et les options de fichiers supplémentaires spécifiés.
FileStream(String, FileMode, FileSystemRights, FileShare, Int32, FileOptions)	Initialise une nouvelle instance de la classe FileStream avec le chemin d’accès, le mode de création, l’autorisation de droits d’accès, l’autorisation de partage, la taille de mémoire tampon et les options de fichiers supplémentaires spécifiés.
FileStream(String, FileMode, FileSystemRights, FileShare, Int32, FileOptions, FileSecurity)	Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès, le mode de création, l'autorisation de droits d'accès, l'autorisation de partage, la taille de mémoire tampon, les options de fichiers supplémentaires et la sécurité de contrôle d'accès et d'audit spécifiés.
FileStream(String, FileStreamOptions)	Initialise une nouvelle instance de la classe avec le chemin d’accès, le FileStream mode de création, l’autorisation de lecture/écriture et de partage, la taille de la mémoire tampon, les options de fichier supplémentaires, la taille de préallocation et l’accès d’autres FileStreams au même fichier.

Propriétés

CanRead	Obtient une valeur qui indique si le flux en cours prend en charge la lecture.
CanSeek	Obtient une valeur qui indique si le flux en cours prend en charge la recherche.
CanTimeout	Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente. (Hérité de Stream)
CanWrite	Obtient une valeur qui indique si le flux en cours prend en charge l'écriture.
Handle	Obsolète. Obsolète. Obsolète. Obsolète. Obtient le handle de fichier du système d'exploitation que l'objet `FileStream` actuel encapsule.
IsAsync	Obtient une valeur qui indique si `FileStream` a été ouvert en mode asynchrone ou synchrone.
Length	Obtient la longueur du flux en octets.
Name	Obtient le chemin absolu du fichier ouvert dans `FileStream`.
Position	Obtient ou définit la position actuelle de ce flux.
ReadTimeout	Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’effectuer la lecture avant dépassement du délai d’attente. (Hérité de Stream)
SafeFileHandle	Obtient un objet SafeFileHandle qui représente le handle de fichier du système d'exploitation pour le fichier encapsulé par l'objet FileStream actuel.
WriteTimeout	Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’écrire des données avant l’expiration du délai d’attente. (Hérité de Stream)

Méthodes

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Débute une opération de lecture asynchrone. Utilisez ReadAsync(Byte[], Int32, Int32, CancellationToken) à la place.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Débute une opération de lecture asynchrone. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Débute une opération d'écriture asynchrone. Utilisez WriteAsync(Byte[], Int32, Int32, CancellationToken) à la place.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Débute une opération d'écriture asynchrone. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
Close()	Ferme le flux actuel et libère toutes les ressources (comme les sockets et les handles de fichiers) associées à celui-ci.
Close()	Ferme le flux actuel et libère toutes les ressources (comme les sockets et les handles de fichiers) associées à celui-ci. Au lieu d'appeler cette méthode, assurez-vous que le flux est correctement supprimé. (Hérité de Stream)
CopyTo(Stream)	Lit les octets du flux actuel et les écrit dans un autre flux. Les positions des deux flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyTo(Stream, Int32)	Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. Les positions des deux flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream)	Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. Les positions des deux flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream, CancellationToken)	Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant un jeton d’annulation spécifié. Les positions des deux flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream, Int32)	Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. Les positions des deux flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lit de façon asynchrone les octets du flux de fichier actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et un jeton d’annulation spécifiés.
CopyToAsync(Stream, Int32, CancellationToken)	Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. Les positions des deux flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CreateObjRef(Type)	Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject)
CreateWaitHandle()	Obsolète. Obsolète. Obsolète. Alloue un objet WaitHandle. (Hérité de Stream)
Dispose()	Libère toutes les ressources utilisées par Stream. (Hérité de Stream)
Dispose(Boolean)	Libère les ressources non managées utilisées par FileStream et libère éventuellement les ressources managées.
DisposeAsync()	Libère de façon asynchrone les ressources non managées utilisées par FileStream.
DisposeAsync()	Libère de façon asynchrone les ressources non managées utilisées par Stream. (Hérité de Stream)
EndRead(IAsyncResult)	Attend que l'opération de lecture asynchrone en attente se termine. (Utilisez ReadAsync(Byte[], Int32, Int32, CancellationToken) à la place.)
EndRead(IAsyncResult)	Attend que la requête asynchrone en attente se termine. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
EndWrite(IAsyncResult)	Termine une opération d'écriture asynchrone et se bloque jusqu'à la fin de l'opération d'E/S. (Utilisez WriteAsync(Byte[], Int32, Int32, CancellationToken) à la place.)
EndWrite(IAsyncResult)	Termine une opération d'écriture asynchrone. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
Finalize()	Vérifie que les ressources sont libérées et que toute autre opération de nettoyage est effectuée quand le garbage collector récupère l'élément `FileStream`.
Flush()	Efface les mémoires tampons pour ce flux et provoque l'écriture dans le fichier des données mises en mémoire tampon.
Flush(Boolean)	Efface les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon dans le fichier et efface également toutes les mémoires tampons de fichiers intermédiaires.
FlushAsync()	Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. (Hérité de Stream)
FlushAsync(CancellationToken)	Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les requêtes d'annulation.
FlushAsync(CancellationToken)	Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les requêtes d'annulation. (Hérité de Stream)
GetAccessControl()	Obtient un objet FileSecurity qui encapsule les entrées de la liste de contrôle d'accès (ACL) pour le fichier décrit par l'objet FileStream actuel.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	Obsolète. Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
InitializeLifetimeService()	Obsolète. Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
Lock(Int64, Int64)	Empêche d'autres processus de lire ou d'écrire dans l'élément FileStream.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
ObjectInvariant()	Obsolète. Assure la prise en charge d'un Contract. (Hérité de Stream)
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(Span<Byte>)	En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. (Hérité de Stream)
ReadAsync(Byte[], Int32, Int32)	Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. (Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon asynchrone une séquence d’octets dans le flux de fichier actuel, les écrit dans un tableau d’octets en commençant à un décalage spécifié, avance la position dans le flux de fichier du nombre d’octets lus et supervise les demandes d’annulation.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. (Hérité de Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Lit de façon asynchrone une séquence d’octets dans le flux de fichier actuel, les écrit dans une zone de mémoire, avance la position dans le flux de fichier du nombre d’octets lus et supervise les demandes d’annulation.
ReadAsync(Memory<Byte>, CancellationToken)	Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. (Hérité de Stream)
ReadAtLeast(Span<Byte>, Int32, Boolean)	Lit au moins un nombre minimal d’octets à partir du flux actuel et avance la position dans le flux par le nombre d’octets lus. (Hérité de Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Lit de manière asynchrone au moins un nombre minimal d’octets à partir du flux actuel, avance la position dans le flux en fonction du nombre d’octets lus et surveille les demandes d’annulation. (Hérité de Stream)
ReadByte()	Lit un octet du fichier et avance la position de lecture d'un octet.
ReadExactly(Byte[], Int32, Int32)	Lit le nombre d’octets `count` du flux actuel et avance la position dans le flux. (Hérité de Stream)
ReadExactly(Span<Byte>)	Lit les octets du flux actuel et avance la position dans le flux jusqu’à ce que soit `buffer` rempli. (Hérité de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Lit de manière asynchrone le nombre d’octets `count` du flux actuel, avance la position dans le flux et surveille les demandes d’annulation. (Hérité de Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Lit de manière asynchrone les octets du flux actuel, avance la position dans le flux jusqu’à ce que le `buffer` soit rempli et surveille les demandes d’annulation. (Hérité de Stream)
Seek(Int64, SeekOrigin)	Définit la position actuelle de ce flux avec la valeur donnée.
SetAccessControl(FileSecurity)	Applique les entrées ACL décrites par un objet FileSecurity au fichier décrit par l'objet FileStream actuel.
SetLength(Int64)	Définit la longueur de ce flux à la valeur donnée.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
Unlock(Int64, Int64)	Permet l'accès par d'autres processus à tout ou partie d'un fichier préalablement verrouillé.
Write(Byte[], Int32, Int32)	Écrit un bloc d'octets dans le flux de fichier.
Write(ReadOnlySpan<Byte>)	Écrit une séquence d’octets depuis une plage en lecture seule dans le flux de fichier actuel et avance la position actuelle dans ce flux de fichier du nombre d’octets écrits.
Write(ReadOnlySpan<Byte>)	En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits. (Hérité de Stream)
WriteAsync(Byte[], Int32, Int32)	Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits. (Hérité de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. (Hérité de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Écrit de façon asynchrone une séquence d’octets depuis une zone de mémoire dans le flux de fichier actuel, avance la position actuelle dans ce flux de fichier du nombre d’octets écrits et supervise les demandes d’annulation.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. (Hérité de Stream)
WriteByte(Byte)	Écrit un octet à la position actuelle dans le flux de fichier.

Implémentations d’interfaces explicites

IDisposable.Dispose()

Libère toutes les ressources utilisées par Stream.

(Hérité de Stream)

Méthodes d’extension

GetAccessControl(FileStream)	Retourne les informations de sécurité d’un fichier.
SetAccessControl(FileStream, FileSecurity)	Change les attributs de sécurité d’un fichier existant.
AsInputStream(Stream)	Convertit un flux managé dans .NET pour les applications du Windows Store en un flux d’entrée Windows Runtime.
AsOutputStream(Stream)	Convertit un flux managé dans .NET pour les applications du Windows Store en un flux de sortie Windows Runtime.
AsRandomAccessStream(Stream)	Convertit le flux spécifié en flux d'accès aléatoire.
ConfigureAwait(IAsyncDisposable, Boolean)	Configure la façon dont les attentes sur les tâches retournées à partir d’un élément supprimable asynchrone sont effectuées.

S’applique à