Stream Classe

Définition

Espace de noms:

System.IO

Assemblys:

netstandard.dll, 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.Extensions.AI.HostedFileDownloadStream

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.Compression.ZstandardStream

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.Net.WebSockets.WebSocketStream

System.Printing.PrintQueueStream

System.Security.Cryptography.CryptoStream

Implémente

IDisposable IAsyncDisposable

Exemples

L’exemple suivant montre comment utiliser deux FileStream objets pour copier de manière asynchrone les fichiers d’un répertoire vers un autre répertoire. La FileStream classe dérive de la Stream classe. Notez que le Click gestionnaire d’événements du Button contrôle est marqué avec le async modificateur, 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 Stream classe 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 Stream héritent 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 , CanWriteet CanSeek des CanReadpropriétés de la Stream classe.

Les Read méthodes et Write les méthodes lisent et écrivent des données dans différents formats. Pour les flux qui prennent en charge la recherche, utilisez les Seek méthodes et SetLength les propriétés et les PositionLength méthodes 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 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 suppression d’un Stream objet vide toutes les données mises en mémoire tampon et appelle essentiellement la Flush méthode pour vous. Dispose libère également les ressources du système d’exploitation telles que les handles de fichiers, les connexions réseau ou la mémoire utilisée pour toute mise en mémoire tampon interne. La BufferedStream classe 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 du .NET Framework 4.5, la Stream classe inclut des méthodes asynchrones pour simplifier les opérations asynchrones. Une méthode asynchrone contient Async son nom, tel que ReadAsync, WriteAsync, CopyToAsync, et 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 async mots clés et await Visual Basic et C#.

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

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 ou FlushAsync la Flush méthode 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 Null champ 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 et Write(Byte[], Int32, Int32) les Read(Byte[], Int32, Int32) méthodes. Les méthodes ReadAsync(Byte[], Int32, Int32)asynchrones, WriteAsync(Byte[], Int32, Int32)et CopyToAsync(Stream) utilisent les méthodes Read(Byte[], Int32, Int32) synchrones et Write(Byte[], Int32, Int32) dans leurs implémentations. Par conséquent, vos implémentations fonctionnent Write(Byte[], Int32, Int32) correctement avec les méthodes asynchronesRead(Byte[], Int32, Int32). Implémentations par défaut de et WriteByte(Byte) création d’un ReadByte() tableau d’octets à élément unique, puis appelez vos implémentations de Read(Byte[], Int32, Int32) et Write(Byte[], Int32, Int32). Lorsque vous dérivez Streamde , 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, , CanWriteCanSeek, Flush(), Length, Position, , Seek(Int64, SeekOrigin)et SetLength(Int64).

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

Constructeurs

Nom	Description
Stream()	Initialise une nouvelle instance de la classe Stream.

Champs

Nom	Description
Null	Un Stream magasin de stockage sans stockage.

Propriétés

Nom	Description
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

Nom	Description
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, 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.
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, 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.
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)	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.
CreateWaitHandle()	Obsolète. Alloue un WaitHandle objet.
Dispose()	Libère toutes les ressources utilisées par le Stream.
Dispose(Boolean)	Libère les ressources non managées utilisées par les Stream 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 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 actuel MarshalByRefObject . (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, 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(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(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 le nombre d’octets count 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 flux soit rempli.
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.
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.
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 spécifié Stream .
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 ou CopyToAsync(Stream, Int32, CancellationToken) aux CopyTo(Stream, Int32) méthodes.
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, 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.
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

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.

Voir aussi

• FileStream
• MemoryStream
• BufferedStream
• E/S de fichier et de flux
• Guide pratique pour convertir des flux .NET Framework et des flux Windows Runtime