UnmanagedMemoryStream.Read Método

Definição

Namespace:

System.IO

Assembly:

mscorlib.dll

Sobrecargas

Nome	Description
Read(Byte[], Int32, Int32)	Lê o número especificado de bytes na matriz especificada.

Read(Byte[], Int32, Int32)

Lê o número especificado de bytes na matriz especificada.

public:
 override int Read(cli::array <System::Byte> ^ buffer, int offset, int count);

public override int Read(byte[] buffer, int offset, int count);

override this.Read : byte[] * int * int -> int

Public Overrides Function Read (buffer As Byte(), offset As Integer, count As Integer) As Integer

Parâmetros

buffer

Byte[]

Quando esse método é retornado, contém a matriz de bytes especificada com os valores entre offset e (offset + count - 1) substituídos pelos bytes lidos da fonte atual. Esse parâmetro é passado sem inicialização.

offset

Int32

O deslocamento de bytes baseado em zero no buffer qual começar a armazenar os dados lidos do fluxo atual.

count

Int32

O número máximo de bytes a serem lidos do fluxo atual.

Retornos

Int32

O número total de bytes lidos no buffer. Isso pode ser menor do que o número de bytes solicitados se muitos bytes não estiverem disponíveis no momento ou zero (0) se o final do fluxo tiver sido atingido.

Exceções

ObjectDisposedException

O fluxo está fechado.

NotSupportedException

A memória subjacente não dá suporte à leitura.

-ou-

A propriedade CanRead está definida como false.

ArgumentNullException

O parâmetro buffer é definido como null.

ArgumentOutOfRangeException

O offset parâmetro é menor que zero.

-ou-

O count parâmetro é menor que zero.

ArgumentException

O comprimento da matriz de buffer menos o offset parâmetro é menor que o count parâmetro.

Exemplos

O exemplo de código a seguir demonstra como ler e gravar em memória não gerenciada usando a UnmanagedMemoryStream classe. Um bloco de memória não gerenciada é alocado e desalocado usando a Marshal classe.

// Note: you must compile this sample using the unsafe flag.
// From the command line, type the following: csc sample.cs /unsafe

using System;
using System.IO;
using System.Text;
using System.Runtime.InteropServices;

unsafe class TestWriter
{
    static void Main()
    {
        // Create some data to read and write.
        byte[] message = UnicodeEncoding.Unicode.GetBytes("Here is some data.");

        // Allocate a block of unmanaged memory and return an IntPtr object.	
        IntPtr memIntPtr = Marshal.AllocHGlobal(message.Length);

        // Get a byte pointer from the IntPtr object.
        byte* memBytePtr = (byte*)memIntPtr.ToPointer();

        // Create an UnmanagedMemoryStream object using a pointer to unmanaged memory.
        UnmanagedMemoryStream writeStream = new UnmanagedMemoryStream(memBytePtr, message.Length, message.Length, FileAccess.Write);

        // Write the data.
        writeStream.Write(message, 0, message.Length);

        // Close the stream.
        writeStream.Close();

        // Create another UnmanagedMemoryStream object using a pointer to unmanaged memory.
        UnmanagedMemoryStream readStream = new UnmanagedMemoryStream(memBytePtr, message.Length, message.Length, FileAccess.Read);

        // Create a byte array to hold data from unmanaged memory.
        byte[] outMessage = new byte[message.Length];

        // Read from unmanaged memory to the byte array.
        readStream.Read(outMessage, 0, message.Length);

        // Close the stream.
        readStream.Close();

        // Display the data to the console.
        Console.WriteLine(UnicodeEncoding.Unicode.GetString(outMessage));

        // Free the block of unmanaged memory.
        Marshal.FreeHGlobal(memIntPtr);

        Console.ReadLine();
    }
}

Comentários

O offset parâmetro fornece o deslocamento do byte no array parâmetro (o índice de buffer) no qual começar a ler e o count parâmetro fornece o número máximo de bytes a serem lidos desse fluxo. O valor retornado é o número real de bytes lidos ou zero se o final do fluxo for atingido. Se a operação de leitura for bem-sucedida, a posição atual do fluxo será avançada pelo número de bytes lidos. Se ocorrer uma exceção, a posição atual do fluxo ficará inalterada.

O Read método retorna zero somente depois de atingir o final do fluxo. Caso contrário, Read sempre lê pelo menos um byte do fluxo antes de retornar. Se nenhum dado estiver disponível no fluxo após uma chamada, Reado método será bloqueado até que pelo menos um byte de dados possa ser retornado. Uma implementação é livre para retornar menos bytes do que o solicitado, mesmo que o final do fluxo não tenha sido atingido.