AOT build warning: IL2026 triggered by JsonSerializer.Deserialize usage

[IchiSamaFR]

Actually working on a MAUI project for Android and iOS and i get this warning causing errors when calling the library.

The IL2026 warning indicates that using JsonSerializer.Deserialize may cause issues when building with AOT (Ahead-Of-Time) compilation.
This is because the dynamic code generation required for serialization and deserialization is not always compatible with AOT environments.
As a result, you may encounter runtime exceptions or incomplete data deserialization on platforms like iOS in Release mode.

Here is my error :

'GoogleMapsApi.Entities.PlaceAutocomplete.Response.Status[]' is missing native code or metadata.
This can happen for code that is not compatible with trimming or AOT.
Inspect and fix trimming and AOT related warnings that were generated when the app was published.
For more information see https://aka.ms/nativeaot-compatibility Path: $.status I LineNumber: 234 I BytePositionlnLine: 18

[maximn]

Thanks for the report — confirmed. The library deserializes with reflection-based System.Text.Json plus a JsonConverterFactory for enums, which the iOS trimmer/NativeAOT strips. That's why Status[] shows up as "missing native code or metadata."

Workaround for now: in your MAUI .csproj, root the assembly so the trimmer keeps its metadata:

<ItemGroup>
  <TrimmerRootAssembly Include="GoogleMapsApi" />
</ItemGroup>

This unblocks legacy trimming. If you're on full NativeAOT it'll reduce the failures but not eliminate them, since dynamic code is still required by the enum converter factory.

Real fix is to add a source-generated JsonSerializerContext and replace the enum converter factory with per-enum converters. Tracking it for a future release — ETA depends on bandwidth, but the work is scoped (~a week). PRs welcome if anyone wants to take a stab.

[IchiSamaFR]

I already test the TrimmerRootAssembly but didn't work at all.

I added the GoogleApsApi as submodule and resolved it for my solution.
Just need some time for cleaning the code and i'll make a PR tomorrow i think.

[maximn]

Appreciate you picking this up! A few notes to keep the PR mergeable, since AOT-safe JSON touches a lot of the surface area:

• Please use System.Text.Json source generators (JsonSerializerContext with JsonSourceGenerationOptions) rather than reflection-based or Newtonsoft paths. That's the only approach that actually eliminates IL2026/IL3050.
• Replace the enum JsonConverterFactory with per-enum converters (or [JsonStringEnumConverter<T>] on .NET 8+ with conditional compilation for older TFMs). The factory pattern is what trips NativeAOT.
• Keep the existing multi-target matrix (net8.0;net6.0;netstandard2.0;net481;net462) green — source generators are fine on the modern TFMs, but you'll likely need #if guards for netstandard2.0 and the .NET Framework targets.
• Existing integration tests should pass unchanged. If you have to change a response shape, flag it — we don't want a silent breaking change.
• Keep the PR scoped to the AOT fix. No drive-by refactors; easier to review and revert if needed.

Ping me when it's up and I'll review promptly.

[maximn]

Pushed a repro at #217 (draft, intentionally red — do not merge). It just flips on IsAotCompatible for net8.0 and promotes IL2026/IL2104/IL3050/IL3053 to errors. No source changes.

Today it fails with 5 errors that line up with the consumer-side failure:

• Engine/MapsAPIGenericEngine.cs:39 — JsonSerializer.Deserialize<T> (IL2026 + IL3050)
• Engine/JsonConverters/EnumMemberJsonConverter.cs — Enum.GetValues(Type) ×2 and Type.MakeGenericType in EnumMemberJsonConverterFactory (IL3050)

Acceptance criterion for the AOT fix PR: dotnet build GoogleMapsApi -f net8.0 -c Release is green with #217's csproj change applied. That's the exact surface the source-generated JsonSerializerContext + per-enum converters need to cover.

[IchiSamaFR]

As far as i found i was unable to stop the message from displaying.
You can apply correction which will lead to a functional code but the warning message still displayed.
See : develop/AOT_IL2026
Still have some code to change like EnumMemberJsonConverter and compatibility with NetFramework

[maximn]

Thanks for sharing the branch — I dug into it and I can see why the warning is still firing, plus a couple of correctness issues you'll want to know about before the PR is ready.

1. The source-gen context isn't actually wired in — that's why IL2026 still shows.

GoogleMapsJsonSerializerContext is defined, but MapsAPIGenericEngine.cs:38 calls:

return JsonSerializer.Deserialize<TResponse>(responseContent)!;

With no JsonSerializerOptions and no JsonTypeInfo, that overload uses the reflection-based serializer — exactly the call site IL2026/IL3050 are warning about. To actually consume the source-gen context with a generic TResponse, you need to route through JsonTypeInfo, e.g.:

var typeInfo = (JsonTypeInfo<TResponse>)GoogleMapsJsonSerializerContext.Default.GetTypeInfo(typeof(TResponse))!;
return JsonSerializer.Deserialize(responseContent, typeInfo)!;

Until the call site uses a JsonSerializerContext/JsonTypeInfo<T> overload, the warning won't go away no matter what else changes.

2. EnumMemberJsonConverter now silently breaks [EnumMember] mappings.

The new Read uses Enum.TryParse<TEnum>(stringValue, true, ...). That works when the JSON string equals the C# member name case-insensitively ("OK" → OK, "DRIVING" → Driving), but it does not honor [EnumMember(Value = "...")]. Concretely, GoogleMapsApi.Entities.Common.LocationType has values like [EnumMember(Value = "street_address")] StreetAddress — "street_address" will no longer parse and any response containing it will throw. Same shape for BusinessStatus, InputType, and Type. Write has the inverse problem: value.ToString() returns StreetAddress instead of "street_address".

The source-generated approach for this is per-enum JsonConverter<T> implementations that read the EnumMemberAttribute once into a static lookup (no Enum.GetValues(Type) / reflection at runtime on the hot path) — or even simpler, hand-write the value↔name dictionaries in each converter for AOT cleanliness. [JsonStringEnumConverter<T>] doesn't help here because Google uses snake_case/SCREAMING_SNAKE_CASE that doesn't map mechanically to PascalCase.

3. Deleting JsonSerializerConfiguration drops three real converters.

PriceLevelJsonConverter, OverviewPolylineJsonConverter, and DurationJsonConverter<> were registered there. Only PriceLevelJsonConverter is also referenced via a [JsonConverter] attribute (PlacesDetails/Response/Result.cs:125); the other two relied entirely on options registration. Without them, overview_polyline and Duration payloads will deserialize incorrectly. Either re-register them on the options passed alongside the context, or add [JsonConverter(...)] attributes on the affected properties.

Quick way to validate while you iterate: rebase your branch onto #217 (or copy that csproj snippet in) — the build will fail until all three are addressed, and the error list shrinking to zero is the signal you're done. Existing integration tests should still pass; if any response shape regresses (especially anything involving LocationType or Duration), that's the smoking gun for #2 or #3.

Happy to review the PR once it's up.

[maximn]

Note that I'm doing some extensive modernization these days so the project changes a lot @IchiSamaFR