是否存在数学操作接口？泛型矩阵类算术操作实现疑问

你遇到的核心问题是C#泛型默认不允许直接使用运算符重载（比如+=），因为编译器无法确定泛型类型T是否支持该运算符。下面提供两种可行的解决方案：

方案一：自定义算术接口（兼容旧版.NET） #

如果你的项目基于.NET 7以下版本，自定义接口是最稳妥的方式：

1. 定义IMathable<T>接口 #

根据线性代数需求，接口需要包含核心算术方法，以及用于初始化的静态零值、单位值：

public interface IMathable<T>
{
    // 加法运算
    T Add(T other);
    // 减法运算
    T Subtract(T other);
    // 乘法运算
    T Multiply(T other);
    // 除法运算
    T Divide(T other);
    
    // 静态零值，用于初始化累加/累减变量
    static abstract T Zero { get; }
    // 静态单位值，用于初始化乘积变量
    static abstract T One { get; }
}

注：static abstract是C# 8.0及以上特性，如果用更低版本，可以把静态成员放到单独的静态类中。

2. 修改泛型矩阵类 #

添加接口约束，并通过接口方法实现算术运算，同时修复原代码中重复累加第一个元素的bug：

class Matrix<T> where T : IMathable<T>
{
    private T[,] _matrix;

    public Matrix(int rows, int cols)
    {
        _matrix = new T[rows, cols];
    }

    public T Sum()
    {
        if (_matrix.Length == 0)
            return IMathable<T>.Zero;

        T sum = IMathable<T>.Zero;
        for (int i = 0; i < _matrix.GetLength(0); i++)
        {
            for (int j = 0; j < _matrix.GetLength(1); j++)
            {
                sum = sum.Add(_matrix[i, j]);
            }
        }
        return sum;
    }
}

3. 实现自定义分数类 #

让你的分数类继承IMathable<Fraction>，并实现所有接口方法，同时可以重载运算符方便直接使用：

public class Fraction : IMathable<Fraction>
{
    public int Numerator { get; }
    public int Denominator { get; }

    public Fraction(int numerator, int denominator)
    {
        if (denominator == 0)
            throw new ArgumentException("分母不能为0");
        int gcd = GCD(Math.Abs(numerator), Math.Abs(denominator));
        Numerator = numerator / gcd * (denominator > 0 ? 1 : -1);
        Denominator = Math.Abs(denominator) / gcd;
    }

    private static int GCD(int a, int b)
    {
        while (b != 0)
        {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    public Fraction Add(Fraction other)
    {
        int newNumerator = Numerator * other.Denominator + other.Numerator * Denominator;
        int newDenominator = Denominator * other.Denominator;
        return new Fraction(newNumerator, newDenominator);
    }

    public Fraction Subtract(Fraction other)
    {
        int newNumerator = Numerator * other.Denominator - other.Numerator * Denominator;
        int newDenominator = Denominator * other.Denominator;
        return new Fraction(newNumerator, newDenominator);
    }

    public Fraction Multiply(Fraction other)
    {
        int newNumerator = Numerator * other.Numerator;
        int newDenominator = Denominator * other.Denominator;
        return new Fraction(newNumerator, newDenominator);
    }

    public Fraction Divide(Fraction other)
    {
        if (other.Numerator == 0)
            throw new DivideByZeroException();
        return new Fraction(Numerator * other.Denominator, Denominator * other.Numerator);
    }

    public static Fraction Zero => new Fraction(0, 1);
    public static Fraction One => new Fraction(1, 1);

    // 重载+运算符，支持直接使用sum += element
    public static Fraction operator +(Fraction a, Fraction b)
    {
        return a.Add(b);
    }
}

方案二：使用.NET官方数值接口（.NET 7+推荐） #

如果你的项目基于.NET 7或更高版本，直接使用System.Numerics.INumber<T>接口，这是官方为泛型数值运算提供的约束，支持所有内置数值类型（如double、int）和自定义数值类型：

1. 修改泛型矩阵类 #

添加INumber<T>约束后，可直接使用运算符和内置静态成员：

using System.Numerics;

class Matrix<T> where T : INumber<T>
{
    private T[,] _matrix;

    public Matrix(int rows, int cols)
    {
        _matrix = new T[rows, cols];
    }

    public T Sum()
    {
        if (_matrix.Length == 0)
            return T.Zero;

        T sum = T.Zero;
        foreach (T element in _matrix)
        {
            sum += element;
        }
        return sum;
    }
}

这个方案无需自定义接口，INumber<T>已经包含了所有算术运算所需的约束，double等内置类型天生支持该接口，自定义分数类只需实现INumber<Fraction>即可无缝兼容。

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