Stream Stream Stream Stream Class

Définition

Fournit une vue générique d'une séquence d'octets.Provides a generic view of a sequence of bytes. Il s’agit d’une classe abstraite.This is an abstract class.

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

Exemples

L’exemple suivant montre comment utiliser deux FileStream objets à copier de façon asynchrone les fichiers d’un répertoire vers un autre répertoire.The following example demonstrates how to use two FileStream objects to asynchronously copy the files from one directory to another directory. La classe FileStream dérive de la classe Stream .The FileStream class derives from the Stream class. 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.Notice that the Click event handler for the Button control is marked with the async modifier because it calls an asynchronous method.

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.Stream is the abstract base class of all streams. 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.A stream is an abstraction of a sequence of bytes, such as a file, an input/output device, an inter-process communication pipe, or a TCP/IP socket. Le Stream classe et ses classes dérivées donnent une vue générique de ces différents types d’entrée et de sortie et isolant ainsi le programmeur des détails spécifiques du système d’exploitation et aux périphériques sous-jacents.The Stream class and its derived classes provide a generic view of these different types of input and output, and isolate the programmer from the specific details of the operating system and the underlying devices.

Les flux impliquent trois opérations fondamentales :Streams involve three fundamental operations:

  • Vous pouvez lire à partir de flux.You can read from streams. Lecture est le transfert de données à partir d’un flux de données dans une structure de données, tel qu’un tableau d’octets.Reading is the transfer of data from a stream into a data structure, such as an array of bytes.

  • Vous pouvez écrire dans le flux de données.You can write to streams. L’écriture est le transfert de données à partir d’une structure de données dans un flux.Writing is the transfer of data from a data structure into a stream.

  • Flux de données peut prendre en charge la recherche.Streams can support seeking. Recherche fait référence à l’interrogation et modification de la position actuelle dans un flux de données.Seeking refers to querying and modifying the current position within a stream. Seek fonctionnalité varie selon le type de magasin de stockage a un flux de données.Seek capability depends on the kind of backing store a stream has. Par exemple, les flux de réseau n’ont aucun concept unifié d’une position actuelle et par conséquent généralement ne gèrent pas recherche.For example, network streams have no unified concept of a current position, and therefore typically do not support seeking.

Certains des plus couramment utilisés les flux qui héritent de Stream sont FileStream, et MemoryStream.Some of the more commonly used streams that inherit from Stream are FileStream, and MemoryStream.

Selon la source de données sous-jacente ou le référentiel, flux de données peut prendre en charge uniquement certaines de ces fonctionnalités.Depending on the underlying data source or repository, streams might support only some of these capabilities. Vous pouvez interroger un flux de données pour ses fonctionnalités en utilisant le CanRead, CanWrite, et CanSeek propriétés de la Stream classe.You can query a stream for its capabilities by using the CanRead, CanWrite, and CanSeek properties of the Stream class.

Le Read et Write méthodes lire et écrire des données dans une variété de formats.The Read and Write methods read and write data in a variety of formats. Pour les flux qui prennent en charge la recherche, utilisez le Seek et SetLength méthodes et les Position et Length propriétés pour interroger et modifier la position actuelle et la longueur d’un flux.For streams that support seeking, use the Seek and SetLength methods and the Position and Length properties to query and modify the current position and length of a stream.

Ce type implémente le IDisposable interface.This type implements the IDisposable interface. Lorsque vous avez fini d’utiliser le type, vous devez supprimer il directement ou indirectement.When you have finished using the type, you should dispose of it either directly or indirectly. Pour supprimer le type directement, appelez sa Dispose méthode dans un try / catch bloc.To dispose of the type directly, call its Dispose method in a try/catch block. Pour supprimer indirectement, utiliser une construction de langage tel que using (en c#) ou Using (en Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Pour plus d’informations, consultez la section « À l’aide un objet qui implémente IDisposable » dans le IDisposable rubrique de l’interface.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Suppression un Stream objet vide toutes les données mises en mémoire tampon et appelle essentiellement le Flush méthode pour vous.Disposing a Stream object flushes any buffered data, and essentially calls the Flush method for you. Dispose libère également les ressources de système d’exploitation telles que les descripteurs de fichiers, les connexions réseau ou la mémoire utilisée pour toute mise en mémoire tampon interne.Dispose also releases operating system resources such as file handles, network connections, or memory used for any internal buffering. Le BufferedStream classe offre la possibilité d’encapsuler un flux mis en mémoire tampon autour d’un autre flux afin d’améliorer en lecture et d’écriture des performances.The BufferedStream class provides the capability of wrapping a buffered stream around another stream in order to improve read and write performance.

En commençant par le .NET Framework 4.5.NET Framework 4.5, la Stream classe inclut des méthodes async pour simplifier les opérations asynchrones.Starting with the .NET Framework 4.5.NET Framework 4.5, the Stream class includes async methods to simplify asynchronous operations. Contient une méthode async Async dans son nom, tel que ReadAsync, WriteAsync, CopyToAsync, et FlushAsync.An async method contains Async in its name, such as ReadAsync, WriteAsync, CopyToAsync, and FlushAsync. Ces méthodes permettent d’effectuer des opérations d’e/s gourmandes en ressources sans bloquer le thread principal.These methods enable you to perform resource-intensive I/O operations without blocking the main thread. Cette considération de performance est particulièrement importante dans une application Windows 8.x StoreWindows 8.x Store ou une application Bureaudesktop 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.This performance consideration is particularly important in a Windows 8.x StoreWindows 8.x Store app or Bureaudesktop app where a time-consuming stream operation can block the UI thread and make your app appear as if it is not working. Les méthodes asynchrones sont utilisées conjointement avec la async et await mots clés dans Visual Basic et c#.The async methods are used in conjunction with the async and await keywords in Visual Basic and C#.

Lorsqu’il est utilisé dans un Windows 8.x StoreWindows 8.x Store app, Stream inclut deux méthodes d’extension : AsInputStream et AsOutputStream.When used in a Windows 8.x StoreWindows 8.x Store app, Stream includes two extension methods: AsInputStream and AsOutputStream. Ces méthodes convertissent un Stream objet dans un flux dans le Windows RuntimeWindows Runtime.These methods convert a Stream object to a stream in the Windows RuntimeWindows Runtime. Vous pouvez également convertir un flux de données dans le Windows RuntimeWindows Runtime à un Stream objet à l’aide de la AsStreamForRead et AsStreamForWrite méthodes.You can also convert a stream in the Windows RuntimeWindows Runtime to a Stream object by using the AsStreamForRead and AsStreamForWrite methods. Pour plus d'informations, voir Procédure : effectuer une conversion entre les flux du .NET Framework et les flux Windows RuntimeFor more information, see How to: Convert Between .NET Framework Streams and Windows Runtime Streams

Certaines implémentations de flux effectuent la mise en mémoire tampon locale des données sous-jacentes pour améliorer les performances.Some stream implementations perform local buffering of the underlying data to improve performance. Pour ces flux, vous pouvez utiliser la Flush ou FlushAsync méthode pour effacer les mémoires tampons internes et de s’assurer que toutes les données a été écrites dans la source de données sous-jacente ou le référentiel.For such streams, you can use the Flush or FlushAsync method to clear any internal buffers and ensure that all data has been written to the underlying data source or repository.

Si vous avez besoin d’un flux sans magasin de stockage (également appelé un « bit bucket »), utilisez le Null champ à extraire une instance de flux de données qui est conçu à cet effet.If you need a stream with no backing store (also known as a bit bucket), use the Null field to retrieve an instance of a stream that is designed for this purpose.

Notes pour les héritiers

Lorsque vous implémentez une classe dérivée de Stream, vous devez fournir des implémentations pour les Read(Byte[], Int32, Int32) et Write(Byte[], Int32, Int32) méthodes.When you implement a derived class of Stream, you must provide implementations for the Read(Byte[], Int32, Int32) and Write(Byte[], Int32, Int32) methods. Les méthodes asynchrones ReadAsync(Byte[], Int32, Int32), WriteAsync(Byte[], Int32, Int32), et CopyToAsync(Stream) utilisent les méthodes synchrones Read(Byte[], Int32, Int32) et Write(Byte[], Int32, Int32) dans leurs implémentations.The asynchronous methods ReadAsync(Byte[], Int32, Int32), WriteAsync(Byte[], Int32, Int32), and CopyToAsync(Stream) use the synchronous methods Read(Byte[], Int32, Int32) and Write(Byte[], Int32, Int32) in their implementations. Par conséquent, vos implémentations de Read(Byte[], Int32, Int32) et Write(Byte[], Int32, Int32) ne fonctionnera correctement avec les méthodes asynchrones.Therefore, your implementations of Read(Byte[], Int32, Int32) and Write(Byte[], Int32, Int32) will work correctly with the asynchronous methods. Les implémentations par défaut de ReadByte() et WriteByte(Byte) créer un tableau d’octets à élément unique, puis appelez vos implémentations de Read(Byte[], Int32, Int32) et Write(Byte[], Int32, Int32).The default implementations of ReadByte() and WriteByte(Byte) create a new single-element byte array, and then call your implementations of Read(Byte[], Int32, Int32) and Write(Byte[], Int32, Int32). Lorsque vous dérivez de Stream, nous vous recommandons de substituer ces méthodes pour accéder à votre mémoire tampon interne, si vous en avez pas, pour améliorer les performances.When you derive from Stream, we recommend that you override these methods to access your internal buffer, if you have one, for substantially better performance. Vous devez également fournir des implémentations de CanRead, CanSeek, CanWrite, Flush(), Length, Position, Seek(Int64, SeekOrigin), et SetLength(Int64).You must also provide implementations of CanRead, CanSeek, CanWrite, Flush(), Length, Position, Seek(Int64, SeekOrigin), and SetLength(Int64).

Ne remplacent pas le Close() (méthode), place tous les Stream logique de nettoyage dans le Dispose(Boolean) (méthode).Do not override the Close() method, instead, put all the Stream cleanup logic in the Dispose(Boolean) method. Pour plus d’informations, consultez implémentation d’une méthode Dispose.For more information, see Implementing a Dispose Method.

Constructeurs

Stream() Stream() Stream() Stream()

Initialise une nouvelle instance de la classe Stream.Initializes a new instance of the Stream class.

Champs

Null Null Null Null

Élément Stream sans magasin de stockage.A Stream with no backing store.

Propriétés

CanRead CanRead CanRead CanRead

En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la lecture.When overridden in a derived class, gets a value indicating whether the current stream supports reading.

CanSeek CanSeek CanSeek CanSeek

En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la recherche.When overridden in a derived class, gets a value indicating whether the current stream supports seeking.

CanTimeout CanTimeout CanTimeout CanTimeout

Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente.Gets a value that determines whether the current stream can time out.

CanWrite CanWrite CanWrite CanWrite

En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge l'écriture.When overridden in a derived class, gets a value indicating whether the current stream supports writing.

Length Length Length Length

En cas de remplacement dans une classe dérivée, obtient la longueur du flux en octets.When overridden in a derived class, gets the length in bytes of the stream.

Position Position Position Position

En cas de remplacement dans une classe dérivée, obtient ou définit la position dans le flux actuel.When overridden in a derived class, gets or sets the position within the current stream.

ReadTimeout ReadTimeout ReadTimeout 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'arriver à expiration.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to read before timing out.

WriteTimeout WriteTimeout WriteTimeout WriteTimeout

Obtient ou définit une valeur exprimée en millisecondes qui définit la durée pendant laquelle le flux tentera d'inscrire des données avant d'arriver à expiration.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to write before timing out.

Méthodes

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

Débute une opération de lecture asynchrone.Begins an asynchronous read operation. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

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

Débute une opération d'écriture asynchrone.Begins an asynchronous write operation. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

Close() Close() Close() Close()

Ferme le flux actuel et libère toutes les ressources (comme les sockets et les handles de fichiers) associées à celui-ci.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Au lieu d'appeler cette méthode, assurez-vous que le flux est correctement supprimé.Instead of calling this method, ensure that the stream is properly disposed.

CopyTo(Stream) CopyTo(Stream) CopyTo(Stream) CopyTo(Stream)

Lit les octets du flux actuel et les écrit dans un autre flux.Reads the bytes from the current stream and writes them to another stream.

CopyTo(Stream, Int32) CopyTo(Stream, Int32) CopyTo(Stream, Int32) 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.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

CopyToAsync(Stream) CopyToAsync(Stream) CopyToAsync(Stream) CopyToAsync(Stream)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux.Asynchronously reads the bytes from the current stream and writes them to another stream.

CopyToAsync(Stream, CancellationToken) CopyToAsync(Stream, CancellationToken) CopyToAsync(Stream, CancellationToken) 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é.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

CopyToAsync(Stream, Int32) CopyToAsync(Stream, Int32) CopyToAsync(Stream, Int32) 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.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

CopyToAsync(Stream, Int32, CancellationToken) CopyToAsync(Stream, Int32, CancellationToken) CopyToAsync(Stream, Int32, CancellationToken) 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.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) 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.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
CreateWaitHandle() CreateWaitHandle() CreateWaitHandle() CreateWaitHandle()

Alloue un objet WaitHandle.Allocates a WaitHandle object.

Dispose() Dispose() Dispose() Dispose()

Libère toutes les ressources utilisées par Stream.Releases all resources used by the Stream.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Libère les ressources non managées utilisées par Stream et libère éventuellement les ressources managées.Releases the unmanaged resources used by the Stream and optionally releases the managed resources.

DisposeAsync() DisposeAsync() DisposeAsync() DisposeAsync()

Libère de façon asynchrone les ressources non managées utilisées par Stream.Asynchronously releases the unmanaged resources used by the Stream.

EndRead(IAsyncResult) EndRead(IAsyncResult) EndRead(IAsyncResult) EndRead(IAsyncResult)

Attend que la requête asynchrone en attente se termine.Waits for the pending asynchronous read to complete. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

EndWrite(IAsyncResult) EndWrite(IAsyncResult) EndWrite(IAsyncResult) EndWrite(IAsyncResult)

Termine une opération d'écriture asynchrone.Ends an asynchronous write operation. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Flush() Flush() Flush() 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.When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device.

FlushAsync() FlushAsync() FlushAsync() 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.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

FlushAsync(CancellationToken) FlushAsync(CancellationToken) FlushAsync(CancellationToken) 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.Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

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.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
ObjectInvariant() ObjectInvariant() ObjectInvariant() ObjectInvariant()

Assure la prise en charge d'un Contract.Provides support for a Contract.

Read(Byte[], Int32, Int32) Read(Byte[], Int32, Int32) Read(Byte[], Int32, Int32) 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.When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

Read(Span<Byte>) Read(Span<Byte>) Read(Span<Byte>) 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.When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

ReadAsync(Byte[], Int32, Int32) ReadAsync(Byte[], Int32, Int32) ReadAsync(Byte[], Int32, Int32) 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.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

ReadAsync(Byte[], Int32, Int32, CancellationToken) ReadAsync(Byte[], Int32, Int32, CancellationToken) ReadAsync(Byte[], Int32, Int32, CancellationToken) 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.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) 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.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

ReadByte() ReadByte() ReadByte() 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.Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin)

En cas de remplacement dans une classe dérivée, définit la position dans le flux actuel.When overridden in a derived class, sets the position within the current stream.

SetLength(Int64) SetLength(Int64) SetLength(Int64) SetLength(Int64)

En cas de substitution dans une classe dérivée, définit la longueur de flux actuel.When overridden in a derived class, sets the length of the current stream.

Synchronized(Stream) Synchronized(Stream) Synchronized(Stream) Synchronized(Stream)

Crée un wrapper thread-safe (synchronisé) autour de l’objet Stream spécifié.Creates a thread-safe (synchronized) wrapper around the specified Stream object.

ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)
Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) 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.When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) 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.When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

WriteAsync(Byte[], Int32, Int32) WriteAsync(Byte[], Int32, Int32) WriteAsync(Byte[], Int32, Int32) 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.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

WriteAsync(Byte[], Int32, Int32, CancellationToken) WriteAsync(Byte[], Int32, Int32, CancellationToken) WriteAsync(Byte[], Int32, Int32, CancellationToken) 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.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) 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.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

WriteByte(Byte) WriteByte(Byte) WriteByte(Byte) WriteByte(Byte)

Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

Implémentations d’interfaces explicites

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Libère toutes les ressources utilisées par Stream.Releases all resources used by the Stream.

Méthodes d’extension

AsInputStream(Stream) AsInputStream(Stream) AsInputStream(Stream) AsInputStream(Stream)

Convertit un flux managé dans .NET pour les applications du Windows Store en un flux d’entrée Windows Runtime.Converts a managed stream in the .NET for Windows Store apps to an input stream in the Windows Runtime.

AsOutputStream(Stream) AsOutputStream(Stream) AsOutputStream(Stream) AsOutputStream(Stream)

Convertit un flux managé dans .NET pour les applications du Windows Store en un flux de sortie Windows Runtime.Converts a managed stream in the .NET for Windows Store apps to an output stream in the Windows Runtime.

AsRandomAccessStream(Stream) AsRandomAccessStream(Stream) AsRandomAccessStream(Stream) AsRandomAccessStream(Stream)

Convertit le flux spécifié en flux d'accès aléatoire.Converts the specified stream to a random access stream.

S’applique à

Voir aussi