Inter-process Communication Between Managed Process

Mohamed Hasan

5y33.6k13100Article

Inter process communicationMemory-mapped FilesDot Net 4.0 new feature. Shared data

13 Comments

Join the conversation! Your thoughts help the community grow.

Subash10y ago
Useful share
Manish Singh14y ago
Really helpful and useful article
Alok Pandey14y ago
Very helpful article. Thanks for sharing.
- Mohamed Hasan14y ago
  Thank you all, for sharing your comment.
Sonakshi Singh14y ago
Very Innovative...really.
Daisy Krause14y ago
Its a very good article for those who want to implement interprocess communication. Thanks for sharing.
Arjun Panwar14y ago
Really very nice article
Deepak Dwij14y ago
Nicely explained !!!!!!!!!!!!!
Vikas Mishra14y ago
It's a very fresh example..thanks for sharing....
Akash Ahlawat14y ago
Perfect example..I'm happy that there are still developers who bring some new examples to ASP.NET community
Sam Hobbs14y ago
I know that memory-mapped files are very useful. They provide a very efficient way to share large amounts of data among processes. This article will help many people. I have one question; are you sure that Virtual Memory Mapped Files have no physical disk space associted with them? I thought that they are backed by the system paging file.
- Mohamed Hasan14y ago
  Thank you for you comment. I think Non-persistent memory mapped files will not have a disk file associated with it. However, the operating system's virtual memory management system may take this memory to disk as part of paging. Once all the processes completed working with the file, the data will just vanish both from memory and hard disk.
- Sam Hobbs14y ago
  I think people should read the MSDN documentation. I think the documentation says that all memory-mapped files are backed by either the pagefile or some other real disk file.

Inter-process communication between Managed Process

There are certain cases, where the developer needs to pass data to another process running on the same system. One of the efficient ways of handling the situation in a Win32 application is using memory mapped files. Mapping between a file and memory allows multiple applications to read and write in the file at the same time. Starting from .NET 4.0, Managed applications can use the memory mapped file functionality as the traditional Win32 application does.

Memory mapped files can be categorized into two types.

1. Physical memory mapped file.

2. Virtual memory mapped file.

Physical Memory Mapped File

Physical memory mapped files are also referred as Persisted memory mapped files. This category of memory mapped file is always associated with a physical file in your hard disk. Very suitable for applications which need to work with huge data files. Once the last process is finished working with the physical memory mapped file, the contents of the file is written back to the source file on the hard disk.

Virtual Memory Mapped File

This category is also known as Non-Persisted memory mapped file. As the name means indicates, it is not associated with a source file on hard disk. It is very effective for run time data communication between two processes.

Let's have a closer look at programming the inter-process communication using the memory mapped files.

As any other files programing you do, the first step is to create the memory mapped file. System.IO.MemoryMappedFile class provides many different static functions to create the memory mapped file.

MemoryMappedFile.CreateNew static function takes 2 arguments. The first one is a string parameter specifying a unique name for the file. This name will uniquely identify the memory mapped file across the processes. The second parameter is a long data type, used to specify the maximum number of bytes that can be stored by the memory mapped file. While creating the file you can also specify the access mode for restricting the access to that file.

The following table lists the entire access mode supported.

Enumerator: MemoryMappedFileAccess

Member name	Description
ReadWrite	Read and write access to the file.
Read	Read-only access to the file.
Write	Write-only access to file.
CopyOnWrite	Read and write access to the file, with the restriction that any write operations will not be seen by other processes.
ReadExecute	Read access to the file that can store and run executable code.
ReadWriteExecute	Read and write access to the file that can can store and run executable code.

Once the file is created, the application must create a view of the file in order to read and write to the file. The view can point to the complete file or to a specific portion of the file.

MemoryMappedfile.CreateViewStream instance function creates a view stream which provides read write operations to the Memory mapped file. You can also create multiple views to the same part of the memory-mapped file, thereby creating concurrent memory. For two views to remain concurrent, they have to be created from the same memory-mapped file.

Once the stream is created, the applications can perform regular read and write operations on the file.

If another process wants to access the same file for read/write purposes, the second process should use "MemoryMappedFile.OpenExisting" function to open the file. OpenExisting function takes file name as an argument. This file name is a unique name, which was provided in the MemoryMappedFile.CreateNew function by the process one.

When two process trying to access the same file, of course it is the programmer's responsibility to make sure that we take care of the synchronization part of it. In the attached sample application, I have used a mutex to implement the synchronization between the processes.