Add trimming annotation (requires also targeting .NET 6 or greater)

[Susko3]

I've recently run into an issue with AutoMapper related to assembly trimming. Even though AutoMapper itself isn't marked IsTrimmable, it depends on libraries marked as such (in the issue I experienced, it's the System.Runtime assembly).

The proper way to solve this problem is to annotate the library with trimmer-specific attributes following the Prepare .NET libraries for trimming guide. I would like to help out with that.

The attributes shown in that guide (eg. DynamicallyAccessedMembers, RequiresUnreferencedCode) are only compatible on .NET 5 and above. AutoMapper currently only targets netstandard2.1. Would it be possible to also target net6.0 for the library? I tried a local Build.ps1 and it seemed to work fine with some minor tweaks.

diff --git a/src/AutoMapper/AutoMapper.csproj b/src/AutoMapper/AutoMapper.csproj
index 1172b2f7..d93b2916 100644
--- a/src/AutoMapper/AutoMapper.csproj
+++ b/src/AutoMapper/AutoMapper.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Summary>A convention-based object-object mapper.</Summary>
     <Description>A convention-based object-object mapper.</Description>
-    <TargetFrameworks>netstandard2.1</TargetFrameworks>
+    <TargetFrameworks>netstandard2.1;net6.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>AutoMapper</AssemblyName>
     <AssemblyOriginatorKeyFile>..\..\AutoMapper.snk</AssemblyOriginatorKeyFile>
diff --git a/src/AutoMapper/Configuration/Profile.cs b/src/AutoMapper/Configuration/Profile.cs
index 499b7fb3..7ad10a74 100644
--- a/src/AutoMapper/Configuration/Profile.cs
+++ b/src/AutoMapper/Configuration/Profile.cs
@@ -1,5 +1,6 @@
 using System.Runtime.CompilerServices;
 using AutoMapper.Configuration.Conventions;
+using TypeExtensions = AutoMapper.Internal.TypeExtensions;
 namespace AutoMapper;
 public interface IProfileConfiguration
 {
diff --git a/src/AutoMapper/Execution/ObjectFactory.cs b/src/AutoMapper/Execution/ObjectFactory.cs
index a43dbbe9..59843487 100644
--- a/src/AutoMapper/Execution/ObjectFactory.cs
+++ b/src/AutoMapper/Execution/ObjectFactory.cs
@@ -1,4 +1,5 @@
 using System.Collections.ObjectModel;
+using TypeExtensions = AutoMapper.Internal.TypeExtensions;
 namespace AutoMapper.Execution;
 [EditorBrowsable(EditorBrowsableState.Never)]
 public static class ObjectFactory

Since the attributes are unavailable on netstandard2.1, they need to be put in between NET6_0_OR_GREATER, which does look a bit ugly:

public readonly record struct TypePair(
#if NET6_0_OR_GREATER
    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
#endif
    Type SourceType,
#if NET6_0_OR_GREATER
    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
#endif
    Type DestinationType)

[lbargaoanu]

We've done multitargeting and I'd rather not go there again :) But replacing .NET Standard with .NET 6 seems like a good idea to me. That would be a major version bump and I think we should release 12.0.1 first. cc @jbogard.
https://dotnet.microsoft.com/en-us/platform/support/policy/dotnet-core#lifecycle

[lbargaoanu]

Details aside, AM is AOT unfriendly by design. It relies on reflection and generates code at runtime. So I don't think those annotations will do much good. Maybe you would get some warning when using any AM API. That wouldn't help much.

[Susko3]

Maybe you would get some warning when using any AM API.

On an app that enables trimming, warnings should already be showing.

While AM itself probably cannot be fully trim-compatible. Adding some annotations should help.
Some areas that I think adding annotations would be useful:

• TypeExtensions
  • Some reflection usage goes trough these extenstions, including a lot of system types explicitly via typeof (the system assemblies support trimming, so those are trimmed out, while the entirety of automapper may be left intact).
• High-level annotation in Automapper.Configuration / any public API entry point
  • any types passed as TSource, TDestination, etc. should be annotated with DynamicallyAccessedMemberTypes.All to preserve members that might get accessed trough reflection by the rest of the code.
• Any explicit usage of typeof (eg. on a System.** class)

Having those annotations should reduce that chance of things failing when trimming is enabled (the default in .NET 7).

[lbargaoanu]

That sounds like a lot of work for little benefit. Any public API could be using reflection. Both on user and system types. I get it how for some libraries this would help, when reflection is used in only a few places, on a few types, but for AM, I'm not sure. You can look into it, but I, for one, would rather not see these annotations all over our code base. And I'm not sure how you could limit the scope. Are there other reflection heavy libraries that did this?