C ＃ use Marshall to manually create unmanaged memory in the heap and use

Use Marshal Make a large array that can quickly free memory .

You need to constantly apply for a large memory array , Then release him , however C# For large memory, it is not released immediately , So there are some performance problems .
In the blog Garden, I saw a great God using Marshal A large array of quick applications , So I learned his way to get one . This article tells you how this class is used

In use , Let's take a look at the original C# Large array performance . You can see that it keeps gc, Poor performance

1. static void Main(string[] args)

2. {

3. for (int i = 0; i < 10000; i++)

4. {

5. Foo();

6. }

7. Console.ReadKey();

8. }

10. private static void Foo()

11. {

12. var foo = new byte[1000000000];

13. }

Introduce

In the use of Marshal You need to know what this is , Actually Marshal Is an offer COM Methods of interoperability .

Use

Here's a quick application int Array to tell you how to use .

Do you remember C Application array for ？ In fact, the following methods and C In the same

1. int n = 100000;// length

2. IntPtr buffer = Marshal.AllocHGlobal(sizeof(int) * n);

It can be used at this time buffer As an array

Here's his first k Elements modified

1. IntPtr buffer = Marshal.AllocHGlobal(sizeof(int) * n);

2. int k = 2;

4. IntPtr t = buffer + k * sizeof(int);

5. var p = Marshal.PtrToStructure<int>(t);

6. Console.WriteLine("p " + p); //196713 The value is uncertain

8. p = 2;

9. Marshal.StructureToPtr(p,t,false);

11. p = Marshal.PtrToStructure<int>(t);

12. Console.WriteLine("p " + p);//2

14. // Traverse

15. Console.WriteLine(" Traverse ");

16. for (int i = 0; i < 10; i++)

17. {

18. t = buffer + i * sizeof(int);

19. Console.WriteLine(Marshal.PtrToStructure<int>(t));

20. }

Traverse ：

1. 43909312

2. 44502144

3. 2

4. 0

5. 0

6. 24

7. 1357220181

8. 196712

9. 550912

10. 543686656

As you can see from the code above , The two main methods used are StructureToPtr and PtrToStructure , and StructureToPtr Is to write from the specified type to the pointer , I hope you also know how to use pointers ,PtrToStructure Is to start reading data from where the pointer points , Read the specified type of data . So you can go from Marshal Use one type to read from another , However, generally, the type to be read needs to be determined by the type size , Such as char Sure 、string Can not be .

In turn, ,StructureToPtr Is to write the specified type to the specified pointer , It is also necessary to determine the size of this type , If you can write char But you can't write string. This is how to read and write arrays .

So when traversing, what output some strange values , In fact, because there is no initialization , The value inside is uncertain . I think it's good to use this as a random number .

Use Marshal It's safer , because ms Did a lot of processing , But it also causes the program to flash back , Like the following code

1. private static void Foo()

2. {

3. int n = 100000;// length

4. IntPtr buffer = Marshal.AllocHGlobal(sizeof(int) * n);

6. try

7. {

8. var t = buffer + (n * 10) * sizeof(int);

9. var p = Marshal.PtrToStructure<int>(t);

10. }

11. catch (Exception e)

12. {

13. Console.WriteLine(e);

14. }

16. Marshal.FreeHGlobal(buffer);

17. }

There will be anomalies System.AccessViolationException, This exception cannot be catch Of , So you'd better encapsulate it when you use it

1. “System.AccessViolationException” The unhandled exception of type Unknown module

2. Trying to read or write to protected memory . This usually indicates that other memory is corrupted

if necessary catch Then please app.config Add the following code

1. <?xml version="1.0" encoding="utf-8" ?>

2. <configuration>

3. <runtime>

4. <legacyCorruptedStateExceptionsPolicy enabled="true" />

5. </runtime>

6. </configuration>

And then in Main Function add HandleProcessCorruptedStateExceptions , Please look at the code.

1. [HandleProcessCorruptedStateExceptions]

2. static void Main(string[] args)

3. {

4. AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;

6. for (int i = 0; i < 100000; i++)

7. {

8. try

9. {

10. Foo();

11. }

12. catch (Exception e)

13. {

14. Console.WriteLine(e);

16. }

17. }

18. Console.WriteLine(" complete ");

19. Console.ReadKey();

20. }

Then you can see entering UnhandledException , But I can't catch , The software will still crash

Free memory

So how to free memory ？ Because this application is not managed , If there is no manual release , Then there is a memory leak .

1. static void Main(string[] args)

2. {

3. for (int i = 0; i < 10000; i++)

4. {

5. Foo();

6. }

7. Console.ReadKey();

8. }

10. private static void Foo()

11. {

12. int n = 100000;// length

13. IntPtr buffer = Marshal.AllocHGlobal(sizeof(int) * n);

15. }

The above code will soon see that the memory is occupied by 2G, So you need to release it manually

            Marshal.FreeHGlobal(buffer);

The original byte Arrays need to use 1G Memory , And it's very slow , Now using this method only needs 7M Memory , fast

So when you need to apply for a large array , Need to keep releasing , You can use this method .