好的，.NET 2.0的答案是:

如果不需要克隆值，可以使用构造函数重载to Dictionary，该构造函数接受一个现有的Dictionary。(也可以将比较器指定为现有字典的比较器。)

如果你确实需要克隆值，你可以使用这样的方法:

public static Dictionary<TKey, TValue> CloneDictionaryCloningValues<TKey, TValue>
   (Dictionary<TKey, TValue> original) where TValue : ICloneable
{
    Dictionary<TKey, TValue> ret = new Dictionary<TKey, TValue>(original.Count,
                                                            original.Comparer);
    foreach (KeyValuePair<TKey, TValue> entry in original)
    {
        ret.Add(entry.Key, (TValue) entry.Value.Clone());
    }
    return ret;
}

当然，这也依赖于TValue.Clone()是一个适当的深度克隆。

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

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

这对我来说很好

 // 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>>上测试

我将计算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;
        }
    }

在这种情况下，你有一个"object"的字典，object可以是(double, int，…或ComplexClass):

Dictionary<string, object> dictSrc { get; set; }

public class ComplexClass : ICloneable
{
    
    private Point3D ...;
    private Vector3D ....;
    [...]

    public object Clone()
    {
        ComplexClass clone = new ComplexClass();
        clone = (ComplexClass)this.MemberwiseClone();
        return clone;
    }

}


dictSrc["toto"] = new ComplexClass()
dictSrc["tata"] = 12.3
...

dictDest = dictSrc.ToDictionary(entry => entry.Key,
                                entry => ((entry.Value is ICloneable) ? (entry.Value as ICloneable).Clone() : entry.Value) );