C ＃ - realize serialization with Marshall class

Mainly used Marshal Two methods in class ：

The first is StructureToPtr, Marshaling data from managed objects to unmanaged memory blocks .

The second is PtrToStructure, Marshals data from an unmanaged memory block to a newly allocated managed object of the specified type .

As long as there are these two methods of mutual transformation , We can realize serialization .

First, let's look at serialization

serialize ：
There is a prerequisite , That is, we must know the size of the serialized object .

First step ： Let's find out the size of the object first , Then allocate the corresponding memory size to it in unmanaged memory .

The second step ： Then we will send this object to the memory just allocated , Then we will get a pointer to the first address of the allocated memory block .

The third step ： Finally, we can use this first address pointer , Start at the position indicated by the pointer , Copy data to the specified byte[] Array , The length of the copy is the amount of memory we allocate for this object , obtain byte[] After the data , I don't need to say more about the following things , You can save to database Or in the file .

Deserialization ：
When serializing, we first marshal an object into an unmanaged memory block , Then read the data in the memory block to byte[] Array ,

Now we deserialize

First step ： Let's find out the size of the object first , Then allocate the corresponding memory size to it in unmanaged memory .

The second step ： And put this byte[] Copy the data to an unmanaged memory block .

The third step ： Finally, marshal the data of the specified size from the memory block to the object .

There is one thing to note , That is because we cannot find the actual size of an object of reference type , So we can only use unmanaged objects , such as struct Structure .

therefore , When we just use it to store data , Objects that do not involve any operations , We can treat it as a structure , In this way, we can save space when serializing .

Because if you use the usual serialization method to serialize a class object , It requires more space than you need to serialize a with the same structure struct object .

Here is the code ： 

1. public static class MyConverter

2. {

3. /// <summary>

4. /// From structure to byte Array

5. /// </summary>

6. public static byte[] StructureToByte<T>(T structure)

7. {

8. int size = Marshal.SizeOf(typeof(T));

9. byte[] buffer = new byte[size];

10. IntPtr bufferIntPtr = Marshal.AllocHGlobal(size);

11. try

12. {

13. Marshal.StructureToPtr(structure, bufferIntPtr, true);

14. Marshal.Copy(bufferIntPtr, buffer, 0, size);

15. }

16. finally

17. {

18. Marshal.FreeHGlobal(bufferIntPtr);

19. }

20. return buffer;

21. }

23. /// <summary>

24. /// from byte The array is converted to a structure

25. /// </summary>

26. public static T ByteToStructure<T>(byte[] dataBuffer)

27. {

28. object structure = null;

29. int size = Marshal.SizeOf(typeof(T));

30. IntPtr allocIntPtr = Marshal.AllocHGlobal(size);

31. try

32. {

33. Marshal.Copy(dataBuffer, 0, allocIntPtr, size);

34. structure = Marshal.PtrToStructure(allocIntPtr, typeof(T));

35. }

36. finally

37. {

38. Marshal.FreeHGlobal(allocIntPtr);

39. }

40. return (T)structure;

41. }

42. }

44. // Test code ///

45. class Program

46. {

47. static void Main(string[] args)

48. {

49. Student student1 = new Student { Name = " Huchangjun ", ID = 2 };

50. Console.WriteLine(" Before serialization => full name :{0} ID:{1}", student1.ID, student1.Name);

52. byte[] bytes = MyConverter.StructureToByte<Student>(student1);

53. Student sudent2 = MyConverter.ByteToStructure<Student>(bytes);

55. Console.WriteLine(" After serialization => full name :{0} ID:{1}", sudent2.ID, sudent2.Name);

56. Console.Read();

57. }

58. }

60. public struct Student

61. {

62. public int ID { get; set; }

63. public string Name { get; set; }

64. }