Stream Classe

Définition

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

public ref class Stream abstract : IDisposable
public ref class Stream abstract : MarshalByRefObject, IAsyncDisposable, IDisposable
public ref class Stream abstract : MarshalByRefObject, IDisposable
public abstract class Stream : IDisposable
public abstract class Stream : MarshalByRefObject, IAsyncDisposable, IDisposable
public abstract class Stream : MarshalByRefObject, IDisposable
[System.Serializable]
public abstract class Stream : MarshalByRefObject, IDisposable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Stream : MarshalByRefObject, IDisposable
type Stream = class
    interface IDisposable
type Stream = class
    inherit MarshalByRefObject
    interface IAsyncDisposable
    interface IDisposable
type Stream = class
    inherit MarshalByRefObject
    interface IDisposable
[<System.Serializable>]
type Stream = class
    inherit MarshalByRefObject
    interface IDisposable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Stream = class
    inherit MarshalByRefObject
    interface IDisposable
Public MustInherit Class Stream
Implements IDisposable
Public MustInherit Class Stream
Inherits MarshalByRefObject
Implements IAsyncDisposable, IDisposable
Public MustInherit Class Stream
Inherits MarshalByRefObject
Implements IDisposable
Héritage
Stream
Héritage
Dérivé
Attributs
Implémente

Exemples

L’exemple suivant montre comment utiliser deux FileStream objets pour copier de façon 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 appareil d'entrée/sortie, un canal de communication inter-processus 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 héritent sont Stream FileStream, et MemoryStream.

Selon la source de données ou le 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 CanReadCanWritepropriétés , et CanSeek des propriétés de la Stream classe.

Les méthodes et Write les Read 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 méthodes et Length les Position propriétés 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 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 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 de .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, , WriteAsyncCopyToAsyncet 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 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 fonctionnait pas. Les méthodes asynchrones sont utilisées conjointement avec les mots clés et await Visual async 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 le Windows Runtime. Vous pouvez également convertir un flux dans le Windows Runtime en objet Stream à l’aide des méthodes et AsStreamForWrite des AsStreamForRead méthodes. 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 ou Flush FlushAsync méthode pour effacer toutes 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 Read(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) correctement avec les méthodes asynchrones. Implémentations par défaut d’un ReadByte() WriteByte(Byte) tableau d’octets à un seul élément, puis appelez vos implémentations et Write(Byte[], Int32, Int32)Read(Byte[], Int32, Int32) . Lorsque vous dérivez de , nous vous recommandons de Streamremplacer ces méthodes pour accéder à votre mémoire tampon interne, si vous en avez une, pour améliorer considérablement les performances. Vous devez également fournir des implémentations de CanRead, , CanSeek, CanWrite, LengthFlush(), , Position, Seek(Int64, SeekOrigin)et SetLength(Int64).

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

Constructeurs

Stream()

Initialise une nouvelle instance de la classe Stream.

Champs

Null

Élément Stream sans magasin de stockage.

Propriétés

CanRead

En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la lecture.

CanSeek

En cas de remplacement 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 dépasser le délai d'attente.

CanWrite

En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge l'écriture.

Length

En cas de remplacement dans une classe dérivée, obtient la longueur du flux en octets.

Position

En cas de remplacement dans une classe dérivée, obtient ou définit la position dans le flux actuel.

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.

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.

Méthodes

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération de lecture asynchrone. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération d'écriture asynchrone. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.)

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é.

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 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 deux positions de flux sont avancées par le nombre d’octets copiés.

CopyToAsync(Stream)

Lit de façon asynchrone tous 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 façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant 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 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 deux positions de flux sont avancées par le nombre d’octets copié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 deux positions de flux sont avancées par le nombre d’octets copiés.

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.

Dispose()

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

Dispose(Boolean)

Libère les ressources non managées utilisées par Stream et libère éventuellement les ressources managées.

DisposeAsync()

Libère de façon asynchrone les ressources non managées utilisées par Stream.

EndRead(IAsyncResult)

Attend que la requête asynchrone en attente se termine. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)

EndWrite(IAsyncResult)

Termine une opération d'écriture asynchrone. (Utilisez 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 remplacement dans une classe dérivée, efface toutes les mémoires tampons pour ce flux et provoque l'écriture de toutes les données se trouvant dans des mémoires tampons sur l'appareil sous-jacent.

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.

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.

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)
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.

Read(Byte[], Int32, Int32)

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.

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.

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.

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.

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.

ReadAtLeast(Span<Byte>, Int32, Boolean)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)
ReadByte()

Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte.

ReadExactly(Byte[], Int32, Int32)
ReadExactly(Span<Byte>)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)
ReadExactlyAsync(Memory<Byte>, CancellationToken)
Seek(Int64, SeekOrigin)

En cas de remplacement 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 de 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 ou CopyToAsync(Stream, Int32, CancellationToken) aux CopyTo(Stream, Int32) méthodes.

Write(Byte[], Int32, Int32)

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.

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.

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.

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(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.

WriteByte(Byte)

Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux.

Implémentations d’interfaces explicites

IDisposable.Dispose()

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

Méthodes d’extension

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 à

Voir aussi