克隆/深度复制。net通用Dictionary<字符串，T>最好的方法是什么?

小开

(注意:虽然克隆版本可能很有用，但对于简单的浅复制，我在另一篇文章中提到的构造函数是更好的选择。)

你希望拷贝的深度是多少，你使用的是什么版本的。net ?如果你使用的是。net 3.5，我认为对ToDictionary的LINQ调用，同时指定键和元素选择器将是最简单的方法。

例如，如果你不介意这个值是一个浅克隆:

var newDictionary = oldDictionary.ToDictionary(entry => entry.Key,
entry => entry.Value);

如果你已经限制了T来实现ICloneable:

var newDictionary = oldDictionary.ToDictionary(entry => entry.Key,
entry => (T) entry.Value.Clone());

(这些方法未经测试，但应该有效。)

小开

最佳答案

好的，.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()是一个适当的深度克隆。

小开

对于。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，但除此之外，泛型实现根本不实用。

小开

你总是可以使用序列化。你可以序列化对象，然后反序列化它。这将为您提供Dictionary及其所有条目的深层副本。现在您可以创建任何标记为[Serializable]的对象的深度副本，而无需编写任何特殊代码。

这里有两种将使用二进制序列化的方法。如果使用这些方法，只需调用

object deepcopy = FromBinary(ToBinary(yourDictionary));


public Byte[] ToBinary()
{
MemoryStream ms = null;
Byte[] byteArray = null;
try
{
BinaryFormatter serializer = new BinaryFormatter();
ms = new MemoryStream();
serializer.Serialize(ms, this);
byteArray = ms.ToArray();
}
catch (Exception unexpected)
{
Trace.Fail(unexpected.Message);
throw;
}
finally
{
if (ms != null)
ms.Close();
}
return byteArray;
}


public object FromBinary(Byte[] buffer)
{
MemoryStream ms = null;
object deserializedObject = null;


try
{
BinaryFormatter serializer = new BinaryFormatter();
ms = new MemoryStream();
ms.Write(buffer, 0, buffer.Length);
ms.Position = 0;
deserializedObject = serializer.Deserialize(ms);
}
finally
{
if (ms != null)
ms.Close();
}
return deserializedObject;
}

小开

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

小开

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


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

小开

对我来说最好的方法是:

Dictionary<int, int> copy= new Dictionary<int, int>(yourListOrDictionary);

小开

如果键/值是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;
}

小开

这对我来说很好

 // 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在评论中所描述的，如果值类型是可变类，这是行不通的。

小开

这对我很有帮助，当我试图深度复制一本词典时。字符串，字符串>

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

祝你好运

小开

在这种情况下，你有一个“对象”字典;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) );

小开

这里有一些真正的“真正的深度复制”;在不知道类型的情况下用一些递归的方法走一走，不错的开始。我认为它适用于嵌套类型和几乎所有棘手的类型。我还没有添加嵌套数组处理，但是您可以根据自己的选择进行修改。

Dictionary<string, Dictionary<string, dynamic>> buildInfoDict =
new Dictionary<string, Dictionary<string, dynamic>>()
{
{"tag",new Dictionary<string,dynamic>(){
{ "attrName", "tag"  },
{ "isCss", "False"  },
{ "turnedOn","True" },
{ "tag",null }
} },
{"id",new Dictionary<string,dynamic>(){
{ "attrName", "id"  },
{ "isCss", "False"  },
{ "turnedOn","True" },
{ "id",null }
} },
{"width",new Dictionary<string,dynamic>(){
{ "attrName", "width"  },
{ "isCss", "True"  },
{ "turnedOn","True" },
{ "width","20%" }
} },
{"height",new Dictionary<string,dynamic>(){
{ "attrName", "height"  },
{ "isCss", "True"  },
{ "turnedOn","True" },
{ "height","20%" }
} },
{"text",new Dictionary<string,dynamic>(){
{ "attrName", null  },
{ "isCss", "False"  },
{ "turnedOn","True" },
{ "text","" }
} },
{"href",new Dictionary<string,dynamic>(){
{ "attrName", null  },
{ "isCss", "False"  },
{ "flags", "removeAttrIfTurnedOff"  },
{ "turnedOn","True" },
{ "href","about:blank" }
} }
};


var cln=clone(buildInfoDict);


public static dynamic clone(dynamic obj)
{
dynamic cloneObj = null;
if (IsAssignableFrom(obj, typeof(IDictionary)))
{
cloneObj = Activator.CreateInstance(obj.GetType());
foreach (var key in obj.Keys)
{
cloneObj[key] = clone(obj[key]);
}


}
else if (IsNumber(obj) || obj.GetType() == typeof(string))
{
cloneObj = obj;
}
else
{
Debugger.Break();
}
return cloneObj;
}




public static bool IsAssignableFrom(this object obj, Type ObjType = null, Type ListType = null, bool HandleBaseTypes = false)
{
if (ObjType == null)
{
ObjType = obj.GetType();
}


bool Res;


do
{
Res = (ObjType.IsGenericType && ObjType.GetGenericTypeDefinition().IsAssignableFrom(ListType)) ||
(ListType == null && ObjType.IsAssignableFrom(obj.GetType()));
ObjType = ObjType.BaseType;
} while ((!Res && ObjType != null) && HandleBaseTypes && ObjType != typeof(object));


return Res;
}


public static bool IsNumber(this object value)
{
return value is sbyte
|| value is byte
|| value is short
|| value is ushort
|| value is int
|| value is uint
|| value is long
|| value is ulong
|| value is float
|| value is double
|| value is decimal;
}

小开

下面是另一种克隆字典的方法，假设你知道如何正确地克隆字典。至于处理隐藏在“t”后面的东西。(又称“对象”)。

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;
}
}