MemoryStream Classe

Définition

Espace de noms:: System.IO

Assemblys:: mscorlib.dll, System.IO.dll

Assembly:: mscorlib.dll

Assembly:: System.IO.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Crée un flux dont le magasin de stockage est la mémoire.

public ref class MemoryStream : System::IO::Stream

public class MemoryStream : System.IO.Stream

[System.Serializable]
public class MemoryStream : System.IO.Stream

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class MemoryStream : System.IO.Stream

type MemoryStream = class
    inherit Stream

[<System.Serializable>]
type MemoryStream = class
    inherit Stream

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type MemoryStream = class
    inherit Stream

Public Class MemoryStream
Inherits Stream

Héritage: Object

Stream
MemoryStream

Héritage: Object

MarshalByRefObject

Stream
MemoryStream

Attributs: SerializableAttribute ComVisibleAttribute

Exemples

L’exemple de code suivant montre comment lire et écrire des données à l’aide de la mémoire en tant que magasin de stockage.

using System;
using System.IO;
using System.Text;

class MemStream
{
    static void Main()
    {
        int count;
        byte[] byteArray;
        char[] charArray;
        UnicodeEncoding uniEncoding = new UnicodeEncoding();

        // Create the data to write to the stream.
        byte[] firstString = uniEncoding.GetBytes(
            "Invalid file path characters are: ");
        byte[] secondString = uniEncoding.GetBytes(
            Path.GetInvalidPathChars());

        using(MemoryStream memStream = new MemoryStream(100))
        {
            // Write the first string to the stream.
            memStream.Write(firstString, 0 , firstString.Length);

            // Write the second string to the stream, byte by byte.
            count = 0;
            while(count < secondString.Length)
            {
                memStream.WriteByte(secondString[count++]);
            }

            // Write the stream properties to the console.
            Console.WriteLine(
                "Capacity = {0}, Length = {1}, Position = {2}\n",
                memStream.Capacity.ToString(),
                memStream.Length.ToString(),
                memStream.Position.ToString());

            // Set the position to the beginning of the stream.
            memStream.Seek(0, SeekOrigin.Begin);

            // Read the first 20 bytes from the stream.
            byteArray = new byte[memStream.Length];
            count = memStream.Read(byteArray, 0, 20);

            // Read the remaining bytes, byte by byte.
            while(count < memStream.Length)
            {
                byteArray[count++] = (byte)memStream.ReadByte();
            }

            // Decode the byte array into a char array
            // and write it to the console.
            charArray = new char[uniEncoding.GetCharCount(
                byteArray, 0, count)];
            uniEncoding.GetDecoder().GetChars(
                byteArray, 0, count, charArray, 0);
            Console.WriteLine(charArray);
        }
    }
}

Imports System.IO
Imports System.Text

Module MemStream

    Sub Main()
    
        Dim count As Integer
        Dim byteArray As Byte()
        Dim charArray As Char()
        Dim uniEncoding As New UnicodeEncoding()

        ' Create the data to write to the stream.
        Dim firstString As Byte() = _
            uniEncoding.GetBytes("Invalid file path characters are: ")
        Dim secondString As Byte() = _
            uniEncoding.GetBytes(Path.GetInvalidPathChars())

        Dim memStream As New MemoryStream(100)
        Try
            ' Write the first string to the stream.
            memStream.Write(firstString, 0 , firstString.Length)

            ' Write the second string to the stream, byte by byte.
            count = 0
            While(count < secondString.Length)
                memStream.WriteByte(secondString(count))
                count += 1
            End While
            
            ' Write the stream properties to the console.
            Console.WriteLine( _
                "Capacity = {0}, Length = {1}, Position = {2}", _
                memStream.Capacity.ToString(), _
                memStream.Length.ToString(), _
                memStream.Position.ToString())

            ' Set the stream position to the beginning of the stream.
            memStream.Seek(0, SeekOrigin.Begin)

            ' Read the first 20 bytes from the stream.
            byteArray = _
                New Byte(CType(memStream.Length, Integer)){}
            count = memStream.Read(byteArray, 0, 20)

            ' Read the remaining Bytes, Byte by Byte.
            While(count < memStream.Length)
                byteArray(count) = _
                    Convert.ToByte(memStream.ReadByte())
                count += 1
            End While

            ' Decode the Byte array into a Char array 
            ' and write it to the console.
            charArray = _
                New Char(uniEncoding.GetCharCount( _
                byteArray, 0, count)){}
            uniEncoding.GetDecoder().GetChars( _
                byteArray, 0, count, charArray, 0)
            Console.WriteLine(charArray)
        Finally
            memStream.Close()
        End Try

    End Sub
End Module

Remarques

La position actuelle d’un flux est la position à laquelle l’opération de lecture ou d’écriture suivante peut avoir lieu. La position actuelle peut être récupérée ou définie par le biais de la Seek méthode. Lorsqu’une nouvelle instance est MemoryStream créée, la position actuelle est définie sur zéro.

Note

Ce type implémente l’interface IDisposable , mais n’a pas réellement de ressources à supprimer. Cela signifie que la suppression directe en appelant directement Dispose() ou en utilisant une construction de langage telle que using (en C#) ou Using (dans Visual Basic) n’est pas nécessaire.

Les flux de mémoire créés avec un tableau d’octets non signés fournissent un flux non redimensionnable des données. Lorsque vous utilisez un tableau d’octets, vous ne pouvez ni ajouter ni réduire le flux, bien que vous puissiez modifier le contenu existant en fonction des paramètres passés dans le constructeur. Les flux de mémoire vides sont redimensionnables et peuvent être écrits dans et lus.

Si un MemoryStream objet est ajouté à un fichier ResX ou à un fichier .resources, appelez la méthode au moment de l’exécution GetStream pour le récupérer.

Si un MemoryStream objet est sérialisé dans un fichier de ressources, il est en fait sérialisé en tant que UnmanagedMemoryStream. Ce comportement offre de meilleures performances, ainsi que la possibilité d’obtenir un pointeur vers les données directement, sans avoir à passer par Stream des méthodes.

Constructeurs

Nom	Description
MemoryStream()	Initialise une nouvelle instance de la MemoryStream classe avec une capacité extensible initialisée à zéro.
MemoryStream(Byte[], Boolean)	Initialise une nouvelle instance non resizable de la MemoryStream classe en fonction du tableau d’octets spécifié avec la CanWrite propriété définie comme spécifié.
MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)	Initialise une nouvelle instance de la MemoryStream classe en fonction de la région spécifiée d’un tableau d’octets, avec la CanWrite propriété définie comme spécifié et la possibilité d’appeler GetBuffer() le jeu comme spécifié.
MemoryStream(Byte[], Int32, Int32, Boolean)	Initialise une nouvelle instance non resizable de la classe en fonction de la MemoryStream région spécifiée d’un tableau d’octets, avec la CanWrite propriété définie comme spécifié.
MemoryStream(Byte[], Int32, Int32)	Initialise une nouvelle instance non redimensionnable de la classe en fonction de la MemoryStream région (index) spécifiée d’un tableau d’octets.
MemoryStream(Byte[])	Initialise une nouvelle instance non resizable de la MemoryStream classe en fonction du tableau d’octets spécifié.
MemoryStream(Int32)	Initialise une nouvelle instance de la MemoryStream classe avec une capacité extensible initialisée comme spécifié.

Propriétés

Nom	Description
CanRead	Obtient une valeur indiquant si le flux actuel prend en charge la lecture.
CanSeek	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. (Hérité de Stream)
CanWrite	Obtient une valeur indiquant si le flux actuel prend en charge l’écriture.
Capacity	Obtient ou définit le nombre d’octets alloués pour ce flux.
Length	Obtient la longueur du flux en octets.
Position	Obtient ou définit la position actuelle dans le flux.
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. (Hérité de Stream)
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. (Hérité de Stream)

Méthodes

Nom	Description
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération de lecture asynchrone. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32, CancellationToken) à la place.)
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération de lecture asynchrone. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32, CancellationToken) à la place.)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
Close()	Ferme le flux pour la lecture et l’écriture.
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é. (Hérité de Stream)
CopyTo(Stream, Int32)	Lit les octets du flux de mémoire actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon spécifiée.
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. (Hérité de Stream)
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. (Hérité de Stream)
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. (Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lit de manière asynchrone tous 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.
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. (Hérité de Stream)
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. (Hérité de Stream)
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. (Hérité de Stream)
CreateObjRef(Type)	Crée un objet qui contient toutes les informations pertinentes requises pour générer un proxy utilisé pour communiquer avec un objet distant. (Hérité de MarshalByRefObject)
CreateWaitHandle()	Obsolète. Alloue un WaitHandle objet. (Hérité de Stream)
Dispose()	Libère toutes les ressources utilisées par le Stream. (Hérité de Stream)
Dispose(Boolean)	Libère les ressources non managées utilisées par la MemoryStream classe 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. (Hérité de Stream)
EndRead(IAsyncResult)	Attend la fin de la lecture asynchrone en attente. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32, CancellationToken) à la place.)
EndRead(IAsyncResult)	Attend la fin de la lecture asynchrone en attente. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
EndWrite(IAsyncResult)	Termine une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32, CancellationToken) à la place.)
EndWrite(IAsyncResult)	Termine une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
Flush()	Remplace la Flush() méthode afin qu’aucune action n’est effectuée.
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. (Hérité de Stream)
FlushAsync(CancellationToken)	Efface de façon asynchrone toutes les mémoires tampons pour ce flux et surveille les demandes d’annulation.
GetBuffer()	Retourne le tableau d’octets non signés à partir duquel ce flux a été créé.
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	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()	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()	Cette API prend en charge l'infrastructure du produit et n'est pas destinée à être utilisée directement à partir de votre code. Fournit la prise en charge d’un Contract.
ObjectInvariant()	Obsolète. Fournit la prise en charge d’un Contract. (Hérité de Stream)
Read(Byte[], Int32, Int32)	Lit un bloc d’octets du flux actuel et écrit les données dans une mémoire tampon.
Read(Span<Byte>)	Lit une séquence d’octets à partir du flux de mémoire actuel et avance la position dans le flux de mémoire 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. (Hérité de Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Lit de façon asynchrone une séquence d’octets à partir du flux de mémoire actuel, écrit la séquence dans `destination`, avance la position dans le flux de mémoire par le nombre d’octets lus et surveille les demandes d’annulation.
ReadByte()	Lit un octet à partir du flux actuel.
Seek(Int64, SeekOrigin)	Définit la position dans le flux actuel sur la valeur spécifiée.
SetLength(Int64)	Définit la longueur du flux actuel sur la valeur spécifiée.
ToArray()	Écrit le contenu du flux dans un tableau d’octets, quelle que soit la Position propriété.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
TryGetBuffer(ArraySegment<Byte>)	Retourne le tableau d’octets non signés à partir duquel ce flux a été créé. La valeur de retour indique si la conversion a réussi.
Write(Byte[], Int32, Int32)	Écrit un bloc d’octets dans le flux actuel à l’aide de données lues à partir d’une mémoire tampon.
Write(ReadOnlySpan<Byte>)	Écrit la séquence d’octets contenue dans `source` le flux de mémoire actuel et avance la position actuelle dans ce flux de mémoire 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. (Hérité de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Écrit de façon asynchrone la séquence d’octets contenue dans `source` le flux de mémoire actuel, avance la position actuelle dans ce flux de mémoire en fonction du nombre d’octets écrits et surveille les demandes d’annulation.
WriteByte(Byte)	Écrit un octet dans le flux actuel à la position actuelle.
WriteTo(Stream)	Écrit tout le contenu de ce flux de mémoire dans un autre flux.

Implémentations d’interfaces explicites

Nom	Description
IDisposable.Dispose()	Libère toutes les ressources utilisées par le Stream. (Hérité de Stream)

Méthodes d’extension

Nom	Description
AsInputStream(Stream)	Convertit un flux managé dans .NET pour les applications du Windows Store en flux d’entrée dans Windows Runtime.
AsOutputStream(Stream)	Convertit un flux managé dans .NET pour les applications du Windows Store en flux de sortie dans 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 jetable asynchrone sont effectuées.
GetWindowsRuntimeBuffer(MemoryStream, Int32, Int32)	Retourne un Windows. Interface Storage.Streams.IBuffer qui représente une région dans la mémoire que le flux de mémoire spécifié représente.
GetWindowsRuntimeBuffer(MemoryStream)	Retourne un Windows. Interface Storage.Streams.IBuffer qui représente la même mémoire que le flux de mémoire spécifié.

S’applique à

Voir aussi

Commentaires

Cette page a-t-elle été utile ?