UnmanagedMemoryStream Classe

Référence

Définition

Espace de noms:: System.IO

Assemblys:: mscorlib.dll, System.IO.UnmanagedMemoryStream.dll

Assembly:: System.Runtime.dll

Assembly:: System.IO.UnmanagedMemoryStream.dll

Assembly:: System.Runtime.InteropServices.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Important

Cette API n’est pas conforme CLS.

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

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

public class UnmanagedMemoryStream : System.IO.Stream

[System.CLSCompliant(false)]
public class UnmanagedMemoryStream : System.IO.Stream

type UnmanagedMemoryStream = class
    inherit Stream

[<System.CLSCompliant(false)>]
type UnmanagedMemoryStream = class
    inherit Stream

Public Class UnmanagedMemoryStream
Inherits Stream

Héritage: Object

Stream
UnmanagedMemoryStream

Héritage: Object

MarshalByRefObject

Stream
UnmanagedMemoryStream

Dérivé: System.IO.MemoryMappedFiles.MemoryMappedViewStream

Attributs: CLSCompliantAttribute

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ésaffecté à 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

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

Notes

Ce type implémente l’interface IDisposable, mais il n’a en fait aucune ressource à supprimer. Cela signifie que sa suppression 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 taille de la mémoire spécifiés.
UnmanagedMemoryStream(Byte*, Int64, Int64, FileAccess)	Initialise une nouvelle instance de la classe UnmanagedMemoryStream à l'aide des valeurs spécifiées pour l'emplacement, la taille et la quantité totale de la mémoire, ainsi que l'accès au fichier.
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 l'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 dépasser le délai d'attente. (Hérité de Stream)
CanWrite	Obtient une valeur indiquant si un flux prend en charge l'écriture.
Capacity	Obtient la longueur de flux (taille) ou la quantité totale de mémoire assignée au 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 basé sur la position actuelle.
ReadTimeout	Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’effectuer la lecture avant dépassement du délai d’attente. (Hérité de Stream)
WriteTimeout	Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’écrire des données avant l’expiration du délai d’attente. (Hérité de Stream)

Méthodes

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Débute une opération de lecture asynchrone. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Débute une opération d'écriture asynchrone. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
Close()	Ferme le flux actuel et libère toutes les ressources (comme les sockets et les handles de fichiers) associées à celui-ci. Au lieu d'appeler cette méthode, assurez-vous 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. (Hérité de Stream)
CopyTo(Stream, Int32)	Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. (Hérité de Stream)
CopyToAsync(Stream)	Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. (Hérité de Stream)
CopyToAsync(Stream, CancellationToken)	Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant un jeton d’annulation spécifié. (Hérité de Stream)
CopyToAsync(Stream, Int32)	Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. (Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. (Hérité de Stream)
CreateObjRef(Type)	Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject)
CreateWaitHandle()	Obsolète. Obsolète. Alloue un objet WaitHandle. (Hérité de Stream)
Dispose()	Libère toutes les ressources utilisées par Stream. (Hérité de Stream)
Dispose(Boolean)	Libère les ressources non managées utilisées par UnmanagedMemoryStream et libère éventuellement les ressources managées.
DisposeAsync()	Libère de façon asynchrone les ressources non managées utilisées par Stream. (Hérité de Stream)
EndRead(IAsyncResult)	Attend que la requête asynchrone en attente se termine. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.) (Hérité de Stream)
EndWrite(IAsyncResult)	Termine une opération d'écriture asynchrone. (Utilisez 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 ne soit effectuée.
FlushAsync()	Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. (Hérité de Stream)
FlushAsync(CancellationToken)	Substitue la méthode FlushAsync(CancellationToken) pour que l'opération soit annulée si spécifié, mais sans qu'aucune autre action ne soit effectuée.
FlushAsync(CancellationToken)	Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les requêtes d'annulation. (Hérité de Stream)
GetHashCode()	Fait office 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 en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetType()	Obtient le 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 la mémoire non managée.
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 l'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 Object actuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
ObjectInvariant()	Obsolète. Assure la prise en charge d'un Contract. (Hérité de Stream)
Read(Byte[], Int32, Int32)	Lit le nombre d'octets spécifié dans le tableau indiqué.
Read(Span<Byte>)	Lit tous les octets de ce flux de mémoire non managé dans la plage d’octets spécifiée.
Read(Span<Byte>)	En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. (Hérité de Stream)
ReadAsync(Byte[], Int32, Int32)	Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. (Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lit de manière asynchrone le nombre d'octets spécifié dans le tableau indiqué.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. (Hérité de Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Lit de façon asynchrone les octets du flux de mémoire non managé dans la région de la mémoire.
ReadAsync(Memory<Byte>, CancellationToken)	Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. (Hérité de Stream)
ReadByte()	Lit un octet à partir d'un flux et avance d'un octet la position au sein du flux, ou retourne -1 s'il se situe à la fin du flux.
Seek(Int64, SeekOrigin)	Affecte la valeur donnée à la position actuelle du flux.
SetLength(Int64)	Affecte la valeur spécifiée à la longueur d'un flux.
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 en utilisant les 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 des données de la plage d’octets fournie.
Write(ReadOnlySpan<Byte>)	En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits. (Hérité de Stream)
WriteAsync(Byte[], Int32, Int32)	Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du 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 du nombre d'octets écrits et surveille les demandes d'annulation.
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 du nombre d'octets écrits et surveille les demandes d'annulation. (Hérité de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Écrit de façon asynchrone une plage d’octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d’octets écrits et supervise les demandes d’annulation.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. (Hérité de Stream)
WriteByte(Byte)	Écrit un octet à la position actuelle dans le flux de fichier.

Méthodes d’extension

AsInputStream(Stream)	Convertit un flux managé dans .NET pour les applications du Windows Store en un flux d’entrée Windows Runtime.
AsOutputStream(Stream)	Convertit un flux managé dans .NET pour les applications du Windows Store en un flux de sortie Windows Runtime.
AsRandomAccessStream(Stream)	Convertit le flux spécifié en flux d'accès aléatoire.
ConfigureAwait(IAsyncDisposable, Boolean)	Configure la façon dont les attentes sur les tâches retournées à partir d’un élément supprimable asynchrone sont effectuées.

S’applique à