File mappati alla memoriaMemory-mapped files

Un file mappato alla memoria include il contenuto di un file nella memoria virtuale.A memory-mapped file contains the contents of a file in virtual memory. Questo mapping tra un file e uno spazio di memoria consente a un'applicazione, inclusi più processi, di modificare il file leggendo e scrivendo direttamente nella memoria.This mapping between a file and memory space enables an application, including multiple processes, to modify the file by reading and writing directly to the memory. È possibile utilizzare il codice gestito per accedere ai file mappati alla memoria nello stesso modo in cui le funzioni Windows native accedono ai file mappati alla memoria, come descritto in gestione dei file di Memory-Mapped.You can use managed code to access memory-mapped files in the same way that native Windows functions access memory-mapped files, as described in Managing Memory-Mapped Files.

Esistono due tipi di file di cui è stato eseguito il mapping alla memoria:There are two types of memory-mapped files:

  • File persistenti di cui è stato eseguito il mapping alla memoriaPersisted memory-mapped files

    I file persistenti sono file di cui è stato eseguito il mapping alla memoria associati a un file di origine su un disco.Persisted files are memory-mapped files that are associated with a source file on a disk. Quando l'ultimo processo ha terminato di usare il file, i dati vengono salvati nel file di origine sul disco.When the last process has finished working with the file, the data is saved to the source file on the disk. Questi file di cui è stato eseguito il mapping alla memoria sono adatti per usare file di origine di dimensioni molto grandi.These memory-mapped files are suitable for working with extremely large source files.

  • File non persistenti di cui è stato eseguito il mapping alla memoriaNon-persisted memory-mapped files

    I file non persistenti sono file di cui è stato eseguito il mapping alla memoria non associati a un file su un disco.Non-persisted files are memory-mapped files that are not associated with a file on a disk. Quando l'ultimo processo ha terminato di usare il file, i dati vanno persi e il file viene recuperato dalla Garbage Collection.When the last process has finished working with the file, the data is lost and the file is reclaimed by garbage collection. Questi file sono adatti per la creazione di memoria condivisa per le comunicazioni interprocesso (IPC).These files are suitable for creating shared memory for inter-process communications (IPC).

Processi, visualizzazioni e gestione della memoriaProcesses, Views, and Managing Memory

I file di cui è stato eseguito il mapping alla memoria non possono essere condivisi tra più processi.Memory-mapped files can be shared across multiple processes. I processi possono eseguire il mapping allo stesso file di cui è stato eseguito il mapping alla memoria usando un nome comune assegnato dal processo che ha creato il file.Processes can map to the same memory-mapped file by using a common name that is assigned by the process that created the file.

Per usare un file di cui è stato eseguito il mapping alla memoria, è necessario creare una visualizzazione dell'intero file di cui è stato eseguito il mapping alla memoria o di una parte.To work with a memory-mapped file, you must create a view of the entire memory-mapped file or a part of it. È anche possibile creare più visualizzazioni alla stessa parte del file di cui è stato eseguito il mapping alla memoria, creando quindi una memoria simultanea.You can also create multiple views to the same part of the memory-mapped file, thereby creating concurrent memory. Per rimanere simultanee, due visualizzazioni devono essere create dallo stesso file di cui è stato eseguito il mapping alla memoria.For two views to remain concurrent, they have to be created from the same memory-mapped file.

Potrebbero essere necessarie più visualizzazioni Se il file è maggiore della dimensione dello spazio di memoria logica dell'applicazione disponibile per il mapping della memoria (2 GB in un computer a 32 bit).Multiple views may also be necessary if the file is greater than the size of the application's logical memory space available for memory mapping (2 GB on a 32-bit computer).

Esistono due tipi di visualizzazioni: visualizzazione di accesso a flusso e visualizzazione di accesso casuale.There are two types of views: stream access view and random access view. Usare le visualizzazioni di accesso a flusso per l'accesso sequenziale a un file. Questa opzione è consigliata per i file non persistenti e la comunicazione interprocesso.Use stream access views for sequential access to a file; this is recommended for non-persisted files and IPC. Le visualizzazioni di accesso casuale sono preferibili per l'uso di file persistenti.Random access views are preferred for working with persisted files.

È possibile accedere ai file mappati alla memoria tramite il gestore della memoria del sistema operativo, in modo che il file venga partizionato automaticamente in un numero di pagine e accessibile in base alle esigenze.Memory-mapped files are accessed through the operating system's memory manager, so the file is automatically partitioned into a number of pages and accessed as needed. Non è necessario occuparsi personalmente della gestione della memoria.You do not have to handle the memory management yourself.

La figura seguente illustra come più processi possono avere contemporaneamente più visualizzazioni sovrapposte per lo stesso file di cui è stato eseguito il mapping alla memoria.The following illustration shows how multiple processes can have multiple and overlapping views to the same memory-mapped file at the same time.

L'immagine seguente illustra più visualizzazioni sovrapposte per un file di cui è stato eseguito il mapping alla memoria:The following image shows multiple and overlapped views to a memory-mapped file:

Screenshot che illustra le visualizzazioni per un file di cui è stato eseguito il mapping alla memoria.

Programmazione con i file di cui è stato eseguito il mapping alla memoriaProgramming with Memory-Mapped Files

La tabella seguente fornisce una guida all'uso di oggetti di file di cui è stato eseguito il mapping alla memoria e dei relativi membri.The following table provides a guide for using memory-mapped file objects and their members.

AttivitàTask Metodi o proprietà da usareMethods or properties to use
Ottenere un oggetto MemoryMappedFile che rappresenta un file persistente di cui è stato eseguito il mapping alla memoria da un file su disco.To obtain a MemoryMappedFile object that represents a persisted memory-mapped file from a file on disk. MetodoMemoryMappedFile.CreateFromFile .MemoryMappedFile.CreateFromFile method.
Ottenere un oggetto MemoryMappedFile che rappresenta un file non persistente di cui è stato eseguito il mapping alla memoria (non associato a un file su disco).To obtain a MemoryMappedFile object that represents a non-persisted memory-mapped file (not associated with a file on disk). MetodoMemoryMappedFile.CreateNew .MemoryMappedFile.CreateNew method.

- oppure -- or -

MetodoMemoryMappedFile.CreateOrOpen .MemoryMappedFile.CreateOrOpen method.
Ottenere un oggetto MemoryMappedFile di un file esistente di cui è stato eseguito il mapping alla memoria (persistente o non persistente).To obtain a MemoryMappedFile object of an existing memory-mapped file (either persisted or non-persisted). MetodoMemoryMappedFile.OpenExisting .MemoryMappedFile.OpenExisting method.
Ottenere un oggetto UnmanagedMemoryStream per una visualizzazione accessibile in sequenza per il file di cui è stato eseguito il mapping alla memoria.To obtain a UnmanagedMemoryStream object for a sequentially accessed view to the memory-mapped file. MetodoMemoryMappedFile.CreateViewStream .MemoryMappedFile.CreateViewStream method.
Ottenere un oggetto UnmanagedMemoryAccessor per una visualizzazione di accesso casuale per un file di cui è stato eseguito il mapping alla memoria.To obtain a UnmanagedMemoryAccessor object for a random access view to a memory-mapped fie. MetodoMemoryMappedFile.CreateViewAccessor .MemoryMappedFile.CreateViewAccessor method.
Ottenere un oggetto SafeMemoryMappedViewHandle da usare con il codice non gestito.To obtain a SafeMemoryMappedViewHandle object to use with unmanaged code. Proprietà MemoryMappedFile.SafeMemoryMappedFileHandle.MemoryMappedFile.SafeMemoryMappedFileHandle property.

- oppure -- or -

Proprietà MemoryMappedViewAccessor.SafeMemoryMappedViewHandle.MemoryMappedViewAccessor.SafeMemoryMappedViewHandle property.

- oppure -- or -

Proprietà MemoryMappedViewStream.SafeMemoryMappedViewHandle.MemoryMappedViewStream.SafeMemoryMappedViewHandle property.
Ritardare l'allocazione della memoria finché non viene creata una visualizzazione (solo file non persistenti).To delay allocating memory until a view is created (non-persisted files only).

Per determinare la dimensione di paging del sistema corrente, usare la proprietà Environment.SystemPageSize.(To determine the current system page size, use the Environment.SystemPageSize property.)
Metodo CreateNew con il valore MemoryMappedFileOptions.DelayAllocatePages.CreateNew method with the MemoryMappedFileOptions.DelayAllocatePages value.

- oppure -- or -

Metodi CreateOrOpen che hanno un'enumerazione MemoryMappedFileOptions come parametro.CreateOrOpen methods that have a MemoryMappedFileOptions enumeration as a parameter.

SicurezzaSecurity

È possibile applicare i diritti di accesso quando si crea un file di cui è stato eseguito il mapping alla memoria, usando i metodi seguenti che accettano un'enumerazione MemoryMappedFileAccess come parametro:You can apply access rights when you create a memory-mapped file, by using the following methods that take a MemoryMappedFileAccess enumeration as a parameter:

È possibile specificare i diritti di accesso per l'apertura di un file esistente di cui è stato eseguito il mapping alla memoria usando i metodi OpenExisting che accettano MemoryMappedFileRights come parametro.You can specify access rights for opening an existing memory-mapped file by using the OpenExisting methods that take an MemoryMappedFileRights as a parameter.

È anche possibile includere un oggetto MemoryMappedFileSecurity che contiene le regole di accesso predefinite.In addition, you can include a MemoryMappedFileSecurity object that contains predefined access rules.

Per applicare regole di accesso nuove o modificate a un file di cui è stato eseguito il mapping alla memoria, usare il metodo SetAccessControl.To apply new or changed access rules to a memory-mapped file, use the SetAccessControl method. Per recuperare le regole di accesso o controllo da un file esistente, usare il metodo GetAccessControl.To retrieve access or audit rules from an existing file, use the GetAccessControl method.

EsempiExamples

File persistenti di cui è stato eseguito il mapping alla memoriaPersisted Memory-Mapped Files

I metodi CreateFromFile creano un file di cui viene eseguito il mapping alla memoria da un file esistente su disco.The CreateFromFile methods create a memory-mapped file from an existing file on disk.

L'esempio seguente crea una visualizzazione di cui viene eseguito il mapping alla memoria di una parte di un file molto grande e ne modifica una parte.The following example creates a memory-mapped view of a part of an extremely large file and manipulates a portion of it.

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

Per visualizzare i commenti del codice tradotti in lingue diverse dall'inglese, segnalare il problema in questo argomento di discussione su GitHub.If you would like to see code comments translated to languages other than English, let us know in this GitHub discussion issue.

L'esempio seguente apre lo stesso file di cui è stato eseguito il mapping alla memoria per un altro processo.The following example opens the same memory-mapped file for another process.

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

class Program
{
    static void Main(string[] args)
    {
        // Assumes another process has created the memory-mapped file.
        using (var mmf = MemoryMappedFile.OpenExisting("ImgA"))
        {
            using (var accessor = mmf.CreateViewAccessor(4000000, 2000000))
            {
                int colorSize = Marshal.SizeOf(typeof(MyColor));
                MyColor color;

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

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

    // Make the view brigher.
    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.MemoryMappedFiles
Imports System.Runtime.InteropServices

Class Program
    Public Shared Sub Main(ByVal args As String())
        ' Assumes another process has created the memory-mapped file.
        Using mmf = MemoryMappedFile.OpenExisting("ImgA")
            Using accessor = mmf.CreateViewAccessor(4000000, 2000000)
                Dim colorSize As Integer = Marshal.SizeOf(GetType(MyColor))
                Dim color As MyColor

                ' Make changes to the view.
                Dim i As Long = 0
                While i < 1500000
                    accessor.Read(i, color)
                    color.Brighten(30)
                    accessor.Write(i, color)
                    i += colorSize
                End While
            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 brigher.
    Public Sub Brighten(ByVal value As Short)
        Red = CShort(Math.Min(Short.MaxValue, CInt(Red) + value))
        Green = CShort(Math.Min(Short.MaxValue, CInt(Green) + value))
        Blue = CShort(Math.Min(Short.MaxValue, CInt(Blue) + value))
        Alpha = CShort(Math.Min(Short.MaxValue, CInt(Alpha) + value))
    End Sub
End Structure

File non persistenti di cui è stato eseguito il mapping alla memoriaNon-Persisted Memory-Mapped Files

I metodi CreateNew e CreateOrOpen creano un file di cui viene eseguito il mapping alla memoria del quale non viene eseguito il mapping a un file esistente su disco.The CreateNew and CreateOrOpen methods create a memory-mapped file that is not mapped to an existing file on disk.

L'esempio seguente è costituito da tre processi separati (applicazioni console) che scrivono i valori booleani in un file di cui è stato eseguito il mapping alla memoria.The following example consists of three separate processes (console applications) that write Boolean values to a memory-mapped file. Si verifica la sequenza di azioni seguente:The following sequence of actions occur:

  1. Process A crea il file di cui viene eseguito il mapping alla memoria e vi scrive un valore.Process A creates the memory-mapped file and writes a value to it.

  2. Process B apre il file di cui è stato eseguito il mapping alla memoria e vi scrive un valore.Process B opens the memory-mapped file and writes a value to it.

  3. Process C apre il file di cui è stato eseguito il mapping alla memoria e vi scrive un valore.Process C opens the memory-mapped file and writes a value to it.

  4. Process A legge e visualizza i valori dal file di cui è stato eseguito il mapping alla memoria.Process A reads and displays the values from the memory-mapped file.

  5. Dopo che Process A è terminato con il file di cui è stato eseguito il mapping alla memoria, il file viene immediatamente recuperato dalla Garbage Collection.After Process A is finished with the memory-mapped file, the file is immediately reclaimed by garbage collection.

Per eseguire questo esempio, seguire questa procedura:To run this example, do the following:

  1. Compilare le applicazioni e aprire tre finestre del prompt dei comandi.Compile the applications and open three Command Prompt windows.

  2. Nella prima finestra del prompt dei comandi eseguire Process A.In the first Command Prompt window, run Process A.

  3. Nella seconda finestra del prompt dei comandi eseguire Process B.In the second Command Prompt window, run Process B.

  4. Tornare a Process A e premere INVIO.Return to Process A and press ENTER.

  5. Nella terza finestra del prompt dei comandi eseguire Process C.In the third Command Prompt window, run Process C.

  6. Tornare a Process A e premere INVIO.Return to Process A and press ENTER.

L'output di Process A è indicato di seguito:The output of Process A is as follows:

Start Process B and press ENTER to continue.  
Start Process C and press ENTER to continue.  
Process A says: True  
Process B says: False  
Process C says: True  

Process AProcess A

using System;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Threading;

class Program
{
    // Process A:
    static void Main(string[] args)
    {
        using (MemoryMappedFile mmf = MemoryMappedFile.CreateNew("testmap", 10000))
        {
            bool mutexCreated;
            Mutex mutex = new Mutex(true, "testmapmutex", out mutexCreated);
            using (MemoryMappedViewStream stream = mmf.CreateViewStream())
            {
                BinaryWriter writer = new BinaryWriter(stream);
                writer.Write(1);
            }
            mutex.ReleaseMutex();

            Console.WriteLine("Start Process B and press ENTER to continue.");
            Console.ReadLine();

            Console.WriteLine("Start Process C and press ENTER to continue.");
            Console.ReadLine();

            mutex.WaitOne();
            using (MemoryMappedViewStream stream = mmf.CreateViewStream())
            {
                BinaryReader reader = new BinaryReader(stream);
                Console.WriteLine("Process A says: {0}", reader.ReadBoolean());
                Console.WriteLine("Process B says: {0}", reader.ReadBoolean());
                Console.WriteLine("Process C says: {0}", reader.ReadBoolean());
            }
            mutex.ReleaseMutex();
        }
    }
}
Imports System.IO
Imports System.IO.MemoryMappedFiles
Imports System.Threading

Module Module1

    ' Process A:
    Sub Main()
        Using mmf As MemoryMappedFile = MemoryMappedFile.CreateNew("testmap", 10000)
            Dim mutexCreated As Boolean
            Dim mTex As Mutex = New Mutex(True, "testmapmutex", mutexCreated)
            Using Stream As MemoryMappedViewStream = mmf.CreateViewStream()
                Dim writer As BinaryWriter = New BinaryWriter(Stream)
                writer.Write(1)
            End Using
            mTex.ReleaseMutex()
            Console.WriteLine("Start Process B and press ENTER to continue.")
            Console.ReadLine()

            Console.WriteLine("Start Process C and press ENTER to continue.")
            Console.ReadLine()

            mTex.WaitOne()
            Using Stream As MemoryMappedViewStream = mmf.CreateViewStream()
                Dim reader As BinaryReader = New BinaryReader(Stream)
                Console.WriteLine("Process A says: {0}", reader.ReadBoolean())
                Console.WriteLine("Process B says: {0}", reader.ReadBoolean())
                Console.WriteLine("Process C says: {0}", reader.ReadBoolean())
            End Using
            mTex.ReleaseMutex()

        End Using

    End Sub

End Module

Process BProcess B

using System;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Threading;

class Program
{
    // Process B:
    static void Main(string[] args)
    {
        try
        {
            using (MemoryMappedFile mmf = MemoryMappedFile.OpenExisting("testmap"))
            {

                Mutex mutex = Mutex.OpenExisting("testmapmutex");
                mutex.WaitOne();

                using (MemoryMappedViewStream stream = mmf.CreateViewStream(1, 0))
                {
                    BinaryWriter writer = new BinaryWriter(stream);
                    writer.Write(0);
                }
                mutex.ReleaseMutex();
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("Memory-mapped file does not exist. Run Process A first.");
        }
    }
}
Imports System.IO
Imports System.IO.MemoryMappedFiles
Imports System.Threading

Module Module1
    ' Process B:
    Sub Main()
        Try
            Using mmf As MemoryMappedFile = MemoryMappedFile.OpenExisting("testmap")
                Dim mTex As Mutex = Mutex.OpenExisting("testmapmutex")
                mTex.WaitOne()
                Using Stream As MemoryMappedViewStream = mmf.CreateViewStream(1, 0)
                    Dim writer As BinaryWriter = New BinaryWriter(Stream)
                    writer.Write(0)
                End Using
                mTex.ReleaseMutex()
            End Using
        Catch noFile As FileNotFoundException
            Console.WriteLine("Memory-mapped file does not exist. Run Process A first." & vbCrLf & noFile.Message)
        End Try

    End Sub

End Module

Process CProcess C

using System;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Threading;

class Program
{
    // Process C:
    static void Main(string[] args)
    {
        try
        {
            using (MemoryMappedFile mmf = MemoryMappedFile.OpenExisting("testmap"))
            {

                Mutex mutex = Mutex.OpenExisting("testmapmutex");
                mutex.WaitOne();

                using (MemoryMappedViewStream stream = mmf.CreateViewStream(2, 0))
                {
                    BinaryWriter writer = new BinaryWriter(stream);
                    writer.Write(1);
                }
                mutex.ReleaseMutex();
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("Memory-mapped file does not exist. Run Process A first, then B.");
        }
    }
}
Imports System.IO
Imports System.IO.MemoryMappedFiles
Imports System.Threading

Module Module1
    ' Process C:
    Sub Main()
        Try
            Using mmf As MemoryMappedFile = MemoryMappedFile.OpenExisting("testmap")
                Dim mTex As Mutex = Mutex.OpenExisting("testmapmutex")
                mTex.WaitOne()
                Using Stream As MemoryMappedViewStream = mmf.CreateViewStream(2, 0)
                    Dim writer As BinaryWriter = New BinaryWriter(Stream)
                    writer.Write(1)
                End Using
                mTex.ReleaseMutex()
            End Using
        Catch noFile As FileNotFoundException
            Console.WriteLine("Memory-mapped file does not exist. Run Process A first, then B." & vbCrLf & noFile.Message)
        End Try

    End Sub

End Module

Vedere ancheSee also