MemoryMappedFile Classe

Définition

Espace de noms:

System.IO.MemoryMappedFiles

Assembly:

System.IO.MemoryMappedFiles.dll

Source:

MemoryMappedFile.cs

Représente un fichier mappé en mémoire.

public ref class MemoryMappedFile : IDisposable

public class MemoryMappedFile : IDisposable

type MemoryMappedFile = class
    interface IDisposable

Public Class MemoryMappedFile
Implements IDisposable

Héritage

Object

MemoryMappedFile

Implémente

IDisposable

Exemples

L’exemple suivant crée une vue mappée en mémoire d’une partie d’un fichier très volumineux et manipule une partie de ce dernier.

using System;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Runtime.InteropServices;

class Program
{
    static void Main(string[] args)
    {
        long offset = 0x10000000; // 256 megabytes
        long length = 0x20000000; // 512 megabytes

        // Create the memory-mapped file.
        using (var mmf = MemoryMappedFile.CreateFromFile(@"c:\ExtremelyLargeImage.data", FileMode.Open,"ImgA"))
        {
            // Create a random access view, from the 256th megabyte (the offset)
            // to the 768th megabyte (the offset plus length).
            using (var accessor = mmf.CreateViewAccessor(offset, length))
            {
                int colorSize = Marshal.SizeOf(typeof(MyColor));
                MyColor color;

                // Make changes to the view.
                for (long i = 0; i < length; i += colorSize)
                {
                    accessor.Read(i, out color);
                    color.Brighten(10);
                    accessor.Write(i, ref color);
                }
            }
        }
    }
}

public struct MyColor
{
    public short Red;
    public short Green;
    public short Blue;
    public short Alpha;

    // Make the view brighter.
    public void Brighten(short value)
    {
        Red = (short)Math.Min(short.MaxValue, (int)Red + value);
        Green = (short)Math.Min(short.MaxValue, (int)Green + value);
        Blue = (short)Math.Min(short.MaxValue, (int)Blue + value);
        Alpha = (short)Math.Min(short.MaxValue, (int)Alpha + value);
    }
}

Imports System.IO
Imports System.IO.MemoryMappedFiles
Imports System.Runtime.InteropServices

Class Program

    Sub Main()
        Dim offset As Long = &H10000000 ' 256 megabytes
        Dim length As Long = &H20000000 ' 512 megabytes

        ' Create the memory-mapped file.
        Using mmf = MemoryMappedFile.CreateFromFile("c:\ExtremelyLargeImage.data", FileMode.Open, "ImgA")
            ' Create a random access view, from the 256th megabyte (the offset)
            ' to the 768th megabyte (the offset plus length).
            Using accessor = mmf.CreateViewAccessor(offset, length)
                Dim colorSize As Integer = Marshal.SizeOf(GetType(MyColor))
                Dim color As MyColor
                Dim i As Long = 0

                ' Make changes to the view.
                Do While (i < length)
                    accessor.Read(i, color)
                    color.Brighten(10)
                    accessor.Write(i, color)
                    i += colorSize
                Loop
            End Using
        End Using
    End Sub
End Class

Public Structure MyColor
    Public Red As Short
    Public Green As Short
    Public Blue As Short
    Public Alpha As Short

    ' Make the view brighter.
    Public Sub Brighten(ByVal value As Short)
        Red = CType(Math.Min(Short.MaxValue, (CType(Red, Integer) + value)), Short)
        Green = CType(Math.Min(Short.MaxValue, (CType(Green, Integer) + value)), Short)
        Blue = CType(Math.Min(Short.MaxValue, (CType(Blue, Integer) + value)), Short)
        Alpha = CType(Math.Min(Short.MaxValue, (CType(Alpha, Integer) + value)), Short)
    End Sub
End Structure

Remarques

Un fichier mappé en mémoire mappe le contenu d’un fichier à l’espace d’adressage logique d’une application. Les fichiers mappés en mémoire permettent aux programmeurs d’utiliser des fichiers extrêmement volumineux, car la mémoire peut être gérée simultanément, et ils autorisent un accès complet et aléatoire à un fichier sans avoir à rechercher. Les fichiers mappés en mémoire peuvent également être partagés entre plusieurs processus.

Les CreateFromFile méthodes créent un fichier mappé en mémoire à partir d’un chemin d’accès spécifié ou d’un FileStream fichier existant sur le disque. Les modifications sont automatiquement propagées sur le disque lorsque le fichier n’est pas mappé.

Les CreateNew méthodes créent un fichier mappé en mémoire qui n’est pas mappé à un fichier existant sur le disque ; et sont adaptées à la création de mémoire partagée pour la communication interprocess (IPC).

Un fichier mappé en mémoire peut être associé à un nom facultatif qui permet de partager le fichier mappé en mémoire avec d’autres processus.

Vous pouvez créer plusieurs vues du fichier mappé en mémoire, y compris des vues de parties du fichier. Vous pouvez mapper la même partie d’un fichier à plusieurs adresses pour créer de la mémoire simultanée. Pour que deux vues restent simultanées, elles doivent être créées à partir du même fichier mappé en mémoire. La création de deux mappages de fichiers du même fichier avec deux vues ne fournit pas d’accès concurrentiel.

Propriétés

SafeMemoryMappedFileHandle

Obtient le handle de fichier d'un fichier mappé en mémoire.

Méthodes

CreateFromFile(FileStream, String, Int64, MemoryMappedFileAccess, HandleInheritability, Boolean)	Crée un fichier mappé en mémoire à partir d’un fichier existant avec le mode d’accès, le nom, les règles d’héritage et la capacité spécifiés.
CreateFromFile(SafeFileHandle, String, Int64, MemoryMappedFileAccess, HandleInheritability, Boolean)	Crée un fichier mappé en mémoire à partir d’un fichier existant à l’aide d’un SafeFileHandle et du mode d’accès, du nom, de l’héritage et de la capacité spécifiés.
CreateFromFile(String)	Crée un fichier mappé en mémoire à partir d'un fichier sur le disque.
CreateFromFile(String, FileMode)	Crée un fichier mappé en mémoire qui a le mode d’accès spécifié d’un fichier sur le disque.
CreateFromFile(String, FileMode, String)	Crée un fichier mappé en mémoire qui a le mode d'accès et le nom spécifiés d'un fichier sur le disque.
CreateFromFile(String, FileMode, String, Int64)	Crée un fichier mappé en mémoire qui a le mode d'accès, le nom et la capacité spécifiés d'un fichier sur le disque.
CreateFromFile(String, FileMode, String, Int64, MemoryMappedFileAccess)	Crée un fichier mappé en mémoire qui a le mode d'accès, le nom, la capacité et le type d'accès spécifiés d'un fichier sur le disque.
CreateNew(String, Int64)	Crée un fichier mappé en mémoire qui a la capacité spécifiée dans la mémoire système.
CreateNew(String, Int64, MemoryMappedFileAccess)	Crée un fichier mappé en mémoire qui a la capacité et le type d’accès spécifiés dans la mémoire système.
CreateNew(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, HandleInheritability)	Crée un fichier mappé en mémoire qui a le nom, la capacité, le type d’accès, les options d’allocation mémoire et les règles d’héritage spécifiés.
CreateOrOpen(String, Int64)	Crée ou ouvre un fichier mappé en mémoire qui a la capacité et le nom spécifiés dans la mémoire système.
CreateOrOpen(String, Int64, MemoryMappedFileAccess)	Crée ou ouvre un fichier mappé en mémoire qui a la capacité, le nom et le type d’accès spécifiés dans la mémoire système.
CreateOrOpen(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, HandleInheritability)	Crée un fichier mappé en mémoire vide ou ouvre un fichier mappé en mémoire existant s’il en existe un du même nom. En cas d’ouverture d’un fichier existant, la capacité, les options et les arguments de mémoire sont ignorés.
CreateViewAccessor()	Crée un objet MemoryMappedViewAccessor mappé à un affichage du fichier mappé en mémoire.
CreateViewAccessor(Int64, Int64)	Crée un MemoryMappedViewAccessor mappé à une vue du fichier mappé en mémoire et ayant le décalage et la taille spécifiés.
CreateViewAccessor(Int64, Int64, MemoryMappedFileAccess)	Crée un MemoryMappedViewAccessor mappé à une vue du fichier mappé en mémoire et ayant le décalage, la taille et les restrictions d’accès spécifiés.
CreateViewStream()	Crée un flux mappé à un affichage du fichier mappé en mémoire.
CreateViewStream(Int64, Int64)	Crée un flux mappé à un affichage du fichier mappé en mémoire et ayant le décalage et la taille spécifiés.
CreateViewStream(Int64, Int64, MemoryMappedFileAccess)	Crée un flux mappé à un affichage du fichier mappé en mémoire et ayant le décalage, la taille et le type d'accès spécifiés.
Dispose()	Libère toutes les ressources utilisées par MemoryMappedFile.
Dispose(Boolean)	Libère les ressources non managées utilisées par MemoryMappedFile et libère éventuellement les ressources managées.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
OpenExisting(String)	Ouvre un fichier mappé en mémoire existant qui a le nom spécifié dans la mémoire système.
OpenExisting(String, MemoryMappedFileRights)	Ouvre un fichier mappé en mémoire existant qui a le nom et les droits d'accès spécifiés dans la mémoire système.
OpenExisting(String, MemoryMappedFileRights, HandleInheritability)	Ouvre un fichier mappé en mémoire existant qui a le nom, les droits d'accès et les règles d'héritage spécifiés dans la mémoire système.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Voir aussi

• Fichiers mappés en mémoire