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 de mapeamento na memória de parte de um arquivo muito grande e manipula uma porção 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 em memória mapeia o conteúdo de um arquivo para o espaço de endereço lógico de um aplicativo. 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 completo e aleatório a um arquivo sem a necessidade de busca. Arquivos mapeados em memória também podem ser compartilhados em vários processos.

Os CreateFromFile métodos criam um arquivo mapeado na memória de um caminho especificado ou de um FileStream arquivo existente no 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 no 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 na memória seja compartilhado com outros processos.

Você pode criar várias exibições do arquivo mapeado em 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 dois modos de exibição permaneçam simultâneos, precisam ser criados usando o mesmo arquivo de memória mapeada. A criação de dois mapeamentos de arquivo do mesmo arquivo com dois modos de exibição não fornece simultaneidade.

Propriedades

Métodos

Aplica-se a

Confira também

• Arquivos mapeados em memória