对于。net 2.0，你可以实现一个继承自Dictionary并实现ICloneable的类。

public class CloneableDictionary<TKey, TValue> : Dictionary<TKey, TValue> where TValue : ICloneable
{
    public IDictionary<TKey, TValue> Clone()
    {
        CloneableDictionary<TKey, TValue> clone = new CloneableDictionary<TKey, TValue>();

        foreach (KeyValuePair<TKey, TValue> pair in this)
        {
            clone.Add(pair.Key, (TValue)pair.Value.Clone());
        }

        return clone;
    }
}

然后，只需调用clone方法就可以克隆字典。当然，这个实现要求字典的值类型实现ICloneable，但除此之外，泛型实现根本不实用。

这里是克隆字典的另一种方法，假设你知道做“正确”的事情，只要处理任何隐藏在“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; 
    }

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

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

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

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

祝你好运

如果键/值是ICloneable，试试这个:

    public static Dictionary<K,V> CloneDictionary<K,V>(Dictionary<K,V> dict) where K : ICloneable where V : ICloneable
    {
        Dictionary<K, V> newDict = null;

        if (dict != null)
        {
            // If the key and value are value types, just use copy constructor.
            if (((typeof(K).IsValueType || typeof(K) == typeof(string)) &&
                 (typeof(V).IsValueType) || typeof(V) == typeof(string)))
            {
                newDict = new Dictionary<K, V>(dict);
            }
            else // prepare to clone key or value or both
            {
                newDict = new Dictionary<K, V>();

                foreach (KeyValuePair<K, V> kvp in dict)
                {
                    K key;
                    if (typeof(K).IsValueType || typeof(K) == typeof(string))
                    {
                        key = kvp.Key;
                    }
                    else
                    {
                        key = (K)kvp.Key.Clone();
                    }
                    V value;
                    if (typeof(V).IsValueType || typeof(V) == typeof(string))
                    {
                        value = kvp.Value;
                    }
                    else
                    {
                        value = (V)kvp.Value.Clone();
                    }

                    newDict[key] = value;
                }
            }
        }

        return newDict;
    }

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