0Pricing
C# Academy · レッスン

Native AOTコンパイル

.NETプロジェクトでNative AOTを有効にし、トリム解析を理解して、自己完結型のネイティブバイナリを公開します。

「Native AOTコンパイル」はCoddyKit上の無料C# Academyレッスンです。 これはレッスン1/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはC# Academy学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 C# Academyコースには全4レッスンが含まれています。

Native AOTとは

ネイティブAOT（Ahead-of-Time）コンパイルは、発行時に.NETアプリを自己完結型のネイティブバイナリへコンパイルします。JITコンパイラもターゲット上の.NETランタイムも不要で、単一の実行可能ファイルだけで動作します。

Native AOTを使う場面

Native AOTは、起動時間とメモリフットプリントが重要なマイクロサービス、CLIツール、サーバーレス関数に特に適しています。実行時リフレクションに大きく依存するアプリには向いていません。

// 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)

Native AOTでの発行

プロジェクトファイルでAOTを有効にし、dotnet publishで発行します。出力は、ランタイムへの依存関係がない単一のネイティブ実行可能ファイルです。

// .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

Native AOTを使ったMinimal API

ASP.NET CoreのMinimal APIは、.NET 8以降でNative AOTを完全にサポートしています。あらかじめ構成された出発点として、dotnet new webapiaotテンプレートを使用します。

// 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 { }

ソース生成によるJSONシリアル化

Native AOTではリフレクションベースのJSONシリアル化を使用できません。コンパイル時にシリアル化コードを生成するには、System.Text.Jsonのソース生成を使用する必要があります。

// 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);

トリミングの警告

Native AOTで発行すると、デフォルトでトリミングが有効になります。コンパイラーは、未使用のコードが削除された後に失敗する可能性があるコードを検出すると警告します。CIでは、トリミングの警告をエラーとして扱ってください。

// .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互換性アナライザー

開発中にAOT互換性アナライザーを実行して、発行時の失敗につながる前に互換性のないコードパスを検出してください。

// 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

起動パフォーマンスの比較

Native AOTは、JITコンパイルされたアプリと比較して、起動時間とメモリ使用量を大幅に削減します。一部のワークロードでは、発行時間が長くなり、実行可能ファイルのサイズが大きくなるというトレードオフがあります。

// 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

実践例：AOTを使用したLambda関数

コールドスタートのパフォーマンスを最大化するために、公式のAmazon.Lambda.RuntimeSupportパッケージを使用するNative AOT Lambda関数です。

// 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\"}" };
}

確認問題

Native AOTでは、リフレクションベースのシリアル化ではなく、なぜSystem.Text.Jsonのソース生成を使用する必要があるのでしょうか。

まとめ：Native AOTコンパイル

主なポイント：

  • Native AOTは自己完結型のネイティブバイナリにコンパイルされるため、ランタイムは必要ありません
  • サーバーレス、マイクロサービス、CLIツールに適しています（高速な起動、少ないメモリ使用量）
  • <PublishAot>true</PublishAot>を有効にし、-r <rid>を指定して発行します
  • System.Text.Jsonのソース生成を使用する必要があります。リフレクションによるシリアル化は機能しません
  • EnableAotAnalyzerを使用して、開発中に互換性の問題を検出します
  • トレードオフとして、発行時間が長くなり、リフレクションに制限がありますが、コールドスタートは5～35倍高速になります

よくある質問

「Native AOTコンパイル」レッスンは無料ですか？

はい。「Native AOTコンパイル」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、C# Academyコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 C# Academyコースには全4レッスンが含まれています。

「Native AOTコンパイル」で何を学びますか？

.NETプロジェクトでNative AOTを有効にし、トリム解析を理解して、自己完結型のネイティブバイナリを公開します。 ブラウザで直接実行するハンズオンコードでC# Academyを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

C# Academyを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのC# Academyは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン1/4です。

「Native AOTコンパイル」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このC# Academyレッスンでコードを書いて実行できますか？

はい。すべてのC# Academyレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. Native AOTコンパイル
  2. トリミングとリフレクションの制限
  3. ReadyToRunと階層型コンパイル
  4. BenchmarkDotNetによるベンチマーク
← C# Academyに戻る