Fix issue with editlevel and clone (#4796)

* Fix edit level preservation when cloning object graphs with children

When cloning an object graph during an active edit session, child objects
were having their edit levels incorrectly reset. This occurred because
InsertItem called UndoableBase.ResetChildEditLevel when adding deserialized
children back to their parent collection, which cleared the child's
already-restored state stack.

The fix adds an _isDeserializing flag to BusinessListBase and
BusinessBindingListBase that is set during OnSetChildren. When this flag
is true, InsertItem skips the ResetChildEditLevel call, preserving the
child's correctly deserialized edit level and undo state.

This enables the clone-edit-save pattern where users can:
- Begin editing an object
- Clone it to show in a separate view
- Continue editing or cancel on either the original or clone independently

Co-Authored-By: Claude Opus 4.5 <[email protected]>

* Update gitignore for claude

* #4794 Add another unit test

---------

Co-authored-by: Claude Opus 4.5 <[email protected]>

Author: rockfordlhotka

.gitignore

@@ -181,3 +181,4 @@ Source/Csla.Xaml.Uwp/project.lock.json
 /Samples/ProjectTracker/ProjectTracker.Ui.UWP/ProjectTracker.Ui.UWP.nuget.targets
 .vscode
 .idea
+.claude/settings.local.json

Source/Csla.test/BusinessListBase/BusinessListBaseTests.cs

@@ -266,6 +266,200 @@ static Root SimulateLocationTransfer(Root original)
       }
     }
 
+    [TestMethod]
+    public void ClonePreservesChildEditLevel()
+    {
+      // Arrange: Create a root with children and begin editing
+      var root = CreateRoot();
+      var child = root.Children.AddNew();
+      child.Data = "original";
+
+      root.BeginEdit();
+
+      // Make changes after BeginEdit
+      child.Data = "modified";
+
+      // Verify edit levels before clone
+      var rootEditLevel = ((Core.IUndoableObject)root).EditLevel;
+      var childEditLevel = ((Core.IUndoableObject)child).EditLevel;
+      var childListEditLevel = ((Core.IUndoableObject)root.Children).EditLevel;
+
+      Assert.AreEqual(1, rootEditLevel, "Root EditLevel should be 1 before clone");
+      Assert.AreEqual(1, childEditLevel, "Child EditLevel should be 1 before clone");
+      Assert.AreEqual(1, childListEditLevel, "ChildList EditLevel should be 1 before clone");
+
+      // Act: Clone the object graph
+      var clonedRoot = root.Clone();
+
+      // Assert: Verify edit levels are preserved after clone
+      var clonedRootEditLevel = ((Core.IUndoableObject)clonedRoot).EditLevel;
+      var clonedChildEditLevel = ((Core.IUndoableObject)clonedRoot.Children[0]).EditLevel;
+      var clonedChildListEditLevel = ((Core.IUndoableObject)clonedRoot.Children).EditLevel;
+
+      Assert.AreEqual(1, clonedRootEditLevel, "Cloned Root EditLevel should be 1");
+      Assert.AreEqual(1, clonedChildEditLevel, "Cloned Child EditLevel should be 1");
+      Assert.AreEqual(1, clonedChildListEditLevel, "Cloned ChildList EditLevel should be 1");
+
+      // Verify the modified data is preserved
+      Assert.AreEqual("modified", clonedRoot.Children[0].Data, "Modified data should be preserved in clone");
+    }
+
+    [TestMethod]
+    public void ClonePreservesUndoStateForCancelEdit()
+    {
+      // Arrange: Create a root with children and begin editing
+      var root = CreateRoot();
+      var child = root.Children.AddNew();
+      child.Data = "original";
+
+      root.BeginEdit();
+
+      // Make changes after BeginEdit
+      child.Data = "modified";
+
+      // Act: Clone the object graph
+      var clonedRoot = root.Clone();
+
+      // Cancel edit on the clone - this should restore the original value
+      clonedRoot.CancelEdit();
+
+      // Assert: The cloned child should revert to original value
+      Assert.AreEqual("original", clonedRoot.Children[0].Data, "CancelEdit on clone should restore original value");
+      Assert.AreEqual(0, ((Core.IUndoableObject)clonedRoot).EditLevel, "Root EditLevel should be 0 after CancelEdit");
+    }
+
+    [TestMethod]
+    public void ClonePreservesUndoStateForApplyEdit()
+    {
+      // Arrange: Create a root with children and begin editing
+      var root = CreateRoot();
+      var child = root.Children.AddNew();
+      child.Data = "original";
+
+      root.BeginEdit();
+
+      // Make changes after BeginEdit
+      child.Data = "modified";
+
+      // Act: Clone the object graph
+      var clonedRoot = root.Clone();
+
+      // Apply edit on the clone
+      clonedRoot.ApplyEdit();
+
+      // Assert: The cloned child should keep the modified value
+      Assert.AreEqual("modified", clonedRoot.Children[0].Data, "ApplyEdit on clone should keep modified value");
+      Assert.AreEqual(0, ((Core.IUndoableObject)clonedRoot).EditLevel, "Root EditLevel should be 0 after ApplyEdit");
+
+      // Should be able to save without errors
+      Assert.IsTrue(clonedRoot.IsDirty, "Clone should be dirty");
+      clonedRoot = clonedRoot.Save();
+      Assert.IsFalse(clonedRoot.IsDirty, "Clone should not be dirty after save");
+    }
+
+    [TestMethod]
+    public void ClonePreservesMultiLevelUndo()
+    {
+      // Arrange: Create a root with children
+      var root = CreateRoot();
+      var child = root.Children.AddNew();
+      child.Data = "level0";
+
+      // First level of editing
+      root.BeginEdit();
+      child.Data = "level1";
+
+      // Second level of editing
+      root.BeginEdit();
+      child.Data = "level2";
+
+      // Verify edit level is 2 before clone
+      Assert.AreEqual(2, ((Core.IUndoableObject)root).EditLevel, "Root EditLevel should be 2");
+      Assert.AreEqual(2, ((Core.IUndoableObject)child).EditLevel, "Child EditLevel should be 2");
+
+      // Act: Clone the object graph
+      var clonedRoot = root.Clone();
+      var clonedChild = clonedRoot.Children[0];
+
+      // Assert: Edit levels preserved
+      Assert.AreEqual(2, ((Core.IUndoableObject)clonedRoot).EditLevel, "Cloned Root EditLevel should be 2");
+      Assert.AreEqual(2, ((Core.IUndoableObject)clonedChild).EditLevel, "Cloned Child EditLevel should be 2");
+
+      // Verify multi-level undo works
+      Assert.AreEqual("level2", clonedChild.Data, "Should be at level2");
+
+      clonedRoot.CancelEdit();
+      Assert.AreEqual("level1", clonedChild.Data, "After first CancelEdit should be at level1");
+      Assert.AreEqual(1, ((Core.IUndoableObject)clonedRoot).EditLevel, "EditLevel should be 1");
+
+      clonedRoot.CancelEdit();
+      Assert.AreEqual("level0", clonedChild.Data, "After second CancelEdit should be at level0");
+      Assert.AreEqual(0, ((Core.IUndoableObject)clonedRoot).EditLevel, "EditLevel should be 0");
+    }
+
+    [TestMethod]
+    public void ClonePreservesChildAddedDuringEdit()
+    {
+      // Arrange: Create a root and begin editing before adding child
+      var root = CreateRoot();
+
+      root.BeginEdit();
+
+      // Add child after BeginEdit - child should have EditLevelAdded = 1
+      var child = root.Children.AddNew();
+      child.Data = "new child";
+
+      // Act: Clone the object graph
+      var clonedRoot = root.Clone();
+
+      // Assert: Clone should have the child
+      Assert.AreEqual(1, clonedRoot.Children.Count, "Clone should have 1 child");
+      Assert.AreEqual("new child", clonedRoot.Children[0].Data, "Clone should have child data");
+
+      // Cancel edit should remove the child (it was added after BeginEdit)
+      clonedRoot.CancelEdit();
+      Assert.AreEqual(0, clonedRoot.Children.Count, "After CancelEdit, child added during edit should be removed");
+    }
+
+    [TestMethod]
+    public void ClonePreservesChildEditLevelWhenUsingBindingSource()
+    {
+      // Arrange: Create a root with children and begin editing
+      var root = CreateRoot();
+      var child = root.Children.AddNew();
+      child.Data = "original";
+
+      ((System.ComponentModel.IEditableObject)root).BeginEdit();
+      ((System.ComponentModel.IEditableObject)child).BeginEdit();
+
+      // Make changes after BeginEdit
+      child.Data = "modified";
+
+      // Verify edit levels before clone
+      var rootEditLevel = ((Core.IUndoableObject)root).EditLevel;
+      var childEditLevel = ((Core.IUndoableObject)child).EditLevel;
+      var childListEditLevel = ((Core.IUndoableObject)root.Children).EditLevel;
+
+      Assert.AreEqual(1, rootEditLevel, "Root EditLevel should be 1 before clone");
+      Assert.AreEqual(1, childEditLevel, "Child EditLevel should be 1 before clone");
+      Assert.AreEqual(0, childListEditLevel, "ChildList EditLevel should be 0 before clone");
+
+      // Act: Clone the object graph
+      var clonedRoot = root.Clone();
+
+      // Assert: Verify edit levels are preserved after clone
+      var clonedRootEditLevel = ((Core.IUndoableObject)clonedRoot).EditLevel;
+      var clonedChildEditLevel = ((Core.IUndoableObject)clonedRoot.Children[0]).EditLevel;
+      var clonedChildListEditLevel = ((Core.IUndoableObject)clonedRoot.Children).EditLevel;
+
+      Assert.AreEqual(1, clonedRootEditLevel, "Cloned Root EditLevel should be 1");
+      Assert.AreEqual(1, clonedChildEditLevel, "Cloned Child EditLevel should be 1");
+      Assert.AreEqual(0, clonedChildListEditLevel, "Cloned ChildList EditLevel should be 0");
+
+      // Verify the modified data is preserved
+      Assert.AreEqual("modified", clonedRoot.Children[0].Data, "Modified data should be preserved in clone");
+    }
+
     private Root CreateRoot()
     {
       IDataPortal<Root> dataPortal = _testDIContext.CreateDataPortal<Root>();

Source/Csla/BusinessBindingListBase.cs

@@ -300,9 +300,13 @@ protected virtual void EditChildComplete(IEditableBusinessObject child)
 
     #region Insert, Remove, Clear
 
+    [NonSerialized]
+    [NotUndoable]
+    private bool _isDeserializing;
+
     /// <summary>
     /// Override this method to create a new object that is added
-    /// to the collection. 
+    /// to the collection.
     /// </summary>
     protected override object AddNewCore()
     {
@@ -354,12 +358,15 @@ protected override void InsertItem(int index, C item)
         // ensure child uses same context as parent
         if (item is IUseApplicationContext iuac)
           iuac.ApplicationContext = ApplicationContext;
-        // set child edit level
-        UndoableBase.ResetChildEditLevel(item, EditLevel, false);
-        // when an object is inserted we assume it is
-        // a new object and so the edit level when it was
-        // added must be set
-        item.EditLevelAdded = EditLevel;
+        if (!_isDeserializing)
+        {
+          // set child edit level
+          UndoableBase.ResetChildEditLevel(item, EditLevel, false);
+          // when an object is inserted we assume it is
+          // a new object and so the edit level when it was
+          // added must be set
+          item.EditLevelAdded = EditLevel;
+        }
         base.InsertItem(index, item);
       }
       else
@@ -667,7 +674,15 @@ protected override void OnSetChildren(Serialization.Mobile.SerializationInfo inf
       {
         _deletedList = (MobileList<C>)formatter.GetObject(child.ReferenceId);
       }
-      base.OnSetChildren(info, formatter);
+      _isDeserializing = true;
+      try
+      {
+        base.OnSetChildren(info, formatter);
+      }
+      finally
+      {
+        _isDeserializing = false;
+      }
     }
 
     /// <inheritdoc/>

Source/Csla/BusinessListBase.cs

@@ -307,9 +307,13 @@ protected virtual void EditChildComplete(IEditableBusinessObject child)
 
     #region Insert, Remove, Clear
 
+    [NonSerialized]
+    [NotUndoable]
+    private bool _isDeserializing;
+
     /// <summary>
     /// Override this method to create a new object that is added
-    /// to the collection. 
+    /// to the collection.
     /// </summary>
     protected override C AddNewCore()
     {
@@ -373,12 +377,15 @@ protected override void InsertItem(int index, C item)
         // ensure child uses same context as parent
         if (item is IUseApplicationContext iuac)
           iuac.ApplicationContext = ApplicationContext;
-        // set child edit level
-        UndoableBase.ResetChildEditLevel(item, EditLevel, false);
-        // when an object is inserted we assume it is
-        // a new object and so the edit level when it was
-        // added must be set
-        item.EditLevelAdded = EditLevel;
+        if (!_isDeserializing)
+        {
+          // set child edit level
+          UndoableBase.ResetChildEditLevel(item, EditLevel, false);
+          // when an object is inserted we assume it is
+          // a new object and so the edit level when it was
+          // added must be set
+          item.EditLevelAdded = EditLevel;
+        }
         base.InsertItem(index, item);
       }
       else
@@ -701,7 +708,15 @@ protected override void OnSetChildren(SerializationInfo info, MobileFormatter fo
       {
         _deletedList = (MobileList<C>)formatter.GetObject(child.ReferenceId);
       }
-      base.OnSetChildren(info, formatter);
+      _isDeserializing = true;
+      try
+      {
+        base.OnSetChildren(info, formatter);
+      }
+      finally
+      {
+        _isDeserializing = false;
+      }
     }
 
     /// <inheritdoc/>