c#进程通信——通过内存映射文件

内存映射文件究竟是个什么？内存映射文件允许你保留一块地址空间，然后将该物理存储映射到这块内存空间中进行操作。应用程序需要频繁地或者随机地访问文件时，最好使用内存映射文件。使用这种方式允许文件的一部分或者全部加载到一段虚拟内存上，这些文件内容会显示给应用程序，就好像这个文件包含在应用程序的主内存中一样。

 优势：
     1.访问磁盘文件上的数据不需执行I/O操作和缓存操作(当访问文件数据时，作用尤其显著)；
     2.让运行在同一台机器上的多个进程共享数据(单机多进程间数据通信效率最高)；

分类：

• 持久内存映射文件

  持久文件是与磁盘上的源文件关联的内存映射文件。在最后一个进程使用完此文件后，数据将保存到磁盘上的源文件中。这些内存映射文件适合用来处理非常大的源文件。

• 非持久内存映射文件

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

 注意：

    1）在多个进程之间进行共享内存映射文件，进程可通过使用由创建同一内存映射文件的进程所指派的公用名来映射到此文件。

    2）若要使用一个内存映射文件，则必须创建该内存映射文件的完整视图或部分视图。还可以创建内存映射文件的同一部分的多个视图，进而创建并发内存。为了使两个视图能够并发，必须基于同一内存映射文件创建这两个视图。

    3）如果文件大于应用程序用于内存映射的逻辑内存空间（在 32 位计算机上为2GB），则还需要使用多个视图。

示例

进程1,wpf程序

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows;



namespace WpfApp1
{

    public struct ServiceMsg
    {
        public int Id;
        public long NowTime;
    }

    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();     
        }

        /// <summary>
        /// 创建内存映射文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_Click(object sender, RoutedEventArgs e)
        {
           ConsoleManager.Show();
            Console.Write("请输入共享内存公用名(默认:testmap):");
            string shareName = Console.ReadLine();
            if (string.IsNullOrEmpty(shareName))
                shareName = "testmap";

            MemoryMappedFile mmf = MemoryMappedFile.CreateOrOpen(shareName, 1024000, MemoryMappedFileAccess.ReadWrite);
            {
                bool mutexCreated;
                //进程间同步
                var mutex = new Mutex(true, "testmapmutex", out mutexCreated);
                using (MemoryMappedViewStream stream = mmf.CreateViewStream()) //创建文件内存视图流
                {
                    var writer = new BinaryWriter(stream);
                    for (int i = 0; i < 5; i++)
                    {
                        writer.Write(i);
                        Console.WriteLine("{0}位置写入流:{0}", i);
                    }
                }

                mutex.ReleaseMutex();

                Console.WriteLine("启动状态服务，按【回车】读取共享内存数据");
                Console.ReadLine();

                mutex.WaitOne();
                using (MemoryMappedViewStream stream = mmf.CreateViewStream())
                {
                    var reader = new BinaryReader(stream);
                    for (int i = 0; i < 10; i++)
                    {
                        Console.WriteLine("{1}位置:{0}", reader.ReadInt32(), i);
                    }
                }

                using (MemoryMappedViewAccessor accessor = mmf.CreateViewAccessor(1024, 10240))
                {
                    int colorSize = Marshal.SizeOf(typeof(ServiceMsg));
                    ServiceMsg color;
                    for (int i = 0; i < 50; i += colorSize)
                    {
                        accessor.Read(i, out color);
                        Console.WriteLine("{1}\tNowTime:{0}", new DateTime(color.NowTime), color.Id);
                    }
                }
                mutex.ReleaseMutex();
            }
            Console.WriteLine("测试： 我是 即时通讯 - 消息服务 我启动啦！！！");
            Console.ReadKey();




        }


        private void Button_Click_1(object sender, RoutedEventArgs e)
        {
            ConsoleManager.Show();
            Console.WriteLine("Start Process B");

            using (Process myProcess = new Process())
            {
                myProcess.StartInfo.UseShellExecute = false;

                myProcess.StartInfo.FileName = @"D:\CodeTest\ConsoleApp1\x64\Debug\ConsoleApp1.exe";
                myProcess.StartInfo.CreateNoWindow = false;
                myProcess.Start();

            }

        }
    }


    public static class ConsoleManager
    {
        private const string Kernel32_DllName = "kernel32.dll";
        [DllImport(Kernel32_DllName)]
        private static extern bool AllocConsole();
        [DllImport(Kernel32_DllName)]
        private static extern bool FreeConsole();
        [DllImport(Kernel32_DllName)]
        private static extern IntPtr GetConsoleWindow();
        [DllImport(Kernel32_DllName)]
        private static extern int GetConsoleOutputCP();
        public static bool HasConsole
        {
            get { return GetConsoleWindow() != IntPtr.Zero; }
        }
        /// Creates a new console instance if the process is not attached to a console already.  
        public static void Show()
        {
#if DEBUG
            if (!HasConsole)
            {
                AllocConsole();
                InvalidateOutAndError();
            }
#endif
        }
        /// If the process has a console attached to it, it will be detached and no longer visible. Writing to the System.Console is still possible, but no output will be shown.   
        public static void Hide()
        {
#if DEBUG
            if (HasConsole)
            {
                SetOutAndErrorNull();
                FreeConsole();
            }
#endif
        }
        public static void Toggle()
        {
            if (HasConsole)
            {
                Hide();
            }
            else
            {
                Show();
            }
        }
        static void InvalidateOutAndError()
        {
            Type type = typeof(System.Console);
            System.Reflection.FieldInfo _out = type.GetField("_out",
                System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
            System.Reflection.FieldInfo _error = type.GetField("_error",
                System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
            System.Reflection.MethodInfo _InitializeStdOutError = type.GetMethod("InitializeStdOutError",
                System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
            Debug.Assert(_out != null);
            Debug.Assert(_error != null);
            Debug.Assert(_InitializeStdOutError != null);
            _out.SetValue(null, null);
            _error.SetValue(null, null);
            _InitializeStdOutError.Invoke(null, new object[] { true });
        }
        static void SetOutAndErrorNull()
        {
            Console.SetOut(TextWriter.Null);
            Console.SetError(TextWriter.Null);
        }
    }



}

进程2，控制台程序

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    /// <summary>
    /// 用于共享内存方式通信的 值类型 结构体
    /// </summary>
    public struct ServiceMsg
    {
        public int Id;
        public long NowTime;
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("请输入共享内存公用名(默认:testmap):");
            string shareName = Console.ReadLine();
            if (string.IsNullOrEmpty(shareName))
                shareName = "testmap";
            MemoryMappedFile mmf = MemoryMappedFile.OpenExisting(shareName);

            Mutex mutex = Mutex.OpenExisting("testmapmutex");
            mutex.WaitOne();
            using (MemoryMappedViewStream stream = mmf.CreateViewStream(20, 0)) //注意这里的偏移量
            {
                var writer = new BinaryWriter(stream);
                for (int i = 5; i < 10; i++)
                {
                    writer.Write(i);
                    Console.WriteLine("{0}位置写入流:{0}", i);
                }
            }
            using (MemoryMappedViewAccessor accessor = mmf.CreateViewAccessor(1024, 10240))
            {
                int colorSize = Marshal.SizeOf(typeof(ServiceMsg));
                var color = new ServiceMsg();
                for (int i = 0; i < colorSize * 5; i += colorSize)
                {
                    color.Id = i;
                    color.NowTime = DateTime.Now.Ticks;
                    //accessor.Read(i, out color);
                    accessor.Write(i, ref color);
                    Console.WriteLine("{1}\tNowTime:{0}", new DateTime(color.NowTime), color.Id);
                    Thread.Sleep(1000);
                }
            }
            Thread.Sleep(5000);

            mutex.ReleaseMutex();

            Console.WriteLine("测试： 我是 即时通讯 - 状态服务 我启动啦！！！");
            Console.ReadKey();
        }
    }
}

参考：

https://www.cnblogs.com/zeroone/archive/2012/04/18/2454776.html

https://docs.microsoft.com/en-us/previous-versions/ms810613(v=msdn.10)?redirectedfrom=MSDN

https://blog.csdn.net/wangtiewei/article/details/51112668

https://www.cnblogs.com/lanshy/p/4441450.html