ObservableCollection deep cloning

Question

I've implemented deep cloning of ObservableCollection in order to reset items to It's original state in editable Datagrid, via cancel button.

For this I have two collections - one ObservableCollection to bind Datagrid to It, and cloned List to re-initialize ObservableCollection to It's original state when needed.

My code works only first time I hit a cancel button, after that my cloned List has changes in It too.

Provided code is an example (mine is a bit longer), but It's 100% same as mine:

Model, which implements ICloneable:

public class EmployeeModel : ICloneable
{
   public object Clone()
   {
       return MemberwiseClone();
   }
    
   public string NAME
   {
      get { return _name; }
      set
         {
            if (_name != value)
            {
               CHANGE = true;
                _name = value;
             }
          }
     }
     private string _name;

     public string SURNAME
     {
        get { return _surname; }
        set
         {
            if (_surname != value)
            {
               CHANGE = true;
                _surname = value;
             }
          }
     }
     private string _surname; 

     ///<summary>Property for tracking changes in model</summary>
     public bool CHANGE { get; set; }
}

Viewmodel:

public ViewModel() : Base //Implements InotifyPropertyChanged
{
   public ViewModel()
   {
      Task.Run(()=> GetData());
   }

   public ObservableCollection<EmployeeModel> Employees
   {
       get { return _employees; }
       set { _employees = value; OnPropertyChanged();}
   }
   private ObservableCollection<EmployeeModel> _employees;

   public List<EmployeeModel> Copy_employees
   {
        get { return _copy_employees; }
        set { _copy_employees = value; OnPropertyChanged();}
   }
   private List<EmployeeModel> _copy_employees;

   //Fetch data from DB
   private async Task Get_data()
   {
       //Returns new ObservableCollection of type Employee
       Employees = await _procedures.Get_employees();

       if (Employees != null) //Now make a deep copy of Collection
       {
            Copy_employees = new List<EmployeeModel>();
            Copy_employees = Employees.Select(s => (EmployeeModel)s.Clone()).ToList();
       }
    }

   //My Command for canceling changes (reseting DataGrid)
   //CanExecute happens, when model is changed - tracking via CHANGE property of EmployeeModel
   public void Cancel_Execute(object parameter)
   {
        Employees.Clear(); //Tried with re-initializing too, but same result
        
        foreach (var item in Copy_employees)// Reset binded ObservableCollection with old items
        {
             Employees.Add(item);
        }
         
        //Check if copied List really hasn't got any changes                    
        foreach (EmployeeModel item in Copy_employees)
        {
           Console.WriteLine("Changes are " + item.CHANGES.ToString());
        }

     }
 }

Output of cancel command:

1.) First time I hit cancel button:

// Changes are False

Every next time:

// Changes are True

So, as I see It from Console, my copied List get's updated when ObservableColection get's updated, even if It's not binded to DataGrid. And It updates only a property which I changed, so List reflects ObservableCollection items.

How can I keep my original items of List<Employee>, and copy those into binded ObservableCollection anytime ?

Answer 1

When you return values, you do not return them, but write backing item references to the editable collection. As a result, you have the same instances in both collections. In the simplest case, when you return them, you also need to clone.

public void Cancel_Execute(object parameter) { Employees.Clear(); //Tried with re-initializing too, but same result

    foreach (var item in Copy_employees)// Reset binded ObservableCollection with old items
    {
         Employees.Add((EmployeeModel)item.Clone());
    }
     
    //Check if copied List really hasn't got any changes                    
    foreach (EmployeeModel item in Copy_employees)
    {
       Console.WriteLine("Changes are " + item.CHANGES.ToString());
    }

 }

Not relevant to the question, but I still advise you to use a slightly more user-friendly interface for cloneable:

public interface ICloneable<T> : ICloneable
{
    new T Clone();
}