Quelle est la meilleure façon de clone/copie en profondeur un .NET Dictionnaire générique<string, T>?

J'ai un dictionnaire générique Dictionary<string, T> que je tiens essentiellement à faire un Clone() de ..des suggestions.

InformationsquelleAutor mikeymo | 2008-09-26

c#clone collections generics

170

D'accord, l' .NET 2.0 réponses:

Si vous n'avez pas besoin de cloner les valeurs, vous pouvez utiliser le constructeur de la surcharge Dictionnaire qui prend un existant IDictionary. (Vous pouvez spécifier le comparer à l'existant dictionnaire de comparer, aussi.)

Si vous ne besoin de cloner les valeurs, vous pouvez utiliser quelque chose comme ceci:
```
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;
}
```
Qui s'appuie sur TValue.Clone() être suffisamment profonde clone aussi, bien entendu.
- Je pense que c'est seulement en faisant une copie du dictionnaire de valeurs, bien que. Le entry.Value la valeur pourrait être encore un autre [sub]collection.
- Eh bien, c'est de demander à chaque valeur à être cloné - c'est à la Clone() méthode si elle est profonde ou peu profonde. J'ai ajouté une note à cet effet.
- Cher @JonSkeet, Que sur l'approche suivante? stackoverflow.com/questions/5963115/... que l'on ne yous proposer?
- Eh bien, si les valeurs n'ont pas besoin d'être cloné, "l'utilisation de la surcharge du constructeur de Dictionnaire qui prend un existant IDictionary" est très bien, et déjà dans ma réponse. Si les valeurs de ne besoin d'être clonés, la réponse que vous avez lié à n'aide pas du tout.
- Donc, si j'ai garder les objets qui sont des structures plutôt que de classes dans le dictionnaire le constructeur approche est satisfaisante, à droite?
- Qui devrait être bien, oui. (Bien sûr, si les structures contenir des références à des mutable types de référence, qui peut encore être un problème... mais j'espère que ce n'est pas le cas.)
- > "utiliser le constructeur de la surcharge Dictionnaire qui prend un existant IDictionary" est bien" < C'est thread-safe, droit? Je n'ai pas besoin d'ajouter un verrou de l'objet alors que le clonage?
- Cela dépend de ce que d'autre se passe. Si d'autres threads ne sont que lecture dans le dictionnaire original, alors je pense qu'elle doit être fine. Si quoi que ce soit de la modifier, vous devez le verrouiller en tant que le thread et le clonage fil, pour éviter de se produire en même temps. Si vous voulez thread de sécurité lors de l'utilisation de dictionnaires, de l'utilisation ConcurrentDictionary.
- Cher @JonSkeet, merci pour vos réponses rapides, je suis en utilisant ConcurrentDictionary, mais à un certain moment, j'ai besoin de Cloner ses valeurs et clair, après l'opération de duplication j'ai besoin pour continuer sur la cloné, tandis que les autres threads sont l'écriture à haute vitesse sur le CD. Je ne veux pas manquer de toutes les valeurs
- Si vous êtes le clonage depuis un ConcurrentDictionary, qui doit être fine. Mais à ce point je pense que si vous avez toute autre question que vous devriez poser dans un nouveau post, plutôt que d'ajouter des commentaires ici.
- Laissez-nous continuer cette discussion dans le chat.
InformationsquelleAutor Jon Skeet
186

(Remarque: bien que le clonage version est potentiellement utile, pour une simple copie du constructeur que je mentionne dans l'autre post est une meilleure option.)

Quelle profondeur vous voulez que la copie soit, et quelle version de .NET vous aide? Je soupçonne qu'un LINQ appel à ToDictionary, en précisant à la fois la clé et le sélecteur d'élément, sera le moyen le plus facile pour aller si vous êtes en utilisant .NET 3.5.

Par exemple, si vous n'avez pas l'esprit la valeur d'être un clone simple:
```
var newDictionary = oldDictionary.ToDictionary(entry => entry.Key,
                                               entry => entry.Value);
```
Si vous avez déjà limitée T pour mettre en œuvre ICloneable:
```
var newDictionary = oldDictionary.ToDictionary(entry => entry.Key, 
                                               entry => (T) entry.Value.Clone());
```
(Ceux qui ne sont pas testés, mais devrait fonctionner.)
- Merci pour la réponse, Jon. Je suis en fait à l'aide de v2.0 de le cadre.
- Ce qui est "entrée => entrée.Clé, entrée => entrée.Valeur" dans ce contexte. Comment vais-je ajouter une clé et une valeur. Montrant une erreur lors de mon stage de fin
- Ils sont les expressions lambda - partie de C# 3.
- Par défaut LINQ ToDictionary ne copie pas les comparer. Vous avez mentionné la copie de la comparer à votre réponse, mais je pense que cette version de clonage devrait également passer à les comparer.
InformationsquelleAutor Jon Skeet
73
```
Dictionary<string, int> dictionary = new Dictionary<string, int>();

Dictionary<string, int> copy = new Dictionary<string, int>(dictionary);
```
- Les pointeurs des valeurs sont toujours les mêmes, si vous appliquez les modifications apportées aux valeurs de la copie, les modifications seront également reflété dans le dictionnaire de l'objet.
- non, il le sentait, il copie tout simplement le keyValuePairs dans nouvel objet
- Absolument, cela fonctionne bien, il crée un clone à la fois la clé et la valeur. Bien sûr, cela ne fonctionne que si la valeur n'est PAS un type de référence, si la valeur est un type de référence, alors effectivement il ne prend qu'une copie des clés comme son d'une copie.
- dans ce cas, puisque string et int ne sont PAS un type de référence, il va travailler?
- Non, il travaille également les types de référence. Mon test ici: dotnetfiddle.net/ZNVqfL
- vous oubliez de tester un changement réel d'un objet référencé, vous seul test de remplacement de la valeur des pointeurs dans les cloné dictionnaires qui fonctionne évidemment, mais vos tests échouent, si vous venez de modifier les propriétés des objets d'essai, comme suit: dotnetfiddle.net/xmPPKr
- Cela fonctionne bien si vous êtes en utilisant des primitives ou des structures.
- il fonctionne et c'est bien de ne pas cloner les objets référencés! Nous voulons avoir un clone de Dictionnaire pas son référencé valeurs.
- Elle ne travaille pas .NET Standard 2.0
InformationsquelleAutor Herald Smit

Pour .NET 2.0 vous pouvez implémenter une classe qui hérite de Dictionary et met en œuvre 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;
    }
}

Vous pouvez ensuite cloner le dictionnaire en appelant simplement la Clone méthode. Bien sûr, cette mise en œuvre nécessite que le type de valeur de la dictionnaire met en œuvre ICloneable, mais sinon, une implémentation générique n'est pas pratique du tout.

InformationsquelleAutor Compile This

Vous pouvez toujours utiliser la sérialisation. Vous pourriez sérialiser l'objet puis de le désérialiser. Qui vous donnera une copie du Dictionnaire et de tous les éléments à l'intérieur d'elle. Maintenant, vous pouvez créer une copie de n'importe quel objet qui est marqué comme [Serializable] sans écrire aucun code particulier.

Voici deux méthodes qui leur permettront d'utiliser la Sérialisation Binaire. Si vous utilisez ces méthodes vous suffit d'appeler

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

InformationsquelleAutor Shaun Bowe

3

Méthode de Sérialisation binaire fonctionne très bien mais dans mes tests, il a montré à être 10x plus lent qu'un non-sérialisation de mise en œuvre de clone. Testé sur Dictionary<string , List<double>>
- Êtes-vous sûr que vous avez une profonde et complète de la copie? À la fois les chaînes et les Listes doivent être profond copié. Il y a aussi quelques bugs dans la sérialisation version à l'origine pour être lente: dans ToBinary() la Serialize() méthode est appelée avec this au lieu de yourDictionary. Puis dans FromBinary() le byte[] est d'abord copié manuellement à l'MemStream mais il peut juste être fourni à son constructeur.
InformationsquelleAutor loty
3

La meilleure façon pour moi, c'est ceci:
```
Dictionary<int, int> copy= new Dictionary<int, int>(yourListOrDictionary);
```
- Herald Smit a écrit déjà sur cette voie.
- ce n'est pas une simple copie de la référence et non pas les valeurs depuis le Dictionnaire est un type de référence? cela signifie que si vous modifiez les valeurs dans un, il permet de changer la valeur dans l'autre?
InformationsquelleAutor nikssa23
2

Cela fonctionne très bien pour moi
```
 //assuming this fills the List
 List<Dictionary<string, string>> obj = this.getData(); 

 List<Dictionary<string, string>> objCopy = new List<Dictionary<string, string>>(obj);
```
Que Tomer Wolberg décrit dans les commentaires, cela ne fonctionne pas si le type de valeur est un mutant de classe.
- Ce doit sérieusement upvotes ! Si le dictionnaire original est en lecture seule, cependant, ce sera encore du travail: var newDict = readonlyDict.ToDictionary(kvp => kvp.Clé, kvp => kvp.Valeur)
- Cela ne fonctionne pas si le type de valeur est une classe mutable
InformationsquelleAutor BonifatiusK

Essayer si la clé/valeurs sont 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;
}

InformationsquelleAutor Arvind

De répondre à vieux message mais j'ai trouvé utile pour l'envelopper comme suit:

using System;
using System.Collections.Generic;
public class DeepCopy
{
public static Dictionary<T1, T2> CloneKeys<T1, T2>(Dictionary<T1, T2> dict)
where T1 : ICloneable
{
if (dict == null)
return null;
Dictionary<T1, T2> ret = new Dictionary<T1, T2>();
foreach (var e in dict)
ret[(T1)e.Key.Clone()] = e.Value;
return ret;
}
public static Dictionary<T1, T2> CloneValues<T1, T2>(Dictionary<T1, T2> dict)
where T2 : ICloneable
{
if (dict == null)
return null;
Dictionary<T1, T2> ret = new Dictionary<T1, T2>();
foreach (var e in dict)
ret[e.Key] = (T2)(e.Value.Clone());
return ret;
}
public static Dictionary<T1, T2> Clone<T1, T2>(Dictionary<T1, T2> dict)
where T1 : ICloneable
where T2 : ICloneable
{
if (dict == null)
return null;
Dictionary<T1, T2> ret = new Dictionary<T1, T2>();
foreach (var e in dict)
ret[(T1)e.Key.Clone()] = (T2)(e.Value.Clone());
return ret;
}
}

InformationsquelleAutor Decaf Sux

Vous devez vous connecter pour publier un commentaire.