UnmanagedMemoryStream.Read Méthode

Source:

UnmanagedMemoryStream.cs

Source:

UnmanagedMemoryStream.cs

Source:

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

Paramètres

Retours

Nombre total d’octets lus dans la destination.

Source:

UnmanagedMemoryStream.cs

Source:

UnmanagedMemoryStream.cs

Source:

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

Paramètres

Retours

Nombre total d'octets lus dans la mémoire tampon. Le nombre d'octets peut être inférieur au nombre d'octets demandés si ce nombre n'est pas actuellement disponible ou égal à zéro (0) si la fin du flux a été atteinte.

Exceptions

Exemples

L’exemple de code suivant montre comment lire et écrire dans la mémoire non managée à l’aide de la UnmanagedMemoryStream classe . Un bloc de mémoire non managée est alloué et désalloué à l’aide de la 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();
    }
}

Remarques

Le offset paramètre donne le décalage de l’octet dans le array paramètre (l’index de mémoire tampon) auquel commencer la lecture, et le count paramètre donne le nombre maximal d’octets à lire à partir de ce flux. La valeur retournée est le nombre réel d’octets lus, ou zéro si la fin du flux est atteinte. Si l’opération de lecture réussit, la position actuelle du flux est avancée par le nombre d’octets lus. Si une exception se produit, la position actuelle du flux est inchangée.

La Read méthode retourne zéro uniquement après avoir atteint la fin du flux. Sinon, Read lit toujours au moins un octet à partir du flux avant de revenir. Si aucune donnée n’est disponible à partir du flux lors d’un appel à Read, la méthode se bloque jusqu’à ce qu’au moins un octet de données puisse être retourné. Une implémentation est libre de retourner moins d’octets que demandé même si la fin du flux n’a pas été atteinte.