Native-AOT-Kompilierung

Was ist Native AOT?

Wann Sie Native AOT verwenden sollten

// Ideal use cases:
// - Serverless functions (AWS Lambda, Azure Functions)
// - High-throughput microservices (fast cold start)
// - CLI tools shipped as single-file executables
// - IoT / embedded scenarios

// Poor fit:
// - Apps using extensive reflection (e.g., dynamic proxies)
// - Apps loading plugins at runtime
// - Apps depending on libraries that don't support trimming

// Key benefits:
// - Sub-10ms startup time (vs 200-500ms for JIT)
// - Lower memory at startup (no JIT overhead)
// - Smaller attack surface (no JIT engine)

Mit Native AOT veröffentlichen

// .csproj:
<PropertyGroup>
  <PublishAot>true</PublishAot>
  <!-- Optional: disable invariant globalization for smaller binary -->
  <InvariantGlobalization>true</InvariantGlobalization>
</PropertyGroup>

// Publish for Linux x64:
dotnet publish -r linux-x64 -c Release

// Publish for Windows x64:
dotnet publish -r win-x64 -c Release

// Output: bin/Release/net9.0/linux-x64/publish/MyApp
// Single executable, no dotnet runtime required

Minimal API mit Native AOT

// dotnet new webapiaot -n FastApi

// Program.cs generated template:
var builder = WebApplication.CreateSlimBuilder(args); // AOT-optimized

// Must register serialization context for AOT:
builder.Services.ConfigureHttpJsonOptions(opts =>
    opts.SerializerOptions.TypeInfoResolverChain.Insert(0,
        AppJsonSerializerContext.Default));

var app = builder.Build();
app.MapGet("/hello", () => new Message("Hello, Native AOT!"));
app.Run();

record Message(string Text);

[JsonSerializable(typeof(Message))]
internal partial class AppJsonSerializerContext : JsonSerializerContext { }

Quellcodegenerierte JSON-Serialisierung

// Define types to serialize:
public record Product(int Id, string Name, decimal Price);
public record OrderDto(int OrderId, List<Product> Items);

// Create a JsonSerializerContext for AOT:
[JsonSerializable(typeof(Product))]
[JsonSerializable(typeof(OrderDto))]
[JsonSerializable(typeof(List<Product>))]
internal partial class MyJsonContext : JsonSerializerContext { }

// Serialize / deserialize without reflection:
var json = JsonSerializer.Serialize(product, MyJsonContext.Default.Product);
var product = JsonSerializer.Deserialize(json, MyJsonContext.Default.Product);

Trimming-Warnungen

// .csproj: treat warnings as errors in CI
<PropertyGroup>
  <PublishAot>true</PublishAot>
  <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  <TrimmerRootDescriptor>TrimmerRoots.xml</TrimmerRootDescriptor>
</PropertyGroup>

// Suppressing a specific warning when you know it is safe:
[DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(MyClass))]
public static void EnsureMyClassSurvivesTrimming() { }

// Or annotate parameters:
public static void Register(
    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
    Type serviceType) { }

AOT-Kompatibilitätsanalyse

// Enable analysis without actually publishing AOT:
<PropertyGroup>
  <EnableAotAnalyzer>true</EnableAotAnalyzer>
  <EnableTrimAnalyzer>true</EnableTrimAnalyzer>
  <EnableSingleFileAnalyzer>true</EnableSingleFileAnalyzer>
</PropertyGroup>

// Run:
// dotnet build
// => analyzer reports issues in build output

// Common warnings:
// IL2026: member uses RequiresUnreferencedCode
// IL2046: member annotated with RequiresUnreferencedCode derives from unannotated
// IL3050: member uses RequiresDynamicCode

Vergleich der Startleistung

// Typical Minimal API measurements:
// JIT (.NET 9, linux-x64):
//   Startup time:  ~180ms
//   Memory (RSS):  ~60 MB
//   Publish time:  ~5s
//   Executable:    self-contained ~80 MB

// Native AOT (.NET 9, linux-x64):
//   Startup time:  ~5ms   (36x faster)
//   Memory (RSS):  ~20 MB (3x less)
//   Publish time:  ~30s   (6x slower to build)
//   Executable:    ~10 MB (8x smaller)

// For AWS Lambda / Azure Container Apps:
// AOT cold start: <10ms vs JIT: 300-500ms = significant billing savings

Praxisbeispiel: Lambda-Funktion mit AOT

// dotnet new lambda.NativeAOT

// .csproj:
// <PublishAot>true</PublishAot>
// <StripSymbols>true</StripSymbols>

public class Function
{
    [JsonSerializable(typeof(APIGatewayProxyRequest))]
    [JsonSerializable(typeof(APIGatewayProxyResponse))]
    internal partial class LambdaContext : JsonSerializerContext { }

    static async Task Main()
    {
        Func<APIGatewayProxyRequest, ILambdaContext, APIGatewayProxyResponse>
            handler = FunctionHandler;

        await LambdaBootstrapBuilder
            .Create(handler, LambdaContext.Default.APIGatewayProxyRequest)
            .Build()
            .RunAsync();
    }

    static APIGatewayProxyResponse FunctionHandler(
        APIGatewayProxyRequest req, ILambdaContext ctx)
        => new() { StatusCode = 200, Body = "{\"status\":\"ok\"}" };
}

Kurzer Check

Zusammenfassung: Native-AOT-Kompilierung