MemoryStream (Clase) (System.IO)

Cambiar vista

Contraer todo

Filtro de lenguage

Esta página es específica de

Microsoft Visual Studio 2008/.NET Framework 3.5

Hay además otras versiones disponibles para:

Biblioteca de clases de .NET Framework

MemoryStream (Clase)

Actualización: noviembre 2007

Crea una secuencia cuyo almacén de respaldo es la memoria.

Espacio de nombres: System.IO
Ensamblado: mscorlib (en mscorlib.dll)

Sintaxis

Visual Basic (Declaración)

<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public Class MemoryStream _
    Inherits Stream

Visual Basic (Uso)

Dim instance As MemoryStream

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class MemoryStream : Stream

Visual C++

[SerializableAttribute]
[ComVisibleAttribute(true)]
public ref class MemoryStream : public Stream

/** @attribute SerializableAttribute */ 
/** @attribute ComVisibleAttribute(true) */
public class MemoryStream extends Stream

JScript

public class MemoryStream extends Stream

Comentarios

Para obtener un ejemplo de cómo crear un archivo y escribir texto en él, vea Cómo: Escribir texto en un archivo. Para obtener un ejemplo de cómo leer texto de un archivo, vea Cómo: Leer texto de un archivo. Para obtener un ejemplo de cómo leer y escribir en un archivo binario, vea Cómo: Leer y escribir en un archivo de datos recién creado.

La clase MemoryStream crea secuencias que utilizan como almacén de respaldo la memoria en lugar de un disco o una conexión de red. MemoryStream encapsula los datos almacenados como una matriz de bytes sin signo que se inicializa al crear un objeto MemoryStream; también se puede crear una matriz vacía. Es posible obtener acceso directamente a los datos encapsulados en la memoria. Las secuencias de memoria pueden reducir la necesidad de archivos y búferes temporales en una aplicación.

La posición actual de una secuencia es la posición donde se llevará a cabo la siguiente operación de lectura o escritura. La posición actual puede recuperarse o establecerse mediante el método Seek. Al crear una nueva instancia de MemoryStream, la posición actual se establece en cero.

Las secuencias de memoria creadas con una matriz de bytes sin signo proporcionan una vista de secuencia de los datos que no es de tamaño variable y sólo es posible escribir en ellas. Al utilizar una matriz de bytes, no es posible anexar la secuencia ni reducirla, aunque tal vez sea posible modificar el contenido existente dependiendo de los parámetros pasados al constructor. Las secuencias de memoria vacías son de tamaño variable y se puede escribir y leer en ellas.

Si se agrega un objeto MemoryStream a un archivo ResX o un archivo .resources, llame al método GetStream en tiempo de ejecución para recuperarlo.

Si un objeto MemoryStream se serializa en un archivo de recursos, su serialización se realizará realmente como si fuera UnmanagedMemoryStream. Este comportamiento proporciona un mejor rendimiento, así como la capacidad de obtener directamente un puntero a los datos, sin necesidad de pasar por los métodos de Stream.

Nota de la plataforma Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows CE:

En Windows CE, una secuencia de memoria pegada del Portapapeles puede tener un tamaño ligeramente mayor que la secuencia de memoria copiada al Portapapeles, porque se pueden anexar bytes adicionales al final de la secuencia de memoria original. Para recuperar con precisión la secuencia de memoria se puede encabezar el objeto con su tamaño para determinar cómo recibirlo o copiar un DataObject al Portapapeles que contiene la secuencia de memoria y un valor de cadena de su tamaño.

Ejemplos

En el ejemplo de código siguiente se muestra la forma de leer y escribir datos utilizando la memoria como almacén de respaldo.

Visual Basic

Imports System
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.InvalidPathChars)

        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

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.InvalidPathChars);

        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++] = 
                    Convert.ToByte(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);
        }
    }
}

Visual C++

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();
   }
}

import System.*;
import System.IO.*;
import System.Text.*;

class MemStream
{   
    public static void main(String[] args)
    {
        int count;
        ubyte byteArray[];
        char charArray[];
        UnicodeEncoding uniEncoding =  new UnicodeEncoding();

        // Create the data to write to the stream.
        ubyte firstString[] = uniEncoding.GetBytes(
            "Invalid file path characters are: ");
        ubyte secondString[] = uniEncoding.GetBytes(Path.InvalidPathChars);
        MemoryStream memStream =  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++]);
            }

            // Write the stream properties to the console.
            Console.WriteLine(
                "Capacity = {0}, Length = {1}, Position = {2}\n", 
                (new Integer( memStream.get_Capacity())).ToString(),
                (new Long ( memStream.get_Length())).ToString(),
                (new Long ( memStream.get_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 ubyte[(int)memStream.get_Length()];
            count = memStream.Read(byteArray, 0, 20);

            // Read the remaining bytes, byte by byte.
            while ((count < memStream.get_Length())) {
                byteArray[count++]= Convert.ToByte(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);
        }
        finally {
            memStream.Dispose();
        }
    }//main
} //MemStream

Jerarquía de herencia

System..::.Object
  System..::.MarshalByRefObject
    System.IO..::.Stream
      System.IO..::.MemoryStream

Seguridad para subprocesos

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Plataformas

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile para Smartphone, Windows Mobile para Pocket PC, Xbox 360

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Información de versión