C# MemoryMappedFile.openExisting:使用2个不同进程时未找到指定的文件

我使用了两种不同的流程，比如-

Process1.exe：执行一些操作并更新字符串变量，该变量将保存在MemoryMappedFile（到acheive IPC）中，该文件是文件

//Some code
public void DoSomeStuff()
{
onst int MMF_MAX_SIZE = 4096;
const int MMF_VIEW_SIZE = 4096;
try
   {
     using (MemoryMappedFile mmf = MemoryMappedFile.CreateOrOpen("file", MMF_MAX_SIZE, MemoryMappedFileAccess.ReadWrite))
     {
          using (MemoryMappedViewStream stream = mmf.CreateViewStream(0, MMF_VIEW_SIZE))
          {
               Message message1;
               message1.strName = "Some name";
               BinaryFormatter formatter = new BinaryFormatter();
               formatter.Serialize(stream, message1);
          }
     }
   }
catch(Exception e)
{
     MessageBox.Show(e.Message);
}
}

        const int MMF_VIEW_SIZE = 4096;

        using (MemoryMappedFile file = MemoryMappedFile.OpenExisting("file"))
        {
            using (MemoryMappedViewStream stream = file.CreateViewStream(0, MMF_VIEW_SIZE))
            {
                BinaryFormatter formatter = new BinaryFormatter();
                byte[] buffer = new byte[MMF_VIEW_SIZE];
                Message message1;
                if (stream.CanRead)
                {
                    stream.Read(buffer, 0, MMF_VIEW_SIZE);
                    using (MemoryStream ms = new MemoryStream(buffer))
                    {
                        ms.Seek(0, SeekOrigin.Begin);
                        message1 = (Message)formatter.Deserialize(ms);
                        string name = message1.strName;
                    }
                }
            }
        }

Process2.exe：调用Process1。完成“Process1”后，它尝试打开MemoryMappedFile文件，并获取字符串以供进一步使用

以下是代码片段-

Process1.exe

//Some code
public void DoSomeStuff()
{
onst int MMF_MAX_SIZE = 4096;
const int MMF_VIEW_SIZE = 4096;
try
   {
     using (MemoryMappedFile mmf = MemoryMappedFile.CreateOrOpen("file", MMF_MAX_SIZE, MemoryMappedFileAccess.ReadWrite))
     {
          using (MemoryMappedViewStream stream = mmf.CreateViewStream(0, MMF_VIEW_SIZE))
          {
               Message message1;
               message1.strName = "Some name";
               BinaryFormatter formatter = new BinaryFormatter();
               formatter.Serialize(stream, message1);
          }
     }
   }
catch(Exception e)
{
     MessageBox.Show(e.Message);
}
}

        const int MMF_VIEW_SIZE = 4096;

        using (MemoryMappedFile file = MemoryMappedFile.OpenExisting("file"))
        {
            using (MemoryMappedViewStream stream = file.CreateViewStream(0, MMF_VIEW_SIZE))
            {
                BinaryFormatter formatter = new BinaryFormatter();
                byte[] buffer = new byte[MMF_VIEW_SIZE];
                Message message1;
                if (stream.CanRead)
                {
                    stream.Read(buffer, 0, MMF_VIEW_SIZE);
                    using (MemoryStream ms = new MemoryStream(buffer))
                    {
                        ms.Seek(0, SeekOrigin.Begin);
                        message1 = (Message)formatter.Deserialize(ms);
                        string name = message1.strName;
                    }
                }
            }
        }

Process2.exe

//Some code
public void DoSomeStuff()
{
onst int MMF_MAX_SIZE = 4096;
const int MMF_VIEW_SIZE = 4096;
try
   {
     using (MemoryMappedFile mmf = MemoryMappedFile.CreateOrOpen("file", MMF_MAX_SIZE, MemoryMappedFileAccess.ReadWrite))
     {
          using (MemoryMappedViewStream stream = mmf.CreateViewStream(0, MMF_VIEW_SIZE))
          {
               Message message1;
               message1.strName = "Some name";
               BinaryFormatter formatter = new BinaryFormatter();
               formatter.Serialize(stream, message1);
          }
     }
   }
catch(Exception e)
{
     MessageBox.Show(e.Message);
}
}

        const int MMF_VIEW_SIZE = 4096;

        using (MemoryMappedFile file = MemoryMappedFile.OpenExisting("file"))
        {
            using (MemoryMappedViewStream stream = file.CreateViewStream(0, MMF_VIEW_SIZE))
            {
                BinaryFormatter formatter = new BinaryFormatter();
                byte[] buffer = new byte[MMF_VIEW_SIZE];
                Message message1;
                if (stream.CanRead)
                {
                    stream.Read(buffer, 0, MMF_VIEW_SIZE);
                    using (MemoryStream ms = new MemoryStream(buffer))
                    {
                        ms.Seek(0, SeekOrigin.Begin);
                        message1 = (Message)formatter.Deserialize(ms);
                        string name = message1.strName;
                    }
                }
            }
        }

这是我在两个进程中编写的消息类

class Message
{
    public string strName;
}

问题：在完成进程1后，它已成功地将字符串数据写入MemoryMappedFile，但当我尝试在进程2中使用行打开文件时

MemoryMappedFile=MemoryMappedFile.OpenExisting（“文件”）

我收到错误-

找不到指定的文件

我对实现IPC的内存映射文件非常陌生。有人能告诉我这里出了什么问题吗？

您使用的将创建一个非持久性内存映射文件。在使用（

MemoryMappedFile mmf=

）结束时（或在

Process1

结束时），文件将被“销毁”（它将不再存在）

解决方案：使用真实的文件

---

另一种解决方案是在调用子进程之前打开父进程中的内存映射。甚至还有一个重载，它接受一个

HandleInheritability

来将句柄传递给子进程（我不知道具体是如何传递的），但这可能不是必需的。

在

OpenExisting

中，“existing”是“我知道其他人当前已将该句柄作为内存映射文件打开”。由于您可以有效地运行一个程序，并让它在第二个程序接管之前退出，因此不需要IPC。为什么不使用普通文件呢？两个进程都能找到“文件”的可能性很小。始终使用完整路径名，c:\foo\bar\baz.ext。这样的文件需要是可写的，因此您会喜欢在AppData目录中创建它。在启动子文件（Process2）之前在父文件（Process1）中创建MemoryMappedFile时，它可以完美地完成这项工作。谢谢你的建议！