FileStream Classe

Définition

Espace de noms:

System.IO

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

FileStream.cs

Fournit un Stream fichier prenant en charge les opérations de lecture et d’écriture synchrones et asynchrones.

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

public class FileStream : System.IO.Stream

type FileStream = class
    inherit Stream

Public Class FileStream
Inherits Stream

Héritage

Object

MarshalByRefObject

Stream

FileStream

Dérivé

System.IO.IsolatedStorage.IsolatedStorageFileStream

Exemples

L’exemple suivant illustre certains constructeurs FileStream .

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, ouvrir et fermer des fichiers sur un système de fichiers et manipuler d’autres handles de système d’exploitation liés aux fichiers, notamment les canaux, les entrées standard et la sortie standard. Vous pouvez utiliser les méthodes Read, Write, CopyTo et Flush pour effectuer des opérations synchrones, ou les méthodes ReadAsync, WriteAsync, CopyToAsync et 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 de bureau où une opération de flux fastidieuse peut bloquer le thread d’interface utilisateur et faire apparaître votre application comme si elle ne fonctionne pas. FileStream met en mémoire tampon les entrées et sorties 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, appelez sa Dispose méthode dans un try/catch bloc. Pour la supprimer indirectement, utilisez une construction de langage telle que using (en C#) ou Using (en Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet implémentant IDisposable » dans la rubrique d’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 d’un constructeur FileStream qui a un isAsync, useAsync, ou options un paramètre. Lorsque la propriété est true, le flux utilise des E/S superposées pour effectuer des opérations de fichier de manière asynchrone. Toutefois, il n'est pas nécessaire que la IsAsync propriété soit true pour appeler les méthodes ReadAsync, WriteAsync ou 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 en lecture/écriture vers n’importe quelle position dans le fichier. Cette opération s’effectue avec les paramètres de point de référence de décalage d’octet. 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 .

Note

Les fichiers de disque prennent toujours en charge l’accès aléatoire. Au moment de la construction, la valeur de la propriété CanSeek est définie sur true ou false selon le type de fichier sous-jacent. Si le type de fichier sous-jacent est FILE_TYPE_DISK, tel que 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 par une partie d’un fichier verrouillé ou ferme un fichier qui a des verrous en attente, le comportement n’est pas défini.

Pour les opérations de répertoire et d'autres opérations de fichier, consultez les classes File, Directory et Path. La File classe est une classe utilitaire qui a des méthodes statiques principalement pour la création d’objets basés sur des chemins de FileStream fichier. 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 d’E/S courantes.

Détection des modifications de position de flux

Lorsqu’un FileStream objet ne possède pas exclusivement son descripteur, un autre thread peut accéder au descripteur de fichier de manière concurrente et modifier la position du pointeur du fichier du système d’exploitation associée 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 de handle est détectée dans un appel à la Read méthode, .NET ignore 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 de la poignée est détectée lors d'un appel à la méthode Write, le contenu de la mémoire tampon est supprimé et une exception IOException est levée.

Un objet FileStream ne possédera pas de descripteur exclusif lorsque la propriété SafeFileHandle est accédée pour exposer le descripteur ou lorsque l'objet FileStream reçoit la propriété SafeFileHandle dans son constructeur.

Constructeurs

Nom	Description
FileStream(IntPtr, FileAccess, Boolean, Int32, Boolean)	Obsolète. Initialise une nouvelle instance de la FileStream classe pour le handle de fichier spécifié, avec l’autorisation de lecture/écriture spécifiée, FileStream la propriété de l’instance, la taille de la mémoire tampon et l’état synchrone ou asynchrone.
FileStream(IntPtr, FileAccess, Boolean, Int32)	Obsolète. Initialise une nouvelle instance de la FileStream classe pour le handle de fichier spécifié, avec l’autorisation de lecture/écriture spécifiée, FileStream la propriété de l’instance et la taille de mémoire tampon spécifiées.
FileStream(IntPtr, FileAccess, Boolean)	Obsolète. Initialise une nouvelle instance de la FileStream classe pour le handle de fichier spécifié, avec l’autorisation de lecture/écriture et FileStream la propriété d’instance spécifiées.
FileStream(IntPtr, FileAccess)	Obsolète. Initialise une nouvelle instance de la FileStream classe pour le handle de fichier spécifié, avec l’autorisation de lecture/écriture spécifiée.
FileStream(SafeFileHandle, FileAccess, Int32, Boolean)	Initialise une nouvelle instance de la FileStream classe pour le handle de fichier spécifié, avec l’autorisation de lecture/écriture spécifiée, la taille de la mémoire tampon et l’état synchrone ou asynchrone.
FileStream(SafeFileHandle, FileAccess, Int32)	Initialise une nouvelle instance de la FileStream classe pour le handle de fichier spécifié, avec l’autorisation de lecture/écriture spécifiée et la taille de mémoire tampon spécifiée.
FileStream(SafeFileHandle, FileAccess)	Initialise une nouvelle instance de la FileStream classe pour le handle de fichier spécifié, avec l’autorisation de lecture/écriture spécifiée.
FileStream(String, FileMode, FileAccess, FileShare, Int32, Boolean)	Initialise une nouvelle instance de la FileStream classe avec le chemin d’accès spécifié, le mode de création, l’autorisation de lecture/écriture et de partage, la taille de la mémoire tampon et l’état synchrone ou asynchrone.
FileStream(String, FileMode, FileAccess, FileShare, Int32, FileOptions)	Initialise une nouvelle instance de la FileStream classe avec le chemin d’accès spécifié, le mode de création, l’autorisation de lecture/écriture et de partage, l’accès à d’autres FileStreams peut avoir le même fichier, la taille de la mémoire tampon et d’autres options de fichier.
FileStream(String, FileMode, FileAccess, FileShare, Int32)	Initialise une nouvelle instance de la FileStream classe avec le chemin d’accès, le mode de création, l’autorisation de lecture/écriture et de partage et la taille de mémoire tampon spécifiées.
FileStream(String, FileMode, FileAccess, FileShare)	Initialise une nouvelle instance de la FileStream classe avec le chemin d’accès, le mode de création, l’autorisation de lecture/écriture et l’autorisation de partage spécifiées.
FileStream(String, FileMode, FileAccess)	Initialise une nouvelle instance de la FileStream classe avec le chemin d’accès, le mode de création et l’autorisation de lecture/écriture spécifiés.
FileStream(String, FileMode)	Initialise une nouvelle instance de la FileStream classe avec le chemin d’accès et le mode de création spécifiés.
FileStream(String, FileStreamOptions)	Initialise une nouvelle instance de la FileStream classe avec le chemin d’accès spécifié, le 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 les autres FileStreams d’accès peuvent avoir le même fichier.

Propriétés

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

Méthodes

Nom	Description
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération de lecture asynchrone. Utilisez ReadAsync(Byte[], Int32, Int32, CancellationToken) à la place.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération d’écriture asynchrone. Utilisez WriteAsync(Byte[], Int32, Int32, CancellationToken) à la place.
Close()	Ferme le flux actuel et libère toutes les ressources (telles que les sockets et les handles de fichiers) associées au flux actuel. Au lieu d’appeler cette méthode, vérifiez que le flux est correctement supprimé. (Hérité de Stream)
CopyTo(Stream, Int32)	Lit les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon spécifiée. Les deux positions de flux sont avancées par le nombre d’octets copiés.
CopyTo(Stream)	Lit les octets du flux actuel et les écrit dans un autre flux. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream, CancellationToken)	Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’un jeton d’annulation spécifié. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lit de manière asynchrone les octets du flux de fichiers actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon et d’un jeton d’annulation spécifiés.
CopyToAsync(Stream, Int32)	Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon spécifiée. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream)	Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CreateWaitHandle()	Obsolète. Alloue un WaitHandle objet. (Hérité de Stream)
Dispose()	Libère toutes les ressources utilisées par le Stream. (Hérité de Stream)
Dispose(Boolean)	Libère les ressources non managées utilisées par les FileStream ressources gérées et libère éventuellement les ressources managées.
DisposeAsync()	Libère de façon asynchrone les ressources non managées utilisées par le FileStream.
EndRead(IAsyncResult)	Attend la fin de l’opération de lecture asynchrone en attente. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32, CancellationToken) à la place.)
EndWrite(IAsyncResult)	Termine une opération d’écriture asynchrone et bloque jusqu’à ce que l’opération d’E/S soit terminée. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32, CancellationToken) à la place.)
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
Finalize()	Garantit que les ressources sont libérées et que d’autres opérations de nettoyage sont effectuées lorsque le garbage collector récupère le FileStream.
Flush()	Efface les mémoires tampons pour ce flux et provoque l’écriture de toutes les données mises en mémoire tampon dans le fichier.
Flush(Boolean)	Efface les mémoires tampons pour ce flux et entraîne l’écriture de toutes les données mises en mémoire tampon dans le fichier, et efface également toutes les mémoires tampons de fichier intermédiaires.
FlushAsync()	Efface de façon asynchrone toutes les mémoires tampons de ce flux et entraîne l’écriture de toutes les 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 de ce flux, entraîne l’écriture de toutes les données mises en mémoire tampon dans le fichier et surveille les demandes d’annulation.
GetHashCode()	Sert 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 actuel qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetType()	Obtient la 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 le FileStreamfichier .
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l’objet actuel MarshalByRefObject . (Hérité de MarshalByRefObject)
ObjectInvariant()	Obsolète. Fournit la prise en charge d’un Contract. (Hérité de Stream)
Read(Byte[], Int32, Int32)	Lit un bloc d’octets du flux et écrit les données dans une mémoire tampon donnée.
Read(Span<Byte>)	Lit une séquence d’octets à partir du flux de fichiers actuel et avance la position dans le flux de fichiers en fonction du nombre d’octets lus.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon asynchrone une séquence d’octets du flux de fichiers actuel et les écrit dans un tableau d’octets commençant par un décalage spécifié, avance la position dans le flux de fichiers par le nombre d’octets lus et surveille les demandes d’annulation.
ReadAsync(Byte[], Int32, Int32)	Lit de façon asynchrone une séquence d’octets à partir du flux actuel et avance la position dans le flux en fonction du nombre d’octets lus. (Hérité de Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Lit de façon asynchrone une séquence d’octets à partir du flux de fichiers actuel et les écrit dans une région de mémoire, avance la position dans le flux de fichiers par le nombre d’octets lus et surveille les demandes d’annulation.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Lit au moins un nombre minimal d’octets 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 façon asynchrone au moins un nombre minimal d’octets à partir du flux actuel, avance la position dans le flux par le nombre d’octets lus et surveille les demandes d’annulation. (Hérité de Stream)
ReadByte()	Lit un octet à partir 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 le buffer flux soit rempli. (Hérité de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon 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 façon asynchrone les octets du flux actuel, avance la position dans le flux jusqu’à ce que le buffer flux soit rempli et surveille les demandes d’annulation. (Hérité de Stream)
Seek(Int64, SeekOrigin)	Définit la position actuelle de ce flux sur la valeur donnée.
SetLength(Int64)	Définit la longueur de ce flux sur la valeur donnée.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
Unlock(Int64, Int64)	Autorise l’accès par d’autres processus à tout ou partie d’un fichier précédemment verrouillé.
Write(Byte[], Int32, Int32)	Écrit un bloc d’octets dans le flux de fichiers.
Write(ReadOnlySpan<Byte>)	Écrit une séquence d’octets d’une étendue en lecture seule dans le flux de fichiers actuel et avance la position actuelle dans ce flux de fichiers par le nombre d’octets écrits.
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 par le nombre d’octets écrits et surveille les demandes d’annulation.
WriteAsync(Byte[], Int32, Int32)	Écrit de façon asynchrone une séquence d’octets dans le flux actuel et avance la position actuelle dans ce flux par le nombre d’octets écrits. (Hérité de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Écrit de façon asynchrone une séquence d’octets d’une région mémoire dans le flux de fichiers actuel, avance la position actuelle dans ce flux de fichiers par le nombre d’octets écrits et surveille les demandes d’annulation.
WriteByte(Byte)	Écrit un octet à la position actuelle dans le flux de fichiers.

Méthodes d’extension

Nom	Description
ConfigureAwait(IAsyncDisposable, Boolean)	Configure la façon dont les attentes sur les tâches retournées à partir d’un jetable asynchrone sont effectuées.
CopyToAsync(Stream, PipeWriter, CancellationToken)	Lit de façon asynchrone les octets des Stream octets et les écrit dans le jeton d’annulation spécifié PipeWriter.
GetAccessControl(FileStream)	Retourne les informations de sécurité d’un fichier.
SetAccessControl(FileStream, FileSecurity)	Modifie les attributs de sécurité d’un fichier existant.

Voir aussi

• File
• FileAccess
• FileMode
• FileShare
• E/S de fichier et de flux
• Guide pratique pour lire du texte à partir d’un fichier
• Guide pratique pour écrire du texte dans un fichier
• Guide pratique pour lire et écrire dans un fichier de données nouvellement créé