MemoryMappedFile Classe

Definição

public ref class MemoryMappedFile : IDisposable

public class MemoryMappedFile : IDisposable

type MemoryMappedFile = class
    interface IDisposable

Public Class MemoryMappedFile
Implements IDisposable

Herança

Object

MemoryMappedFile

Implementações

IDisposable

Exemplos

O exemplo a seguir cria uma exibição mapeada por memória de uma parte de um arquivo extremamente grande e manipula uma parte dele.

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

Comentários

Um arquivo mapeado pela memória mapeia o conteúdo de um arquivo para o espaço de endereço lógico de um aplicativo. Os arquivos mapeados em memória permitem que os programadores trabalhem com arquivos extremamente grandes porque a memória pode ser gerenciada simultaneamente e permitem acesso aleatório completo a um arquivo sem a necessidade de procurar. Arquivos mapeados em memória também podem ser compartilhados em vários processos.

Os CreateFromFile métodos criam um arquivo mapeado em memória de um caminho especificado ou de um FileStream arquivo existente em disco. As alterações são propagadas automaticamente para o disco quando o arquivo é não mapeado.

Os CreateNew métodos criam um arquivo mapeado em memória que não é mapeado para um arquivo existente em disco; e são adequados para criar memória compartilhada para comunicação entre processos (IPC).

Um arquivo mapeado em memória pode ser associado a um nome opcional que permite que o arquivo mapeado em memória seja compartilhado com outros processos.

Você pode criar várias exibições do arquivo mapeado pela memória, incluindo exibições de partes do arquivo. Você pode mapear a mesma parte de um arquivo para mais de um endereço para criar memória simultânea. Para que duas exibições permaneçam simultâneas, elas precisam ser criadas a partir do mesmo arquivo mapeado em memória. A criação de dois mapeamentos de arquivo do mesmo arquivo com duas exibições não fornece simultaneidade.

Confira também

• Arquivos mapeados na memória