C # implements memory-mapped file share memory

Original: http://blog.csdn.net/wangtiewei/article/details/51112668

A memory-mapped file uses virtual memory to map a file to the address space of a process, after which the process operates the file as if it were an address in the process space, such as a function that uses memory operations such as C-memcpy. This method can be used very well in situations where a file or a large file is required to be processed frequently, which is more efficient than normal IO in this way.

Shared memory is a special case of memory-mapped files, where memory is mapped to a piece of memory rather than to a file on disk. The subject of shared memory is a process, and the operating system allocates a memory space by default for each process, and each process only allows access to the memory allocated to it by the operating system and not to other processes. And sometimes you need to access the same memory between different processes. The operating system gives an API to create access to shared memory, and processes that require shared memory can access memory that is shared between multiple processes through this set of defined APIs, and each process accesses the memory as if it were a file on a hard disk. System.IO was introduced in. Net 4.0. The MemoryMappedFiles namespace, the namespace class, encapsulates the Windows shared memory-related APIs, making it easier for. NET programmers to use memory-mapped files.

Use shared memory in C #. The following APP1 code lets the user enter a line of text into the shared memory; APP2 refreshes the console continuously, outputting the latest shared memory content, APP3 implements the same functionality as APP2, but with different reading methods.

[CSharp]View PlainCopy

2. APP1 Code:
4. Using System;
6. Using system.collections.generic;android reads the file stream display from the resource file
8. Using System.Linq;
10. Using System.Text;
14. Using System.IO;
18. Referencing a memory-mapped file namespace
20. Using System.IO.MemoryMappedFiles;
24. Namespace App1
26. {
28. Class Program
30. {
32. static void Main (string[] args)
34. {
36. Long capacity = 1<<10<<10;
40. //Create or open shared memory
42. using (var mmf = Memorymappedfile.createoropen ("TESTMMF", capacity, memorymappedfileaccess.readwrite))
44. {
46. //gain access to shared memory through MemoryMappedFile's Createviewaccssor method
48. var viewaccessor = mmf. Createviewaccessor (0, capacity);
50. //cyclic write so that different string values can be written to shared memory in this process
52. While (true)
54. {
56. Console.WriteLine ("Please enter a line of text to write to the shared memory:");
60. string input = Console.ReadLine ();
64. //write the length of the string to the shared memory start location
66. Viewaccessor.write (0, input. Length);
70. //write characters to shared memory 4 location
72. viewaccessor.writearray<char> (4, input. ToArray (), 0, input.  Length);
74. }
78. }
82. }
84. }
86. }

[CSharp]View PlainCopy

2. APP2 Code:
4. Using System;
6. Using System.Collections.Generic;
8. Using System.Linq;
10. Using System.Text;
12. Using System.Threading;
16. Referencing namespaces required for using memory-mapped files
18. Using System.IO.MemoryMappedFiles;
22. Namespace App2
24. {
26. Class Program
28. {
30. static void Main (string[] args)
32. {
34. Long capacity = 1<<10<<10;
38. using (var mmf = memorymappedfile.openexisting ("TESTMMF"))
40. {
42. Memorymappedviewaccessor viewaccessor = mmf. Createviewaccessor (0, capacity);
46. //Cycle refresh value of shared memory string
48. While (true)
50. {
52. //Read character length
54. int strlength = viewaccessor.readint32 (0);
56. char[] charsinmmf = new char[strlength];
58. //Read characters
60. viewaccessor.readarray<char> (4, CHARSINMMF, 0, strlength);
62. Console.clear ();
64. Console.Write (CHARSINMMF);
66. Console.Write ("\ r");
68. Thread.Sleep (200);
70. }
72. }
74. }
76. }
78. }

[CSharp]View PlainCopy

2. APP3 Code:
4. Using System;
6. Using System.Collections.Generic;
8. Using System.Linq;
10. Using System.Text;
14. Using System.IO.MemoryMappedFiles;
16. Using System.IO;
20. Namespace APP3
22. {
24. Class Program
26. {
28. static void Main (string[] args)
30. {
32. Long capacity = 1 << << 10;
34. //Open Shared memory
36. using (var mmf = memorymappedfile.openexisting ("TESTMMF"))
38. {
40. //Use the Createviewstream method to return a stream instance
42. using (var mmviewstream = mmf. Createviewstream (0, capacity))
44. {
46. //There will be a problem with Unicode encoding
48. using (BinaryReader RDR = new BinaryReader (Mmviewstream,encoding.unicode))
50. {
52. While (true)
54. {
56. Mmviewstream.seek (0, Seekorigin.begin);
60. int length = rdr.  ReadInt32 ();
64. char[] chars = rdr.  ReadChars (length);
68. Console.Write (chars);
70. Console.Write ("\ r");
74. System.Threading.Thread.Sleep (200);
76. Console.clear ();
78. }
80. }
82. }
84. }
86. }
88. }
90. }

There are 2 ways to read the data.

Because the communication between processes is seldom used before, this method just wants to get a preliminary understanding. This program is too simple to write, there are many things are not to judge. For example, how to create a shared memory how to delete it and so on ...

I hope I share it with the author of this blog post.

C # implements memory-mapped file share memory