UnmanagedMemoryStream Classe

Définition

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é.Provides access to unmanaged blocks of memory from managed code.

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
Public Class UnmanagedMemoryStream
Inherits Stream
Héritage
UnmanagedMemoryStream
Héritage
UnmanagedMemoryStream
Dérivé
Attributs

Exemples

L’exemple de code suivant montre comment lire et écrire dans la mémoire non managée à l’aide de la classe UnmanagedMemoryStream.The following code example demonstrates how to read from and write to unmanaged memory using the UnmanagedMemoryStream class. Un bloc de mémoire non managée est alloué et désalloué à l’aide de la classe Marshal.A block of unmanaged memory is allocated and de-allocated using the Marshal class.


// 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.This class supports access to unmanaged memory using the existing stream-based model and does not require that the contents in the unmanaged memory be copied to the heap.

Notes

Ce type implémente l’interface IDisposable, mais il n’a en fait aucune ressource à supprimer.This type implements the IDisposable interface, but does not actually have any resources to dispose. 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.This means that disposing it by directly calling Dispose() or by using a language construct such as using (in C#) or Using (in Visual Basic) is not necessary.

Constructeurs

UnmanagedMemoryStream()

Initialise une nouvelle instance de la classe UnmanagedMemoryStream.Initializes a new instance of the UnmanagedMemoryStream class.

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.Initializes a new instance of the UnmanagedMemoryStream class using the specified location and memory length.

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.Initializes a new instance of the UnmanagedMemoryStream class using the specified location, memory length, total amount of memory, and file access values.

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.Initializes a new instance of the UnmanagedMemoryStream class in a safe buffer with a specified offset and length.

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.Initializes a new instance of the UnmanagedMemoryStream class in a safe buffer with a specified offset, length, and file access.

Propriétés

CanRead

Obtient une valeur indiquant si un flux prend en charge la lecture.Gets a value indicating whether a stream supports reading.

CanSeek

Obtient une valeur indiquant si un flux prend en charge la recherche.Gets a value indicating whether a stream supports seeking.

CanTimeout

Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente.Gets a value that determines whether the current stream can time out.

(Hérité de Stream)
CanWrite

Obtient une valeur indiquant si un flux prend en charge l'écriture.Gets a value indicating whether a stream supports writing.

Capacity

Obtient la longueur de flux (taille) ou la quantité totale de mémoire assignée au flux (capacité).Gets the stream length (size) or the total amount of memory assigned to a stream (capacity).

Length

Obtient la longueur des données dans un flux.Gets the length of the data in a stream.

Position

Obtient ou définit la position actuelle dans un flux.Gets or sets the current position in a stream.

PositionPointer

Obtient ou définit un pointeur d'octet vers un flux basé sur la position actuelle.Gets or sets a byte pointer to a stream based on the current position in the stream.

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.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to read before timing out.

(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.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to write before timing out.

(Hérité de Stream)

Méthodes

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Commence une opération de lecture asynchrone.Begins an asynchronous read operation. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Hérité de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Commence une opération d'écriture asynchrone.Begins an asynchronous write operation. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(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.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Au lieu d'appeler cette méthode, assurez-vous que le flux est correctement supprimé.Instead of calling this method, ensure that the stream is properly disposed.

(Hérité de Stream)
CopyTo(Stream)

Lit les octets du flux actuel et les écrit dans un autre flux.Reads the bytes from the current stream and writes them to another stream.

(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.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Hérité de Stream)
CopyToAsync(Stream)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux.Asynchronously reads the bytes from the current stream and writes them to another stream.

(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é.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(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.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(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.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(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.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Hérité de MarshalByRefObject)
CreateWaitHandle()

Alloue un objet WaitHandle.Allocates a WaitHandle object.

(Hérité de Stream)
Dispose()

Libère toutes les ressources utilisées par Stream.Releases all resources used by the 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.Releases the unmanaged resources used by the UnmanagedMemoryStream and optionally releases the managed resources.

DisposeAsync()

Libère de façon asynchrone les ressources non managées utilisées par Stream.Asynchronously releases the unmanaged resources used by the Stream.

(Hérité de Stream)
EndRead(IAsyncResult)

Attend la fin de la lecture asynchrone en attente.Waits for the pending asynchronous read to complete. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Hérité de Stream)
EndWrite(IAsyncResult)

Termine une opération d'écriture asynchrone.Ends an asynchronous write operation. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Hérité de Stream)
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
Flush()

Remplace la méthode Flush() afin qu'aucune action ne soit effectuée.Overrides the Flush() method so that no action is performed.

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.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(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.Overrides the FlushAsync(CancellationToken) method so that the operation is cancelled if specified, but no other action is performed.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetLifetimeService()

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.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(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.Initializes a new instance of the UnmanagedMemoryStream class by using a pointer to an unmanaged memory location.

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.Initializes a new instance of the UnmanagedMemoryStream class in a safe buffer with a specified offset, length, and file access.

InitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(Hérité de MarshalByRefObject)
ObjectInvariant()

Assure la prise en charge d'un Contract.Provides support for a Contract.

(Hérité de Stream)
Read(Byte[], Int32, Int32)

Lit le nombre d'octets spécifié dans le tableau indiqué.Reads the specified number of bytes into the specified array.

Read(Span<Byte>)

Lit tous les octets de ce flux de mémoire non managé dans la plage d’octets spécifiée.Reads all the bytes of this unmanaged memory stream into the specified span of bytes.

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.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lit de manière asynchrone le nombre d'octets spécifié dans le tableau indiqué.Asynchronously reads the specified number of bytes into the specified array.

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.Asynchronously reads the unmanaged memory stream bytes into the memory region.

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.Reads a byte from a stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

Seek(Int64, SeekOrigin)

Affecte la valeur donnée à la position actuelle du flux.Sets the current position of the current stream to the given value.

SetLength(Int64)

Affecte la valeur spécifiée à la longueur d'un flux.Sets the length of a stream to a specified value.

ToString()

Retourne une chaîne qui représente l'objet actif.Returns a string that represents the current object.

(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.Writes a block of bytes to the current stream using data from a buffer.

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.Writes a block of bytes to the current unmanaged memory stream using data from the provided span of bytes.

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.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(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.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

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.Asynchronously writes a span of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

WriteByte(Byte)

Écrit un octet à la position actuelle dans le flux de fichier.Writes a byte to the current position in the file stream.

Implémentations d’interfaces explicites

IDisposable.Dispose()

Libère toutes les ressources utilisées par Stream.Releases all resources used by the Stream.

(Hérité de Stream)

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.Converts a managed stream in the .NET for Windows Store apps to an input stream in the Windows Runtime.

AsOutputStream(Stream)

Convertit un flux managé dans .NET pour les applications du Windows Store en un flux de sortie Windows Runtime.Converts a managed stream in the .NET for Windows Store apps to an output stream in the Windows Runtime.

AsRandomAccessStream(Stream)

Convertit le flux spécifié en flux d'accès aléatoire.Converts the specified stream to a random access stream.

S’applique à