MemoryStream Classe

Referência

Definição

Namespace:: System.IO

Assembly:: System.IO.dll

Assembly:: System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: MemoryStream.cs

Origem:: MemoryStream.cs

Origem:: MemoryStream.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Cria um fluxo cujo repositório de backup é a memória.

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

Herança: Object

Stream
MemoryStream

Herança: Object

MarshalByRefObject

Stream
MemoryStream

Atributos: SerializableAttribute ComVisibleAttribute

Exemplos

O exemplo de código a seguir mostra como ler e gravar dados usando a memória como um repositório de backup.

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

Comentários

A posição atual de um fluxo é a posição na qual a próxima operação de leitura ou gravação pode ocorrer. A posição atual pode ser recuperada ou definida por meio do método Seek. Quando uma nova instância de MemoryStream é criada, a posição atual é definida como zero.

Nota

Esse tipo implementa a interface IDisposable, mas não tem recursos para descartar. Isso significa que não é necessário descartá-lo chamando diretamente Dispose() ou usando um constructo de idioma, como using (em C#) ou Using (no Visual Basic).

Fluxos de memória criados com uma matriz de bytes sem sinal fornecem um fluxo não redimensionável dos dados. Ao usar uma matriz de bytes, você não pode acrescentar nem reduzir o fluxo, embora possa modificar o conteúdo existente dependendo dos parâmetros passados para o construtor. Fluxos de memória vazios são redimensionáveis e podem ser gravados e lidos.

Se um objeto MemoryStream for adicionado a um arquivo ResX ou a um arquivo .resources, chame o método GetStream em runtime para recuperá-lo.

Se um objeto MemoryStream for serializado em um arquivo de recurso, ele será realmente serializado como um UnmanagedMemoryStream. Esse comportamento fornece melhor desempenho, bem como a capacidade de obter um ponteiro para os dados diretamente, sem precisar passar por métodos Stream.

Construtores

MemoryStream()	Inicializa uma nova instância da classe MemoryStream com uma capacidade expansível inicializada como zero.
MemoryStream(Byte[])	Inicializa uma nova instância não redimensionável da classe MemoryStream com base na matriz de bytes especificada.
MemoryStream(Byte[], Boolean)	Inicializa uma nova instância não redimensionável da classe MemoryStream com base na matriz de bytes especificada com a propriedade CanWrite definida conforme especificado.
MemoryStream(Byte[], Int32, Int32)	Inicializa uma nova instância não redimensionável da classe MemoryStream com base na região (índice) especificada de uma matriz de bytes.
MemoryStream(Byte[], Int32, Int32, Boolean)	Inicializa uma nova instância não redimensionável da classe MemoryStream com base na região especificada de uma matriz de bytes, com a propriedade CanWrite definida conforme especificado.
MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)	Inicializa uma nova instância da classe MemoryStream com base na região especificada de uma matriz de bytes, com a propriedade CanWrite definida como especificada e a capacidade de chamar GetBuffer() definida como especificado.
MemoryStream(Int32)	Inicializa uma nova instância da classe MemoryStream com uma capacidade expansível inicializada conforme especificado.

Propriedades

CanRead	Obtém um valor que indica se o fluxo atual dá suporte à leitura.
CanSeek	Obtém um valor que indica se o fluxo atual dá suporte à busca.
CanTimeout	Obtém um valor que determina se o fluxo atual pode acabar. (Herdado de Stream)
CanWrite	Obtém um valor que indica se o fluxo atual dá suporte à gravação.
Capacity	Obtém ou define o número de bytes alocados para esse fluxo.
Length	Obtém o comprimento do fluxo em bytes.
Position	Obtém ou define a posição atual dentro do fluxo.
ReadTimeout	Obtém ou define um valor, em milissegundos, que determina quanto tempo o fluxo tentará ler antes do tempo limite. (Herdado de Stream)
WriteTimeout	Obtém ou define um valor, em milissegundos, que determina por quanto tempo o fluxo tentará gravar antes do tempo limite. (Herdado de Stream)

Métodos

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de leitura assíncrona. (Considere usar ReadAsync(Byte[], Int32, Int32, CancellationToken) em vez disso.)
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de leitura assíncrona. (Considere usar ReadAsync(Byte[], Int32, Int32) em vez disso.) (Herdado de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de gravação assíncrona. (Considere usar WriteAsync(Byte[], Int32, Int32, CancellationToken) em vez disso.)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de gravação assíncrona. (Considere usar WriteAsync(Byte[], Int32, Int32) em vez disso.) (Herdado de Stream)
Close()	Fecha o fluxo para leitura e gravação.
Close()	Fecha o fluxo atual e libera todos os recursos (como soquetes e identificadores de arquivo) associados ao fluxo atual. Em vez de chamar esse método, verifique se o fluxo foi descartado corretamente. (Herdado de Stream)
CopyTo(Stream)	Lê os bytes do fluxo atual e os grava em outro fluxo. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyTo(Stream, Int32)	Lê os bytes do fluxo de memória atual e os grava em outro fluxo, usando um tamanho de buffer especificado.
CopyTo(Stream, Int32)	Lê os bytes do fluxo atual e os grava em outro fluxo, usando um tamanho de buffer especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream)	Lê assíncronamente os bytes do fluxo atual e os grava em outro fluxo. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream, CancellationToken)	Lê assíncronamente os bytes do fluxo atual e os grava em outro fluxo, usando um token de cancelamento especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream, Int32)	Lê de forma assíncrona os bytes do fluxo atual e os grava em outro fluxo, usando um tamanho de buffer especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lê de forma assíncrona todos os bytes do fluxo atual e os grava em outro fluxo, usando um token de cancelamento e tamanho de buffer especificado.
CopyToAsync(Stream, Int32, CancellationToken)	Lê assíncronamente os bytes do fluxo atual e os grava em outro fluxo, usando um token de cancelamento e tamanho de buffer especificado. Ambas as posições de fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CreateObjRef(Type)	Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto. (Herdado de MarshalByRefObject)
CreateWaitHandle()	Obsoleto. Obsoleto. Obsoleto. Aloca um objeto WaitHandle. (Herdado de Stream)
Dispose()	Libera todos os recursos usados pelo Stream. (Herdado de Stream)
Dispose(Boolean)	Libera os recursos não gerenciados usados pela classe MemoryStream e, opcionalmente, libera os recursos gerenciados.
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo Stream e, opcionalmente, libera os recursos gerenciados. (Herdado de Stream)
DisposeAsync()	Libera de forma assíncrona os recursos não gerenciados usados pelo Stream. (Herdado de Stream)
EndRead(IAsyncResult)	Aguarda a conclusão da leitura assíncrona pendente. (Considere usar ReadAsync(Byte[], Int32, Int32, CancellationToken) em vez disso.)
EndRead(IAsyncResult)	Aguarda a conclusão da leitura assíncrona pendente. (Considere usar ReadAsync(Byte[], Int32, Int32) em vez disso.) (Herdado de Stream)
EndWrite(IAsyncResult)	Encerra uma operação de gravação assíncrona. (Considere usar WriteAsync(Byte[], Int32, Int32, CancellationToken) em vez disso.)
EndWrite(IAsyncResult)	Encerra uma operação de gravação assíncrona. (Considere usar WriteAsync(Byte[], Int32, Int32) em vez disso.) (Herdado de Stream)
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
Flush()	Substitui o método Flush() para que nenhuma ação seja executada.
FlushAsync()	Limpa de forma assíncrona todos os buffers para esse fluxo e faz com que todos os dados em buffer sejam gravados no dispositivo subjacente. (Herdado de Stream)
FlushAsync(CancellationToken)	Limpa de forma assíncrona todos os buffers para esse fluxo e monitora solicitações de cancelamento.
FlushAsync(CancellationToken)	Limpa de forma assíncrona todos os buffers para esse fluxo, faz com que todos os dados em buffer sejam gravados no dispositivo subjacente e monitora solicitações de cancelamento. (Herdado de Stream)
GetBuffer()	Retorna a matriz de bytes não assinados dos quais esse fluxo foi criado.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetLifetimeService()	Obsoleto. Recupera o objeto de serviço de tempo de vida atual que controla a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
InitializeLifetimeService()	Obsoleto. Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida dessa instância. (Herdado de MarshalByRefObject)
MemberwiseClone()	Cria uma cópia superficial do Objectatual. (Herdado de Object)
MemberwiseClone(Boolean)	Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject)
ObjectInvariant()	Esta API dá suporte à infraestrutura do produto e não deve ser usada diretamente do seu código. Fornece suporte para um Contract.
ObjectInvariant()	Obsoleto. Fornece suporte para um Contract. (Herdado de Stream)
Read(Byte[], Int32, Int32)	Lê um bloco de bytes do fluxo atual e grava os dados em um buffer.
Read(Span<Byte>)	Lê uma sequência de bytes do fluxo de memória atual e avança a posição dentro do fluxo de memória pelo número de bytes lidos.
Read(Span<Byte>)	Quando substituído em uma classe derivada, lê uma sequência de bytes do fluxo atual e avança a posição dentro do fluxo pelo número de bytes lidos. (Herdado de Stream)
ReadAsync(Byte[], Int32, Int32)	Lê de forma assíncrona uma sequência de bytes do fluxo atual e avança a posição dentro do fluxo pelo número de bytes lidos. (Herdado de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lê de forma assíncrona uma sequência de bytes do fluxo atual, avança a posição dentro do fluxo pelo número de bytes lidos e monitora solicitações de cancelamento.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lê de forma assíncrona uma sequência de bytes do fluxo atual, avança a posição dentro do fluxo pelo número de bytes lidos e monitora solicitações de cancelamento. (Herdado de Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Lê de forma assíncrona uma sequência de bytes do fluxo de memória atual, grava a sequência em `destination`, avança a posição dentro do fluxo de memória pelo número de bytes lidos e monitora solicitações de cancelamento.
ReadAsync(Memory<Byte>, CancellationToken)	Lê de forma assíncrona uma sequência de bytes do fluxo atual, avança a posição dentro do fluxo pelo número de bytes lidos e monitora solicitações de cancelamento. (Herdado de Stream)
ReadAtLeast(Span<Byte>, Int32, Boolean)	Lê pelo menos um número mínimo de bytes do fluxo atual e avança a posição dentro do fluxo pelo número de bytes lidos. (Herdado de Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Lê de forma assíncrona pelo menos um número mínimo de bytes do fluxo atual, avança a posição dentro do fluxo pelo número de bytes lidos e monitora solicitações de cancelamento. (Herdado de Stream)
ReadByte()	Lê um byte do fluxo atual.
ReadExactly(Byte[], Int32, Int32)	Lê `count` número de bytes do fluxo atual e avança a posição dentro do fluxo. (Herdado de Stream)
ReadExactly(Span<Byte>)	Lê bytes do fluxo atual e avança a posição dentro do fluxo até que a `buffer` seja preenchida. (Herdado de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Lê de forma assíncrona `count` número de bytes do fluxo atual, avança a posição dentro do fluxo e monitora solicitações de cancelamento. (Herdado de Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Lê bytes de forma assíncrona do fluxo atual, avança a posição dentro do fluxo até que o `buffer` seja preenchido e monitore as solicitações de cancelamento. (Herdado de Stream)
Seek(Int64, SeekOrigin)	Define a posição dentro do fluxo atual como o valor especificado.
SetLength(Int64)	Define o comprimento do fluxo atual como o valor especificado.
ToArray()	Grava o conteúdo do fluxo em uma matriz de bytes, independentemente da propriedade Position.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
TryGetBuffer(ArraySegment<Byte>)	Retorna a matriz de bytes não assinados dos quais esse fluxo foi criado. O valor retornado indica se a conversão foi bem-sucedida.
Write(Byte[], Int32, Int32)	Grava um bloco de bytes no fluxo atual usando dados lidos de um buffer.
Write(ReadOnlySpan<Byte>)	Grava a sequência de bytes contidos em `source` no fluxo de memória atual e avança a posição atual dentro desse fluxo de memória pelo número de bytes gravados.
Write(ReadOnlySpan<Byte>)	Quando substituído em uma classe derivada, grava uma sequência de bytes no fluxo atual e avança a posição atual dentro desse fluxo pelo número de bytes gravados. (Herdado de Stream)
WriteAsync(Byte[], Int32, Int32)	Grava de forma assíncrona uma sequência de bytes no fluxo atual e avança a posição atual dentro desse fluxo pelo número de bytes gravados. (Herdado de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Grava de forma assíncrona uma sequência de bytes no fluxo atual, avança a posição atual dentro desse fluxo pelo número de bytes gravados e monitora solicitações de cancelamento.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Grava de forma assíncrona uma sequência de bytes no fluxo atual, avança a posição atual dentro desse fluxo pelo número de bytes gravados e monitora solicitações de cancelamento. (Herdado de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Grava de forma assíncrona a sequência de bytes contidos em `source` no fluxo de memória atual, avança a posição atual dentro desse fluxo de memória pelo número de bytes gravados e monitora solicitações de cancelamento.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Grava de forma assíncrona uma sequência de bytes no fluxo atual, avança a posição atual dentro desse fluxo pelo número de bytes gravados e monitora solicitações de cancelamento. (Herdado de Stream)
WriteByte(Byte)	Grava um byte no fluxo atual na posição atual.
WriteTo(Stream)	Grava todo o conteúdo desse fluxo de memória em outro fluxo.

Implantações explícitas de interface

IDisposable.Dispose()

Libera todos os recursos usados pelo Stream.

(Herdado de Stream)

Métodos de Extensão

CopyToAsync(Stream, PipeWriter, CancellationToken)	Lê assíncronamente os bytes do Stream e os grava no PipeWriterespecificado usando um token de cancelamento.
AsInputStream(Stream)	Converte um fluxo gerenciado no .NET para aplicativos da Windows Store em um fluxo de entrada no Windows Runtime.
AsOutputStream(Stream)	Converte um fluxo gerenciado no .NET para aplicativos da Windows Store em um fluxo de saída no Windows Runtime.
AsRandomAccessStream(Stream)	Converte o fluxo especificado em um fluxo de acesso aleatório.
GetWindowsRuntimeBuffer(MemoryStream)	Retorna uma interface Windows.Storage.Streams.IBuffer que representa a mesma memória do fluxo de memória especificado.
GetWindowsRuntimeBuffer(MemoryStream, Int32, Int32)	Retorna uma interface Windows.Storage.Streams.IBuffer que representa uma região dentro da memória que o fluxo de memória especificado representa.
ConfigureAwait(IAsyncDisposable, Boolean)	Configura como as esperas nas tarefas retornadas de um descartável assíncrono serão executadas.

Aplica-se a

Compartilhar via