The Three Execution Models

Each has its place in the ecosystem

Regular .NET - Traditional JIT

IL = Intermediate Language | JIT = Just-In-Time

Regular .NET - Pros & Cons

ReadyToRun (R2R) - Hybrid Approach

Key Point: Ships BOTH IL and precompiled native images

ReadyToRun - Pros & Cons

NativeAOT - Ahead-of-Time

🎯 Single native executable, no CLR needed!

NativeAOT - Pros & Cons

Startup Flow Comparison

AOT eliminates the two slowest steps! ⚡

The Serverless Challenge

NativeAOT eliminates steps 3 & 4 entirely!

Key Benefits Summary

Deploy Latest .NET Today

Don't wait for AWS to support new runtimes!

Test Methodology

❄️ Cold Start Comparison

7.1× faster (Regular → AOT .NET 10)

🔥 Warm Execution Comparison

6.5× faster (Regular → AOT .NET 9)

💾 Memory Usage

52% less memory (Regular → AOT .NET 10)

📈 Detailed Results

💰 Cost Implications

Monthly Cost @ 10M Requests

Savings: 73% lower cost with AOT! 💰

Project Configuration - Regular

<!-- LambdaRegularDemo.csproj -->
<PropertyGroup>
  <OutputType>Library</OutputType>
  <TargetFramework>net8.0</TargetFramework>
  <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
  <PublishAot>false</PublishAot>
  <PublishReadyToRun>false</PublishReadyToRun>
</PropertyGroup>

OutputType = Library (uses Lambda runtime)

Project Configuration - ReadyToRun

<!-- LambdaReadyToRunDemo.csproj -->
<PropertyGroup>
  <OutputType>Library</OutputType>
  <TargetFramework>net8.0</TargetFramework>
  <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
  <PublishReadyToRun>true</PublishReadyToRun>
  <TrimMode>partial</TrimMode>
</PropertyGroup>

Just add PublishReadyToRun=true! One line change.

Project Configuration - NativeAOT

<!-- LambdaAOTDemo9.csproj -->
<PropertyGroup>
  <OutputType>Exe</OutputType> <!-- MUST be Exe -->
  <TargetFramework>net9.0</TargetFramework>
  <RuntimeIdentifiers>linux-x64</RuntimeIdentifiers>
  <PublishAot>true</PublishAot>
  <SelfContained>true</SelfContained>
  <StripSymbols>true</StripSymbols>
  <TrimMode>partial</TrimMode>
  <InvariantGlobalization>true</InvariantGlobalization>
</PropertyGroup>

Key: OutputType=Exe produces native executable

Build Process Comparison

dotnet publish -c Release -o ./publish
zip -r lambda.zip ./publish/*
# Output: Multiple DLLs

dotnet publish -c Release -o ./publish
mv ./publish/LambdaAOTDemo9 ./publish/bootstrap
zip -r lambda.zip ./publish/bootstrap
# Output: Single 'bootstrap' binary

📦 Package Contents

⚠️ The Reflection Challenge

✅ Solution: JSON Source Generation

var json = JsonSerializer.Serialize(input);

[JsonSerializable(typeof(Dictionary<string, string>))]
[JsonSerializable(typeof(Guid))]
public partial class AOTJsonContext 
    : JsonSerializerContext { }

// Usage:
var json = JsonSerializer.Serialize(input, 
    AOTJsonContext.Default.DictionaryStringString);

✅ Solution: Constructor Injection

// ✅ AOT-Friendly: Constructor Injection
public class Function
{
    private readonly IDynamoDBRepository _repo;

    public Function(IDynamoDBRepository repo)
    {
        _repo = repo;  // Type known at compile time
    }

    public async Task<Guid> FunctionHandler(
        Dictionary<string, string> input, 
        ILambdaContext context)
    {
        return await _repo.CreateAsync(cts.Token);
    }
}

✅ Solution: Explicit Service Registration

services.AddFromAssembly(
    typeof(Startup).Assembly);

public void ConfigureServices(
    IServiceCollection services)
{
    services.AddSingleton<IAmazonDynamoDB, 
        AmazonDynamoDBClient>();
    services.AddSingleton<IDynamoDBRepository, 
        DynamoDbRepository>();
    services.AddTransient<Function>();
}

⚠️ Trimming Warnings

warning IL2026: Using member 'Type.GetType(string)' 
which has 'RequiresUnreferencedCodeAttribute' can break 
functionality when trimming application code.

Migration Path Overview

Don't migrate everything at once. Start with non-critical functions.

Phase 1: Assessment

<PropertyGroup>
  <EnableTrimAnalyzer>true</EnableTrimAnalyzer>
</PropertyGroup>

ReadyToRun as Stepping Stone

<!-- Quick win: 34% faster cold starts -->
<PropertyGroup>
  <PublishReadyToRun>true</PublishReadyToRun>
  <TrimMode>partial</TrimMode>
</PropertyGroup>

Quick Decision Guide

Use Case Matrix

Limitations Summary

Key Takeaways

1. AOT delivers real gains: 7× cold start, 6× warm, 50% memory
2. Deploy .NET 9/10 today on Lambda via custom runtime
3. AOT requires discipline: Source generators, constructor injection
4. Start preparing now: Adopt patterns even on Regular
5. R2R is viable middle ground: 34% improvement, low risk
6. Measure your workload: Results vary by application
7. The future is AOT: Each .NET version improves further

Quick Wins to Start Today

// Even if staying on Regular .NET:

// 1. Adopt JSON source generation
[JsonSerializable(typeof(MyModel))]
public partial class AppJsonContext : JsonSerializerContext { }

// 2. Use constructor injection
public MyService(IRepository repo) => _repo = repo;

// 3. Enable trim analyzers
// <EnableTrimAnalyzer>true</EnableTrimAnalyzer>

// 4. Avoid reflection patterns
// No Type.GetType(), Assembly.Load()

This makes future AOT migration trivial!

📚 Resources

Questions?

Let's discuss!

Thank You!

Go Native! 🚀