UnmanagedMemoryStream.Read Método

Origem:

UnmanagedMemoryStream.cs

Origem:

UnmanagedMemoryStream.cs

Origem:

UnmanagedMemoryStream.cs

public:
 override int Read(Span<System::Byte> destination);

public:
 override int Read(Span<System::Byte> buffer);

public override int Read (Span<byte> destination);

public override int Read (Span<byte> buffer);

override this.Read : Span<byte> -> int

override this.Read : Span<byte> -> int

Public Overrides Function Read (destination As Span(Of Byte)) As Integer

Public Overrides Function Read (buffer As Span(Of Byte)) As Integer

Parâmetros

Retornos

O número total de bytes lidos no destino.

Origem:

UnmanagedMemoryStream.cs

Origem:

UnmanagedMemoryStream.cs

Origem:

UnmanagedMemoryStream.cs

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

Retornos

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

Exceções

Exemplos

O exemplo de código a seguir demonstra como ler e gravar na 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 será 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 permanecerá inalterada.

O Read método retorna zero somente depois de chegar ao 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 para Read, o 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.