这里是克隆字典的另一种方法，假设你知道做“正确”的事情，只要处理任何隐藏在“T”(a.k.a)后面的东西。“对象”)。

internal static Dictionary<string, object> Clone(Dictionary<string, object> dictIn) 
    {
        Dictionary<string, object> dictOut = new Dictionary<string, object>();
    
        IDictionaryEnumerator enumMyDictionary = dictIn.GetEnumerator();
        while (enumMyDictionary.MoveNext())
        {
            string strKey = (string)enumMyDictionary.Key;
            object oValue = enumMyDictionary.Value;
            dictOut.Add(strKey, oValue);
        }
    
        return dictOut; 
    }

我将计算T是否为值或引用类型。如果T是值类型，我将使用Dictionary的构造函数，如果T是引用类型，我将确保T继承自ICloneable。

它会给

    private static IDictionary<string, T> Copy<T>(this IDictionary<string, T> dict)
         where T : ICloneable
    {
        if (typeof(T).IsValueType)
        {
            return new Dictionary<string, T>(dict);
        }
        else
        {
            var copy = new Dictionary<string, T>();
            foreach (var pair in dict)
            {
                copy[pair.Key] = pair.Value;
            }
            return copy;
        }
    }

这对我来说很好

 // assuming this fills the List
 List<Dictionary<string, string>> obj = this.getData(); 

 List<Dictionary<string, string>> objCopy = new List<Dictionary<string, string>>(obj);

正如Tomer Wolberg在评论中所描述的，如果值类型是可变类，这是行不通的。

二进制序列化方法工作得很好，但在我的测试中，它比克隆的非序列化实现慢了10倍。在Dictionary<string, List<double>>上测试

这帮助了我，当我试图深度复制Dictionary < string, string >

Dictionary<string, string> dict2 = new Dictionary<string, string>(dict);

祝你好运

Dictionary<string, int> dictionary = new Dictionary<string, int>();

Dictionary<string, int> copy = new Dictionary<string, int>(dictionary);