內存映射文件

內存映射文件^[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("上半段內容：\n");  
  
            int j = 0;  
            for (int i = 0; i < FILE_SIZE / 2; i += 2)  
            {  
                sb.Append("\t");  
                char ch = accessor.ReadChar(i);  
                sb.Append(j);  
                sb.Append(":");  
                sb.Append(ch);  
                j++;  
            }  
            sb.Append("\n下半段內容：\n");  
  
            for (int i = FILE_SIZE / 2; i < FILE_SIZE; i += 2)  
            {  
                sb.Append("\t");  
                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] 內存映射文件