Exportar (0) Imprimir
Expandir todo

MemoryStream (Clase)

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

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

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

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.

current position 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.

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

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

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

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

Los miembros estáticos públicos (Shared en Visual Basic) 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.

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

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 2.0, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft