Stream Classe

Définition

Espace de noms:

System.IO

Assembly:

System.Runtime.dll

Source:

Stream.cs

Fournit une vue générique d’une séquence d’octets. Il s’agit d’une classe abstraite.

public ref class Stream abstract : MarshalByRefObject, IAsyncDisposable, IDisposable

public abstract class Stream : MarshalByRefObject, IAsyncDisposable, IDisposable

type Stream = class
    inherit MarshalByRefObject
    interface IAsyncDisposable
    interface IDisposable

Public MustInherit Class Stream
Inherits MarshalByRefObject
Implements IAsyncDisposable, IDisposable

Héritage

Object

MarshalByRefObject

Stream

Dérivé

Microsoft.JScript.COMCharStream

System.Data.OracleClient.OracleBFile

System.Data.OracleClient.OracleLob

System.Data.SqlTypes.SqlFileStream

System.IO.BufferedStream

System.IO.Compression.BrotliStream

System.IO.Compression.DeflateStream

System.IO.Compression.GZipStream

System.IO.Compression.ZLibStream

System.IO.FileStream

System.IO.MemoryStream

System.IO.Pipes.PipeStream

System.IO.UnmanagedMemoryStream

System.Net.Quic.QuicStream

System.Net.Security.AuthenticatedStream

System.Net.Sockets.NetworkStream

System.Printing.PrintQueueStream

System.Security.Cryptography.CryptoStream

System.ServiceModel.Channels.BufferedReadStream

System.ServiceModel.Channels.DelegatingStream

Implémente

IDisposable IAsyncDisposable

Exemples

L’exemple suivant montre comment utiliser deux objets FileStream pour copier de manière asynchrone les fichiers d’un répertoire vers un autre répertoire. La classe FileStream dérive de la classe Stream. Notez que le gestionnaire d’événements Click pour le contrôle Button est marqué avec le modificateur async, car il appelle une méthode asynchrone.

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

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

        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            string StartDirectory = @"c:\Users\exampleuser\start";
            string EndDirectory = @"c:\Users\exampleuser\end";

            foreach (string filename in Directory.EnumerateFiles(StartDirectory))
            {
                using (FileStream SourceStream = File.Open(filename, FileMode.Open))
                {
                    using (FileStream DestinationStream = File.Create(EndDirectory + filename.Substring(filename.LastIndexOf('\\'))))
                    {
                        await SourceStream.CopyToAsync(DestinationStream);
                    }
                }
            }
        }
    }
}

Imports System.IO

Class MainWindow

    Private Async Sub Button_Click(sender As Object, e As RoutedEventArgs)
        Dim StartDirectory As String = "c:\Users\exampleuser\start"
        Dim EndDirectory As String = "c:\Users\exampleuser\end"

        For Each filename As String In Directory.EnumerateFiles(StartDirectory)
            Using SourceStream As FileStream = File.Open(filename, FileMode.Open)
                Using DestinationStream As FileStream = File.Create(EndDirectory + filename.Substring(filename.LastIndexOf("\"c)))
                    Await SourceStream.CopyToAsync(DestinationStream)
                End Using

            End Using
        Next
    End Sub

End Class

Remarques

Stream est la classe de base abstraite de tous les flux. Un flux est une abstraction d’une séquence d’octets, comme un fichier, un périphérique d’entrée/sortie, un canal de communication interprocessus ou un socket TCP/IP. La classe Stream et ses classes dérivées fournissent une vue générique de ces différents types d’entrée et de sortie, et isolent le programmeur des détails spécifiques du système d’exploitation et des appareils sous-jacents.

Les flux impliquent trois opérations fondamentales :

• Vous pouvez lire à partir de flux. La lecture est le transfert de données d’un flux dans une structure de données, telle qu’un tableau d’octets.

• Vous pouvez écrire dans des flux. L’écriture est le transfert de données d’une structure de données dans un flux.

• Les flux peuvent prendre en charge la recherche. La recherche fait référence à l’interrogation et à la modification de la position actuelle dans un flux. La fonctionnalité de recherche dépend du type de magasin de stockage dont dispose un flux. Par exemple, les flux réseau n’ont pas de concept unifié de position actuelle et, par conséquent, ne prennent pas en charge la recherche.

Certains des flux les plus couramment utilisés qui héritent de Stream sont FileStream, et MemoryStream.

En fonction de la source de données ou du référentiel sous-jacent, les flux peuvent prendre en charge uniquement certaines de ces fonctionnalités. Vous pouvez interroger un flux pour ses fonctionnalités à l’aide des propriétés CanRead, CanWriteet CanSeek de la classe Stream.

Les méthodes Read et Write lisent et écrivent des données dans différents formats. Pour les flux qui prennent en charge la recherche, utilisez les méthodes Seek et SetLength ainsi que les propriétés Position et Length pour interroger et modifier la position et la longueur actuelles d’un flux.

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 le type directement, appelez sa méthode Dispose dans un bloc try/catch. Pour le 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 de l’interface IDisposable.

La suppression d’un objet Stream vide toutes les données mises en mémoire tampon et appelle essentiellement la méthode Flush pour vous. Dispose libère également des ressources de système d’exploitation telles que des handles de fichiers, des connexions réseau ou de la mémoire utilisée pour toute mise en mémoire tampon interne. La classe BufferedStream offre la possibilité d’encapsuler un flux mis en mémoire tampon autour d’un autre flux afin d’améliorer les performances de lecture et d’écriture.

À compter de .NET Framework 4.5, la classe Stream inclut des méthodes asynchrones pour simplifier les opérations asynchrones. Une méthode asynchrone contient des Async dans son nom, telles que ReadAsync, WriteAsync, CopyToAsyncet FlushAsync. Ces méthodes vous permettent d’effectuer des opérations d’E/S gourmandes en ressources sans bloquer le thread principal. Cette considération en matière de performances est particulièrement importante dans une application Windows 8.x Store ou une application de bureau où une opération de flux de temps peut bloquer le thread d’interface utilisateur et faire apparaître votre application comme si elle ne fonctionne pas. Les méthodes asynchrones sont utilisées conjointement avec les mots clés async et await dans Visual Basic et C#.

Lorsqu’il est utilisé dans une application Windows 8.x Store, Stream inclut deux méthodes d’extension : AsInputStream et AsOutputStream. Ces méthodes convertissent un objet Stream en flux dans Windows Runtime. Vous pouvez également convertir un flux dans Windows Runtime en objet Stream à l’aide des méthodes AsStreamForRead et AsStreamForWrite. Pour plus d’informations, consultez How to : Convert Between .NET Framework Streams and Windows Runtime Streams

Certaines implémentations de flux effectuent une mise en mémoire tampon locale des données sous-jacentes pour améliorer les performances. Pour ces flux, vous pouvez utiliser la méthode Flush ou FlushAsync pour effacer les mémoires tampons internes et vous assurer que toutes les données ont été écrites dans la source de données ou le référentiel sous-jacent.

Si vous avez besoin d’un flux sans magasin de stockage (également appelé compartiment de bits), utilisez le champ Null pour récupérer une instance d’un flux conçu à cet effet.

Notes pour les responsables de l’implémentation

Lorsque vous implémentez une classe dérivée de Stream, vous devez fournir des implémentations pour les méthodes Read(Byte[], Int32, Int32) et Write(Byte[], Int32, Int32). Les méthodes asynchrones ReadAsync(Byte[], Int32, Int32), WriteAsync(Byte[], Int32, Int32)et CopyToAsync(Stream) utiliser les méthodes synchrones Read(Byte[], Int32, Int32) et Write(Byte[], Int32, Int32) dans leurs implémentations. Par conséquent, vos implémentations de Read(Byte[], Int32, Int32) et de Write(Byte[], Int32, Int32) fonctionnent correctement avec les méthodes asynchrones. Les implémentations par défaut de ReadByte() et de WriteByte(Byte) créent un tableau d’octets à élément unique, puis appellent vos implémentations de Read(Byte[], Int32, Int32) et de Write(Byte[], Int32, Int32). Lorsque vous dérivez de Stream, nous vous recommandons de remplacer ces méthodes pour accéder à votre mémoire tampon interne, si vous en avez un, pour améliorer considérablement les performances. Vous devez également fournir des implémentations de CanRead, CanSeek, CanWrite, Flush(), Length, Position, Seek(Int64, SeekOrigin)et SetLength(Int64).

Ne remplacez pas la méthode Close(), à la place, placez toutes les Stream logique de nettoyage dans la méthode Dispose(Boolean). Pour plus d’informations, consultez Implémentation d’une méthode Dispose.

Constructeurs

Stream()

Initialise une nouvelle instance de la classe Stream.

Champs

Null	Un Stream sans magasin de stockage.

Propriétés

CanRead	En cas de substitution dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la lecture.
CanSeek	En cas de substitution dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la recherche.
CanTimeout	Obtient une valeur qui détermine si le flux actuel peut expirer.
CanWrite	En cas de substitution dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge l’écriture.
Length	En cas de substitution dans une classe dérivée, obtient la longueur en octets du flux.
Position	En cas de substitution dans une classe dérivée, obtient ou définit la position dans le flux actuel.
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.
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.

Méthodes

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération de lecture asynchrone. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32) à la place.)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32) à 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é.
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.
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.
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.
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.
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.
CopyToAsync(Stream, Int32, CancellationToken)	Lit de manière asynchrone les octets du flux 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. Les deux positions de flux sont avancées par le nombre d’octets copiés.
CreateObjRef(Type)	Crée un objet qui contient toutes les informations pertinentes requises pour générer un proxy utilisé pour communiquer avec un objet distant. (Hérité de MarshalByRefObject)
CreateWaitHandle()	Obsolète. Alloue un objet WaitHandle.
Dispose()	Libère toutes les ressources utilisées par le Stream.
Dispose(Boolean)	Libère les ressources non managées utilisées par le Stream et libère éventuellement les ressources managées.
DisposeAsync()	Libère de façon asynchrone les ressources non managées utilisées par le Stream.
EndRead(IAsyncResult)	Attend la fin de la lecture asynchrone en attente. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32) à la place.)
EndWrite(IAsyncResult)	Termine une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32) à la place.)
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
Flush()	En cas de substitution dans une classe dérivée, efface 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.
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.
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 sur l’appareil sous-jacent 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)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l’objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
ObjectInvariant()	Obsolète. Fournit la prise en charge d’un Contract.
Read(Byte[], Int32, Int32)	En cas de substitution dans une classe dérivée, lit une séquence d’octets à partir du flux actuel et avance la position dans le flux par le nombre d’octets lus.
Read(Span<Byte>)	En cas de substitution dans une classe dérivée, lit une séquence d’octets à partir du flux actuel et avance la position dans le flux par le nombre d’octets lus.
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.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon asynchrone une séquence 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.
ReadAsync(Memory<Byte>, CancellationToken)	Lit de façon asynchrone une séquence 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.
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.
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.
ReadByte()	Lit un octet à partir du flux et avance la position dans le flux d’un octet, ou retourne -1 si à la fin du flux.
ReadExactly(Byte[], Int32, Int32)	Lit count nombre d’octets du flux actuel et avance la position dans le flux.
ReadExactly(Span<Byte>)	Lit les octets du flux actuel et avance la position dans le flux jusqu’à ce que le buffer soit rempli.
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon asynchrone count nombre d’octets du flux actuel, avance la position dans le flux et surveille les demandes d’annulation.
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.
Seek(Int64, SeekOrigin)	En cas de substitution dans une classe dérivée, définit la position dans le flux actuel.
SetLength(Int64)	En cas de substitution dans une classe dérivée, définit la longueur du flux actuel.
Synchronized(Stream)	Crée un wrapper thread-safe (synchronisé) autour de l’objet Stream spécifié.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
ValidateBufferArguments(Byte[], Int32, Int32)	Valide les arguments fournis pour lire et écrire des méthodes sur Stream.
ValidateCopyToArguments(Stream, Int32)	Valide les arguments fournis aux méthodes CopyTo(Stream, Int32) ou CopyToAsync(Stream, Int32, CancellationToken).
Write(Byte[], Int32, Int32)	En cas de substitution dans une classe dérivée, écrit une séquence d’octets dans le flux actuel et avance la position actuelle dans ce flux par le nombre d’octets écrits.
Write(ReadOnlySpan<Byte>)	En cas de substitution dans une classe dérivée, écrit une séquence d’octets dans le flux actuel et avance la position actuelle dans ce flux par le nombre d’octets écrits.
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.
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(ReadOnlyMemory<Byte>, 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.
WriteByte(Byte)	Écrit un octet à la position actuelle dans le flux et avance la position dans le flux d’un octet.

Méthodes d’extension

CopyToAsync(Stream, PipeWriter, CancellationToken)	Lit de manière asynchrone les octets de l'Stream et les écrit dans le PipeWriterspécifié, à l’aide d’un jeton d’annulation.
ConfigureAwait(IAsyncDisposable, Boolean)	Configure la façon dont les attentes sur les tâches retournées à partir d’un jetable asynchrone sont effectuées.

Voir aussi

• FileStream
• MemoryStream
• BufferedStream
• fichier et flux d’E/S
• Comment : convertir entre des flux .NET Framework et des flux Windows Runtime