Can't trim polymorphic json converter

[MarkusRodler]

I have no clue how to make this polymorphic json converter trimmable:

using System;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace Dark
{
    class Program
    {
        static void Main(string[] args)
        {
            var result = JsonSerializer.Serialize(
                new DummyClassName("42"),
                new()
                {
                    Converters = {
                        new PolymorphicConverter<Message>()
                    }
                }
            );
            System.Console.WriteLine(result); // {"DummyClassName":{"bla":"42"}}
        }

        public interface Message { }
        public sealed record DummyClassName(string bla) : Message;
        public class PolymorphicConverter<TInterface> : JsonConverter<TInterface>
        {
            public string assemblyName { get; init; } = "Dark";
            public string namespacePrefix { get; init; } = "Dark.";
            public JsonSerializerOptions? jsonSerializerOptions { get; init; }

            public override bool CanConvert(Type typeToConvert) => typeof(TInterface).IsAssignableFrom(typeToConvert);

            public override TInterface Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
            {
                if (reader.TokenType != JsonTokenType.StartObject)
                {
                    throw new JsonException();
                }

                if (!reader.Read() || reader.TokenType != JsonTokenType.PropertyName)
                {
                    throw new JsonException();
                }
                var interfaceType = Type.GetType(namespacePrefix + reader.GetString() + ", " + assemblyName);

                if (interfaceType is null)
                {
                    throw new NotSupportedException();
                }

                if (!reader.Read() || reader.TokenType != JsonTokenType.StartObject)
                {
                    throw new JsonException();
                }
                var @class = JsonSerializer.Deserialize(ref reader, interfaceType, jsonSerializerOptions);

                return @class switch
                {
                    null => throw new NotSupportedException(),
                    _ => !reader.Read() || reader.TokenType != JsonTokenType.EndObject
                        ? throw new JsonException()
                        : (TInterface)@class,
                };
            }

            public override void Write(Utf8JsonWriter writer, TInterface @class, JsonSerializerOptions options)
            {
                if (@class is not null)
                {
                    writer.WriteStartObject(); // {
                    writer.WritePropertyName(@class.GetType().Name); // "DummyClassName":
                    JsonSerializer.Serialize(writer, (dynamic)@class, jsonSerializerOptions); // { "bla": 42 }
                    writer.WriteEndObject(); // }
                }
            }
        }
    }
}

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net5.0</TargetFramework>
    <PublishTrimmed>true</PublishTrimmed>
    <TrimMode>link</TrimMode>
    <Nullable>enable</Nullable>
    <SuppressTrimAnalysisWarnings>false</SuppressTrimAnalysisWarnings>
  </PropertyGroup>

</Project>

Pubslished with: dotnet publish --configuration Release --runtime linux-x64 --self-contained true /p:PublishTrimmed=true /p:PublishSingleFile=true

It works if I remove "TrimMode link" but I need it for a BlazorWASM App. So I decided to create this minimal console dummy that does not work.

Maybe someone can help me please🙏

[davidfowl]

I'm not sure how this could work. That pattern isn't trim friendly (Type.GetType based on the incoming payload? The linker has no idea what to keep). Did you turn on linker the warnings?

cc @agocke @eerhardt

[MarkusRodler]

I did turn on TrimAnalysisWarnings, but they weren't helpful. Or did you mean different warnings?

[FiniteReality]

I'd replace the Type.GetType call with a dictionary lookup of known strings and types;

var types = new Dictionary<string, Type>()
{
    ["DummyClassName"] = typeof(DummyClassName)
};

// in Read(...)
if (!types.TryGetValue(reader.GetString(), out var interfaceType))
    throw new JsonException("Unknown type");

// in Write(...)
var type = types.FirstOrDefault(x => x.Value == value.GetType()).Key;
if (type == null)
    throw new JsonException("Unknown type");

writer.WritePropertyName(type);

I believe this approach is more linker friendly, and it also avoids the large security hole which exists when deserializing arbitrary types specified by the user.

[MarkusRodler]

I can accept the security risk with allowing only specific classes to be available for serialization via namespacePrefix. If only allowed classes are in this namespace (or deeper namespaces) this should be safe enough for a client-side app or am I overlooking something?

[agocke]

There isn't really a way to make the trimmer understand something like namespace prefix -- it's just too complicated of an operation.

I'm not really an expert on how JsonSerializer works internally, but the trick is going to be to somehow connect the list of types that are deserializable (i.e., everything with a Dark prefix), to all the members that will be accessed via reflection in JsonSerializer. The best case is, of course, for JsonSerializer to not use reflection at all, but that's probably not how it was originally designed.

[MarkusRodler]

I'm no C# expert but maybe it is possible to connect the dictionary approach with SourceGenerators? At least that would prevent the "oops you did forget to add it also to the JsonSerializerDictionary"-problem.

[FiniteReality]

Absolutely - if you're writing a source generator you don't actually need the dictionary, since you can know all of the types thanks to Roslyn, and can just generate a switch statement.

[eerhardt]

It works if I remove "TrimMode link" but I need it for a BlazorWASM App

What fails when you use "TrimMode link"?

By default, a Blazor WASM App won't trim "user" assemblies. It only trims from assemblies that are marked with IsTrimmable=true assembly metadata. So as long as the types you are trying to get aren't in assemblies that are marked for trimming, what you are doing will work.

In general though, your current design (reading the type name from a payload and expecting the type to be there) can't be made trim compatible. Furthermore, JsonSerializer.Serialize(writer, (dynamic)@class, jsonSerializerOptions); is itself not trim-compatible and gives you a warning when you call it:

runtime/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.Utf8JsonWriter.cs

Lines 25 to 31 in 17481fe

	[RequiresUnreferencedCode(SerializationUnreferencedCodeMessage)]
	public static void Serialize<TValue>(
	Utf8JsonWriter writer,
	TValue value,
	JsonSerializerOptions? options = null)
	{
	Serialize(writer, value, GetRuntimeType(value), options);

[MarkusRodler]

Unhandled exception. Microsoft.CSharp.RuntimeBinder.RuntimeBinderException: The best overloaded method match for 'System.Text.Json.JsonSerializer.Serialize<System.Text.Json.Utf8JsonWriter>(ref System.Text.Json.Utf8JsonWriter, System.Type, System.Text.Json.JsonSerializerOptions)' has some invalid arguments
   at CallSite.Target(Closure , CallSite , Type , Utf8JsonWriter , Object , JsonSerializerOptions )
   at System.Dynamic.UpdateDelegates.UpdateAndExecuteVoid4[T0,T1,T2,T3](CallSite site, T0 arg0, T1 arg1, T2 arg2, T3 arg3)
   at Dark.Program.PolymorphicConverter`1.Write(Utf8JsonWriter writer, TInterface class, JsonSerializerOptions options)
   at System.Text.Json.Serialization.JsonConverter`1.TryWrite(Utf8JsonWriter writer, T& value, JsonSerializerOptions options, WriteStack& state)
   at System.Text.Json.Serialization.JsonConverter`1.WriteCore(Utf8JsonWriter writer, T& value, JsonSerializerOptions options, WriteStack& state)
   at System.Text.Json.Serialization.JsonConverter`1.WriteCoreAsObject(Utf8JsonWriter writer, Object value, JsonSerializerOptions options, WriteStack& state)
   at System.Text.Json.JsonSerializer.WriteCore[TValue](JsonConverter jsonConverter, Utf8JsonWriter writer, TValue& value, JsonSerializerOptions options, WriteStack& state)
   at System.Text.Json.JsonSerializer.WriteCore[TValue](Utf8JsonWriter writer, TValue& value, Type inputType, JsonSerializerOptions options)
   at System.Text.Json.JsonSerializer.Serialize[TValue](TValue& value, Type inputType, JsonSerializerOptions options)
   at System.Text.Json.JsonSerializer.Serialize[TValue](TValue value, JsonSerializerOptions options)
   at Dark.Program.Main(String[] args)
Aborted

[agocke]

The main problem there is that it looks like dynamic caused the whole overload to be trimmed away.

First priority here is to get rid of dynamic.

[eerhardt]

Ah, missed the dynamic usage here. @agocke is 💯 on point here. If you use dynamic, not only do you get a bunch of ILLink warnings when you trim, but you are almost guaranteed to get runtime failures.

[MarkusRodler]

Thanks for the hint with the dynamic keywoard. I changed it to object and now it is compatible with trimming:

JsonSerializer.Serialize<object>(writer, @class, jsonSerializerOptions);