这可以通过System.Numerics vector API很好地完成，至少可以自由使用Unsafe类。
据我所知，从二维矩阵中加载向量没有一个好的“标准”方法。普通加载的重载都不适用，也没有一个普通的方法来获得二维数组的Span<T>。但是使用Unsafe，我们可以完成它。
使用8个单独的数组展开8（参见Unrolling FP loops with multiple accumulators），并通过使用Unsafe操作引用将2D矩阵视为1D数组，我们可以做到这一点：（未测试，但在sharplab.io上编译）

static unsafe double Sum(double[,] matrix)
{
    Vector<double> sum0 = Vector<double>.Zero;
    Vector<double> sum1 = Vector<double>.Zero;
    Vector<double> sum2 = Vector<double>.Zero;
    Vector<double> sum3 = Vector<double>.Zero;
    Vector<double> sum4 = Vector<double>.Zero;
    Vector<double> sum5 = Vector<double>.Zero;
    Vector<double> sum6 = Vector<double>.Zero;
    Vector<double> sum7 = Vector<double>.Zero;
    double sum8 = 0;
    uint vlen = (uint)Vector<double>.Count;
    ref double unaligneddata = ref matrix[0, 0];
    uint i = 0;
    uint alignmask = vlen * sizeof(double) - 1;
    for (; i < matrix.Length && ((IntPtr)Unsafe.AsPointer(ref unaligneddata) & alignmask) != 0; i++)
    {
        sum8 += unaligneddata;
        unaligneddata = ref Unsafe.Add(ref unaligneddata, 1);
    }
    uint alignment_skipped = i;
    ref Vector<double> data = ref Unsafe.As<double, Vector<double>>(ref unaligneddata);
    uint bigChunk = ((uint)matrix.Length - alignment_skipped & (0u - (vlen * 8))) + alignment_skipped;
    for (; i < bigChunk; i += vlen * 8)
    {
        sum0 += data;
        sum1 += Unsafe.Add(ref data, 1);
        sum2 += Unsafe.Add(ref data, 2);
        sum3 += Unsafe.Add(ref data, 3);
        sum4 += Unsafe.Add(ref data, 4);
        sum5 += Unsafe.Add(ref data, 5);
        sum6 += Unsafe.Add(ref data, 6);
        sum7 += Unsafe.Add(ref data, 7);
        data = ref Unsafe.Add(ref data, 8);
    }
    uint smallChunk = ((uint)matrix.Length - alignment_skipped & (0u - vlen)) + alignment_skipped;
    for (; i < smallChunk; i += vlen)
    {
        sum0 += data;
        data = ref Unsafe.Add(ref data, 1);
    }
    ref double remainder = ref Unsafe.As<Vector<double>, double>(ref data);
    for (; i < matrix.Length; i++)
    {
        sum8 += remainder;
        remainder = ref Unsafe.Add(ref remainder, 1);
    }
    sum0 += sum1;
    sum2 += sum3;
    sum4 += sum5;
    sum6 += sum7;
    sum0 += sum2;
    sum4 += sum6;
    sum0 += sum4;
    return Vector.Dot(sum0, new Vector<double>(1.0)) + sum8;
}

字符串
最后使用Vector.Dot来做水平求和有点傻，但是很短，而且只发生一次。
在开始时，试图使地址对齐的循环主要是在AVX不使用时。不幸的是，这需要unsafe（关键字，而不是类），据我所知，即使原始指针立即转换为整数，并且从未用作指针。
当AVX 2可用时（Vector<T>是128位的，没有AVX 2，即使你只使用float/double），主循环在汇编中可能看起来像这样：

L008c: vaddpd ymm0, ymm0, [rax]
L0091: vaddpd ymm1, ymm1, [rax+0x20]
L0097: vaddpd ymm2, ymm2, [rax+0x40]
L009d: vaddpd ymm3, ymm3, [rax+0x60]
L00a3: vaddpd ymm4, ymm4, [rax+0x80]
L00ac: vaddpd ymm5, ymm5, [rax+0xa0]
L00b5: vaddpd ymm6, ymm6, [rax+0xc0]
L00be: vaddpd ymm7, ymm7, [rax+0xe0]
L00c7: add rax, 0x100
L00cd: add r8d, 0x20
L00d1: cmp r8d, ecx
L00d4: jb short L008c

型
在我看来很好。我们可以通过直接比较地址来保存add，而不是保留冗余索引，但这不是一个大问题。

首先，你应该做一些基准测试和/或分析，问问自己这是否真的重要？求和是一个非常简单的计算，200 x200不是很大。我猜它可能需要一微秒的数量级，但这只是一个猜测。你还需要一个基准来决定你是否真的实现了 * 任何 * 改进，或者你只是让代码变得更复杂。
但这真的是应用程序的最大瓶颈吗？优化通常是为了避免重复工作。任何SIMD优化给予的最好效果是持续的加速。浪费时间优化对用户没有明显影响的函数是没有意义的。
如果你决定你需要优化，那么我会从摆脱索引计算开始。当你做matrix[i, j]时，框架本质上做了一个i * width + j计算。这可能会比实际的求和时间更长。优化器可能会删除一些，但是我不会在没有实际确认的情况下从优化器中假设任何东西。你可以用fixed (double* ptr = matrix )做不安全的路由，或者创建一个自定义矩阵类，它使用1D数组进行存储，只允许您使用单个循环对值求和，如果您出于其他原因需要[x, y]语法，则可以自己实现2D索引器。
如果你真的需要SIMD的性能，你可以从两个方面入手

1. Vector<T>个
   1.内部特性，如Vector256
   参见the comparison。简而言之，内在给予更好的性能，代价是将其绑定到特定的cpu平台。
   在这两种情况下，你都需要了解内存布局来正确加载元素。但是一旦完成了，它应该非常简单，只需将所有向量加在一起，最后对元素求和。如果元素计数不能被向量长度整除，最后可能会使用一些标量代码。