内存映射文件

内存映射文件^[1][2]

2015-03-31

原理
  有两种类型的内存映射文件
  进程、视图和管理内存
内存映射文件对象及其成员
示例
  示例1：在同一进程内同时读写同一内存映射文件
  示例2：使用内存映射文件在进程间传送值类型数据
  示例3：利用序列化技术通过内存映射文件实现进程通讯
参考

原理^[1]

---

 返回

内存映射文件包含虚拟内存中文件的内容。 利用文件与内存空间之间的映射，应用程序（包括多个进程）可以通过直接在内存中进行读写来修改文件。 从 .NET Framework 4开始，可以使用托管代码按照本机Windows函数访问内存映射文件的方式来访问内存映射文件

内存映射文件与虚拟内存有些类似，通过内存映射文件可以保留一个地址空间的区域，同时将物理存储器提交给此区域，只是内存文件映射的物理存储器来自一个已经存在于磁盘上的文件，而非系统的页文件，而且在对该文件进行操作之前必须首先对文件进行映射，就如同将整个文件从磁盘加载到内存。由此可以看出，使用内存映射文件处理存储于磁盘上的文件时，将不必再对文件执行I/O操作，这意味着在对文件进行处理时将不必再为文件申请并分配缓存，所有的文件缓存操作均由系统直接管理，由于取消了将文件数据加载到内存、数据从内存到文件的回写以及释放内存块等步骤，使得内存映射文件在处理大数据量的文件时能起到相当重要的作用。^[2]

有两种类型的内存映射文件

• 持久内存映射文件：持久文件是与磁盘上的源文件关联的内存映射文件。  在最后一个进程使用完此文件后，数据将保存到磁盘上的源文件中。 这些内存映射文件适合用来处理非常大的源文件。
• 非持久内存映射文件：非持久文件是未与磁盘上的源文件关联的内存映射文件。  当最后一个进程使用完此文件后，数据将丢失，并且垃圾回收功能将回收此文件。 这些文件适用于为进程间通信 (IPC) 创建共享内存。

进程、视图和管理内存

• 内存映射文件可以在多个进程之间进行共享。  进程可以通过使用由创建同一内存映射文件的进程所指派的公用名来映射到此文件。
• 若要使用一个内存映射文件，则必须创建该内存映射文件的完整视图或部分视图。  还可以创建内存映射文件的同一部分的多个视图，进而创建并发内存。 为了使两个视图能够并发，必须基于同一内存映射文件创建这两个视图。
• 如果文件大于应用程序用于内存映射的逻辑内存空间（在 32 位计算机上为 2 GB），则还需要使用多个视图。 
• 有两种类型的视图：流访问视图和随机访问视图。  使用流访问视图可对文件进行顺序访问；对于非持久文件和 IPC，这是建议的方法。 在使用持久文件时，随机访问视图是首选方法。
• 由于内存映射文件是通过操作系统的内存管理器访问的，因此会自动将此文件分隔为多个页，并根据需要对其进行访问。  您不需要自行处理内存管理。

下图演示多个进程如何同时具有对同一内存映射文件的多个重叠视图：

Figure 1 内存映射文件的多个重叠视图 

内存映射文件对象及其成员

---

 返回

表1：有关使用内存映射文件对象及其成员

方法	说明
MemoryMappedFile.CreateFromFile	磁盘上的文件中获取表示持久内存映射文件的 MemoryMappedFile 对象。
MemoryMappedFile.CreateNew 或MemoryMappedFile.CreateOrOpen	获取表示非持久内存映射文件（与磁盘上的文件不关联）的 MemoryMappedFile 对象。
MemoryMappedFile.OpenExisting	获取现有内存映射文件（持久文件或非持久文件）的 MemoryMappedFile 对象。
MemoryMappedFile.CreateViewStream	获取针对内存映射文件的顺序访问视图的 UnmanagedMemoryStream 对象。
MemoryMappedFile.CreateViewAccessor	获取针对内存映射文件的随机访问视图的 UnmanagedMemoryAccessor 对象。

示例^[2]

---

 返回

示例1：在同一进程内同时读写同一内存映射文件

Figure 2 在同一进程内同时读写同一内存映射文件

示例1代码如下：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

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

namespace MemoryMappingFile
{
    public partial class Form1 : Form
    {
        public Form1()  
       {  
           InitializeComponent();  
           CreateMemoryMapFile();  
       }  
       private const int FILE_SIZE = 512;  
       /// <summary>  
       /// 引用内存映射文件  
       /// </summary>  
       private MemoryMappedFile memoryFile = null;  
       /// <summary>  
       /// 用于访问内存映射文件的存取对象  
       /// </summary>  
       private MemoryMappedViewAccessor accessor1, accessor2,accessor;  
       /// <summary>  
       /// 创建内存映射文件  
       /// </summary>  
       private void CreateMemoryMapFile()  
       {  
           try  
           {       
               memoryFile = MemoryMappedFile.CreateFromFile("MyFile.dat", FileMode.OpenOrCreate, "MyFile", FILE_SIZE);                 
               //访问文件前半段  
               accessor1 = memoryFile.CreateViewAccessor(0, FILE_SIZE / 2);              
               //访问文件后半段  
               accessor2 = memoryFile.CreateViewAccessor(FILE_SIZE / 2, FILE_SIZE / 2);                
               //访问全部文件  
               accessor = memoryFile.CreateViewAccessor();  
               //InitFileContent();  
               lblInfo.Text = "内存文件创建成功";  
               ShowFileContents();  
           }  
           catch (Exception ex)  
           {  
               lblInfo.Text = ex.Message;  
           }  
       }  
       /// <summary>  
       /// 关闭并释放资源  
       /// </summary>  
       private void DisposeMemoryMapFile()  
       {  
           if (accessor1 != null)  
               accessor1.Dispose();  
           if (accessor2 != null)  
               accessor2.Dispose();  
           if (memoryFile != null)  
               memoryFile.Dispose();  
       }  
 
       private void frmMain_FormClosing(object sender, FormClosingEventArgs e)  
       {  
           DisposeMemoryMapFile();  
       }  
 
       private void btnWrite1_Click(object sender, EventArgs e)  
       {  
           if (textBox1.Text.Length == 0)  
           {  
               lblInfo.Text = "请输入一个字符";  
               return;  
           }  
           char[] chs = textBox1.Text.ToCharArray();  
           char ch = chs[0];  
            
           for (int i = 0; i < FILE_SIZE / 2; i += 2)  
               accessor1.Write(i, ch);  
             
           lblInfo.Text = "字符“" + ch + "”已写到文件前半部份";  
           ShowFileContents();  
       }  
 
       private void btnShow_Click(object sender, EventArgs e)  
       {  
           ShowFileContents();  
       }  
 
       /// <summary>  
       /// 初始化文件内容为可视的字符“0”  
       /// </summary>  
       private void InitFileContent()  
       {  
           for (int i = 0; i < FILE_SIZE; i += 2)   
                accessor.Write(i,'0');  
        }  
        /// <summary>  
        /// 显示文件内容  
        /// </summary>  
        private void ShowFileContents()  
        {  
            StringBuilder sb = new StringBuilder(FILE_SIZE);  
            sb.Append("上半段内容：
");  
  
            int j = 0;  
            for (int i = 0; i < FILE_SIZE / 2; i += 2)  
            {  
                sb.Append("	");  
                char ch = accessor.ReadChar(i);  
                sb.Append(j);  
                sb.Append(":");  
                sb.Append(ch);  
                j++;  
            }  
            sb.Append("
下半段内容：
");  
  
            for (int i = FILE_SIZE / 2; i < FILE_SIZE; i += 2)  
            {  
                sb.Append("	");  
                char ch = accessor.ReadChar(i);  
                sb.Append(j);  
                sb.Append(":");  
                sb.Append(ch);  
                j++;  
            }  
            richTextBox1.Text = sb.ToString();  
        }  
  
        private void btnWrite2_Click(object sender, EventArgs e)  
        {  
            if (textBox2.Text.Length == 0)  
            {  
                lblInfo.Text = "请输入一个字符";  
                return;  
            }  
            char[] chs = textBox2.Text.ToCharArray();  
            char ch = chs[0];  
  
            for (int i = 0; i < FILE_SIZE / 2; i += 2)  
                accessor2.Write(i, ch);  
            lblInfo.Text = "字符“" + ch + "”已写到文件后半部份";  
            ShowFileContents();  
        }  
    }
}

示例2：使用内存映射文件在进程间传送值类型数据

Figure2 使用内存映射文件在进程间传送值类型数据

示例2代码如下：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

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


namespace MemoryMappingFile
{
     /// <summary>  
     /// 要共享的数据结构，注意，其成员不能是引用类型  
     /// </summary>  
     public struct MyStructure  
     {  
         public int IntValue  
         {  
             get;  
             set;  
         }  
         public float FloatValue  
         {  
             get;  
             set;  
         }   
     }   


    public partial class Form2 : Form
    {
        public Form2()  
       {  
           InitializeComponent();  
           InitMemoryMappedFile();  
       }  
 
       /// <summary>  
       /// 内存映射文件的容量  
       /// </summary>  
       private const int FileSize = 1024 * 1024;  
       private MemoryMappedFile file = null;  
       private MemoryMappedViewAccessor accessor = null;  
 
       /// <summary>  
       /// 初始化内存映射文件  
       /// </summary>  
       private void InitMemoryMappedFile()  
       {  
           file = MemoryMappedFile.CreateOrOpen("UseMMFBetweenProcess", FileSize);  
           accessor = file.CreateViewAccessor();  
           lblInfo.Text = "内存文件创建或连接成功";           
       }  
 
       /// <summary>  
       /// 要共享的数据对象  
       /// </summary>  
       private MyStructure data;  
 
       /// <summary>  
       /// 显示数据到窗体上  
       /// </summary>  
       private void ShowData()  
       {  
           textBox1.Text = data.IntValue.ToString();  
           textBox2.Text = data.FloatValue.ToString();  
       }  
 
       /// <summary>  
       /// 根据用户输入更新数据  
       /// </summary>  
       private void UpdateData()  
       {  
           data.IntValue = int.Parse(textBox1.Text);  
           data.FloatValue = float.Parse(textBox2.Text);  
       }  
 
       private void btnSave_Click(object sender, EventArgs e)  
       {  
           try  
           {  
               UpdateData();  
               accessor.Write<MyStructure>(0, ref data);  
               lblInfo.Text = "数据已经保存到内存文件中";  
           }  
           catch (Exception ex)  
           {  
               lblInfo.Text = ex.Message;  
           }  
        }  
  
        private void btnLoad_Click(object sender, EventArgs e)  
        {  
            accessor.Read<MyStructure>(0, out data);  
            ShowData();  
            lblInfo.Text = "成功从内存文件中提取了数据";  
        }  
  
        private void frmMain_FormClosing(object sender, FormClosingEventArgs e)  
        {  
            if (accessor != null)  
                accessor.Dispose();  
            if (file != null)  
                file.Dispose();  
        }  
    }
}

示例3：利用序列化技术通过内存映射文件实现进程通讯

Figure 3 利用序列化技术通过内存映射文件实现进程通讯

示例3代码如下：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using System.IO;
using System.IO.MemoryMappedFiles;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;


namespace MemoryMappingFile
{
    
    public partial class Form3 : Form
    {
        public Form3()
        {
            InitializeComponent();
            InitMemoryMappedFile();
        }

        [Serializable]
        class MyPic
        {
            public Image pic;
            public string picInfo;
        }

        /// <summary>  
        /// 图片  
        /// </summary>  
        private Image bmp
        {
            get
            {
                return pictureBox1.Image;
            }
            set
            {
                pictureBox1.Image = value;
            }
        }

        /// <summary>  
        /// 图片说明  
        /// </summary>  
        private string info
        {
            get
            {
                return txtImageInfo.Text;
            }
            set
            {
                txtImageInfo.Text = value;
            }
        }

        private MemoryMappedFile memoryFile = null;

        private MemoryMappedViewStream stream = null;

        /// <summary>  
        /// 最大容量:10M  
        /// </summary>  
        private const int FileSize = 1024 * 1024 * 10;

        /// <summary>  
        /// 创建内存映射文件,获取其读写流  
        /// </summary>  
        private void InitMemoryMappedFile()
        {
            try
            {
                memoryFile = MemoryMappedFile.CreateOrOpen("UseMMFBetweenProcess2", FileSize);
                stream = memoryFile.CreateViewStream();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                Close();
            }
        }
        /// <summary>  
        /// 释放相关资源  
        /// </summary>  
        private void DisposeMemoryMappedFile()
        {
            if (stream != null)
                stream.Close();
            if (memoryFile != null)
                memoryFile.Dispose();
        }

        private void btnLoadPic_Click(object sender, EventArgs e)
        {
            ChooseImageFile();
        }

        //选择图片  
        private void ChooseImageFile()
        {
            if (openFileDialog1.ShowDialog() == DialogResult.OK)
            {
                bmp = new Bitmap(openFileDialog1.FileName);
            }
        }
        //根据用户设定的信息创建对象  
        private MyPic CreateMyPicObj()
        {
            MyPic obj = new MyPic();
            obj.pic = bmp;
            obj.picInfo = info;
            return obj;
        }

        /// <summary>  
        /// 将MyPic对象保存到内存映射文件中  
        /// </summary>  
        private void SaveToMMF()
        {
            try
            {
                MyPic obj = CreateMyPicObj();
                IFormatter formatter = new BinaryFormatter();
                stream.Seek(0, SeekOrigin.Begin);
                formatter.Serialize(stream, obj);
                MessageBox.Show("对象已保存到内存映射文件中");
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void LoadFromMMF()
        {
            try
            {
                // CreateMyPicObj();  
                IFormatter formatter = new BinaryFormatter();
                stream.Seek(0, SeekOrigin.Begin);
                MyPic obj = formatter.Deserialize(stream) as MyPic;
                if (obj != null)
                {
                    bmp = obj.pic;
                    info = obj.picInfo;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void frmMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            DisposeMemoryMappedFile();
        }

        private void btnSaveToMMF_Click(object sender, EventArgs e)
        {
            SaveToMMF();
        }

        private void btnLoadFromMMF_Click(object sender, EventArgs e)
        {
            LoadFromMMF();
        }


    }
}

参考

[1] C#内存映射文件学习

[2] 内存映射文件