Address PR review feedback: use shared test classes, consistent RootContract pattern, remove cache invalidation

Co-authored-by: StephenMolloy <19562826+StephenMolloy@users.noreply.github.com>

Author: Copilot

src/libraries/System.Private.DataContractSerialization/src/System/Runtime/Serialization/Json/DataContractJsonSerializer.cs

@@ -105,12 +105,7 @@ internal DataContractJsonSerializer(Type type,
         internal ISerializationSurrogateProvider? SerializationSurrogateProvider
         {
             get { return _serializationSurrogateProvider; }
-            set
-            {
-                _serializationSurrogateProvider = value;
-                // Reset _rootContract when surrogate provider changes so it gets recalculated
-                _rootContract = null;
-            }
+            set { _serializationSurrogateProvider = value; }
         }
 
         public bool IgnoreExtensionDataObject
@@ -193,12 +188,7 @@ private DataContract RootContract
             {
                 if (_rootContract == null)
                 {
-                    Type contractType = _rootType;
-                    if (_serializationSurrogateProvider != null)
-                    {
-                        contractType = DataContractSurrogateCaller.GetDataContractType(_serializationSurrogateProvider, _rootType);
-                    }
-                    _rootContract = DataContract.GetDataContract(contractType);
+                    _rootContract = DataContract.GetDataContract((_serializationSurrogateProvider == null) ? _rootType : GetSurrogatedType(_serializationSurrogateProvider, _rootType));
                     CheckIfTypeIsReference(_rootContract);
                 }
                 return _rootContract;
@@ -625,9 +615,6 @@ private void Initialize(Type type,
             _serializeReadOnlyTypes = serializeReadOnlyTypes;
             _dateTimeFormat = dateTimeFormat;
             _useSimpleDictionaryFormat = useSimpleDictionaryFormat;
-
-            // Reset _rootContract when parameters change so it gets recalculated with surrogate
-            _rootContract = null;
         }
 
         [MemberNotNull(nameof(_rootType))]
@@ -667,5 +654,12 @@ internal static DataContract GetDataContract(DataContract declaredTypeContract,
             CheckIfTypeIsReference(contract);
             return contract;
         }
+
+        [RequiresDynamicCode(DataContract.SerializerAOTWarning)]
+        [RequiresUnreferencedCode(DataContract.SerializerTrimmerWarning)]
+        internal static Type GetSurrogatedType(ISerializationSurrogateProvider serializationSurrogateProvider, Type type)
+        {
+            return DataContractSurrogateCaller.GetDataContractType(serializationSurrogateProvider, DataContract.UnwrapNullableType(type));
+        }
     }
 }

src/libraries/System.Runtime.Serialization.Json/tests/DataContractJsonSerializer.cs

@@ -3128,14 +3128,14 @@ private static string GetAmString(DateTimeFormat dateTimeFormat)
     [Fact]
     public static void DCJS_SerializationSurrogateProvider_PassedToInternalSerializer()
     {
-        // Setup: Create a test surrogate that transforms TestClassA to TestClassB
-        var surrogateProvider = new TestSurrogateProvider();
+        // Setup: Create a test surrogate that transforms NonSerializablePerson
+        var surrogateProvider = new MyPersonSurrogateProvider();
 
         // Create the serializer and set the surrogate provider
-        var serializer = new DataContractJsonSerializer(typeof(TestClassA));
+        var serializer = new DataContractJsonSerializer(typeof(NonSerializablePerson));
         serializer.SetSerializationSurrogateProvider(surrogateProvider);
 
-        var testObj = new TestClassA { Value = "OriginalValue" };
+        var testObj = new NonSerializablePerson("John", 30);
 
         // Act: Serialize the object
         byte[] serializedData;
@@ -3146,72 +3146,22 @@ public static void DCJS_SerializationSurrogateProvider_PassedToInternalSerialize
         }
 
         // The surrogate should have been called during serialization
-        Assert.True(surrogateProvider.SerializationSurrogateWasCalled, "Serialization surrogate should have been called during WriteObject");
+        Assert.True(surrogateProvider.GetSurrogateTypeWasCalled, "GetSurrogateType should have been called during WriteObject");
+        Assert.True(surrogateProvider.GetObjectToSerializeWasCalled, "GetObjectToSerialize should have been called during WriteObject");
 
         // Act: Deserialize the object
-        TestClassA deserializedObj;
+        NonSerializablePerson deserializedObj;
         using (var ms = new MemoryStream(serializedData))
         {
-            deserializedObj = (TestClassA)serializer.ReadObject(ms);
+            deserializedObj = (NonSerializablePerson)serializer.ReadObject(ms);
         }
 
         // The surrogate should have been called during deserialization
-        Assert.True(surrogateProvider.DeserializationSurrogateWasCalled, "Deserialization surrogate should have been called during ReadObject");
+        Assert.True(surrogateProvider.GetDeserializedObjectWasCalled, "GetDeserializedObject should have been called during ReadObject");
 
-        // Verify the surrogate transformation was applied
-        Assert.Equal("TransformedValue", deserializedObj.Value);
+        // Verify the object was properly deserialized
+        Assert.Equal("John", deserializedObj.Name);
+        Assert.Equal(30, deserializedObj.Age);
     }
 
-    // Test classes for surrogate provider testing
-    [DataContract]
-    public class TestClassA
-    {
-        [DataMember]
-        public string Value { get; set; }
-    }
-
-    [DataContract]
-    public class TestClassB
-    {
-        [DataMember]
-        public string TransformedValue { get; set; }
-    }
-
-    // Test surrogate provider implementation
-    public class TestSurrogateProvider : ISerializationSurrogateProvider
-    {
-        public bool SerializationSurrogateWasCalled { get; private set; }
-        public bool DeserializationSurrogateWasCalled { get; private set; }
-
-        public Type GetSurrogateType(Type type)
-        {
-            if (type == typeof(TestClassA))
-            {
-                return typeof(TestClassB);
-            }
-            return type;
-        }
-
-        public object GetObjectToSerialize(object obj, Type targetType)
-        {
-            SerializationSurrogateWasCalled = true;
-            
-            if (obj is TestClassA testA && targetType == typeof(TestClassB))
-            {
-                return new TestClassB { TransformedValue = testA.Value };
-            }
-            return obj;
-        }
-
-        public object GetDeserializedObject(object obj, Type targetType)
-        {
-            DeserializationSurrogateWasCalled = true;
-            
-            if (obj is TestClassB testB && targetType == typeof(TestClassA))
-            {
-                return new TestClassA { Value = "TransformedValue" };
-            }
-            return obj;
-        }
-    }
 }

src/libraries/System.Runtime.Serialization.Xml/tests/SerializationTypes.RuntimeOnly.cs

@@ -2319,8 +2319,13 @@ public object GetDeserializedObject(object obj, Type targetType)
 
     public class MyPersonSurrogateProvider : ISerializationSurrogateProvider
     {
+        public bool GetSurrogateTypeWasCalled { get; private set; }
+        public bool GetObjectToSerializeWasCalled { get; private set; }
+        public bool GetDeserializedObjectWasCalled { get; private set; }
+
         public Type GetSurrogateType(Type type)
         {
+            GetSurrogateTypeWasCalled = true;
             if (type == typeof(NonSerializablePerson))
             {
                 return typeof(NonSerializablePersonSurrogate);
@@ -2337,6 +2342,7 @@ public Type GetSurrogateType(Type type)
 
         public object GetDeserializedObject(object obj, Type targetType)
         {
+            GetDeserializedObjectWasCalled = true;
             if (obj is NonSerializablePersonSurrogate)
             {
                 NonSerializablePersonSurrogate person = (NonSerializablePersonSurrogate)obj;
@@ -2353,6 +2359,7 @@ public object GetDeserializedObject(object obj, Type targetType)
 
         public object GetObjectToSerialize(object obj, Type targetType)
         {
+            GetObjectToSerializeWasCalled = true;
             if (obj is NonSerializablePerson)
             {
                 NonSerializablePerson nsp = (NonSerializablePerson)obj;