C# 如何在静态类中静态重写/创建运算符*

嗨，我想为数组操作编写一些扩展，如：

MatrixProduct

public static double[][] operator *(double[][] matrixA, double[][] matrixB)

public static double[] operator *(double[][] matrix, double[] vector)

MatrixVectorProduct

public static double[][] operator *(double[][] matrixA, double[][] matrixB)

public static double[] operator *(double[][] matrix, double[] vector)

还有更多

我为什么要这个？因为正如你可能知道的，目前在c#中实现了非这样的操作，如果我可以说

matrixC=matrixA*matrixB而不是
matrixC=MatrixProduct（matrixA，matrixB）那么有没有办法做到这一点

因为如果我这样做：

public static class ArrayExtension
{
    public static double[] operator *(double[][] matrix, double[] vector)
    {
        // result of multiplying an n x m matrix by a m x 1 column vector (yielding an n x 1 column vector)
        int mRows = matrix.Length; int mCols = matrix[0].Length;
        int vRows = vector.Length;

        if (mCols != vRows)
            throw new InvalidOperationException("Non-conformable matrix and vector in MatrixVectorProduct");

        double[] result = new double[mRows]; // an n x m matrix times a m x 1 column vector is a n x 1 column vector

        Parallel.For(0, mRows, i =>
        {
            var row = matrix[i];
            for (int j = 0; j < mCols; ++j)
                result[i] += row[j] * vector[j];
        });

        return result;
    }
}

公共静态类ArrayExtension
{
公共静态双[]运算符*（双[]矩阵，双[]向量）
{
//n x m矩阵乘以m x 1列向量的结果（生成n x 1列向量）
int mRows=matrix.Length；int mCols=matrix[0]。Length；
int vRows=向量长度；
如果（mCols！=vRows）
抛出新的InvalidOperationException（“MatrixVectorProduct中的不一致矩阵和向量”）；
double[]result=new double[mRows]；//一个nx m矩阵乘以一个m x 1列向量就是一个nx 1列向量
对于（0，mRows，i=>
{
var行=矩阵[i]；
对于（int j=0；j

一个异常告诉我，我不能将静态类和用户定义的运算符组合起来，所以有解决方法吗？
如果其中一个操作数是用户定义的类型，则只能重载
运算符*
，因此很不幸，答案是否定的

发件人：

要重载自定义类上的运算符，需要创建一个方法
在类上使用正确的签名。必须命名该方法
“运算符X”，其中X是所选运算符的名称或符号
超载。一元运算符有一个参数，二元运算符有一个参数
有两个参数在每种情况下，一个参数必须是相同的类型
作为声明运算符的类或结构[…]

因此，您必须在表达式中包含一个自定义的
矩阵
类，或者使用一个接受
双[]
参数的适当方法。
如果它的一个操作数是用户定义的类型，则只能重载
运算符*
，因此很遗憾，答案是否定的

发件人：

要重载自定义类上的运算符，需要创建一个方法
在类上使用正确的签名。必须命名该方法
“运算符X”，其中X是所选运算符的名称或符号
超载。一元运算符有一个参数，二元运算符有一个参数
有两个参数在每种情况下，一个参数必须是相同的类型
作为声明运算符的类或结构[…]

因此，您必须在表达式中包含一个自定义的
矩阵
类，或者使用一个采用
双[]
参数的适当方法。
您可以始终定义自己的
矩阵
类，并为该类型指定运算符。事实上，我不认为这里有任何其他方法。但我不想重新发明轮子：（而且，这不会是一个，因为第一个参数前面没有
this
@WiiMaxx这里没有太多的重新发明，你的
矩阵
类可以包装一个锯齿状数组并公开所需的运算符/方法（例如，
Transpose
）。可以说，它会更干净（语义上），因为锯齿数组不一定意味着“矩阵”。@Corak你说得对：）我没有看到它，所以情况变得更糟，因为看起来我也不能在那里使用它：你可以定义你自己的
Matrix
类，并为该类型指定运算符。实际上，我认为这里没有其他方法。但我不想重新发明轮子：（另外，这也不是一个简单的例子，因为第一个参数前面没有
this
@WiiMaxx。这里没有太多的重新发明，你的
矩阵
类可以只包装一个锯齿状数组，并公开所需的操作符/方法（例如
转置
）。可以说，它会更干净（语义上），因为锯齿阵列不一定意味着“矩阵”。@Corak你是对的：）没有看到它，所以它变得更糟，因为它看起来也不能在那里使用：d太遗憾了。所以我必须重新发明轮子？我不喜欢这样：（@WiiMaxx:真的没有什么需要重新发明的，你可以编写一个
矩阵
构造函数，直接接受一个
double[，]
并包装它。顺便说一句，这就是你的参数类型——一个矩形数组，而不是
double[]
这是一个锯齿状阵列。我需要lightspeed性能，所以它必须是锯齿状阵列；@WiiMaxx:我确实没有亲身体验过性能是如何受到影响的，但理论上矩形应该更快（减少一个间接寻址）除非你的数组是稀疏的，这里看起来不是这样。你为什么说锯齿更快？因为a
[n，m]
是一个单独的内存空间，其中a
[n][m]
在
n
内存空间中是锯齿状的，因此访问速度更快。您可以在自己的计算机上测试它，或者搜索锯齿状阵列与2d阵列。基于矩阵大小和算法，它可以难以置信地提高性能，高达100%以上。太遗憾了。所以我必须重新发明轮子？我不喜欢这样：（@WiiMaxx:真的没有什么需要重新发明的，你可以编写一个
矩阵
构造函数，直接接受一个
double[，]
并包装它。顺便说一句，这就是你的参数类型——一个矩形数组，而不是
double[]
这是一个锯齿状阵列。我需要lightspeed性能，所以它必须是锯齿状阵列；@WiiMaxx:我确实没有亲身体验过性能是如何受到影响的，但理论上矩形应该更快（减少一个间接寻址）除非你的数组是稀疏的，这里看起来不是这样。你为什么说锯齿更快？因为a
[n，m]
是