HybridCache : simplify AOT usage with default JSON serialization

src/Libraries/Microsoft.Extensions.Caching.Hybrid/HybridCacheBuilderExtensions.cs

@@ -2,7 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
 using Microsoft.Extensions.Caching.Hybrid;
+using Microsoft.Shared.DiagnosticIds;
 using Microsoft.Shared.Diagnostics;
 
 namespace Microsoft.Extensions.DependencyInjection;
@@ -59,4 +61,27 @@ public static IHybridCacheBuilder AddSerializerFactory<
         _ = Throw.IfNull(builder).Services.AddSingleton<IHybridCacheSerializerFactory, TImplementation>();
         return builder;
     }
+
+    /// <summary>
+    /// Register a default <see cref="JsonSerializerOptions"/> for use with JSON serialization.
+    /// </summary>
+    /// <returns>The <see cref="IHybridCacheBuilder"/> instance.</returns>
+    [Experimental(DiagnosticIds.Experiments.HybridCache, UrlFormat = DiagnosticIds.UrlFormat)]
+    public static IHybridCacheBuilder WithJsonSerializerOptions(this IHybridCacheBuilder builder, JsonSerializerOptions options)
+    {
+        _ = Throw.IfNull(builder).Services.AddKeyedSingleton<JsonSerializerOptions>(typeof(IHybridCacheSerializer<>), Throw.IfNull(options));
+        return builder;
+    }
+
+    /// <summary>
+    /// Register a <see cref="JsonSerializerOptions"/> for use with JSON serialization of type <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type being serialized.</typeparam>
+    /// <returns>The <see cref="IHybridCacheBuilder"/> instance.</returns>
+    [Experimental(DiagnosticIds.Experiments.HybridCache, UrlFormat = DiagnosticIds.UrlFormat)]
+    public static IHybridCacheBuilder WithJsonSerializerOptions<T>(this IHybridCacheBuilder builder, JsonSerializerOptions options)
+    {
+        _ = Throw.IfNull(builder).Services.AddKeyedSingleton<JsonSerializerOptions>(typeof(IHybridCacheSerializer<T>), Throw.IfNull(options));
+        return builder;
+    }
 }

src/Libraries/Microsoft.Extensions.Caching.Hybrid/Internal/DefaultJsonSerializerFactory.cs

@@ -12,6 +12,9 @@
 
 namespace Microsoft.Extensions.Caching.Hybrid.Internal;
 
+[UnconditionalSuppressMessage("AOT", "IL2026", Justification = "Checked at runtime, guidance issued")]
+[UnconditionalSuppressMessage("AOT", "IL2070", Justification = "Checked at runtime, guidance issued")]
+[UnconditionalSuppressMessage("AOT", "IL3050", Justification = "Checked at runtime, guidance issued")]
 internal sealed class DefaultJsonSerializerFactory : IHybridCacheSerializerFactory
 {
     private readonly IServiceProvider _serviceProvider;
@@ -34,7 +37,7 @@ public bool TryCreateSerializer<T>([NotNullWhen(true)] out IHybridCacheSerialize
 
         // see if there is a per-type options registered (keyed by the **closed** generic type), otherwise use the default
         JsonSerializerOptions options = _serviceProvider.GetKeyedService<JsonSerializerOptions>(typeof(IHybridCacheSerializer<T>)) ?? Options;
-        if (!options.IncludeFields && ReferenceEquals(options, SystemDefaultJsonOptions) && IsFieldOnlyType(typeof(T)))
+        if (!options.IncludeFields && IsDefaultJsonOptions(options) && IsFieldOnlyType(typeof(T)))
         {
             // value-tuples expose fields, not properties; special-case this as a common scenario
             options = FieldEnabledJsonOptions;
@@ -50,11 +53,38 @@ internal static bool IsFieldOnlyType(Type type)
         return IsFieldOnlyType(type, ref state) == FieldOnlyResult.FieldOnly;
     }
 
+    private static bool IsDefaultJsonOptions(JsonSerializerOptions options)
+    {
+        if (!JsonSerializer.IsReflectionEnabledByDefault)
+        {
+            // can't be, since we don't use default options for AOT
+            return false;
+        }
+
 #pragma warning disable IDE0079 // unnecessary suppression: TFM-dependent
 #pragma warning disable IL2026, IL3050 // AOT bits
-    private static JsonSerializerOptions SystemDefaultJsonOptions => JsonSerializerOptions.Default;
+        return ReferenceEquals(options, JsonSerializerOptions.Default);
 #pragma warning restore IL2026, IL3050
 #pragma warning restore IDE0079
+    }
+
+    private static JsonSerializerOptions SystemDefaultJsonOptions
+    {
+        get
+        {
+            if (!JsonSerializer.IsReflectionEnabledByDefault)
+            {
+                throw new NotSupportedException($"When using AOT, {nameof(JsonSerializerOptions)} with {nameof(JsonSerializerOptions.TypeInfoResolver)} specified must be provided via"
+                + $" {nameof(IHybridCacheBuilder)}.{nameof(HybridCacheBuilderExtensions.WithJsonSerializerOptions)}.");
+            }
+
+#pragma warning disable IDE0079 // unnecessary suppression: TFM-dependent
+#pragma warning disable IL2026, IL3050 // AOT bits
+            return JsonSerializerOptions.Default;
+#pragma warning restore IL2026, IL3050
+#pragma warning restore IDE0079
+        }
+    }
 
     [SuppressMessage("Trimming", "IL2070:'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The parameter of method does not have matching annotations.",
         Justification = "Custom serializers may be needed for AOT with STJ")]

src/Libraries/Microsoft.Extensions.Caching.Hybrid/Microsoft.Extensions.Caching.Hybrid.csproj

@@ -23,6 +23,11 @@
     <DisableMicrosoftExtensionsLoggingSourceGenerator>false</DisableMicrosoftExtensionsLoggingSourceGenerator>
   </PropertyGroup>
 
+  <PropertyGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">
+    <IsTrimmable>true</IsTrimmable>
+    <IsAotCompatible>true</IsAotCompatible>
+  </PropertyGroup>
+
   <PropertyGroup>
     <Stage>normal</Stage>
     <MinCodeCoverage>82</MinCodeCoverage>

src/Shared/DiagnosticIds/DiagnosticIds.cs

@@ -45,6 +45,7 @@ internal static class Experiments
         internal const string DocumentDb = "EXTEXP0011";
         internal const string AutoActivation = "EXTEXP0012";
         internal const string HttpLogging = "EXTEXP0013";
+        internal const string HybridCache = "EXTEXP0018";
     }
 
     internal static class LoggerMessage

test/Libraries/Microsoft.Extensions.AotCompatibility.TestApp/Microsoft.Extensions.AotCompatibility.TestApp.csproj

@@ -17,8 +17,6 @@
     <LibraryProjects Include="$(RepoRoot)\src\Libraries\**\*.csproj" />
     <!-- https://github.com/Azure/azure-sdk-for-net/issues/47069 -->
     <LibraryProjects Remove="$(RepoRoot)\src\Libraries\Microsoft.Extensions.AI.AzureAIInference\Microsoft.Extensions.AI.AzureAIInference.csproj" />
-    <!-- https://github.com/dotnet/extensions/issues/5624 -->
-    <LibraryProjects Remove="$(RepoRoot)\src\Libraries\Microsoft.Extensions.Caching.Hybrid\Microsoft.Extensions.Caching.Hybrid.csproj" />
     <!-- https://github.com/dotnet/extensions/issues/5623 -->
     <LibraryProjects Remove="$(RepoRoot)\src\Libraries\Microsoft.Extensions.Compliance.Redaction\Microsoft.Extensions.Compliance.Redaction.csproj" />
     <!-- https://github.com/dotnet/extensions/issues/5625 -->

test/Libraries/Microsoft.Extensions.Caching.Hybrid.Tests/SerializerTests.cs

@@ -236,20 +236,20 @@ public class NodeB<T>
     private static T RoundTrip<T>(T value, ReadOnlySpan<byte> expectedBytes, JsonSerializer expectedJsonOptions, JsonSerializer addSerializers = JsonSerializer.None, bool binary = false)
     {
         var services = new ServiceCollection();
-        services.AddHybridCache();
+        var hc = services.AddHybridCache();
         JsonSerializerOptions? globalOptions = null;
         JsonSerializerOptions? perTypeOptions = null;
 
         if ((addSerializers & JsonSerializer.CustomGlobal) != JsonSerializer.None)
         {
             globalOptions = new() { IncludeFields = true }; // assume any custom options will serialize the whole type
-            services.AddKeyedSingleton<JsonSerializerOptions>(typeof(IHybridCacheSerializer<>), globalOptions);
+            hc.WithJsonSerializerOptions(globalOptions);
         }
 
         if ((addSerializers & JsonSerializer.CustomPerType) != JsonSerializer.None)
         {
             perTypeOptions = new() { IncludeFields = true }; // assume any custom options will serialize the whole type
-            services.AddKeyedSingleton<JsonSerializerOptions>(typeof(IHybridCacheSerializer<T>), perTypeOptions);
+            hc.WithJsonSerializerOptions<T>(perTypeOptions);
         }
 
         JsonSerializerOptions? expectedOptionsObj = expectedJsonOptions switch