Merge pull request #1917 from khdang/xmlserializer_protected_constructor

Fix XmlSerializer issue when deserializing type with protected parameterless constructor

Author: stephentoub

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

@@ -2109,3 +2109,13 @@ public class TypeWithXmlDocumentProperty
 {
     public XmlDocument Document;
 }
+
+public class TypeWithNonParameterlessConstructor
+{
+    public string StringProperty { get; set; }
+
+    public TypeWithNonParameterlessConstructor(string value)
+    {
+        StringProperty = value;
+    }
+}

src/System.Xml.XmlSerializer/src/System/Xml/Serialization/XmlSerializationWriterILGen.cs

@@ -2416,6 +2416,66 @@ internal void ILGenForCreateInstance(CodeGenerator ilg, Type type, Type cast, bo
                 }
             }
 
+            Label labelReturn = ilg.DefineLabel();
+            Label labelEndIf = ilg.DefineLabel();
+
+            // TypeInfo typeInfo = type.GetTypeInfo();
+            // typeInfo not declared explicitly
+            ilg.Ldc(type);
+            MethodInfo getTypeInfoMehod = typeof(IntrospectionExtensions).GetMethod(
+                  "GetTypeInfo",
+                  CodeGenerator.StaticBindingFlags,
+                  new[] { typeof(Type) }
+                  );
+            ilg.Call(getTypeInfoMehod);
+
+            // IEnumerator<ConstructorInfo> e = typeInfo.DeclaredConstructors.GetEnumerator();
+            LocalBuilder enumerator = ilg.DeclareLocal(typeof(IEnumerator<>).MakeGenericType(typeof(ConstructorInfo)), "e");
+            MethodInfo getDeclaredConstructors = typeof(TypeInfo).GetMethod("get_DeclaredConstructors");
+            MethodInfo getEnumerator = typeof(IEnumerable<>).MakeGenericType(typeof(ConstructorInfo)).GetMethod("GetEnumerator");
+            ilg.Call(getDeclaredConstructors);
+            ilg.Call(getEnumerator);
+            ilg.Stloc(enumerator);
+
+            ilg.WhileBegin();
+            // ConstructorInfo constructorInfo = e.Current();
+            MethodInfo enumeratorCurrent = typeof(IEnumerator).GetMethod("get_Current");
+            ilg.Ldloc(enumerator);
+            ilg.Call(enumeratorCurrent);
+            LocalBuilder constructorInfo = ilg.DeclareLocal(typeof(ConstructorInfo), "constructorInfo");
+            ilg.Stloc(constructorInfo);
+
+            // if (!constructorInfo.IsStatic && constructorInfo.GetParameters.Length() == 0)
+            ilg.Ldloc(constructorInfo);
+            MethodInfo constructorIsStatic = typeof(ConstructorInfo).GetMethod("get_IsStatic");
+            ilg.Call(constructorIsStatic);
+            ilg.Brtrue(labelEndIf);
+            ilg.Ldloc(constructorInfo);
+            MethodInfo constructorGetParameters = typeof(ConstructorInfo).GetMethod("GetParameters");
+            ilg.Call(constructorGetParameters);
+            ilg.Ldlen();
+            ilg.Ldc(0);
+            ilg.Cne();
+            ilg.Brtrue(labelEndIf);
+
+            // constructorInfo.Invoke(null);
+            MethodInfo constructorInvoke = typeof(ConstructorInfo).GetMethod("Invoke", new Type[] { typeof(object[]) });
+            ilg.Ldloc(constructorInfo);
+            ilg.Load(null);
+            ilg.Call(constructorInvoke);
+            ilg.Br(labelReturn);
+
+            ilg.MarkLabel(labelEndIf);
+            ilg.WhileBeginCondition(); // while (e.MoveNext())
+            MethodInfo IEnumeratorMoveNext = typeof(IEnumerator).GetMethod(
+                "MoveNext",
+                CodeGenerator.InstanceBindingFlags,
+                Array.Empty<Type>());
+            ilg.Ldloc(enumerator);
+            ilg.Call(IEnumeratorMoveNext);
+            ilg.WhileEndCondition();
+            ilg.WhileEnd();
+
             MethodInfo Activator_CreateInstance = typeof(Activator).GetMethod(
                   "CreateInstance",
                   CodeGenerator.StaticBindingFlags,
@@ -2425,6 +2485,7 @@ internal void ILGenForCreateInstance(CodeGenerator ilg, Type type, Type cast, bo
             ilg.Call(Activator_CreateInstance);
             if (cast != null)
                 ilg.ConvertValue(Activator_CreateInstance.ReturnType, cast);
+            ilg.MarkLabel(labelReturn);
         }
 
         internal void WriteLocalDecl(string variableName, SourceInfo initValue)

src/System.Xml.XmlSerializer/tests/XmlSerializerTests.cs

@@ -8,6 +8,7 @@
 using System.Globalization;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Xml;
 using System.Xml.Serialization;
 using System.Xml.Linq;
@@ -1111,6 +1112,24 @@ public static void Xml_TypeWithMismatchBetweenAttributeAndPropertyType()
         Assert.StrictEqual(value.IntValue, actual.IntValue);
     }
 
+    [Fact]
+    public static void Xml_TypeWithNonPublicDefaultConstructor()
+    {
+        TypeInfo ti = IntrospectionExtensions.GetTypeInfo(typeof(TypeWithNonPublicDefaultConstructor));
+        TypeWithNonPublicDefaultConstructor value = null;
+        value = (TypeWithNonPublicDefaultConstructor)FindDefaultConstructor(ti).Invoke(null);
+        Assert.StrictEqual("Mr. FooName", value.Name);
+        var actual = SerializeAndDeserialize(value, "<?xml version=\"1.0\"?>" + Environment.NewLine + "<TypeWithNonPublicDefaultConstructor xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">" + Environment.NewLine + "  <Name>Mr. FooName</Name>" + Environment.NewLine + "</TypeWithNonPublicDefaultConstructor>");
+        Assert.StrictEqual(value.Name, actual.Name);
+    }
+
+    [Fact]
+    public static void Xml_TypeWithNonParameterlessConstructor()
+    {
+        var obj = new TypeWithNonParameterlessConstructor("string value");
+        Assert.Throws<InvalidOperationException>(() => { SerializeAndDeserialize(obj, string.Empty); });
+    }
+
     private static T SerializeAndDeserialize<T>(T value, string baseline, Func<XmlSerializer> serializerFactory = null)
     {
         XmlSerializer serializer = new XmlSerializer(typeof(T));