HybridCache : simplify AOT usage with default JSON serialization #6475

mgravell · 2025-05-21T10:12:58Z

don't touch JsonSerializerOptions.Default in AOT mode
add new extension methods to register JsonSerializerOptions (these are convenience methods on an existing registration pattern)
offer a suitable runtime error message instead, if no JSON options supplied in AOT mode
include [UnconditionalSuppressMessage] to prevent build-time consumer warnings

This has been tested successfully with an AOT published project; it now works correctly at runtime with zero build-time warnings, test code shown below; without the WithJsonSerializerOptions line, exception at runtime:

When using AOT, JsonSerializerOptions with TypeInfoResolver specified must be provided via IHybridCacheBuilder.WithJsonSerializerOptions.

Without this work, it is not obvious how to register AOT JSON options, and the consumer must use <NoWarn>$(NoWarn);IL2026;IL2104;IL3053</NoWarn> or similar to get a clean build, which is too wide.

open questions:

API naming: With* or Add* ?
which API review process should this follow?

Sample:

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Text.Json;
using System.Text.Json.Serialization;
using Microsoft.Extensions.Caching.Hybrid;
using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();
var jsonOptions = new JsonSerializerOptions() { TypeInfoResolver = Bar.MyJsonSerializationContext.Default };
services.AddHybridCache().WithJsonSerializerOptions(jsonOptions);
services.AddStackExchangeRedisCache(options => options.Configuration = "localhost:6379");
using var provider = services.BuildServiceProvider();

var cache = provider.GetRequiredService<HybridCache>();

int id = 42;
var obj = await cache.GetOrCreateAsync($"/ob/{id}", ct => GetTheThingAsync(id));
Console.WriteLine(obj.Id);

static ValueTask<Bar.Foo> GetTheThingAsync(int id) => new(new Bar.Foo(id));

namespace Bar
{
    [JsonSourceGenerationOptions(WriteIndented = true)]
    [JsonSerializable(typeof(Foo))]
    internal partial class MyJsonSerializationContext : JsonSerializerContext
    {
    }

    internal sealed class Foo(int id)
    {
        public int Id => id;
    }
}

Microsoft Reviewers: Open in CodeFlow

2. add new extension methods to register JsonSerializerOptions 3. offer a suitable error message instead, if none supplied in AOT mode open question: naming: With* or Add* ?

mgravell · 2025-05-21T11:11:09Z

CI build fail is because of API delta:

error LA0003: (NETCORE_ENGINEERING_TELEMETRY=Build) Newly added symbol 'Microsoft.Extensions.DependencyInjection.HybridCacheBuilderExtensions.WithJsonSerializerOptions(Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder, System.Text.Json.JsonSerializerOptions)' must be marked as experimental

This in in turn tied into the open "which API review process should this follow?" question; however, I'll add the attribute for now

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

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

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

eerhardt · 2025-05-21T22:19:51Z

This should be able to resolve Microsoft.Extensions.Caching.Hybrid is not trim/AOT compatible (dotnet/extensions#5624).

eerhardt · 2025-05-21T22:21:11Z

We should remove

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

Lines 20 to 21 in 6f29ab5

    
           <!-- https://github.com/dotnet/extensions/issues/5624 --> 
        
           <LibraryProjects Remove="$(RepoRoot)\src\Libraries\Microsoft.Extensions.Caching.Hybrid\Microsoft.Extensions.Caching.Hybrid.csproj" />

as well. We should make the library trimming and AOT compatible.

eerhardt · 2025-05-23T21:43:02Z

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

  </PropertyGroup>

+  <PropertyGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">
+    <IsTrimmable>true</IsTrimmable>
+    <IsAotCompatible>true</IsAotCompatible>


Suggested change

</PropertyGroup>

<PropertyGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">

<IsTrimmable>true</IsTrimmable>

<IsAotCompatible>true</IsAotCompatible>

<IsAotCompatible Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">true</IsAotCompatible>

You only need to set IsAotCompatible. It will default IsTrimmable. See https://github.com/dotnet/sdk/blob/fd301ec19c3190b8129b28847d6faed9d26bc0d3/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Publish.targets#L24

eerhardt · 2025-05-23T21:44:37Z

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

+[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")]


These should be moved even more local to only suppress around the lines of code that need it. Doing it the current way will suppress it for all new code written in this class, which isn't correct.

Also, is there a better Justifcation that can be written here? A little more of a reason why this is OK.

See

https://github.com/dotnet/aspnetcore/blob/5678f227fafa5dcd10b98801d4da54f1add7de6d/src/Http/Http.Results/src/HttpResultsHelper.cs#L22-L24

extensions/src/Libraries/Microsoft.Extensions.AI.Abstractions/Utilities/AIJsonUtilities.Defaults.cs

Lines 41 to 57 in 6f29ab5

[UnconditionalSuppressMessage("AotAnalysis", "IL3050", Justification = "DefaultJsonTypeInfoResolver is only used when reflection-based serialization is enabled")]

[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026", Justification = "DefaultJsonTypeInfoResolver is only used when reflection-based serialization is enabled")]

private static JsonSerializerOptions CreateDefaultOptions()

{

// Copy configuration from the source generated context.

JsonSerializerOptions options = new(JsonContext.Default.Options)

{

Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,

};

if (JsonSerializer.IsReflectionEnabledByDefault)

{

// If reflection-based serialization is enabled by default, use it as a fallback for all other types.

// Also turn on string-based enum serialization for all unknown enums.

options.TypeInfoResolverChain.Add(new DefaultJsonTypeInfoResolver());

options.Converters.Add(new JsonStringEnumConverter());

}

for some examples.

1. don't touch JsonSerializerOptions.Default in AOT mode

118bdf9

2. add new extension methods to register JsonSerializerOptions 3. offer a suitable error message instead, if none supplied in AOT mode open question: naming: With* or Add* ?

mgravell requested a review from a team as a code owner May 21, 2025 10:12

github-actions bot added the area-caching-hybrid label May 21, 2025

dotnet-policy-service bot assigned mgravell May 21, 2025

mgravell requested review from sebastienros and eerhardt May 21, 2025 10:13

Use the new API in the tests

4b62673

mark new APIs as [Experimental]

b5eb531

mgravell requested a review from a team as a code owner May 21, 2025 11:18

eerhardt reviewed May 21, 2025

View reviewed changes

src/Libraries/Microsoft.Extensions.Caching.Hybrid/Internal/DefaultJsonSerializerFactory.cs Show resolved Hide resolved

PR feedback

7d862c5

This was referenced May 22, 2025

Microsoft.Extensions.Caching.Hybrid is not trim/AOT compatible #5624

Open

HybridCache doc -- Add AOT, explain immutable, and edit pass using Acrolinx dotnet/AspNetCore.Docs#35508

Open

mgravell requested a review from eerhardt May 22, 2025 08:59

eerhardt reviewed May 23, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

HybridCache : simplify AOT usage with default JSON serialization #6475

HybridCache : simplify AOT usage with default JSON serialization #6475

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

	[UnconditionalSuppressMessage("AotAnalysis", "IL3050", Justification = "DefaultJsonTypeInfoResolver is only used when reflection-based serialization is enabled")]
	[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026", Justification = "DefaultJsonTypeInfoResolver is only used when reflection-based serialization is enabled")]
	private static JsonSerializerOptions CreateDefaultOptions()
	{
	// Copy configuration from the source generated context.
	JsonSerializerOptions options = new(JsonContext.Default.Options)
	{
	Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
	};

	if (JsonSerializer.IsReflectionEnabledByDefault)
	{
	// If reflection-based serialization is enabled by default, use it as a fallback for all other types.
	// Also turn on string-based enum serialization for all unknown enums.
	options.TypeInfoResolverChain.Add(new DefaultJsonTypeInfoResolver());
	options.Converters.Add(new JsonStringEnumConverter());
	}

HybridCache : simplify AOT usage with default JSON serialization #6475

Are you sure you want to change the base?

HybridCache : simplify AOT usage with default JSON serialization #6475

Uh oh!

Conversation

Uh oh!

Microsoft Reviewers: Open in CodeFlow

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!