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 FileStream objets pour copier de manière asynchrone les fichiers d’un répertoire vers un autre. 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 vers 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 vers 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 capacité de recherche dépend du type de magasin de stockage d’un flux. Par exemple, les flux réseau n’ont pas de concept unifié de position actuelle et ne prennent donc généralement pas en charge la recherche.

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

Selon la source de données ou le référentiel sous-jacent, les flux ne peuvent prendre en charge que certaines de ces fonctionnalités. Vous pouvez interroger un flux pour connaître ses fonctionnalités à l’aide des CanReadpropriétés , CanWriteet CanSeek de la Stream classe .

Les Read méthodes et Write 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 et les Position propriétés 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 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 dans son nom, par ReadAsyncexemple , WriteAsync, CopyToAsyncet FlushAsync. Ces méthodes vous permettent d’effectuer des opérations d’E/S gourmandes en ressources sans bloquer le thread main. Cette considération de performance est particulièrement importante dans une application Windows 8.x Store ou une application de bureau où une longue opération de flux peut bloquer le thread d'interface utilisateur et faire que l'application s'affiche comme si elle ne fonctionnait pas. Les méthodes asynchrones sont utilisées conjointement avec les async mots clés et await dans Visual Basic et C#.

En cas d’utilisation 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 AsStreamForRead méthodes et AsStreamForWrite . Pour plus d’informations, consultez Guide pratique pour convertir entre 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 Flush méthode 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 Null champ pour récupérer un 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 Read(Byte[], Int32, Int32) méthodes et Write(Byte[], Int32, Int32) . 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 de Read(Byte[], Int32, Int32) et Write(Byte[], Int32, Int32) fonctionnent correctement avec les méthodes asynchrones. Implémentations par défaut de ReadByte() et WriteByte(Byte) créez un 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 de Stream, nous vous recommandons de remplacer ces méthodes pour accéder à votre mémoire tampon interne, le cas échéant, pour de meilleures performances. Vous devez également fournir des implémentations de CanRead, CanSeek, CanWrite, LengthFlush(), Position, , , et Seek(Int64, SeekOrigin)SetLength(Int64).

Ne remplacez pas la Close() méthode, au lieu de cela, 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

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 de données E/S
• Procédure : convertir entre des flux .NET Framework et des flux Windows Runtime