Stream Classe

Définition

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

Object

Stream

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

Plus…

Attributs

SerializableAttribute ComVisibleAttribute

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

Champs

Propriétés

Méthodes

Implémentations d’interfaces explicites

Méthodes d’extension

S’applique à

Voir aussi

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