Allow to apply DynamicallyAccessedMembers recursively for type members

[Dreamescaper]

I'm wondering whether it would be possible for something like this to happen:

MyMethod<TypeWithNestedTypeProperty>(item);

void MyMethod
<[DynamicallyAccessedMembers(
   DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties,
   ApplyRecursively = true)] T>
(T item) 
{
}

class TypeWithNestedTypeProperty
{
    public string Id { get; set; }
    public string Name { get; set; }
    public SubType SubType { get; set; }
}

class SubType
{
    public string SubName { get; set; }
}

Basically, the suggestion is to add ApplyRecursively property to DynamicallyAccessedMembers attribute. It would instruct the linker to preserve not only member of the target type, but also apply it recursively - in this case, to SubType type - preserving its public properties and constructors.

I realize that the proper way to handle such cases - is via source generation. But I think that most libraries (especially smaller ones) will not create their source generators.

[MichalStrehovsky]

This doesn't currently exists. We considered adding it, but in the end none of the reflection-based serializers that we looked at would be able to use this. The places where a simple recursive enumeration fell apart were things like:

• Collections, arrays, dictionaries
• Polymorphic serialization

[Dreamescaper]

I understand polymorphic serialization, but what's wrong with collections?

[MichalStrehovsky]

How does one recurse into the element of the collection with DynamicallyAccessedMembers? One of the serializers I looked at for example checked if the type implements IList<Something> and if so, treated it as a collection. The point is that there would be no property of type Something on the collection and custom heuristics (as defined by the serializer) are needed to figure out element type.

[Dreamescaper]

There is Items indexer with type Something. Is there any way to preserve indexers via DynamicallyAccessedMembers? Haven't checked whether All / PublicProperties / PublicMethods cover indexers...

Still, serializer could make a choise to support List<T> and T[] specifically, when used with AOT.

Anyway, my point is for lots of libraries people are advised to use [DynamicDependency] and TrimmerRootAssembly when using with AOT (like here aws/aws-sdk-net#3646 ). And it is understandable - writing a source generator is hard, and most libraries won't do that.

Therefore, I think such addition would make life a bit easier... even if it won't cover 100% of cases.