UnmanagedMemoryStream Classe

Définition

Espace de noms:

System.IO

Assembly:

System.Runtime.dll

Source:

UnmanagedMemoryStream.cs

Important

Cette API n’est pas conforme CLS.

Fournit l’accès aux blocs de mémoire non managés à partir du code managé.

public ref class UnmanagedMemoryStream : System::IO::Stream

public class UnmanagedMemoryStream : System.IO.Stream

type UnmanagedMemoryStream = class
    inherit Stream

Public Class UnmanagedMemoryStream
Inherits Stream

Héritage

Object

MarshalByRefObject

Stream

UnmanagedMemoryStream

Dérivé

System.IO.MemoryMappedFiles.MemoryMappedViewStream

Exemples

L’exemple de code suivant montre comment lire et écrire dans la mémoire non managée à l’aide de la classe UnmanagedMemoryStream. Un bloc de mémoire non managée est alloué et désaffecté à l’aide de la classe Marshal.

// 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

Cette classe prend en charge l’accès à la mémoire non managée à l’aide du modèle basé sur le flux existant et ne nécessite pas que le contenu de la mémoire non managée soit copié dans le tas.

Note

Ce type implémente l’interface IDisposable, mais n’a pas réellement de ressources à supprimer. Cela signifie que la suppression directe en appelant directement Dispose() ou en utilisant une construction de langage telle que using (en C#) ou Using (en Visual Basic) n’est pas nécessaire.

Constructeurs

UnmanagedMemoryStream()	Initialise une nouvelle instance de la classe UnmanagedMemoryStream.
UnmanagedMemoryStream(Byte*, Int64)	Initialise une nouvelle instance de la classe UnmanagedMemoryStream à l’aide de l’emplacement et de la longueur de mémoire spécifiés.
UnmanagedMemoryStream(Byte*, Int64, Int64, FileAccess)	Initialise une nouvelle instance de la classe UnmanagedMemoryStream à l’aide de l’emplacement, de la longueur de la mémoire, de la quantité totale de mémoire et des valeurs d’accès aux fichiers spécifiées.
UnmanagedMemoryStream(SafeBuffer, Int64, Int64)	Initialise une nouvelle instance de la classe UnmanagedMemoryStream dans une mémoire tampon sécurisée avec un décalage et une longueur spécifiés.
UnmanagedMemoryStream(SafeBuffer, Int64, Int64, FileAccess)	Initialise une nouvelle instance de la classe UnmanagedMemoryStream dans une mémoire tampon sécurisée avec un décalage, une longueur et un accès au fichier spécifiés.

Propriétés

CanRead	Obtient une valeur indiquant si un flux prend en charge la lecture.
CanSeek	Obtient une valeur indiquant si un flux prend en charge la recherche.
CanTimeout	Obtient une valeur qui détermine si le flux actuel peut expirer. (Hérité de Stream)
CanWrite	Obtient une valeur indiquant si un flux prend en charge l’écriture.
Capacity	Obtient la longueur du flux (taille) ou la quantité totale de mémoire affectée à un flux (capacité).
Length	Obtient la longueur des données dans un flux.
Position	Obtient ou définit la position actuelle dans un flux.
PositionPointer	Obtient ou définit un pointeur d’octet vers un flux en fonction de la position actuelle dans le flux.
ReadTimeout	Obtient ou définit une valeur, en millisecondes, qui détermine la durée pendant laquelle le flux tente de lire avant l’expiration du délai d’attente. (Hérité de Stream)
WriteTimeout	Obtient ou définit une valeur, en millisecondes, qui détermine la durée pendant laquelle le flux tentera d’écrire avant l’expiration du délai d’attente. (Hérité de Stream)

Méthodes

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération de lecture asynchrone. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Commence une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
Close()	Ferme le flux actuel et libère toutes les ressources (telles que les sockets et les handles de fichiers) associées au flux actuel. Au lieu d’appeler cette méthode, vérifiez que le flux est correctement supprimé. (Hérité de Stream)
CopyTo(Stream)	Lit les octets du flux actuel et les écrit dans un autre flux. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyTo(Stream, Int32)	Lit les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon spécifiée. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream)	Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream, CancellationToken)	Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’un jeton d’annulation spécifié. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream, Int32)	Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon spécifiée. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon et d’un jeton d’annulation spécifiés. Les deux positions de flux sont avancées par le nombre d’octets copiés. (Hérité de Stream)
CreateObjRef(Type)	Crée un objet qui contient toutes les informations pertinentes requises pour générer un proxy utilisé pour communiquer avec un objet distant. (Hérité de MarshalByRefObject)
CreateWaitHandle()	Obsolète. Alloue un objet WaitHandle. (Hérité de Stream)
Dispose()	Libère toutes les ressources utilisées par le Stream. (Hérité de Stream)
Dispose(Boolean)	Libère les ressources non managées utilisées par le UnmanagedMemoryStream et libère éventuellement les ressources managées.
DisposeAsync()	Libère de façon asynchrone les ressources non managées utilisées par le Stream. (Hérité de Stream)
EndRead(IAsyncResult)	Attend la fin de la lecture asynchrone en attente. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
EndWrite(IAsyncResult)	Termine une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
Flush()	Remplace la méthode Flush() afin qu’aucune action n’est effectuée.
FlushAsync()	Efface de façon asynchrone toutes les mémoires tampons de ce flux et entraîne l’écriture de toutes les données mises en mémoire tampon sur l’appareil sous-jacent. (Hérité de Stream)
FlushAsync(CancellationToken)	Remplace la méthode FlushAsync(CancellationToken) afin que l’opération soit annulée si spécifiée, mais aucune autre action n’est effectuée.
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	Obsolète. Récupère l’objet de service de durée de vie actuel qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
Initialize(Byte*, Int64, Int64, FileAccess)	Initialise une nouvelle instance de la classe UnmanagedMemoryStream à l’aide d’un pointeur vers un emplacement de mémoire non managé.
Initialize(SafeBuffer, Int64, Int64, FileAccess)	Initialise une nouvelle instance de la classe UnmanagedMemoryStream dans une mémoire tampon sécurisée avec un décalage, une longueur et un accès au fichier spécifiés.
InitializeLifetimeService()	Obsolète. Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l’objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
ObjectInvariant()	Obsolète. Fournit la prise en charge d’un Contract. (Hérité de Stream)
Read(Byte[], Int32, Int32)	Lit le nombre spécifié d’octets dans le tableau spécifié.
Read(Span<Byte>)	Lit tous les octets de ce flux de mémoire non managé dans l’étendue spécifiée d’octets.
ReadAsync(Byte[], Int32, Int32)	Lit de façon asynchrone une séquence d’octets à partir du flux actuel et avance la position dans le flux en fonction du nombre d’octets lus. (Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon asynchrone le nombre spécifié d’octets dans le tableau spécifié.
ReadAsync(Memory<Byte>, CancellationToken)	Lit de façon asynchrone les octets de flux de mémoire non managés dans la région mémoire.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Lit au moins un nombre minimal d’octets du flux actuel et avance la position dans le flux par le nombre d’octets lus. (Hérité de Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Lit de façon asynchrone au moins un nombre minimal d’octets à partir du flux actuel, avance la position dans le flux par le nombre d’octets lus et surveille les demandes d’annulation. (Hérité de Stream)
ReadByte()	Lit un octet à partir d’un flux et avance la position dans le flux d’un octet, ou retourne -1 si à la fin du flux.
ReadExactly(Byte[], Int32, Int32)	Lit count nombre d’octets du flux actuel et avance la position dans le flux. (Hérité de Stream)
ReadExactly(Span<Byte>)	Lit les octets du flux actuel et avance la position dans le flux jusqu’à ce que le buffer soit rempli. (Hérité de Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon asynchrone count nombre d’octets du flux actuel, avance la position dans le flux et surveille les demandes d’annulation. (Hérité de Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Lit de manière asynchrone les octets du flux actuel, avance la position dans le flux jusqu’à ce que le buffer soit rempli et surveille les demandes d’annulation. (Hérité de Stream)
Seek(Int64, SeekOrigin)	Définit la position actuelle du flux actuel sur la valeur donnée.
SetLength(Int64)	Définit la longueur d’un flux sur une valeur spécifiée.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
Write(Byte[], Int32, Int32)	Écrit un bloc d’octets dans le flux actuel à l’aide de données d’une mémoire tampon.
Write(ReadOnlySpan<Byte>)	Écrit un bloc d’octets dans le flux de mémoire non managé actuel à l’aide de données de l’étendue fournie d’octets.
WriteAsync(Byte[], Int32, Int32)	Écrit de façon asynchrone une séquence d’octets dans le flux actuel et avance la position actuelle dans ce flux par le nombre d’octets écrits. (Hérité de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Écrit de façon asynchrone une séquence d’octets dans le flux actuel, avance la position actuelle dans ce flux par le nombre d’octets écrits et surveille les demandes d’annulation.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Écrit de façon asynchrone une étendue d’octets dans le flux actuel, avance la position actuelle dans ce flux par le nombre d’octets écrits et surveille les demandes d’annulation.
WriteByte(Byte)	Écrit un octet à la position actuelle dans le flux de fichiers.

Méthodes d’extension

CopyToAsync(Stream, PipeWriter, CancellationToken)	Lit de manière asynchrone les octets de l'Stream et les écrit dans le PipeWriterspécifié, à l’aide d’un jeton d’annulation.
ConfigureAwait(IAsyncDisposable, Boolean)	Configure la façon dont les attentes sur les tâches retournées à partir d’un jetable asynchrone sont effectuées.