如何在无装箱/拆箱操作下处理已知泛型类型

我有一个处理大量不同类型数据的泛型方法。当数据为特定类型（本文中为double）时，我希望执行额外处理，其余功能在不同类型间完全一致。是否存在比示例中所示的（速度极慢的）装箱/拆箱更优的实现方式？这似乎意味着我们需要在断言T和double为同一类型的if..else代码块中，让编译器认可这一点。

原代码示例：

public static T[] HalfIfDouble<T>(T[] data)
{
    T[] result;

    if (typeof(T) == typeof(double))
    {
        // result = data.Select(x => x * 0.5).ToArray(); // does not compile

        result = data.Select(x =>
        {
            double d = (double)(object)x;
            return (T)(object)(d * 0.5);
        }).ToArray();
    }
    else
    {
        result = data;
    }

    // do some more processing...

    return result;
}

实际功能显然比该示例更复杂，且需兼容.NET Framework和.NET 6。

方案1：使用Unsafe类实现无装箱转换 #

通过System.Runtime.CompilerServices.Unsafe类直接进行数组类型的强制转换，完全避免装箱拆箱操作，性能最优。.NET Framework需先安装NuGet包System.Runtime.CompilerServices.Unsafe。

using System.Runtime.CompilerServices;

public static T[] HalfIfDouble<T>(T[] data)
{
    T[] result;

    if (typeof(T) == typeof(double))
    {
        // 直接将T[]转为double[]，无装箱
        var doubleData = Unsafe.As<T[], double[]>(ref data);
        var doubleResult = new double[doubleData.Length];
        
        // 手动循环处理（比LINQ性能更高，适合大量数据）
        for (int i = 0; i < doubleData.Length; i++)
        {
            doubleResult[i] = doubleData[i] * 0.5;
        }
        
        // 再将double[]转回T[]
        result = Unsafe.As<double[], T[]>(ref doubleResult);
    }
    else
    {
        result = data;
        // 若后续处理需要修改数组，此处应创建原数组的副本，避免修改原数据
        // result = (T[])data.Clone();
    }

    // 后续统一处理逻辑
    return result;
}

方案2：泛型委托缓存 #

利用泛型静态构造函数的特性，提前创建对应类型的处理委托，仅在第一次调用时进行类型检查，后续调用直接执行委托，避免重复类型判断开销，代码更安全且兼容性好。

public static class DataProcessor<T>
{
    public static readonly Func<T[], T[]> Process;

    static DataProcessor()
    {
        if (typeof(T) == typeof(double))
        {
            // 预定义double类型的处理逻辑
            Process = input =>
            {
                var doubleInput = (double[])(object)input;
                var doubleOutput = new double[doubleInput.Length];
                
                for (int i = 0; i < doubleInput.Length; i++)
                {
                    doubleOutput[i] = doubleInput[i] * 0.5;
                }
                
                return (T[])(object)doubleOutput;
            };
        }
        else
        {
            // 其他类型直接返回原数组（或根据需求创建副本）
            Process = input => input;
        }
    }
}

public static T[] HalfIfDouble<T>(T[] data)
{
    var result = DataProcessor<T>.Process(data);

    // 后续统一处理逻辑
    return result;
}

• Unsafe方案：性能天花板，完全消除装箱拆箱，但依赖非托管API，需确保类型检查的准确性（已通过typeof(T) == typeof(double)保证安全）。
• 委托缓存方案：首次调用有一次类型检查开销，后续调用无额外成本，代码更易维护，适合频繁调用的场景。

内容的提问来源于stack exchange，提问作者Mark Pattison