.NET泛型计算器类运算符错误解决及.NET6以下版本实现方案

解决创建泛型算术类时遇到的“运算符‘+’无法应用于类型‘T’和‘T’”错误。

.NET 7+ 可行方案（对比参考） #

.NET 7引入了INumber<T>等数值抽象接口，直接添加约束即可实现类型安全的泛型运算：

public class GenericCalculator<T> where T : INumber<T>
{
    public T Add(T a, T b) => a + b;
    public T Subtract(T a, T b) => a - b;
    public T Multiply(T a, T b) => a * b;
}

.NET 6及以下版本替代方案 #

方案1：静态辅助类+手动注册（编译时安全） #

通过静态类为每个支持的数值类型预定义运算逻辑，避免编译时错误：

// 运算逻辑存储类
public static class NumericOperations<T>
{
    public static Func<T, T, T> Add { get; set; }
    public static Func<T, T, T> Subtract { get; set; }
    public static Func<T, T, T> Multiply { get; set; }
}

// 初始化各数值类型的运算逻辑
static NumericOperations()
{
    // 注册int类型运算
    NumericOperations<int>.Add = (a, b) => a + b;
    NumericOperations<int>.Subtract = (a, b) => a - b;
    NumericOperations<int>.Multiply = (a, b) => a * b;

    // 注册double类型运算
    NumericOperations<double>.Add = (a, b) => a + b;
    NumericOperations<double>.Subtract = (a, b) => a - b;
    NumericOperations<double>.Multiply = (a, b) => a * b;

    // 按需添加float、long、decimal等其他数值类型
}

// 泛型计算器实现
public class GenericCalculator<T>
{
    public T Add(T a, T b) => NumericOperations<T>.Add(a, b);
    public T Subtract(T a, T b) => NumericOperations<T>.Subtract(a, b);
    public T Multiply(T a, T b) => NumericOperations<T>.Multiply(a, b);
}

• 优势：编译时就能检查类型是否支持，性能无损耗
• 劣势：需要手动为每个要支持的类型注册逻辑，扩展性一般

方案2：反射调用运算符方法（灵活但有性能开销） #

通过反射获取类型的运算符方法，动态调用实现运算，无需手动注册：

public class GenericCalculator<T>
{
    private static readonly MethodInfo _addMethod = typeof(T).GetMethod("op_Addition", new[] { typeof(T), typeof(T) });
    private static readonly MethodInfo _subtractMethod = typeof(T).GetMethod("op_Subtraction", new[] { typeof(T), typeof(T) });
    private static readonly MethodInfo _multiplyMethod = typeof(T).GetMethod("op_Multiply", new[] { typeof(T), typeof(T) });

    public T Add(T a, T b)
    {
        if (_addMethod == null)
            throw new NotSupportedException($"类型 {typeof(T)} 不支持加法运算");
        return (T)_addMethod.Invoke(null, new object[] { a, b });
    }

    public T Subtract(T a, T b)
    {
        if (_subtractMethod == null)
            throw new NotSupportedException($"类型 {typeof(T)} 不支持减法运算");
        return (T)_subtractMethod.Invoke(null, new object[] { a, b });
    }

    public T Multiply(T a, T b)
    {
        if (_multiplyMethod == null)
            throw new NotSupportedException($"类型 {typeof(T)} 不支持乘法运算");
        return (T)_multiplyMethod.Invoke(null, new object[] { a, b });
    }
}

• 优势：自动支持所有重载了运算符的类型，无需手动配置
• 劣势：反射调用有性能损耗，仅能在运行时发现不支持的类型

方案3：社区提供的dynamic实现（极简但无编译检查） #

利用dynamic绕过编译时类型校验，直接在运行时解析运算符：

public class GenericCalculator<T>
{
    public T Add(T a, T b) => (T)(dynamic)a + (dynamic)b;
    public T Subtract(T a, T b) => (T)(dynamic)a - (dynamic)b;
    public T Multiply(T a, T b) => (T)(dynamic)a * (dynamic)b;
}

• 优势：代码极度简洁，无需额外配置
• 劣势：编译时无类型检查，运行时若类型不支持运算符会抛出异常，且dynamic有一定性能损耗

内容的提问来源于stack exchange，提问作者Sameer Ahmed S