如何在C#中创建不关心参数顺序的标量矩阵乘法方法？

方案1：提取核心逻辑，通过方法重载复用代码 #

先把真正的乘法计算逻辑抽成私有核心方法，再用方法重载实现两个参数顺序的公开方法——因为参数类型顺序不同，编译器可以区分，不需要不同的方法名：

// 核心计算逻辑，仅实现一次
private static decimal[,] MultiplyCore(decimal[,] matrix, decimal scalar)
{
    int rows = matrix.GetLength(0);
    int cols = matrix.GetLength(1);
    decimal[,] result = new decimal[rows, cols];
    
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            result[i, j] = matrix[i, j] * scalar;
        }
    }
    return result;
}

// 公开方法：数组 * 标量
public static decimal[,] Multiply(decimal[,] matrix, decimal scalar)
{
    return MultiplyCore(matrix, scalar);
}

// 公开方法：标量 * 数组（复用核心逻辑）
public static decimal[,] Multiply(decimal scalar, decimal[,] matrix)
{
    return MultiplyCore(matrix, scalar);
}

调用时直接用Multiply(myMatrix, 2.5m)或者Multiply(2.5m, myMatrix)即可，无需区分方法名，也没有代码重复。

方案2：自定义矩阵类 + 运算符重载（最符合数学直觉） #

如果场景允许自定义矩阵类，推荐用运算符重载实现，这样可以像写数学表达式一样用*运算符，同时利用乘法交换律复用代码：

public class Matrix
{
    private readonly decimal[,] _data;
    
    public int Rows => _data.GetLength(0);
    public int Columns => _data.GetLength(1);

    public Matrix(decimal[,] data)
    {
        _data = data ?? throw new ArgumentNullException(nameof(data));
    }

    // 矩阵 * 标量：实现核心计算
    public static Matrix operator *(Matrix matrix, decimal scalar)
    {
        decimal[,] result = new decimal[matrix.Rows, matrix.Columns];
        for (int i = 0; i < matrix.Rows; i++)
        {
            for (int j = 0; j < matrix.Columns; j++)
            {
                result[i, j] = matrix._data[i, j] * scalar;
            }
        }
        return new Matrix(result);
    }

    // 标量 * 矩阵：直接复用上面的运算符（乘法交换律成立）
    public static Matrix operator *(decimal scalar, Matrix matrix)
    {
        return matrix * scalar;
    }
}

使用时直接写：

var myMatrix = new Matrix(new decimal[,] { {1,2}, {3,4} });
var result1 = myMatrix * 2m;   // 数组*标量
var result2 = 2m * myMatrix;   // 标量*数组，结果和result1一致

这种方案最贴近数学运算的写法，代码简洁且无重复。

方案3：扩展方法（适配原生二维数组） #

如果不想自定义类，想直接对decimal[,]操作，可以用扩展方法+核心逻辑复用：

public static class MatrixExtensions
{
    private static decimal[,] MultiplyCore(decimal[,] matrix, decimal scalar)
    {
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        decimal[,] result = new decimal[rows, cols];
        
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                result[i, j] = matrix[i, j] * scalar;
            }
        }
        return result;
    }

    // 数组*标量：扩展方法，调用更直观
    public static decimal[,] MultiplyByScalar(this decimal[,] matrix, decimal scalar)
    {
        return MultiplyCore(matrix, scalar);
    }

    // 标量*数组：静态方法，补全参数顺序场景
    public static decimal[,] MultiplyScalarByMatrix(decimal scalar, decimal[,] matrix)
    {
        return MultiplyCore(matrix, scalar);
    }
}

调用示例：

decimal[,] myMatrix = new decimal[,] { {1,2}, {3,4} };
var result1 = myMatrix.MultiplyByScalar(2m);
var result2 = MatrixExtensions.MultiplyScalarByMatrix(2m, myMatrix);

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