1 /// <summary>
 2 /// 提供结构体转换器的工厂类。
 3 /// Provides a factory class for structure converters.
 4 /// </summary>
 5 public class StructConvertFactory
 6 {
 7     /// <summary>
 8     /// 根据结构体类型的复杂性选择合适的转换器。
 9     /// Selects an appropriate converter based on the complexity of the structure type.
10     /// </summary>
11     /// <typeparam name="T">要为其创建转换器的结构体类型。</typeparam>
12     /// <returns>返回符合结构体类型特性的转换器实例。</returns>
13     /// <remarks>
14     /// 如果结构体包含复杂字段，则返回一个基于反射的转换器，否则返回一个基于内存操作的转换器。
15     /// If the structure contains complex fields, a reflection-based converter is returned; otherwise, a memory operation-based converter is provided.
16     /// </remarks>
17     public static IStructConvert CreateConvertor<T>() where T : struct
18     {
19         // 判断结构体类型T是否包含复杂字段
20         if (HasComplexFields(typeof(T)))
21         {
22             // 返回反射方式实现的结构体转换器
23             return new StructConvert();
24         }
25         else
26         {
27             // 返回Marshal自带的操作方式实现的结构体转换器
28             return new MarshalConvert();
29         }
30     }
31 
32     /// <summary>
33     /// 验证指定类型的字段是否包含复杂类型。
34     /// Verifies whether the fields of the specified type contain complex types.
35     /// </summary>
36     /// <param name="type">要检查的类型。</param>
37     /// <returns>如果包含复杂类型字段，则返回true；否则返回false。</returns>
38     /// <remarks>
39     /// 复杂类型包括数组、类以及非基本的值类型（如结构体），但不包括decimal。
40     /// Complex types include arrays, classes, and non-primitive value types such as structures, but exclude decimal.
41     /// </remarks>
42     private static bool HasComplexFields(Type type)
43     {
44         foreach (var field in type.GetFields(BindingFlags.Public | BindingFlags.Instance))
45         {
46             if (field.FieldType.IsArray || field.FieldType.IsClass ||
47                 (field.FieldType.IsValueType && !field.FieldType.IsPrimitive &&
48                  field.FieldType != typeof(decimal)))
49             {
50                 return true;
51             }
52         }
53         return false;
54     }
55 }

 1 /// <summary>
 2 /// IStructConvert 接口，提供结构体与字节数组之间的序列化和反序列化功能。
 3 /// IStructConvert interface, providing serialization and deserialization functionality between structures and byte arrays.
 4 /// </summary>
 5 public interface IStructConvert
 6 {
 7     /// <summary>
 8     /// 将字节数组反序列化为结构体。
 9     /// Deserializes a byte array into a structure.
10     /// </summary>
11     /// <typeparam name="T">结构体的类型。</typeparam>
12     /// <param name="data">包含结构体数据的字节数组。</param>
13     /// <returns>反序列化后的结构体实例。</returns>
14     byte[] StructToBytes<T>(T structure) where T : struct;
15 
16     /// <summary>
17     /// 将结构体实例转换为字节数组。
18     /// Converts a structure instance into a byte array.
19     /// </summary>
20     /// <typeparam name="T">要转换的结构体类型，必须是值类型。</typeparam>
21     /// <param name="structure">要转换的结构体实例。</param>
22     /// <returns>表示结构体数据的字节数组。</returns>
23     T BytesToStruct<T>(byte[] data) where T : struct;
24 }

 1   /// <summary>
 2   /// 实现IStructConvert接口，提供结构体与字节数组间的基本转换功能。
 3   /// Implements the IStructConvert interface to provide conversion between structures and byte arrays.
 4   /// </summary>
 5   public class MarshalConvert : IStructConvert
 6   {
 7       /// <summary>
 8       /// 将字节数组转换为指定类型的结构体实例。
 9       /// Converts a byte array into an instance of the specified type of structure.
10       /// </summary>
11       /// <typeparam name="T">要转换的结构体类型，必须是值类型。</typeparam>
12       /// <param name="data">包含结构体数据的字节数组。</param>
13       /// <returns>转换后的结构体实例。</returns>
14       public T BytesToStruct<T>(byte[] data) where T : struct
15       {
16           T structure;
17           // 计算结构体类型T的内存大小
18           // Calculate the memory size of the structure type T
19           int size = Marshal.SizeOf(typeof(T));
20           // 分配相应大小的内存缓冲区
21           // Allocate a memory buffer of the appropriate size
22           IntPtr buffer = Marshal.AllocHGlobal(size);
23           try
24           {
25               // 将字节数组复制到分配的内存中
26               // Copy the byte array to the allocated memory
27               Marshal.Copy(data, 0, buffer, size);
28               // 将内存缓冲区转换为指定的结构体
29               // Convert the memory buffer to the specified structure
30               structure = Marshal.PtrToStructure<T>(buffer);
31           }
32           finally
33           {
34               // 释放内存缓冲区
35               // Free the memory buffer
36               Marshal.FreeHGlobal(buffer);
37           }
38           return structure;
39       }
40 
41       /// <summary>
42       /// 将结构体实例转换为字节数组。
43       /// Converts a structure instance into a byte array.
44       /// </summary>
45       /// <typeparam name="T">要转换的结构体类型，必须是值类型。</typeparam>
46       /// <param name="structure">要转换的结构体实例。</param>
47       /// <returns>表示结构体数据的字节数组。</returns>
48       public byte[] StructToBytes<T>(T structure) where T : struct
49       {
50           // 计算结构体实例的内存大小
51           // Calculate the memory size of the structure instance
52           int size = Marshal.SizeOf(structure);
53           byte[] array = new byte[size];
54           // 分配相应大小的内存缓冲区
55           // Allocate a memory buffer of the appropriate size
56           IntPtr buffer = Marshal.AllocHGlobal(size);
57           try
58           {
59               // 将结构体实例复制到内存缓冲区
60               // Copy the structure instance to the memory buffer
61               Marshal.StructureToPtr(structure, buffer, false);
62               // 将内存缓冲区的数据复制到字节数组
63               // Copy the data from the memory buffer to the byte array
64               Marshal.Copy(buffer, array, 0, size);
65           }
66           finally
67           {
68               // 释放内存缓冲区
69               // Free the memory buffer
70               Marshal.FreeHGlobal(buffer);
71           }
72           return array;
73       }
74   }