C# - Trabalhando com arquivos mapeados na memória

Neste artigo veremos como trabalhar com arquivos mapeados na memória.

Um arquivo mapeado pela memória tem o conteúdo de um arquivo em memória virtual. Esse mapeamento entre um espaço de arquivo e a memória permite que um aplicativo, inclusive vários processos, modifique o arquivo ao ler e gravar diretamente na memória.

Dessa forma arquivos mapeados na memória permitem acessar arquivos ou compartilhar a memória de diferentes processos.

Existem diversos cenários e recursos com essa tecnologia:

• Fazer o acesso aleatório e rápido a arquivos enormes usando mapas do arquivo;
• Compartilhar arquivos entre diferentes processos ou tarefas;
• Compartilhar a memória entre diferentes processos ou tarefas;
• Usar acessores para ler e escrever diretamente de posições de memória;
• Usar fluxos para ler e escrever;

Assim esse recurso fornece uma vantagem de desempenho. Ele pode ser encontrado no namespace System.IO.MemoryMappedFiles sendo um tipo de dados abstrato.

Há dois tipos de arquivos mapeados na memória:

• Arquivos persistentes mapeados na memória

  Arquivos persistentes são arquivos mapeados na memória associados a um arquivo de origem em um disco. Quando o último processo termina de trabalhar com o arquivo, os dados são salvos no arquivo de origem no disco. Esses arquivos mapeados na memória são adequados para trabalhar com arquivos de origem muito grandes.
   

• Arquivos não persistentes mapeados na memória

  Arquivos não persistentes são arquivos mapeados na memória não associados a um arquivo em disco. Quando o último processo termina de trabalhar com o arquivo, os dados são perdidos e o arquivo é solicitado pela coleta de lixo. Esses arquivos são adequados para a criação de memória compartilhada para comunicações entre processos (IPC).

A API de arquivos mapeados na memória permite usar um arquivo físico ou uma memória compartilhada - onde
o arquivo de paginação do sistema é usado como um armazenamento de apoio. A memória compartilhada pode ser maior que a memória física disponível , portanto, é necessário um suporte.

Com uma dessas opções, você pode atribuir um nome para o mapa de memória, e assim permitir que diferentes processos tenham acesso à mesma memória compartilhada.

Depois de criar o mapa de memória, você pode criar uma visualização. Uma visão é usada para mapear uma parte do arquivo completo de memória mapeada para acessá-lo para leitura ou escrita.

Temos a disposição os seguintes recursos para trabalhar com arquivos mapeados em memória:

• MemoryMappedFile – representação de um arquivo mapeado na memória;
• MemoryMappedFileSecurity – permissões para arquivo mapeado na memória;
• MemoryMappedViewAccessor – visão acessada randomicamente de um arquivo mapeado na memória;
• MemoryMappedViewStream – representação uma stream acessada sequenciamente;

Vejamos como isso funciona na prática.

Criando o projeto Console

Vamos criar  uma aplicação Console  App (.NET Core) usando o VS 2017 Community com o nome NetCore_MapFiles.

Inclua o código abaixo no arquivo Program.cs :

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

namespace NetCore_MapFiles
{
    public struct MinhaCor
    {
        public short Red;
        public short Green;
        public short Blue;
        public short Alpha;

        // Torna a view mais brilhante
        public void Brilhante(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);
        }
    }

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

            // criar um arquivo mapeado na memoria
            using (var mmf = MemoryMappedFile.CreateFromFile(@"c:\dados\ArquivoMuitoGrande.data", 
                                                                FileMode.Open, "ImagemA"))
            {
                // Cria uma visualização de acesso aleatório, a partir do 256º megabyte (o deslocamento)
                // para o 768º megabyte (o deslocamento mais comprimento).
                using (var accessor = mmf.CreateViewAccessor(offset, tamanho))
                {
                    int colorSize = Marshal.SizeOf(typeof(MinhaCor));
                    MinhaCor cor;

                    // Faz alterações na view
                    for (long i = 0; i < length; i += colorSize)
                    {
                        accessor.Read(i, out cor);
                        cor.Brilhante(10);
                        accessor.Write(i, ref cor);
                    }
                }
            }
        }
    }
}

O método CreateFromFile cria um arquivo mapeado na memória de um arquivo existente no disco.

Ao invocar o método CreateViewAccessor retornamos um MemoryMappedViewAccessor para acessar a memória compartilhada. Com o view accessor, você pode definir um deslocamento e tamanho que é usado por esta tarefa. Claro, o tamanho máximo que você pode usar é o tamanho do arquivo de memória mapeado em si.

Podemos abrir o mesmo arquivo mapeado na memória para outro processo usando o código a seguir:

           // Assume que outro processo criou o arquivo mapeado na memória
            using (var mmf = MemoryMappedFile.OpenExisting("ImagemA"))
            {
                using (var accessor = mmf.CreateViewAccessor(4000000, 2000000))
                {
                    int colorSize = Marshal.SizeOf(typeof(MinhaCor));
                    MinhaCor color;

                    // Faz mudanças na view
                    for (long i = 0; i < 1500000; i += colorSize)
                    {
                        accessor.Read(i, out color);
                        color.Brilhante(20);
                        accessor.Write(i, ref color);
                    }
                }
            }

Aqui usamos o método OpenExisting que abre um arquivo mapeado em memória nomeado existente na memória
do sistema.

Pegue o código projeto aqui:  NetCore_MapFiles.zip

(disse Jesus) - "Porque por tuas palavras serás justificado, e por tuas palavras serás condenado."
Mateus 12:37

Referências:

• Seção VB .NET do Site Macoratti.net

• Super DVD .NET - A sua porta de entrada na plataforma .NET

• Super DVD Vídeo Aulas - Vídeo Aula sobre VB .NET, ASP .NET e C#

• Super DVD C# - Recursos de aprendizagens e vídeo aulas para C#

• Seção C# do site Macoratti.net

• Seção ASP .NET do site Macoratti .net

• ASP .NET Core 2 - MiniCurso Básico - Macoratti

• ASP .NET Core - Macoratti

• Conceitos - .NET Framework versus .NET Core - Macoratti

• ASP .NET Core - Conceitos Básicos - Macoratti.net

• ASP .NET Core MVC - CRUD básico com ADO .NET - Macoratti

• ASP .NET Core - Implementando a segurança com ... - Macoratti.net

• ASP .NET Core - Apresentando Razor Pages - Macoratti

• Minicurso ASP .NET Core 2.0 - Autenticação com JWT - I - Macoratti

• Minicurso ASP .NET Core 2.0 - Autenticação com JWT - II - Macoratti.net

José Carlos Macoratti