如何利用并行机制快速实现C#中两个Dictionary的相加操作？

现有方案的问题 #

你当前的Modifier类实现存在两个核心问题：

1. 副作用问题：operator+直接修改输入对象a，而非返回全新的结果字典，这会导致原对象被意外修改，引发难以排查的bug。
2. 性能瓶颈：串行遍历处理大字典时，无法利用多核CPU的优势，数据量越大效率越低。

并行实现的核心思路 #

C#的普通Dictionary并非线程安全，直接并行修改会引发线程冲突。因此实现并行相加的关键是：

• 要么用线程安全的集合（如ConcurrentDictionary）处理并行写入
• 要么先并行计算所有键的最终值，再一次性生成结果字典

最优实现方案 #

方案1：PLINQ+并行计算键值（推荐） #

适合两个字典规模相近的场景，先获取所有唯一键，并行计算每个键的累加值，最后生成结果字典。这种方式避免了线程安全集合的锁开销，效率更高：

public static class DictionaryExtensions
{
    public static Dictionary<string, int> Add(this Dictionary<string, int> dict1, Dictionary<string, int> dict2)
    {
        // 获取两个字典的所有唯一键
        var allKeys = dict1.Keys.Union(dict2.Keys);
        
        // 并行计算每个键的累加值，直接生成结果字典
        return allKeys.AsParallel()
            .ToDictionary(
                key => key,
                key => 
                    (dict1.TryGetValue(key, out var val1) ? val1 : 0) + 
                    (dict2.TryGetValue(key, out var val2) ? val2 : 0)
            );
    }
}

使用方式：

var dict3 = dict1.Add(dict2);

方案2：ConcurrentDictionary+并行写入 #

适合其中一个字典远小于另一个的场景（比如用小字典更新大字典），利用线程安全集合处理并行写入：

public static Dictionary<string, int> AddDictionaries(Dictionary<string, int> mainDict, Dictionary<string, int> addDict)
{
    // 基于主字典初始化线程安全集合
    var result = new ConcurrentDictionary<string, int>(mainDict);
    
    // 并行处理待添加的字典元素
    addDict.AsParallel().ForAll(kv =>
    {
        // 存在则累加，不存在则添加
        result.AddOrUpdate(kv.Key, kv.Value, (key, existing) => existing + kv.Value);
    });
    
    // 转换回普通字典（如果不需要线程安全的话）
    return result.ToDictionary(kv => kv.Key, kv => kv.Value);
}

方案3：改进Modifier类的并行实现 #

如果必须保留Modifier封装，建议将内部字典替换为ConcurrentDictionary，并在operator+中实现无副作用的并行处理：

public class Modifier
{
    private readonly ConcurrentDictionary<string, int> _modifier = new ConcurrentDictionary<string, int>();

    public void Add(string key, int value)
    {
        _modifier.TryAdd(key, value);
    }

    public bool ContainsKey(string key)
    {
        return _modifier.ContainsKey(key);
    }

    public int this[string key]
    {
        get => _modifier[key];
        set => _modifier[key] = value;
    }

    public static Modifier operator +(Modifier a, Modifier b)
    {
        var result = new Modifier();
        
        // 先复制a的所有元素
        foreach (var kv in a._modifier)
        {
            result._modifier.TryAdd(kv.Key, kv.Value);
        }
        
        // 并行处理b的元素，完成累加/添加
        b._modifier.AsParallel().ForAll(kv =>
        {
            result._modifier.AddOrUpdate(kv.Key, kv.Value, (k, existing) => existing + kv.Value);
        });
        
        return result;
    }
}

性能注意事项 #

• 并行不是银弹：当字典元素数量少于1万时，线程调度的开销会抵消并行的优势，此时串行实现反而更快。
• 避免修改输入对象：始终返回全新的结果字典，防止原数据被意外篡改。
• 选择合适的方案：两个字典规模相近选方案1，规模差异大选方案2，需要封装选方案3。

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