如何将ReadOnlySpan<byte>传入HashAlgorithm优化大文件哈希计算？

我正在用生产者/消费者模式处理大文件，并行计算哈希值来提升应用速度。其中一个优化是把byte[]块换成ReadOnlySpan<byte>，既提升了性能又简化了代码，但遇到了一个关键问题：

目前.NET框架里的HashAlgorithm类都不支持直接处理部分Span数据——如果保留这些算法，就必须把Span数据复制到byte[]里，这会带来性能损耗。唯一支持Span的方法是TryComputeHash，但它需要完整的数据集，而我处理的文件体积极大，完全没法用这个方法。

我想请教：有没有（可能涉及unsafe的）“hack”方法，能把Span数据传入HashAlgorithm对象？我的相关代码如下：

protected override void DoWork(CancellationToken ct) {
    HashAlgorithm.Initialize();
    ReadOnlySpan<byte> block;
    int bytesProcessed;
    do {
        ct.ThrowIfCancellationRequested();
        block = Reader.GetBlock(ReadLength);
        // 想让这行代码直接用Span工作
        bytesProcessed = HashAlgorithm.TransformBlock((byte[])block, 0, block.Length, null, 0);
    } while(Reader.Advance(bytesProcessed) && bytesProcessed != 0);
    var lastBytes = block.Length - bytesProcessed;
    // 同样想让这行直接用Span工作
    HashValue = HashAlgorithm.TransformFinalBlock((byte[])block.Slice(bytesProcessed, lastBytes), 0, lastBytes).ToArray();
    Reader.Advance(lastBytes);
}

嘿，这个场景我之前优化大文件哈希计算时也碰到过！其实咱们完全可以绕过TransformBlock的数组限制，借助unsafe代码直接把Span的内存指针传给HashAlgorithm的核心逻辑，避免不必要的数组复制。下面给你两种可行的方案：

方案1：针对具体哈希算法的直接调用（性能最优） #

大部分HashAlgorithm子类（比如SHA256、MD5）都有受保护的HashCore方法，它直接接受内存指针和长度——这正是咱们需要的！我们可以用unsafe代码获取Span的指针，然后直接调用这个方法。

先写个扩展方法：

using System.Runtime.CompilerServices;
using System.Security.Cryptography;

public static class HashAlgorithmSpanExtensions
{
    public static void UpdateWithSpan(this HashAlgorithm hash, ReadOnlySpan<byte> data)
    {
        if (hash is null) throw new ArgumentNullException(nameof(hash));
        if (data.IsEmpty) return;

        fixed (byte* dataPtr = data)
        {
            // 根据具体哈希算法调用对应的HashCore
            switch (hash)
            {
                case SHA256 sha256:
                    sha256.HashCore(dataPtr, data.Length);
                    break;
                case SHA1 sha1:
                    sha1.HashCore(dataPtr, data.Length);
                    break;
                case MD5 md5:
                    md5.HashCore(dataPtr, data.Length);
                    break;
                case SHA512 sha512:
                    sha512.HashCore(dataPtr, data.Length);
                    break;
                // 你用到的其他哈希算法都可以加在这里
                default:
                    // 兼容未覆盖的算法， fallback到数组复制（尽量避免）
                    hash.TransformBlock(data.ToArray(), 0, data.Length, null, 0);
                    break;
            }
        }
    }

    public static byte[] FinalizeWithSpan(this HashAlgorithm hash, ReadOnlySpan<byte> finalData)
    {
        hash.UpdateWithSpan(finalData);
        return hash.FinalizeHash();
    }

    public static byte[] FinalizeHash(this HashAlgorithm hash)
    {
        if (hash is null) throw new ArgumentNullException(nameof(hash));

        switch (hash)
        {
            case SHA256 sha256:
                return sha256.HashFinal();
            case SHA1 sha1:
                return sha1.HashFinal();
            case MD5 md5:
                return md5.HashFinal();
            case SHA512 sha512:
                return sha512.HashFinal();
            default:
                return hash.TransformFinalBlock(Array.Empty<byte>(), 0, 0).ToArray();
        }
    }
}

然后你的业务代码就可以改成这样，完全摆脱byte[]复制：

protected override void DoWork(CancellationToken ct) {
    HashAlgorithm.Initialize();
    ReadOnlySpan<byte> block;
    int bytesProcessed;
    do {
        ct.ThrowIfCancellationRequested();
        block = Reader.GetBlock(ReadLength);
        // 直接用Span更新哈希
        HashAlgorithm.UpdateWithSpan(block);
        bytesProcessed = block.Length;
    } while(Reader.Advance(bytesProcessed) && bytesProcessed != 0);
    
    // 处理最后一块数据并生成最终哈希
    var lastBytes = block.Length - bytesProcessed;
    if (lastBytes > 0)
    {
        HashValue = HashAlgorithm.FinalizeWithSpan(block.Slice(bytesProcessed, lastBytes));
        Reader.Advance(lastBytes);
    }
    else
    {
        HashValue = HashAlgorithm.FinalizeHash();
    }
}

方案2：通用反射适配（兼容所有HashAlgorithm） #

如果你不想针对每个哈希算法写分支，可以用反射调用所有HashAlgorithm都继承的抽象HashCore方法，这样不管用什么哈希算法都能适配：

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;

public static class HashAlgorithmSpanExtensions
{
    // 缓存HashCore方法的反射实例，避免重复查找
    private static readonly MethodInfo _hashCoreMethod = typeof(HashAlgorithm)
        .GetMethod("HashCore", BindingFlags.Instance | BindingFlags.NonPublic);
    private static readonly MethodInfo _hashFinalMethod = typeof(HashAlgorithm)
        .GetMethod("HashFinal", BindingFlags.Instance | BindingFlags.NonPublic);

    public static void UpdateWithSpan(this HashAlgorithm hash, ReadOnlySpan<byte> data)
    {
        if (hash is null) throw new ArgumentNullException(nameof(hash));
        if (data.IsEmpty) return;

        fixed (byte* dataPtr = data)
        {
            // 通过反射调用受保护的HashCore，传入指针和长度
            _hashCoreMethod.Invoke(hash, new object[] { (IntPtr)dataPtr, data.Length });
        }
    }

    public static byte[] FinalizeWithSpan(this HashAlgorithm hash, ReadOnlySpan<byte> finalData)
    {
        hash.UpdateWithSpan(finalData);
        return (byte[])_hashFinalMethod.Invoke(hash, null);
    }
}

这个方案的好处是通用性强，但反射调用会有一点点性能开销——不过比起数组复制的损耗来说，这点开销完全可以忽略。

关键注意事项 #

1. 启用Unsafe编译：你需要在项目的csproj文件里添加<AllowUnsafeBlocks>true</AllowUnsafeBlocks>，才能编译unsafe代码。
2. 版本兼容性：不同.NET版本（比如.NET Framework和.NET 6+）的HashAlgorithm内部实现可能有细微变化，建议在目标框架上充分测试。
3. 线程安全：HashAlgorithm实例本身不是线程安全的，一定要确保每个工作线程使用独立的哈希算法实例，不要共享。

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