MemoryStream Classe

Definição

Espaço de Nomes:: System.IO

Assemblagens:: mscorlib.dll, System.IO.dll

Assemblagem:: mscorlib.dll

Assemblagem:: System.IO.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Cria um stream cujo armazenamento de apoio é 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 seguinte exemplo de código mostra como ler e escrever dados usando memória como armazenamento de apoio.

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

Observações

A posição atual de um fluxo é a posição onde poderá ocorrer a próxima operação de leitura ou escrita. A posição atual pode ser recuperada ou definida através do Seek método. Quando uma nova instância de MemoryStream é criada, a posição atual é definida para zero.

Note

Este tipo implementa a IDisposable interface, mas na verdade não tem recursos para eliminar. Isto significa que não é necessário eliminá-lo chamando diretamente Dispose() ou usando uma construção de linguagem como using (em C#) ou Using (em Visual Basic).

Fluxos de memória criados com um array de bytes sem assinatura fornecem um fluxo não redimensionável dos dados. Ao usar um array de bytes, não pode adicionar nem diminuir o fluxo, embora possa ser possível modificar o conteúdo existente dependendo dos parâmetros passados no construtor. Fluxos de memória vazios são redimensionáveis e podem ser escritos e lidos.

Se um MemoryStream objeto for adicionado a um ficheiro ResX ou .resources, chame o GetStream método em tempo de execução para o recuperar.

Se um MemoryStream objeto for serializado para um ficheiro de recurso, será, na verdade, serializado como um UnmanagedMemoryStreamficheiro . Este comportamento proporciona melhor desempenho, bem como a capacidade de obter um ponteiro diretamente para os dados, sem ter de passar por Stream métodos.

Construtores

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

Propriedades

Name	Description
CanRead	Recebe um valor que indica se o fluxo atual suporta leitura.
CanSeek	Recebe um valor que indica se o fluxo atual suporta a procura.
CanTimeout	Obtém um valor que determina se o fluxo atual pode expirar. (Herdado de Stream)
CanWrite	Recebe um valor que indica se o fluxo atual suporta escrita.
Capacity	Obtém ou define o número de bytes alocados para este fluxo.
Length	Obtém o comprimento do fluxo em bytes.
Position	Obtém ou define a posição atual dentro do fluxo.
ReadTimeout	Recebe ou define um valor, em milissegundos, que determina quanto tempo o fluxo tentará ler antes de expirar. (Herdado de Stream)
WriteTimeout	Recebe ou define um valor, em milissegundos, que determina quanto tempo o fluxo tenta escrever antes de expirar. (Herdado de Stream)

Métodos

Name	Description
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 escrita assíncrona. (Considere usar WriteAsync(Byte[], Int32, Int32, CancellationToken) em vez disso.)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Inicia uma operação de escrita assíncrona. (Considere usar WriteAsync(Byte[], Int32, Int32) em vez disso.) (Herdado de Stream)
Close()	Fecha o stream para leitura e escrita.
Close()	Fecha o fluxo atual e liberta quaisquer recursos (como sockets e handles de ficheiros) associados ao fluxo atual. Em vez de chamar este método, certifique-se de que o fluxo é devidamente descartado. (Herdado de Stream)
CopyTo(Stream, Int32)	Lê os bytes do fluxo de memória atual e escreve-os noutro fluxo, usando um tamanho de buffer especificado.
CopyTo(Stream, Int32)	Lê os bytes do fluxo atual e escreve-os noutro fluxo, usando um tamanho de buffer especificado. As posições de ambos os fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyTo(Stream)	Lê os bytes do fluxo atual e escreve-os noutro fluxo. As posições de ambos os 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 escreve-os noutro fluxo, usando um token de cancelamento especificado. As posições de ambos os fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lê assíncronamente todos os bytes do fluxo atual e escreve-os noutro fluxo, usando um tamanho de buffer especificado e um token de cancelamento.
CopyToAsync(Stream, Int32, CancellationToken)	Lê assíncronamente os bytes do fluxo atual e escreve-os noutro fluxo, usando um tamanho de buffer especificado e um token de cancelamento. As posições de ambos os fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CopyToAsync(Stream, Int32)	Lê assíncronamente os bytes do fluxo atual e escreve-os noutro fluxo, usando um tamanho de buffer especificado. As posições de ambos os 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 escreve-os noutro fluxo. As posições de ambos os fluxos são avançadas pelo número de bytes copiados. (Herdado de Stream)
CreateObjRef(Type)	Cria um objeto que contém toda a informação relevante necessária para gerar um proxy usado para comunicar com um objeto remoto. (Herdado de MarshalByRefObject)
CreateWaitHandle()	Obsoleto. Aloca um WaitHandle objeto. (Herdado de Stream)
Dispose()	Liberta todos os recursos utilizados pelo Stream. (Herdado de Stream)
Dispose(Boolean)	Liberta os recursos não geridos usados pela MemoryStream classe e, opcionalmente, liberta os recursos geridos.
DisposeAsync()	De forma assíncrona, liberta os recursos não geridos usados pelos Stream. (Herdado de Stream)
EndRead(IAsyncResult)	Espera que a leitura assíncrona pendente seja concluída. (Considere usar ReadAsync(Byte[], Int32, Int32, CancellationToken) em vez disso.)
EndRead(IAsyncResult)	Espera que a leitura assíncrona pendente seja concluída. (Considere usar ReadAsync(Byte[], Int32, Int32) em vez disso.) (Herdado de Stream)
EndWrite(IAsyncResult)	Termina uma operação de escrita assíncrona. (Considere usar WriteAsync(Byte[], Int32, Int32, CancellationToken) em vez disso.)
EndWrite(IAsyncResult)	Termina uma operação de escrita 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()	Sobrepõe o Flush() método para que nenhuma ação seja realizada.
FlushAsync()	Apaga assíncronamente todos os buffers deste fluxo e faz com que quaisquer dados armazenados sejam escritos no dispositivo subjacente. (Herdado de Stream)
FlushAsync(CancellationToken)	Apaga assíncronamente todos os buffers deste fluxo e monitoriza pedidos de cancelamento.
GetBuffer()	Devolve o array de bytes sem assinatura a partir do qual este fluxo foi criado.
GetHashCode()	Serve como função de hash predefinida. (Herdado de Object)
GetLifetimeService()	Recupera o objeto de serviço de tempo de vida atual que controla a política de vida útil neste caso. (Herdado de MarshalByRefObject)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
InitializeLifetimeService()	Obtém-se um objeto de serviço vitalício para controlar a apólice vitalícia neste caso. (Herdado de MarshalByRefObject)
MemberwiseClone()	Cria uma cópia superficial do atual Object. (Herdado de Object)
MemberwiseClone(Boolean)	Cria uma cópia superficial do objeto atual MarshalByRefObject . (Herdado de MarshalByRefObject)
ObjectInvariant()	Esta API suporta a infraestrutura de produtos e não é pressuposta para ser utilizada diretamente a partir 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 escreve os dados num 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.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	A leitura 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 monitoriza pedidos de cancelamento.
ReadAsync(Byte[], Int32, Int32)	A leitura 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(Memory<Byte>, CancellationToken)	Lê assíncronamente uma sequência de bytes do fluxo de memória atual, escreve a sequência em `destination`, avança a posição dentro do fluxo de memória pelo número de bytes lidos e monitoriza pedidos de cancelamento.
ReadByte()	Lê um byte do fluxo atual.
Seek(Int64, SeekOrigin)	Define a posição dentro do fluxo atual para o valor especificado.
SetLength(Int64)	Define o comprimento do fluxo atual para o valor especificado.
ToArray()	Escreve o conteúdo do fluxo num array de bytes, independentemente da propriedade Position .
ToString()	Devolve uma cadeia que representa o objeto atual. (Herdado de Object)
TryGetBuffer(ArraySegment<Byte>)	Devolve o array de bytes sem assinatura a partir do qual este fluxo foi criado. O valor de retorno indica se a conversão teve sucesso.
Write(Byte[], Int32, Int32)	Escreve um bloco de bytes no fluxo atual usando dados lidos de um buffer.
Write(ReadOnlySpan<Byte>)	Escreve a sequência de bytes contida 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 escritos.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Escreve assíncronamente uma sequência de bytes no fluxo atual, avança a posição atual dentro deste fluxo pelo número de bytes escritos e monitoriza pedidos de cancelamento.
WriteAsync(Byte[], Int32, Int32)	Escreve assíncronamente uma sequência de bytes no fluxo atual e avança a posição atual dentro desse fluxo pelo número de bytes escritos. (Herdado de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Escreve assíncronamente a sequência de bytes contida 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 escritos e monitoriza pedidos de cancelamento.
WriteByte(Byte)	Escreve um byte no fluxo atual na posição atual.
WriteTo(Stream)	Escreve todo o conteúdo deste fluxo de memória noutro fluxo.

Implementações de Interface Explícita

Name	Description
IDisposable.Dispose()	Liberta todos os recursos utilizados pelo Stream. (Herdado de Stream)

Métodos da Extensão

Name	Description
AsInputStream(Stream)	Converte um fluxo gerido nas aplicações .NET for Windows Store num fluxo de entrada no Windows Runtime.
AsOutputStream(Stream)	Converte um fluxo gerido nas aplicações .NET for Windows Store num fluxo de saída no Windows Runtime.
AsRandomAccessStream(Stream)	Converte o fluxo especificado num fluxo de acesso aleatório.
ConfigureAwait(IAsyncDisposable, Boolean)	Configura como aguarda nas tarefas devolvidas de um descartável assíncrono será realizada.
GetWindowsRuntimeBuffer(MemoryStream, Int32, Int32)	Devolve um Windows. Interface Storage.Streams.IBuffer que representa uma região dentro da memória que o fluxo de memória especificado representa.
GetWindowsRuntimeBuffer(MemoryStream)	Devolve um Windows. Interface Storage.Streams.IBuffer que representa a mesma memória do fluxo de memória especificado.

Aplica-se a

Ver também

Comentários

Esta página foi útil?