Generic method to create deep copy of all elements in a collection

I have various ObservableC开发者_高级运维ollections of different object types. I'd like to write a single method that will take a collection of any of these object types and return a new collection where each element is a deep copy of elements in the given collection. Here is an example for a specifc class

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

How can I make this method generic for any class which implements ICloneable?

You could do something like this:

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

Note that you could make this more general by taking IEnumerable<T>, and LINQ makes it even easier:

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

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

I use a very similar function which works with all ICollections which can be constructed (e.g. many standard collections):

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

Unfortunately the compiler isn't able to deduce the types so that one must pass them explicitly. For more than a handful calls I write a specialization. Here is an example for Lists (which itself can be called with implicitly deduced T).

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

I use this function extensively in order to create copies of lists serving as datasources for datagridviews on dialogs which can be canceled. The modified list is simply discarded when the dialog is cancelled; when the dialog is OKed the edited list simply replaces the original. Prerequisite for this pattern is, of course, to have a semantically correct and well maintained T.clone().