Generische Methode zum Erstellen einer tiefen Kopie aller Elemente in einer Sammlung

Question

Ich habe verschiedene ObservableCollections von verschiedenen Objekttypen. Ich würde gerne eine einzelne Methode schreiben, die eine Sammlung dieser Objekttypen erstellt und eine neue Sammlung zurückgibt, bei der jedes Element eine tiefe Kopie der Elemente in der angegebenen Sammlung ist. Hier ist ein Beispiel für eine specifc Klasse

private static ObservableCollection<PropertyValueRow> DeepCopy(ObservableCollection<PropertyValueRow> list) 
    { 
     ObservableCollection<PropertyValueRow> newList = new ObservableCollection<PropertyValueRow>(); 
     foreach (PropertyValueRow rec in list) 
     { 
      newList.Add((PropertyValueRow)rec.Clone()); 
     } 
     return newList; 
    } 

Wie kann ich diese Methode generisch für jede Klasse machen die ICloneable implementiert?

Answer 1

Man könnte so etwas tun:

private static ObservableCollection<T> DeepCopy<T>(ObservableCollection<T> list) 
    where T : ICloneable 
{ 
    ObservableCollection<T> newList = new ObservableCollection<T>(); 
    foreach (T rec in list) 
    { 
     newList.Add((T)rec.Clone()); 
    } 
    return newList; 
} 

Beachten Sie, dass diese allgemeinere machen könnte IEnumerable<T> indem sie, und LINQ macht es noch einfacher:

private static ObservableCollection<T> DeepCopy<T>(IEnumerable<T> list) 
    where T : ICloneable 
{ 
    return new ObservableCollection<T>(list.Select(x => x.Clone()).Cast<T>()); 
} 

Answer 2

private static ObservableCollection<T> DeepCopy<T>(ObservableCollection<T> list) 
    where T : ICloneable 
{ 
    ObservableCollection<T> newList = new ObservableCollection<T>(); 
    foreach (T rec in list) 
    { 
     newList.Add((T)rec.Clone()); 
    } 
    return newList; 
} 

Answer 3

Ich benutze ein sehr ähnliche Funktion, die mit allen ICollections funktioniert, die konstruiert werden können (zB viele Standardsammlungen):

public static TContainer CloneDeep<TContainer, T>(TContainer r) 
     where T : ICloneable 
     where TContainer: ICollection<T>, new() 
    { 
     // could use linq here, but this is my original pedestrian code ;-) 
     TContainer l = new TContainer(); 
     foreach(var t in r) 
     { 
      l.Add((T)t.Clone()); 
     } 

     return l; 
    } 

Leider kann der Compiler die Typen nicht ableiten, so dass man sie explizit übergeben muss. Für mehr als eine Handvoll Anrufe schreibe ich eine Spezialisierung. Hier ist ein Beispiel für Listen (die selbst mit implizit abgeleitetem T aufgerufen werden können).

public static List<T> CloneListDeep<T>(List<T> r) where T : ICloneable 
    { 
     return CloneDeep<List<T>, T>(r); 
    } 

Ich benutze diese Funktion ausgiebig, um Kopien der Listen als Datenquellen für datagridviews auf Dialoge dienen zu schaffen, die rückgängig gemacht werden kann. Die geänderte Liste wird einfach verworfen, wenn der Dialog abgebrochen wird. Wenn der Dialog OK ist, ersetzt die bearbeitete Liste einfach das Original. Voraussetzung für dieses Muster ist natürlich eine semantisch korrekte und gut gepflegte T.clone().