C#嵌套型结构体数据的转换

/// <summary>
/// 提供结构体转换器的工厂类。
/// Provides a factory class for structure converters.
/// </summary>
public class StructConvertFactory
{
    /// <summary>
    /// 根据结构体类型的复杂性选择合适的转换器。
    /// Selects an appropriate converter based on the complexity of the structure type.
    /// </summary>
    /// <typeparam name="T">要为其创建转换器的结构体类型。</typeparam>
    /// <returns>返回符合结构体类型特性的转换器实例。</returns>
    /// <remarks>
    /// 如果结构体包含复杂字段，则返回一个基于反射的转换器，否则返回一个基于内存操作的转换器。
    /// If the structure contains complex fields, a reflection-based converter is returned; otherwise, a memory operation-based converter is provided.
    /// </remarks>
    public static IStructConvert CreateConvertor<T>() where T : struct
    {
        // 判断结构体类型T是否包含复杂字段
        if (HasComplexFields(typeof(T)))
        {
            // 返回反射方式实现的结构体转换器
            return new StructConvert();
        }
        else
        {
            // 返回Marshal自带的操作方式实现的结构体转换器
            return new MarshalConvert();
        }
    }

    /// <summary>
    /// 验证指定类型的字段是否包含复杂类型。
    /// Verifies whether the fields of the specified type contain complex types.
    /// </summary>
    /// <param name="type">要检查的类型。</param>
    /// <returns>如果包含复杂类型字段，则返回true；否则返回false。</returns>
    /// <remarks>
    /// 复杂类型包括数组、类以及非基本的值类型（如结构体），但不包括decimal。
    /// Complex types include arrays, classes, and non-primitive value types such as structures, but exclude decimal.
    /// </remarks>
    private static bool HasComplexFields(Type type)
    {
        foreach (var field in type.GetFields(BindingFlags.Public | BindingFlags.Instance))
        {
            if (field.FieldType.IsArray || field.FieldType.IsClass ||
                (field.FieldType.IsValueType && !field.FieldType.IsPrimitive &&
                 field.FieldType != typeof(decimal)))
            {
                return true;
            }
        }
        return false;
    }
}

/// <summary>
/// IStructConvert 接口，提供结构体与字节数组之间的序列化和反序列化功能。
/// IStructConvert interface, providing serialization and deserialization functionality between structures and byte arrays.
/// </summary>
public interface IStructConvert
{
    /// <summary>
    /// 将字节数组反序列化为结构体。
    /// Deserializes a byte array into a structure.
    /// </summary>
    /// <typeparam name="T">结构体的类型。</typeparam>
    /// <param name="data">包含结构体数据的字节数组。</param>
    /// <returns>反序列化后的结构体实例。</returns>
    byte[] StructToBytes<T>(T structure) where T : struct;

    /// <summary>
    /// 将结构体实例转换为字节数组。
    /// Converts a structure instance into a byte array.
    /// </summary>
    /// <typeparam name="T">要转换的结构体类型，必须是值类型。</typeparam>
    /// <param name="structure">要转换的结构体实例。</param>
    /// <returns>表示结构体数据的字节数组。</returns>
    T BytesToStruct<T>(byte[] data) where T : struct;
}

  /// <summary>
  /// 实现IStructConvert接口，提供结构体与字节数组间的基本转换功能。
  /// Implements the IStructConvert interface to provide conversion between structures and byte arrays.
  /// </summary>
  public class MarshalConvert : IStructConvert
  {
      /// <summary>
      /// 将字节数组转换为指定类型的结构体实例。
      /// Converts a byte array into an instance of the specified type of structure.
      /// </summary>
      /// <typeparam name="T">要转换的结构体类型，必须是值类型。</typeparam>
      /// <param name="data">包含结构体数据的字节数组。</param>
      /// <returns>转换后的结构体实例。</returns>
      public T BytesToStruct<T>(byte[] data) where T : struct
      {
          T structure;
          // 计算结构体类型T的内存大小
          // Calculate the memory size of the structure type T
          int size = Marshal.SizeOf(typeof(T));
          // 分配相应大小的内存缓冲区
          // Allocate a memory buffer of the appropriate size
          IntPtr buffer = Marshal.AllocHGlobal(size);
          try
          {
              // 将字节数组复制到分配的内存中
              // Copy the byte array to the allocated memory
              Marshal.Copy(data, 0, buffer, size);
              // 将内存缓冲区转换为指定的结构体
              // Convert the memory buffer to the specified structure
              structure = Marshal.PtrToStructure<T>(buffer);
          }
          finally
          {
              // 释放内存缓冲区
              // Free the memory buffer
              Marshal.FreeHGlobal(buffer);
          }
          return structure;
      }

      /// <summary>
      /// 将结构体实例转换为字节数组。
      /// Converts a structure instance into a byte array.
      /// </summary>
      /// <typeparam name="T">要转换的结构体类型，必须是值类型。</typeparam>
      /// <param name="structure">要转换的结构体实例。</param>
      /// <returns>表示结构体数据的字节数组。</returns>
      public byte[] StructToBytes<T>(T structure) where T : struct
      {
          // 计算结构体实例的内存大小
          // Calculate the memory size of the structure instance
          int size = Marshal.SizeOf(structure);
          byte[] array = new byte[size];
          // 分配相应大小的内存缓冲区
          // Allocate a memory buffer of the appropriate size
          IntPtr buffer = Marshal.AllocHGlobal(size);
          try
          {
              // 将结构体实例复制到内存缓冲区
              // Copy the structure instance to the memory buffer
              Marshal.StructureToPtr(structure, buffer, false);
              // 将内存缓冲区的数据复制到字节数组
              // Copy the data from the memory buffer to the byte array
              Marshal.Copy(buffer, array, 0, size);
          }
          finally
          {
              // 释放内存缓冲区
              // Free the memory buffer
              Marshal.FreeHGlobal(buffer);
          }
          return array;
      }
  }