C#中ConcurrentDictionary内Patient对象深度复制失败问题

核心问题 #

1. 浅复制导致对象引用共享：使用MemberwiseClone克隆Patient结构体时，仅复制了结构体本身，但其中的PatientCovariates是嵌套字典（引用类型），克隆后的所有对象共享同一字典实例，修改时会互相干扰，甚至影响原基线数据。
2. 重复操作引发字典Key冲突：外层循环遍历2个arm，内层循环遍历5个患者，由于浅复制共享字典，第二次循环时向同一字典实例添加相同Key的Covariate会触发报错；同时多次向_patientsCurrentArm添加相同患者ID（j值），也会导致Key重复问题。

解决方案 #

1. 实现真正的深度复制 #

修改Patient的Clone方法，递归复制嵌套字典，确保每个克隆对象拥有独立的字典实例：

internal struct Patient : ICloneable
{
    public Dictionary<int, Dictionary<string, string>> PatientCovariates { get; set; }

    public Patient()
    {
        PatientCovariates = new();
    }

    public readonly object Clone()
    {
        // 复制结构体本身
        Patient cloned = (Patient)this.MemberwiseClone();
        // 深度复制外层字典
        cloned.PatientCovariates = new Dictionary<int, Dictionary<string, string>>();
        foreach (var cycleEntry in PatientCovariates)
        {
            // 复制每个周期对应的Covariate字典
            cloned.PatientCovariates.Add(
                cycleEntry.Key, 
                new Dictionary<string, string>(cycleEntry.Value)
            );
        }
        return cloned;
    }
}

2. 避免重复Key冲突 #

如果需要为每个arm维护独立的患者集合，将_patientsCurrentArm改为按arm编号分组的字典：

internal class Exampel
{
    private ConcurrentDictionary<int, Patient> _baselinePatients = new();
    // 改为按arm编号存储对应患者集合
    private ConcurrentDictionary<int, ConcurrentDictionary<int, Patient>> _armPatients = new();

    public void DoStuff()
    {
        const int EXAMPLE_CYCLE = 0;
        int _nArms = 2;
        int _nPatients = 5;

        // 初始化基线患者（原代码不变）
        for (int i = 0; i < _nPatients; i++)
        {
            Patient patient = new Patient();
            patient.PatientCovariates.Add(0, new());
            _baselinePatients.TryAdd(i, patient);
        }

        // 为每个arm创建独立的患者字典
        for (int i = 0; i < _nArms; i++)
        {
            var currentArmPatients = new ConcurrentDictionary<int, Patient>();
            _armPatients.TryAdd(i, currentArmPatients);

            for (int j = 0; j < _nPatients; j++)
            {
                Patient clonedPatient = (Patient)_baselinePatients[j].Clone();
                // 设置Covariate值，确保Key唯一或覆盖已有值
                clonedPatient.PatientCovariates[EXAMPLE_CYCLE]["Covariate"] = 
                    $"Covariate for patient {j} in arm {i}";
                
                currentArmPatients.TryAdd(j, clonedPatient);
            }
        }

        // 输出测试结果
        Console.WriteLine("Arm 0 患者0: " + _armPatients[0][0].PatientCovariates[EXAMPLE_CYCLE]["Covariate"]);
        Console.WriteLine("Arm 0 患者1: " + _armPatients[0][1].PatientCovariates[EXAMPLE_CYCLE]["Covariate"]);
        Console.WriteLine("Arm 1 患者0: " + _armPatients[1][0].PatientCovariates[EXAMPLE_CYCLE]["Covariate"]);
        Console.WriteLine("Arm 1 患者1: " + _armPatients[1][1].PatientCovariates[EXAMPLE_CYCLE]["Covariate"]);
    }
}

如果不需要保留多arm数据，仅需覆盖最新患者状态，可将TryAdd替换为AddOrUpdate：

_patientsCurrentArm.AddOrUpdate(
    j, 
    patObjCopy, 
    (key, existing) => patObjCopy
);

关键说明 #

• MemberwiseClone对于值类型（如struct）会复制结构体实例，但其中的引用类型成员仅复制引用，必须手动递归复制才能实现深度克隆。
• 你遇到的Key: Covariate报错实际来自嵌套字典的Add操作，这是因为浅复制导致多个对象共享同一字典实例，重复添加相同Key触发冲突；ConcurrentDictionary的TryAdd仅会在Key已存在时返回false，不会抛出异常。

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