如何减少生命周期未定义的数据类型的内存分配

您可能过于关注每个 GC 分配的精确大小，但最好尽量减少 GC 分配的数量和代码的整体复杂性。由于您使用的是 C# 8，实际上不需要序列化您的类型DamageData，并且愿意编写unsafe代码，因此我将建议一种替代的、更简单的设计：您可以将您的DamageDataInternal类替换为unsafe fixed int values[DamageTypeLength];某个私有结构字段中的字段。这种设计DamageData会比您的理想解决方案稍大，但它仍然相当小，同时无需分配和处置任何额外的内存（无论是否池化）。

假设你的DamageType代码看起来是这样的。首先添加一些编译时常量来指示它的长度：

public enum DamageType { Default = 0, Rupture = 1, Kinetic = 2, Thermal = 3, Cryogenic = 4, Explosive = 5, Chemical = 6, Light = 7, Radiation = 8, Electric = 9, };

public static class DamageTypeConstants
{
    static DamageTypeConstants()
    {
        DamageTypes = (DamageType[])Enum.GetValues(typeof(DamageType));
        Debug.Assert(DamageTypes.All(d => (int)d >= 0 && (int)d < DamageTypeConstants.DamageTypeLength));
        Debug.Assert(DamageTypes.Length == DamageTypeConstants.DamageTypeLength);
    }

    // KEEP THIS IN SYNC WITH THE MAX VALUE IN THE DamageType enum!!!
    public const int DamageTypeLength = 1 + (int)DamageType.Electric; 
    public static readonly DamageType[] DamageTypes; // I moved this into the "Constants" class
}

然后重新实现你的DamageData和DamageDataInternal，如下所示，创建一个包含固定大小缓冲区的DamageDataInternal私有字段：struct

public class DamageData
{
    private DamageDataStruct damageDataStruct = new();

    public int this[DamageType damageType]
    {
        get => damageDataStruct[damageType];
        set => damageDataStruct[damageType] = value;
    }
    
    public int TotalDamage => damageDataStruct.TotalDamage;
}

public unsafe struct DamageDataStruct
{
    int totalDamage;
    unsafe fixed int values[DamageTypeConstants.DamageTypeLength];

    public int TotalDamage => totalDamage;

    public int this[DamageType damageType]
    {
        get
        {
            var index = (int)damageType;
            if (index < 0 || index >= DamageTypeConstants.DamageTypeLength)
                throw new IndexOutOfRangeException(nameof(damageType));
            return values[index];
        }
        set
        {
            var index = (int)damageType;
            if (index < 0 || index >= DamageTypeConstants.DamageTypeLength)
                throw new IndexOutOfRangeException(nameof(damageType));
            var oldValue = values[index];
            totalDamage += (value - oldValue);
            values[index] = value;
        }
    }
}

我怀疑（但不确定）Unity 是否可以序列化固定大小的缓冲区字段。您在评论中提到我有另一种类型作为的初始化程序DamageData。如果是这样，它需要看起来像以下 DTO：

[Serializable]
public class DamageDataDTO
{
    public int [] values;
    
    public DamageDataDTO(DamageData data)
    {
        values = new int[DamageTypeConstants.DamageTypeLength];
        for (int i = 0; i < values.Length; i++)
            values[i] = data[(DamageType)i];
    }
    
    public DamageData ToDamageData()
    {
        var data = new DamageData();
        if (values == null)
            return data;
        for (int i = 0, count = Math.Min(values.Length, DamageTypeConstants.DamageTypeLength); i < count; i++)
            data[(DamageType)i] = values[i];
        return data;
    }
}

要构建DamageData具有某些特定损坏的，您可以使用如下初始化程序：

var damageType = DamageType.Explosive;
var value = 10;
var damageData = new DamageData
{
    [damageType] = value,
};

笔记：

• 您现有的DamageData类将其大部分数据保存在DamageDataInternal使用租用float []数组的池化类型中。这种方法不会减少GC 分配的数量（您仍然每次都会分配DamageData），它只会减少每个 GC 分配的大小，但代价是池化分配。

• 您写道，创建结构是行不通的，因为它需要不断复制数据。只要该damageDataInternal字段是私有的，并且您永远不会通过某些属性或方法返回它，这在实践中就不会成为问题，因为您永远不会真正复制它。

• 结构的大小DamageDataInternal将是DamageTypeLength整数，加上缓存总值的额外整数。因此总共 11 个整数 = 44 字节（更可能是 48 字节加上填充）。

• 由于DamageDataInternal结构嵌入在DamageData类中，因此此类的大小将是结构的大小DamageDataInternal加上您存储在那里的其他内容，例如缓存的哈希码。

• 您现有的DamageData类使用终结器来释放池化DamageDataInternal和租用的float[]数组。带有终结器的类会对 GC 性能产生负面影响，如析构函数是否会影响性能？中所述，并且不是确定性的，正如Guru Stron在评论中指出的那样。

  通过使用dispose 模式并调用 GC.SuppressFinalize(this);可以避免GC 性能下降Dispose()——但是您指出 的生存期DamageData是未定义的，因此这似乎不可行，因为您永远不知道何时调用Dispose()。用从未复制的较小固定大小缓冲区替换池化和租用的值似乎是一种合理的选择，可以消除最终确定性能损失。

  如果损坏类型数量太多，我的设计就会变得不那么有吸引力。

• 在您的问题中，您没有说明如何DamageData使用。也许可以用它代替它DamageDataStruct，并通过使用属性和索引器来访问它来避免过度复制ref return。

• 固定大小的缓冲区只能是结构的实例字段，但是这些结构可以是类的实例字段，也可以直接在堆栈上分配。

• 在C# 12中，你可以unsafe使用内联数组来消除代码，如下图所示：

  public struct DamageDataStruct
  {
      int totalDamage;
      [System.Runtime.CompilerServices.InlineArray(DamageTypeConstants.DamageTypeLength)]
      struct Buffer { private int _element0; }
      Buffer values;
  
      public int TotalDamage => totalDamage;
  
      public int this[DamageType damageType]
      {
          get => values[(int)damageType];
          set
          {
              var index = (int)damageType;
              var oldValue = values[index];
              totalDamage += (value - oldValue);
              values[index] = value;
          }
      }
  }