Implement IMobileObjectMetastate on ReadOnlyListBase (#4766)

* Initial plan

* Add IMobileObjectMetastate implementation to ReadOnlyListBase and create tests

Co-authored-by: rockfordlhotka <2333134+rockfordlhotka@users.noreply.github.com>

* Fix JsonElement handling in MobileObjectMetastateHelper and update tests

Co-authored-by: rockfordlhotka <2333134+rockfordlhotka@users.noreply.github.com>

* Final implementation complete

Co-authored-by: rockfordlhotka <2333134+rockfordlhotka@users.noreply.github.com>

* Remove accidentally added nuget.exe

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: rockfordlhotka <2333134+rockfordlhotka@users.noreply.github.com>

Author: Copilot

Source/Csla/ReadOnlyListBase.cs

@@ -10,6 +10,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Csla.Core;
 using Csla.Properties;
+using Csla.Serialization.Mobile;
 using Csla.Server;
 
 namespace Csla
@@ -30,7 +31,8 @@ public abstract class ReadOnlyListBase<T, C> :
 #endif
     IDataPortalTarget,
     IReadOnlyListBase<C>,
-    IUseApplicationContext
+    IUseApplicationContext,
+    IMobileObjectMetastate
     where T : ReadOnlyListBase<T, C>
   {
     /// <summary>
@@ -252,5 +254,21 @@ void IDataPortalTarget.Child_OnDataPortalException(DataPortalEventArgs e, Except
     }
 
     #endregion
+
+    #region IMobileObjectMetastate Members
+
+    /// <inheritdoc />
+    byte[] IMobileObjectMetastate.GetMetastate()
+    {
+      return MobileObjectMetastateHelper.SerializeMetastate(this);
+    }
+
+    /// <inheritdoc />
+    void IMobileObjectMetastate.SetMetastate(byte[] metastate)
+    {
+      MobileObjectMetastateHelper.DeserializeMetastate(this, metastate);
+    }
+
+    #endregion
   }
 }

Source/Csla/Serialization/Mobile/MobileObjectMetastateHelper.cs

@@ -93,7 +93,43 @@ private static void PopulateSerializationInfo(SerializationInfo info,
     {
       foreach (var kvp in values)
       {
-        info.AddValue(kvp.Key, kvp.Value.Value, kvp.Value.IsDirty, kvp.Value.EnumTypeName);
+        var value = kvp.Value.Value;
+        
+        // Convert JsonElement to appropriate type if needed
+        if (value is JsonElement jsonElement)
+        {
+          value = ConvertJsonElement(jsonElement);
+        }
+        
+        info.AddValue(kvp.Key, value, kvp.Value.IsDirty, kvp.Value.EnumTypeName);
+      }
+    }
+
+    private static object? ConvertJsonElement(JsonElement element)
+    {
+      switch (element.ValueKind)
+      {
+        case JsonValueKind.String:
+          return element.GetString();
+        case JsonValueKind.Number:
+          if (element.TryGetInt32(out int intValue))
+            return intValue;
+          if (element.TryGetInt64(out long longValue))
+            return longValue;
+          if (element.TryGetDouble(out double doubleValue))
+            return doubleValue;
+          return element.GetDecimal();
+        case JsonValueKind.True:
+          return true;
+        case JsonValueKind.False:
+          return false;
+        case JsonValueKind.Null:
+        case JsonValueKind.Undefined:
+          return null;
+        default:
+          // For complex types, return the element as-is and let the normal
+          // conversion logic handle it
+          return element;
       }
     }
 

Source/tests/Csla.test/Serialization/ReadOnlyListBaseMetastateTests.cs

@@ -0,0 +1,133 @@
+//-----------------------------------------------------------------------
+// <copyright file="ReadOnlyListBaseMetastateTests.cs" company="Marimer LLC">
+//     Copyright (c) Marimer LLC. All rights reserved.
+//     Website: https://cslanet.com
+// </copyright>
+// <summary>Tests for IMobileObjectMetastate interface implementation on ReadOnlyListBase.</summary>
+//-----------------------------------------------------------------------
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Csla.Serialization.Mobile;
+using Csla.TestHelpers;
+
+namespace Csla.Test.Serialization
+{
+  [TestClass]
+  public class ReadOnlyListBaseMetastateTests
+  {
+    private static TestDIContext _testDIContext;
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext context)
+    {
+      _testDIContext = TestDIContextFactory.CreateDefaultContext();
+    }
+
+    [TestInitialize]
+    public void Initialize()
+    {
+      TestResults.Reinitialise();
+    }
+
+    [TestMethod]
+    public void ReadOnlyListBase_GetSetMetastate_IsReadOnly_RoundTrip()
+    {
+      // Arrange
+      var dataPortal = _testDIContext.CreateDataPortal<TestReadOnlyList>();
+      var original = dataPortal.Fetch();
+      
+      // The list should be readonly by default
+      Assert.IsTrue(original.IsReadOnly);
+
+      // Act - Get the metastate
+      var metastate = ((IMobileObjectMetastate)original).GetMetastate();
+      
+      // Create a new instance and restore the metastate
+      var restored = dataPortal.Fetch();
+      
+      // Verify before setting metastate
+      Assert.IsTrue(restored.IsReadOnly);
+      
+      // Set the metastate
+      ((IMobileObjectMetastate)restored).SetMetastate(metastate);
+      
+      // Assert - The IsReadOnly property should be preserved
+      Assert.AreEqual(original.IsReadOnly, restored.IsReadOnly);
+    }
+
+    [TestMethod]
+    public void ReadOnlyListBase_GetSetMetastate_IsReadOnly_False()
+    {
+      // Arrange
+      var dataPortal = _testDIContext.CreateDataPortal<TestReadOnlyList>();
+      var original = dataPortal.Fetch();
+      
+      // Unlock the list to test IsReadOnly = false
+      original.SetIsReadOnlyForTest(false);
+      Assert.IsFalse(original.IsReadOnly);
+
+      // Act - Get the metastate
+      var metastate = ((IMobileObjectMetastate)original).GetMetastate();
+      
+      // Create a new instance (which will be readonly by default)
+      var restored = dataPortal.Fetch();
+      Assert.IsTrue(restored.IsReadOnly);
+      
+      // Set the metastate
+      ((IMobileObjectMetastate)restored).SetMetastate(metastate);
+      
+      // Assert - The IsReadOnly property should be false after restore
+      Assert.AreEqual(original.IsReadOnly, restored.IsReadOnly);
+      Assert.IsFalse(restored.IsReadOnly);
+    }
+
+    [TestMethod]
+    [ExpectedException(typeof(ArgumentNullException))]
+    public void ReadOnlyListBase_SetMetastate_ThrowsOnNullMetastate()
+    {
+      // Arrange
+      var dataPortal = _testDIContext.CreateDataPortal<TestReadOnlyList>();
+      var list = dataPortal.Fetch();
+
+      // Act
+      ((IMobileObjectMetastate)list).SetMetastate(null);
+    }
+
+    [TestMethod]
+    [ExpectedException(typeof(ArgumentException))]
+    public void ReadOnlyListBase_SetMetastate_ThrowsOnEmptyMetastate()
+    {
+      // Arrange
+      var dataPortal = _testDIContext.CreateDataPortal<TestReadOnlyList>();
+      var list = dataPortal.Fetch();
+
+      // Act
+      ((IMobileObjectMetastate)list).SetMetastate(new byte[0]);
+    }
+
+    #region Test Helper Classes
+
+    [Serializable]
+    public class TestReadOnlyList : ReadOnlyListBase<TestReadOnlyList, string>
+    {
+      [Fetch]
+      private void DataPortal_Fetch()
+      {
+        // Populate with some simple test data
+        IsReadOnly = false;
+        Add("Item1");
+        Add("Item2");
+        Add("Item3");
+        IsReadOnly = true;
+      }
+
+      // Expose a method to set IsReadOnly for testing
+      public void SetIsReadOnlyForTest(bool value)
+      {
+        IsReadOnly = value;
+      }
+    }
+
+    #endregion
+  }
+}