Trimming/AOT : is it possible to propagate DynamicDependency to all children of a base class?

[CyberSinh]

I use the following code to record some debugging information from exceptions thrown in my program.

I use reflection to extract data from exception properties. Unfortunately, this mechanism no longer works if the program is trimmed.

I've tried to use the DynamicDependency attribute to tell the trimmer to keep all public properties of exceptions, but this indication doesn't seem to apply to child classes derived from the Exception base class, and I haven't found any parameter to specify the scope of this indication to the trimmer.

Is there any other way of making the DynamicDependency attribute applicable to all child classes? Failing that, do you have an alternative design to recommend?

Thanks!

internal class Program
{
   public static void Main()
   {
      ExceptionData? data = null;
      try
      {
         throw new ArgumentException("Fake message", "fakeParam");
      }
      catch (Exception ex)
      {
         data = new ExceptionData(ex);
      }

      if (data.Data!.TryGetValue(nameof(ArgumentException.ParamName), out string? value) && value == "fakeParam")
         Console.WriteLine("ok"); // if not trimmed
      else
         Console.WriteLine("not ok"); // if trimmed because the ArgumentException.ParamName property is not kept by the trimmer
   }
}

public class ExceptionData
{
   public Dictionary<string, string?>? Data { get; }

   [DynamicDependency(DynamicallyAccessedMemberTypes.PublicProperties, typeof(Exception))]
   // TODO : how to tell the trimmer to keep all properties of all classes that inherit from the Exception base class (and not only the Exception class)
   public ExceptionData(Exception exception)
   {
      Type type = exception.GetType();
      PropertyInfo[] properties = type.GetProperties(); // warning IL2075 from the linker
      var data = new Dictionary<string, string?>(properties.Length);

      foreach (PropertyInfo property in properties)
      {
         object? value = property.GetValue(exception);
         if (value != null)
            data.Add(property.Name, value.ToString());
      }

      Data = data;
   }
}

cc @MichalStrehovsky @eerhardt @vitek-karas

[MichalStrehovsky]

There is no mechanism to do this, sorry. This pattern is not compatible with trimming.

The main reason there are no facilities for this is that it would be too easy to end up with code that completely prevents trimming - e.g. replace Exception with object, or any other popular base class (what is a popular base class changes from appmodel to appmodel).

[CyberSinh]

I understand. But the possibility of extending DynamicDependency to child classes would be on an opt-in basis. This would put the responsibility back on the developers.

Taking the extreme case you give as an example (keeping all properties of all .NET classes - I confess I can't think of any scenarios in which this would be relevant), using the trimming feature could still be useful: while properties would be kept, all unused methods would be removed. The gain in size would still be significant.

By not giving developers the flexibility to define what they want to keep, you're simply depriving them of the possibility of using the trimming feature, when it could offer a space saving that's always worth taking.

[MichalStrehovsky]

If you want to see more of the problems that such feature would bring, consider:

class EvilException : Exception
{
    public object Property { [RequiresUnreferencedCode("")] get; }
}

Now the DynamicDependency should trigger a warning, because we're trying to reflect on a property marked as trim-unsafe. But this would never trigger a warning in the Roslyn analyzer because we don't know what are all the exception types in the app. This would lead to situations where a NuGet that defines EvilException is trim safe and no issue can be detected, the NuGet that declares the DynamicDependency on all properties of all Exception descendants is trim safe and no issue can be detected, but when combined, one gets trimming warnings that are not actionable.

[CyberSinh]

I can't help thinking that the trimming feature has a lot of potential and would benefit from covering more scenarios.
Is there anything on the roadmap to improve the compatibility of trimming with the use of reflection?

[MichalStrehovsky]

Your scenario is similar to the "reflection based serialization" bucket that we keep thinking about, but don't have anything that works with static analysis right now.