DataContractSerialization has Type.GetMethod extension method that is not trim-safe

[eerhardt]

We have some reflection code in DataContractSerialization that is not trim-safe:

runtime/src/libraries/System.Private.DataContractSerialization/src/System/Runtime/Serialization/XmlFormatGeneratorStatics.cs

Line 48 in e17d818

s_writeEndElementMethod = typeof(XmlWriterDelegator).GetMethod("WriteEndElement", Globals.ScanAllMembers, Array.Empty<Type>());

runtime/src/libraries/System.Private.DataContractSerialization/src/System/Runtime/Serialization/XmlFormatGeneratorStatics.cs

Line 617 in e17d818

s_createSerializationExceptionMethod = typeof(XmlObjectSerializerReadContext).GetMethod("CreateSerializationException", Globals.ScanAllMembers, new Type[] { typeof(string) });

On the surface, this appears to be safe since the ILLinker should be able to see this usage of reflection and preserve the referenced methods. However, the issue is that overload of Type.GetMethod doesn't exist. (See #42753 for proposal to create it.)

Instead, DataContractSerialization has its own extension method that implements this API:

runtime/src/libraries/System.Private.DataContractSerialization/src/System/Runtime/Serialization/Globals.cs

Lines 819 to 824 in e17d818

	internal static MethodInfo? GetMethod(this Type type, string methodName, BindingFlags bindingFlags, Type[] parameterTypes)
	{
	var methodInfos = type.GetMethods(bindingFlags);
	var methodInfo = FilterMethodBases(methodInfos.Cast<MethodBase>().ToArray()!, parameterTypes, methodName);
	return methodInfo != null ? (MethodInfo)methodInfo : null;
	}

The ILLinker can't see through this usage of Reflection, so all 41 usages of this method are broken when an application is trimmed.

We should remove this method and call directly into Reflection APIs, so the linker has a chance of preserving these necessary methods.

This is the underlying problem that was discovered in dotnet/aspnetcore#25909. Here's a repro program from that issue that fails when PublishTrimmed=true and TrimMode=link are set.

using System;
using System.IO;
using System.Threading.Tasks;
using System.Net.Http;
using System.Text;
using System.Runtime.Serialization;
using MyApplication.Blazor.Shared.Types;

namespace LinkerEHBug
{
    class Program
    {
        static async Task Main(string[] args)
        {
            string v = @"<AuthState xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://schemas.datacontract.org/2004/07/MyApplication.Blazor.Shared.Types""> <GivenName>Admin User</GivenName> <IsAuthenticated>true</IsAuthenticated> <Name>[email protected]</Name> </AuthState>";

            var s = DeserializeDataContract<AuthState>(v);
            Console.WriteLine(s);
        }

        public static T DeserializeDataContract<T>(string serialized)
        {
            using (var inStream = new MemoryStream(new UTF8Encoding().GetBytes(serialized)))
            {
                Console.WriteLine($"{inStream.Length} bytes to deserialize for type {typeof(T).Name}");
                var ser = new DataContractSerializer(typeof(T));
                Console.WriteLine("Calling ReadObject");
                return (T)ser.ReadObject(inStream); // <---- FAILS HERE
            }
        }
    }
}

namespace MyApplication.Blazor.Shared.Types
{
    public class AuthState
    {
        public AuthState()
        {
        }

        public AuthState(bool isAuthenticated, string name, string givenName)
        {
            IsAuthenticated = isAuthenticated;
            Name = name;
            GivenName = givenName;
        }

        public bool IsAuthenticated { get; set; }
        public string Name { get; set; }
        public string GivenName { get; set; }
    }
}

[jkotas]

FWIW, .NET Framework called the Type.GetMethod directly https://referencesource.microsoft.com/#System.Runtime.Serialization/System/Runtime/Serialization/XmlFormatGeneratorStatics.cs . This method is left-over from .NET Core 1.0 era reduced reflection surface that made people to introduce stub implementations like this in many places.

However, the issue is that overload of Type.GetMethod doesn't exist

The calls to this method are long and verbose already because of the need to create array of types. The .NET Framework implementation passed in the extra nulls and it looks just fine to me.