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.