MemoryStream Classe

Définition

Espace de noms:

System.IO

Assembly:

System.Runtime.dll

Source:

MemoryStream.cs

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

type MemoryStream = class
    inherit Stream

Public Class MemoryStream
Inherits Stream

Héritage

Object

MarshalByRefObject

Stream

MemoryStream

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 namespace System;
using namespace System::IO;
using namespace System::Text;

int main()
{
   int count;
   array<Byte>^byteArray;
   array<Char>^charArray;
   UnicodeEncoding^ uniEncoding = gcnew UnicodeEncoding;

   // Create the data to write to the stream.
   array<Byte>^firstString = uniEncoding->GetBytes( "Invalid file path characters are: " );
   array<Byte>^secondString = uniEncoding->GetBytes( Path::InvalidPathChars );

   MemoryStream^ memStream = gcnew 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++ ] );
      }

      
      // 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 stream position to the beginning of the stream.
      memStream->Seek( 0, SeekOrigin::Begin );

      // Read the first 20 bytes from the stream.
      byteArray = gcnew array<Byte>(memStream->Length);
      count = memStream->Read( byteArray, 0, 20 );

      // Read the remaining bytes, byte by byte.
      while ( count < memStream->Length )
      {
         byteArray[ count++ ] = Convert::ToByte( memStream->ReadByte() );
      }
      
      // Decode the Byte array into a Char array 
      // and write it to the console.
      charArray = gcnew array<Char>(uniEncoding->GetCharCount( byteArray, 0, count ));
      uniEncoding->GetDecoder()->GetChars( byteArray, 0, count, charArray, 0 );
      Console::WriteLine( charArray );
   }
   finally
   {
      memStream->Close();
   }
}

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 méthode Seek. Lorsqu’une nouvelle instance de MemoryStream est 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 (en 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 objet MemoryStream est ajouté à un fichier ResX ou à un fichier .resources, appelez la méthode GetStream au moment de l’exécution pour la récupérer.

Si un objet MemoryStream 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 méthodes.

Constructeurs

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

Propriétés

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

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération de lecture asynchrone. (Envisagez d’utiliser ReadAsync(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, CancellationToken) à la place.)
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)	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)
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.
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)
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)	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, 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.
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 objet WaitHandle. (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 classe MemoryStream 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.)
EndWrite(IAsyncResult)	Termine une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32, CancellationToken) à la place.)
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
Flush()	Remplace la méthode Flush() 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()	Obsolète. 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()	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 Objectactuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l’objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
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)	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(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(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.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Lit au moins un nombre minimal d’octets du flux actuel et avance la position dans le flux par le nombre d’octets lus. (Hérité de Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Lit de façon asynchrone au moins un nombre minimal d’octets à partir du flux actuel, avance la position dans le flux par le nombre d’octets lus et surveille les demandes d’annulation. (Hérité de Stream)
ReadByte()	Lit un octet à partir du flux actuel.
ReadExactly(Byte[], Int32, Int32)	Lit count nombre d’octets du flux actuel et avance la position dans le flux. (Hérité de Stream)
ReadExactly(Span<Byte>)	Lit les octets du flux actuel et avance la position dans le flux jusqu’à ce que le buffer soit rempli. (Hérité de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon asynchrone count nombre d’octets du flux actuel, avance la position dans le flux et surveille les demandes d’annulation. (Hérité de Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Lit de manière asynchrone les octets du flux actuel, avance la position dans le flux jusqu’à ce que le buffer soit rempli et surveille les demandes d’annulation. (Hérité de Stream)
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 propriété Position.
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 contenus dans source dans 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)	É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(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(ReadOnlyMemory<Byte>, CancellationToken)	Écrit de façon asynchrone la séquence d’octets contenus dans source dans le flux de mémoire actuel, avance la position actuelle dans ce flux de mémoire par le 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.

Méthodes d’extension

CopyToAsync(Stream, PipeWriter, CancellationToken)	Lit de manière asynchrone les octets de l'Stream et les écrit dans le PipeWriterspécifié, à l’aide d’un jeton d’annulation.
ConfigureAwait(IAsyncDisposable, Boolean)	Configure la façon dont les attentes sur les tâches retournées à partir d’un jetable asynchrone sont effectuées.

Voir aussi

• fichier et flux d’E/S
• Guide pratique pour lire du texte à partir d’un fichier
• Comment : écrire du texte dans un fichier