如何为C#泛型Stats类定义接受异源数值类型参数的运算符？

一、修复运算符重载的泛型参数声明 #

你之前的运算符定义问题在于未在方法级别声明第二个泛型参数T2，且约束需要调整以适配跨类型运算。以下是正确的实现方式：

public class Stats<T> where T : System.Numerics.INumberBase<T>
{
    private Dictionary<string, T> _stats = new();

    // 跨类型加法：Stats<T2> 与 Stats<T> 相加返回 Stats<T>
    public static Stats<T> operator +(Stats<T> a, Stats<T2> b) 
        where T2 : System.Numerics.INumberBase<T2>, System.Numerics.IAdditionOperators<T2, T, T>
    {
        var result = new Stats<T>();
        // 遍历键集合（假设双方键完全匹配，可根据需求补全键缺失逻辑）
        foreach (var key in a._stats.Keys)
        {
            result._stats[key] = b._stats[key] + a._stats[key];
        }
        return result;
    }

    // 反向跨类型加法：Stats<T> 与 Stats<T2> 相加返回 Stats<T2>
    public static Stats<T2> operator +(Stats<T2> a, Stats<T> b) 
        where T2 : System.Numerics.INumberBase<T2>, System.Numerics.IAdditionOperators<T, T2, T2>
    {
        var result = new Stats<T2>();
        foreach (var key in a._stats.Keys)
        {
            result._stats[key] = b._stats[key] + a._stats[key];
        }
        return result;
    }

    // 同理可实现减法、乘法运算符，只需替换IAdditionOperators为对应接口
}

核心注意点：

• 在运算符方法上显式声明T2泛型参数
• 通过INumberBase确保类型为数值类型，通过IAdditionOperators约束跨类型运算的合法性
• 实现双向运算符重载，覆盖两种类型顺序的运算场景

二、实现Stats类型间的转换（如Stats → Stats） #

通过隐式/显式转换运算符实现类型转换，无需手动编写转换方法：

public class Stats<T> where T : System.Numerics.INumberBase<T>
{
    // ... 保留之前的代码 ...

    // 隐式转换：适用于无精度丢失的类型转换（如byte→ulong）
    public static implicit operator Stats<T>(Stats<TOther> other) 
        where TOther : System.Numerics.INumberBase<TOther>, IConvertible
    {
        var result = new Stats<T>();
        foreach (var (key, value) in other._stats)
        {
            // 使用INumberBase的Create方法安全转换数值类型
            result._stats[key] = T.Create(value);
        }
        return result;
    }

    // 显式转换：适用于可能丢失精度的场景（如ulong→byte）
    public static explicit operator Stats<T>(Stats<TOther> other) 
        where TOther : System.Numerics.INumberBase<TOther>, IConvertible
    {
        var result = new Stats<T>();
        foreach (var (key, value) in other._stats)
        {
            // 可在此添加精度检查逻辑，比如判断value是否在T的取值范围内
            result._stats[key] = T.Create(value);
        }
        return result;
    }
}

使用示例：

Stats<byte> byteStats = new();
Stats<ulong> ulongStats = byteStats; // 隐式转换
// 显式转换示例：Stats<byte> newByteStats = (Stats<byte>)ulongStats;

三、优化建议 #

1. 用枚举替代字符串键：既然键来自有限集合，建议定义枚举类型（如PlayerStat），避免字符串拼写错误，同时确保所有Stats实例的键一致性：

public enum PlayerStat { Health, Mana, Attack }
public class Stats<T> where T : System.Numerics.INumberBase<T>
{
    private Dictionary<PlayerStat, T> _stats = new();
    // 后续代码将string替换为PlayerStat即可
}

2. 处理键缺失场景：如果两个Stats实例的键不完全匹配，可在运算时默认补0或抛出异常：

result._stats[key] = a._stats.TryGetValue(key, out var aVal) ? aVal : T.Zero 
                   + b._stats.TryGetValue(key, out var bVal) ? bVal : T.Zero;

3. 复用运算逻辑：抽离通用运算方法，避免重复代码：

private static Stats<TResult> Combine<TLeft, TRight, TResult>(
    Stats<TLeft> left, Stats<TRight> right, 
    Func<TLeft, TRight, TResult> operation)
    where TResult : System.Numerics.INumberBase<TResult>
{
    var result = new Stats<TResult>();
    var allKeys = left._stats.Keys.Union(right._stats.Keys);
    foreach (var key in allKeys)
    {
        var leftVal = left._stats.TryGetValue(key, out var l) ? l : TLeft.Zero;
        var rightVal = right._stats.TryGetValue(key, out var r) ? r : TRight.Zero;
        result._stats[key] = operation(leftVal, rightVal);
    }
    return result;
}

// 运算符可简化为：
public static Stats<T> operator +(Stats<T> a, Stats<T2> b) 
    where T2 : System.Numerics.INumberBase<T2>, System.Numerics.IAdditionOperators<T2, T, T>
{
    return Combine(b, a, (bVal, aVal) => bVal + aVal);
}

内容的提问来源于stack exchange，提问作者Ryan Chou