MemoryMappedFile Classe

Definizione

Rappresenta un file mappato alla memoria.Represents a memory-mapped file.

public ref class MemoryMappedFile : IDisposable
public class MemoryMappedFile : IDisposable
type MemoryMappedFile = class
    interface IDisposable
Public Class MemoryMappedFile
Implements IDisposable
Ereditarietà
MemoryMappedFile
Implementazioni

Esempi

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

Commenti

Un file mappato alla memoria esegue il mapping del contenuto di un file allo spazio degli indirizzi logici di un'applicazione.A memory-mapped file maps the contents of a file to an application's logical address space. I file mappati alla memoria consentono ai programmatori di lavorare con file di dimensioni molto grandi perché la memoria può essere gestita simultaneamente e consentono l'accesso completo e casuale a un file senza la necessità di cercare.Memory-mapped files enable programmers to work with extremely large files because memory can be managed concurrently, and they allow complete, random access to a file without the need for seeking. I file mappati alla memoria possono anche essere condivisi tra più processi.Memory-mapped files can also be shared across multiple processes.

I CreateFromFile metodi creano un file mappato alla memoria da un percorso specificato o FileStream da un file esistente su disco.The CreateFromFile methods create a memory-mapped file from a specified path or a FileStream of an existing file on disk. Le modifiche vengono propagate automaticamente al disco quando viene annullato il mapping del file.Changes are automatically propagated to disk when the file is unmapped.

I CreateNew metodi creano un file mappato alla memoria di cui non è stato eseguito il mapping a un file esistente su disco e sono adatti per la creazione di memoria condivisa per la comunicazione interprocesso (IPC).The CreateNew methods create a memory-mapped file that is not mapped to an existing file on disk; and are suitable for creating shared memory for interprocess communication (IPC).

Un file mappato alla memoria può essere associato a un nome facoltativo che consente di condividere il file mappato alla memoria con altri processi.A memory-mapped file can be associated with an optional name that allows the memory-mapped file to be shared with other processes.

È possibile creare più visualizzazioni del file mappato alla memoria, incluse le visualizzazioni delle parti del file.You can create multiple views of the memory-mapped file, including views of parts of the file. È possibile eseguire il mapping della stessa parte di un file a più indirizzi per creare una memoria simultanea.You can map the same part of a file to more than one address to create 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. La creazione di due mapping di file dello stesso file con due visualizzazioni non fornisce concorrenza.Creating two file mappings of the same file with two views does not provide concurrency.

Proprietà

SafeMemoryMappedFileHandle

Ottiene l'handle di file di un file mappato alla memoria.Gets the file handle of a memory-mapped file.

Metodi

CreateFromFile(FileStream, String, Int64, MemoryMappedFileAccess, HandleInheritability, Boolean)

Crea un file mappato alla memoria da un file esistente con la modalità di accesso, il nome, l'ereditabilità e la capacità specificati.Creates a memory-mapped file from an existing file with the specified access mode, name, inheritability, and capacity.

CreateFromFile(FileStream, String, Int64, MemoryMappedFileAccess, MemoryMappedFileSecurity, HandleInheritability, Boolean)

Crea un file mappato alla memoria con il nome, la capacità, il tipo di accesso, le autorizzazioni di sicurezza, l'ereditabilità e requisito di eliminazione specificati da un file su disco.Creates a memory-mapped file that has the specified name, capacity, access type, security permissions, inheritability, and disposal requirement from a file on disk.

CreateFromFile(String)

Crea un file mappato alla memoria da un file su disco.Creates a memory-mapped file from a file on disk.

CreateFromFile(String, FileMode)

Crea un file mappato alla memoria con la modalità di accesso specificata da un file su disco.Creates a memory-mapped file that has the specified access mode from a file on disk.

CreateFromFile(String, FileMode, String)

Crea un file mappato alla memoria con il nome e la modalità di accesso specificati da un file su disco.Creates a memory-mapped file that has the specified access mode and name from a file on disk.

CreateFromFile(String, FileMode, String, Int64)

Crea un file mappato alla memoria con la modalità di accesso, il nome e la capacità specificati da un file su disco.Creates a memory-mapped file that has the specified access mode, name, and capacity from a file on disk.

CreateFromFile(String, FileMode, String, Int64, MemoryMappedFileAccess)

Crea un file mappato alla memoria con la modalità di accesso, il nome, la capacità e il tipo di accesso specificati da un file su disco.Creates a memory-mapped file that has the specified access mode, name, capacity, and access type from a file on disk.

CreateNew(String, Int64)

Crea un file mappato alla memoria con la capacità specificata nella memoria di sistema.Creates a memory-mapped file that has the specified capacity in system memory.

CreateNew(String, Int64, MemoryMappedFileAccess)

Crea un file mappato alla memoria con la capacità e il tipo di accesso specificati nella memoria di sistema.Creates a memory-mapped file that has the specified capacity and access type in system memory.

CreateNew(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, HandleInheritability)

Crea un file mappato alla memoria con il nome, la capacità, il tipo di accesso, le opzioni di allocazione di memoria e l'ereditabilità specificati.Creates a memory-mapped file that has the specified name, capacity, access type, memory allocation options and inheritability.

CreateNew(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, MemoryMappedFileSecurity, HandleInheritability)

Crea un file mappato alla memoria con la capacità, il tipo di accesso, l'allocazione di memoria, le autorizzazioni di sicurezza e l'ereditabilità specificati nella memoria di sistema.Creates a memory-mapped file that has the specified capacity, access type, memory allocation, security permissions, and inheritability in system memory.

CreateOrOpen(String, Int64)

Crea o apre un file di cui è stato eseguito il mapping alla memoria che ha il nome e la capacità specificati nella memoria di sistema.Creates or opens a memory-mapped file that has the specified name and capacity in system memory.

CreateOrOpen(String, Int64, MemoryMappedFileAccess)

Crea o apre un file di cui è stato eseguito il mapping alla memoria che ha il nome, la capacità e il tipo di accesso specificati nella memoria di sistema.Creates or opens a memory-mapped file that has the specified name, capacity and access type in system memory.

CreateOrOpen(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, HandleInheritability)

Crea un nuovo file mappato alla memoria vuoto oppure ne apre uno esistente se ne esiste uno con lo stesso nome.Creates a new empty memory mapped file or opens an existing memory mapped file if one exists with the same name. Nel caso dell'apertura di un file esistente, la capacità, le opzioni e gli argomenti relativi alla memoria verranno ignorati.If opening an existing file, the capacity, options, and memory arguments will be ignored.

CreateOrOpen(String, Int64, MemoryMappedFileAccess, MemoryMappedFileOptions, MemoryMappedFileSecurity, HandleInheritability)

Crea o apre un file di cui è stato eseguito il mapping alla memoria che ha il nome, la capacità, il tipo di accesso, l'allocazione di memoria, le autorizzazioni di sicurezza e l'ereditabilità specificati nella memoria di sistema.Creates or opens a memory-mapped file that has the specified name, capacity, access type, memory allocation, security permissions, and inheritability in system memory.

CreateViewAccessor()

Crea un oggetto MemoryMappedViewAccessor mappato a una visualizzazione del file mappato alla memoria.Creates a MemoryMappedViewAccessor that maps to a view of the memory-mapped file.

CreateViewAccessor(Int64, Int64)

Crea un oggetto MemoryMappedViewAccessor mappato a una visualizzazione del file mappato alla memoria, con l'offset e la dimensione specificati.Creates a MemoryMappedViewAccessor that maps to a view of the memory-mapped file, and that has the specified offset and size.

CreateViewAccessor(Int64, Int64, MemoryMappedFileAccess)

Crea un oggetto MemoryMappedViewAccessor mappato a una visualizzazione del file mappato alla memoria, con l'offset, la dimensione e le restrizioni di accesso specificati.Creates a MemoryMappedViewAccessor that maps to a view of the memory-mapped file, and that has the specified offset, size, and access restrictions.

CreateViewStream()

Crea un flusso mappato a una visualizzazione del file mappato alla memoria.Creates a stream that maps to a view of the memory-mapped file.

CreateViewStream(Int64, Int64)

Crea un flusso mappato a una visualizzazione del file mappato alla memoria, con l'offset e la dimensione specificati.Creates a stream that maps to a view of the memory-mapped file, and that has the specified offset and size.

CreateViewStream(Int64, Int64, MemoryMappedFileAccess)

Crea un flusso mappato a una visualizzazione del file mappato alla memoria, con l'offset, la dimensione e il tipo di accesso specificati.Creates a stream that maps to a view of the memory-mapped file, and that has the specified offset, size, and access type.

Dispose()

Rilascia tutte le risorse usate da MemoryMappedFile.Releases all resources used by the MemoryMappedFile.

Dispose(Boolean)

Rilascia le risorse non gestite usate da MemoryMappedFile e, facoltativamente, le risorse gestite.Releases the unmanaged resources used by the MemoryMappedFile and optionally releases the managed resources.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetAccessControl()

Ottiene il controllo di accesso della risorsa di un file mappato alla memoria.Gets the access control to the memory-mapped file resource.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
OpenExisting(String)

Apre un file mappato alla memoria esistente con il nome specificato nella memoria di sistema.Opens an existing memory-mapped file that has the specified name in system memory.

OpenExisting(String, MemoryMappedFileRights)

Apre un file mappato alla memoria esistente con il nome e i diritti di accesso specificati nella memoria di sistema.Opens an existing memory-mapped file that has the specified name and access rights in system memory.

OpenExisting(String, MemoryMappedFileRights, HandleInheritability)

Apre un file mappato alla memoria esistente con il nome, i diritti di accesso e l'ereditabilità specificati nella memoria di sistema.Opens an existing memory-mapped file that has the specified name, access rights, and inheritability in system memory.

SetAccessControl(MemoryMappedFileSecurity)

Imposta il controllo di accesso della risorsa di un file mappato alla memoria.Sets the access control to the memory-mapped file resource.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Si applica a

Vedi anche