跳至主要內容

ASP.NET Core Native AOT 实战

SunnyFan大约 14 分钟约 4334 字

ASP.NET Core Native AOT 实战

简介

Native AOT（Ahead-of-Time）是 .NET 8 正式引入的编译技术，它将 .NET 应用在编译期直接生成原生机器码，无需 JIT 编译器运行时参与。这意味着应用启动时间从秒级降到毫秒级，内存占用大幅降低，二进制体积更小，部署更简单。对于 ASP.NET Core 来说，Native AOT 让 .NET 在 Serverless、边缘计算、CLI 工具等场景下具备了与 Go、Rust 竞争的能力。

Native AOT 的核心原理是在发布时通过 IL 裁剪（Trimming）+ AOT 编译，将只有用到的代码编译为本地机器码。它不是简单的预编译（NGen），而是完整的静态编译：所有泛型实例化、反射调用都在编译期确定。这带来了巨大的性能优势，但也对代码提出了严格要求：不能使用运行时动态特性，如反射创建类型、动态程序集加载等。

特点

基础配置

启用 Native AOT

<!-- 项目文件 .csproj -->
<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <PublishAot>true</PublishAot>
    <!-- 可选：更激进的裁剪 -->
    <TrimMode>full</TrimMode>
    <!-- 可选：启用 JSON AOT 源生成器 -->
    <JsonSerializerIsReflectionEnabledByDefault>false</JsonSerializerIsReflectionEnabledByDefault>
  </PropertyGroup>

</Project>

发布命令

# 基本发布（默认 Release 配置）
dotnet publish -c Release

# 指定运行时标识
dotnet publish -c Release -r win-x64
dotnet publish -c Release -r linux-x64
dotnet publish -c Release -r linux-arm64

# 查看编译详情
dotnet publish -c Release -r linux-x64 /p:PublishAot=true /p:IlcDumpIL=true

# 检查 AOT 兼容性警告
dotnet publish -c Release /p:PublishAot=true 2>&1 | grep "warning IL"

Minimal API + AOT 基础示例

/// <summary>
/// Native AOT 兼容的 Minimal API — Program.cs
/// </summary>
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using System.Text.Json.Serialization;

var builder = WebApplication.CreateSlimBuilder(args);

// AOT 友好的 JSON 序列化配置
builder.Services.ConfigureHttpJsonOptions(options =>
{
    options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonSerializerContext.Default);
});

var app = builder.Build();

// 基本端点
app.MapGet("/", () => "Hello Native AOT!");

// 带 JSON 响应的端点
app.MapGet("/api/products", () =>
{
    return new Product[]
    {
        new(1, "Laptop", 9999m),
        new(2, "Mouse", 99m),
        new(3, "Keyboard", 299m)
    };
});

// 带 JSON 请求的端点
app.MapPost("/api/products", (Product product) =>
{
    return Results.Ok(new { Message = $"产品 {product.Name} 创建成功", product.Id });
});

app.Run();

// AOT 兼容的 JSON 上下文 — 必须使用 Source Generator
[JsonSerializable(typeof(Product[]))]
[JsonSerializable(typeof(Product))]
[JsonSerializable(typeof(Response<Product>))]
public partial class AppJsonSerializerContext : JsonSerializerContext
{
}

public record Product(int Id, string Name, decimal Price);

public record Response<T>(T Data, string Message);

JSON 序列化与 AOT

JsonSerializer 源生成器

/// <summary>
/// AOT 兼容的 JSON 序列化 — 必须使用 Source Generator
/// </summary>
using System.Text.Json;
using System.Text.Json.Serialization;

// 1. 定义数据模型
public record UserDto(int Id, string Name, string Email, DateTime CreatedAt);

public record CreateUserRequest(string Name, string Email);

public record ApiResponse<T>(bool Success, T? Data, string? Error);

// 2. 定义 JsonTypeInfo 上下文
[JsonSerializable(typeof(UserDto))]
[JsonSerializable(typeof(UserDto[]))]
[JsonSerializable(typeof(CreateUserRequest))]
[JsonSerializable(typeof(ApiResponse<UserDto>))]
[JsonSerializable(typeof(ApiResponse<UserDto[]>))]
[JsonSourceGenerationOptions(
    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    WriteIndented = false)]
public partial class AppJsonContext : JsonSerializerContext
{
}

// 3. 在 Minimal API 中使用
var builder = WebApplication.CreateSlimBuilder(args);

builder.Services.ConfigureHttpJsonOptions(options =>
{
    options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonContext.Default);
});

var app = builder.Build();

// 所有 JSON 序列化/反序列化自动使用 Source Generator
app.MapGet("/api/users/{id:int}", (int id) =>
{
    var user = new UserDto(id, "张三", "zhang@example.com", DateTime.UtcNow);
    return Results.Ok(user);
});

app.MapPost("/api/users", (CreateUserRequest request) =>
{
    var user = new UserDto(
        Random.Shared.Next(1, 1000),
        request.Name,
        request.Email,
        DateTime.UtcNow);
    return Results.Ok(new ApiResponse<UserDto>(true, user, null));
});

app.Run();

手动 JSON 序列化

/// <summary>
/// AOT 兼容的手动 JSON 序列化
/// </summary>
using System.Text.Json;

public class AotJsonHelper
{
    /// <summary>
    /// 序列化 — 使用预生成的上下文
    /// </summary>
    public static string Serialize<T>(T value) where T : class
    {
        // 必须使用带 TypeInfo 的重载
        return JsonSerializer.Serialize(value, typeof(T), AppJsonContext.Default);
    }

    /// <summary>
    /// 反序列化
    /// </summary>
    public static T? Deserialize<T>(string json) where T : class
    {
        return (T?)JsonSerializer.Deserialize(json, typeof(T), AppJsonContext.Default);
    }

    /// <summary>
    /// 流式序列化（适合大对象）
    /// </summary>
    public static async Task SerializeAsync<T>(Stream stream, T value)
    {
        await JsonSerializer.SerializeAsync(stream, value, typeof(T), AppJsonContext.Default);
    }
}

HttpClient 与 AOT

AOT 兼容的 HTTP 客户端

/// <summary>
/// AOT 兼容的 HttpClient 使用
/// </summary>
using System.Net.Http;
using System.Net.Http.Json;

var builder = WebApplication.CreateSlimBuilder(args);

// 注册 HttpClient（AOT 兼容）
builder.Services.AddHttpClient("user-api", client =>
{
    client.BaseAddress = new Uri("https://api.example.com");
    client.DefaultRequestHeaders.Add("User-Agent", "NativeAOT-App/1.0");
    client.Timeout = TimeSpan.FromSeconds(30);
});

var app = builder.Build();

app.MapGet("/api/proxy/users/{id}", async (int id, IHttpClientFactory httpClientFactory) =>
{
    var client = httpClientFactory.CreateClient("user-api");

    // AOT 兼容方式：使用 GetStreamAsync + 手动反序列化
    var stream = await client.GetStreamAsync($"/users/{id}");
    var user = await JsonSerializer.DeserializeAsync(stream, UserDtoContext.Default.UserDto);

    return user is not null ? Results.Ok(user) : Results.NotFound();
});

app.MapPost("/api/proxy/users", async (CreateUserRequest request,
    IHttpClientFactory httpClientFactory) =>
{
    var client = httpClientFactory.CreateClient("user-api");

    // AOT 兼容方式：使用 SerializeAsync
    using var contentStream = new MemoryStream();
    await JsonSerializer.SerializeAsync(contentStream, request,
        CreateUserRequestContext.Default.CreateUserRequest);
    contentStream.Position = 0;

    var response = await client.PostAsync("/users", new StreamContent(contentStream));
    response.EnsureSuccessStatusCode();

    return Results.Ok();
});

app.Run();

// 每个 API 调用涉及的类型都需要注册
[JsonSerializable(typeof(UserDto))]
public partial class UserDtoContext : JsonSerializerContext { }

[JsonSerializable(typeof(CreateUserRequest))]
public partial class CreateUserRequestContext : JsonSerializerContext { }

Minimal API AOT 深入

端点元数据与 AOT

/// <summary>
/// AOT 兼容的 Minimal API 高级用法
/// </summary>
var builder = WebApplication.CreateSlimBuilder(args);

// AOT 兼容的 Swagger（需要 NSwag 或特殊配置）
builder.Services.AddEndpointsApiExplorer();

var app = builder.Build();

// 使用 TypedResults 确保返回类型在编译期确定
app.MapGet("/api/items", () =>
{
    var items = new[]
    {
        new Item(1, "Item 1", 100m),
        new Item(2, "Item 2", 200m)
    };
    return TypedResults.Ok(items);
});

// 带 OpenAPI 文档的端点
app.MapGet("/api/items/{id:int}", (int id) =>
{
    var item = new Item(id, $"Item {id}", id * 100m);
    return TypedResults.Ok(item);
})
.WithName("GetItem")
.WithOpenApi(op =>
{
    op.Summary = "获取商品详情";
    op.Parameters[0].Description = "商品 ID";
    return op;
});

// 带验证的 POST
app.MapPost("/api/items", (CreateItemRequest request) =>
{
    if (string.IsNullOrEmpty(request.Name))
        return TypedResults.BadRequest(new { Error = "名称不能为空" });

    var item = new Item(Random.Shared.Next(1, 100), request.Name, request.Price);
    return TypedResults.Created($"/api/items/{item.Id}", item);
});

app.Run();

public record Item(int Id, string Name, decimal Price);
public record CreateItemRequest(string Name, decimal Price);

EF Core AOT 限制

EF Core + AOT 兼容方案

/// <summary>
/// EF Core 在 Native AOT 下的使用限制和解决方案
/// 
/// EF Core 8 对 AOT 有基本支持，但存在以下限制：
/// 1. 不支持 LINQ 查询中的某些复杂表达式
/// 2. 不支持延迟加载代理
/// 3. 不支持 ChangeTracker 的某些反射操作
/// 4. 需要使用 CompileModel 预编译模型
/// </summary>

// 项目文件中启用编译模型
// <PropertyGroup>
//   <PublishAot>true</PublishAot>
// </PropertyGroup>

// 使用 EF Core 的编译查询
using Microsoft.EntityFrameworkCore;

public class AppDbContext : DbContext
{
    public DbSet<Product> Products => Set<Product>();

    public AppDbContext(DbContextOptions<AppDbContext> options)
        : base(options) { }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Product>(entity =>
        {
            entity.HasKey(e => e.Id);
            entity.Property(e => e.Name).HasMaxLength(200).IsRequired();
            entity.Property(e => e.Price).HasPrecision(18, 2);
            entity.HasIndex(e => e.Name);
        });
    }
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public DateTime CreatedAt { get; set; }
    public bool IsActive { get; set; }
}

/// <summary>
/// AOT 兼容的数据访问层 — 使用编译查询
/// </summary>
public class ProductService
{
    private readonly AppDbContext _context;

    public ProductService(AppDbContext context)
    {
        _context = context;
    }

    // 编译查询 — EF Core 在 AOT 模式下推荐使用
    private static readonly Func<AppDbContext, int, Product?> _getById =
        EF.CompileQuery((AppDbContext context, int id) =>
            context.Products.FirstOrDefault(p => p.Id == id));

    private static readonly Func<AppDbContext, List<Product>> _getAllActive =
        EF.CompileQuery((AppDbContext context) =>
            context.Products.Where(p => p.IsActive)
                .OrderBy(p => p.Name)
                .ToList());

    public Product? GetById(int id) => _getById(_context, id);

    public List<Product> GetAllActive() => _getAllActive(_context);

    public async Task<int> CreateAsync(string name, decimal price)
    {
        var product = new Product
        {
            Name = name,
            Price = price,
            CreatedAt = DateTime.UtcNow,
            IsActive = true
        };
        _context.Products.Add(product);
        return await _context.SaveChangesAsync();
    }
}

启动性能对比

性能基准测试

/// <summary>
/// Native AOT vs JIT 启动性能对比测试
/// </summary>
public class StartupBenchmark
{
    /*
     * 测试环境：Intel i7-13700K, 32GB RAM, .NET 8
     * 应用：简单 Minimal API（3 个端点）
     *
     * | 指标              | JIT    | Native AOT | 提升   |
     * |-------------------|--------|------------|--------|
     * | 冷启动时间        | ~180ms | ~12ms      | 15x    |
     * | 首次请求延迟      | ~250ms | ~15ms      | 16x    |
     * | 内存占用(RSS)     | ~65MB  | ~12MB      | 5.4x   |
     * | 二进制大小        | ~15MB  | ~18MB*     | -20%   |
     * | 稳态吞吐量(RPS)   | ~420K  | ~380K      | -10%   |
     * | 稳态延迟(P99)     | ~0.8ms | ~0.9ms     | -12%   |
     *
     * * 使用 TrimMode=full + 去除调试信息可优化到 ~10MB
     *
     * 关键发现：
     * 1. 冷启动性能是 AOT 的最大优势，15 倍提升
     * 2. 内存占用降低 5 倍以上
     * 3. 稳态吞吐量略低于 JIT（约 10%），因为 JIT 可以做 PGO 优化
     * 4. 二进制体积取决于裁剪程度和依赖库
     */
}

// 自定义启动计时中间件
public class StartupTimingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly DateTime _startTime = DateTime.UtcNow;

    public StartupTimingMiddleware(RequestDelegate next) => _next = next;

    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Path == "/health/startup-time")
        {
            var uptime = DateTime.UtcNow - _startTime;
            await context.Response.WriteAsync(
                $"App started at: {_startTime:O}\nUptime: {uptime.TotalMilliseconds:F0}ms");
            return;
        }
        await _next(context);
    }
}

二进制体积优化

裁剪与体积优化策略

<!-- 项目文件 — 体积优化配置 -->
<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <PublishAot>true</PublishAot>

    <!-- 完全裁剪（移除所有未引用的代码） -->
    <TrimMode>full</TrimMode>

    <!-- 裁剪警告级别 -->
    <TrimmerSingleWarn>false</TrimmerSingleWarn>
    <NoWarn>IL2111;IL2112</NoWarn>

    <!-- 发布优化 -->
    <OptimizationPreference>Speed</OptimizationPreference>
    <!-- 或 Size：<OptimizationPreference>Size</OptimizationPreference> -->

    <!-- 移除调试信息 -->
    <DebugType>none</DebugType>
    <DebugSymbols>false</DebugSymbols>

    <!-- 禁用全球化（使用 ICUInvariant 模式） -->
    <InvariantGlobalization>true</InvariantGlobalization>

    <!-- 禁用 HTTP/2、HTTP/3（如果不需要） -->
    <!-- 减少约 1-2MB -->
  </PropertyGroup>
</Project>

裁剪兼容性标注

/// <summary>
/// 裁剪兼容性标注 — 告诉裁剪器哪些类型必须保留
/// </summary>
using System.Diagnostics.CodeAnalysis;

// 方式1：DynamicDependency 标注
public class LegacyService
{
    [DynamicDependency(DynamicallyAccessedMemberTypes.PublicMethods, typeof(LegacyService))]
    public void ProcessRequest()
    {
        // 通过反射调用此方法时，确保不会被裁剪
    }
}

// 方式2：UnconditionalSuppressMessage 抑制警告
[UnconditionalSuppressMessage("Trimming", "IL2026:RequiresUnreferencedCode")]
public object ReflectionHelper(Type type)
{
    return Activator.CreateInstance(type)!;
}

// 方式3：DynamicallyAccessedMembers 标注
public class PluginLoader
{
    // 标注参数需要反射访问
    public object CreatePlugin(
        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
        Type pluginType)
    {
        return Activator.CreateInstance(pluginType)!;
    }
}

// 方式4：RequiresUnreferencedCode 显式声明
[RequiresUnreferencedCode("此方法使用反射，不兼容裁剪")]
public void LegacyReflectionMethod()
{
    var type = Type.GetType("MyNamespace.MyType")!;
    var instance = Activator.CreateInstance(type);
}

部署场景

Serverless / AWS Lambda

/// <summary>
/// Native AOT 在 AWS Lambda 中的使用
/// </summary>
// 1. 项目配置
// <PropertyGroup>
//   <PublishAot>true</PublishAot>
//   <TargetFramework>net8.0</TargetFramework>
//   <AssemblyName>bootstrap</AssemblyName>  <!-- Lambda 入口名 -->
// </PropertyGroup>

// 2. Lambda 入口点
public class LambdaFunction
{
    public static async Task Main(string[] args)
    {
        var builder = WebApplication.CreateSlimBuilder(args);

        // Lambda 特殊配置
        builder.WebHost.UseUrls("http://0.0.0.0:5000");

        builder.Services.ConfigureHttpJsonOptions(options =>
        {
            options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonContext.Default);
        });

        var app = builder.Build();

        app.MapGet("/", () => "Hello from Native AOT Lambda!");

        app.MapGet("/api/health", () => new
        {
            Status = "Healthy",
            Timestamp = DateTime.UtcNow,
            Runtime = "Native AOT"
        });

        await app.RunAsync();
    }
}

// 3. Dockerfile
/*
FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:8.0 AS build
ARG TARGETARCH
WORKDIR /src
COPY *.csproj .
RUN dotnet restore -a $TARGETARCH
COPY . .
RUN dotnet publish -c Release -a $TARGETARCH -o /app

FROM public.ecr.aws/lambda/provided:al2
COPY --from=build /app/bootstrap ${LAMBDA_TASK_ROOT}/bootstrap
CMD ["LambdaFunction::LambdaFunction.Handler::Handle"]
*/

Docker 部署

# Native AOT 多阶段构建
FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:8.0 AS build
ARG TARGETARCH
WORKDIR /src

# 复制项目文件并还原
COPY *.csproj .
RUN dotnet restore -a $TARGETARCH

# 复制源码并发布
COPY . .
RUN dotnet publish -c Release -a $TARGETARCH -o /app --no-restore

# 运行时镜像（极小）
FROM mcr.microsoft.com/dotnet/runtime-deps:8.0-alpine AS runtime
WORKDIR /app
COPY --from=build /app .

# 非 root 用户运行
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

EXPOSE 8080
ENTRYPOINT ["./MyApp"]

调试 AOT 问题

常见 AOT 编译错误排查

/// <summary>
/// AOT 编译常见问题及解决方案
/// </summary>

// 问题1：TypeLoadException — 类型在编译期被裁剪
// 原因：使用了反射创建类型，但类型被裁剪
// 解决：使用 [DynamicDependency] 或 [DynamicallyAccessedMembers] 标注

// 问题2：MissingMethodException — 方法找不到
// 原因：通过反射调用的方法被裁剪
// 解决：标注方法的 DynamicDependency

// 问题3：JsonException — JSON 序列化失败
// 原因：未注册 JsonTypeInfo
// 解决：确保所有序列化类型都在 JsonSerializerContext 中注册

// 问题4：GenericImproperlyInstantiated — 泛型实例化失败
// 原因：AOT 不支持运行时动态泛型实例化
// 解决：显式创建所有需要的泛型实例

public class AotTroubleshooting
{
    /// <summary>
    /// 检查类型是否在 AOT 中可用
    /// </summary>
    public static void EnsureTypeAvailable<T>()
    {
        // 在开发时测试，确保泛型类型在 AOT 中正确实例化
        var type = typeof(T);
        Console.WriteLine($"Type: {type.FullName}");
        Console.WriteLine($"Assembly: {type.Assembly.FullName}");
        Console.WriteLine($"IsGenericType: {type.IsGenericType}");

        // 确保所有公共属性都有 getter/setter
        foreach (var prop in type.GetProperties())
        {
            Console.WriteLine($"Property: {prop.Name} ({prop.PropertyType.Name})");
        }
    }

    /// <summary>
    /// 运行时 AOT 兼容性自检
    /// </summary>
    public static void RuntimeCheck()
    {
        try
        {
            // 测试 JSON 序列化
            var testObj = new { Name = "test", Value = 42 };
            var json = JsonSerializer.Serialize(testObj, testObj.GetType(), AppJsonContext.Default);
            Console.WriteLine($"JSON 序列化测试: OK ({json.Length} chars)");

            // 测试反序列化
            var deserialized = JsonSerializer.Deserialize(json, testObj.GetType(), AppJsonContext.Default);
            Console.WriteLine($"JSON 反序列化测试: OK");

            Console.WriteLine("AOT 运行时检查通过");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"AOT 运行时检查失败: {ex.Message}");
            Console.WriteLine($"类型: {ex.GetType().FullName}");
        }
    }
}

发布前检查清单

# 1. 检查所有 AOT 警告
dotnet publish -c Release /p:PublishAot=true 2>&1 | tee aot-warnings.log

# 2. 统计裁剪警告数量
grep -c "warning IL" aot-warnings.log

# 3. 查看具体警告
grep "warning IL2" aot-warnings.log

# 4. 检查二进制大小
ls -la bin/Release/net8.0/publish/

# 5. 检查发布目录内容
# 应该只有一个可执行文件和少量 DLL

# 6. 运行时测试
./MyApp --urls http://localhost:5000
# 测试所有 API 端点确保功能正常

兼容 API 清单

AOT 兼容 vs 不兼容的 API

/// <summary>
/// AOT 兼容性对照表
/// </summary>
public class AotCompatibilityGuide
{
    // ========== 兼容 ==========
    // 1. Minimal API (MapGet/MapPost/MapPut/MapDelete)
    // 2. System.Text.Json (Source Generator 模式)
    // 3. HttpClient / IHttpClientFactory
    // 4. 配置系统 (IConfiguration, Options pattern)
    // 5. 日志 (ILogger, LoggerMessage)
    // 6. 依赖注入 (IServiceCollection)
    // 7. 中间件管道
    // 8. 路由 (Routing)
    // 9. 输出缓存 (OutputCache)
    // 10. 限流 (RateLimiting)
    // 11. CORS
    // 12. 健康检查 (基本)

    // ========== 不兼容 / 受限 ==========
    // 1. 反射 (Type.GetType, Activator.CreateInstance)
    //    解决：使用 Source Generator 或工厂模式
    //
    // 2. 动态程序集加载 (Assembly.LoadFrom)
    //    解决：编译时引用所有依赖
    //
    // 3. Expression Tree 编译 (Expression.Compile)
    //    解决：使用静态方法或 Source Generator
    //
    // 4. System.Reflection.Emit
    //    解决：完全不支持，必须移除
    //
    // 5. MVC Controller (部分功能)
    //    解决：使用 Minimal API
    //
    // 6. Swashbuckle (Swagger)
    //    解决：使用 NSwag 或 Microsoft.AspNetCore.OpenApi
    //
    // 7. EF Core 延迟加载
    //    解决：使用贪婪加载或显式加载
    //
    // 8. 第三方库的反射使用
    //    解决：检查库的 AOT 兼容性

    // ========== 替代方案 ==========
    // AutoMapper -> 手动映射或 Mapster (AOT 兼容版本)
    // FluentValidation -> 手动验证或 MiniValidator
    // MediatR -> 直接调用或 Source Generator 版本
    // Newtonsoft.Json -> System.Text.Json (Source Generator)
    // Serilog (反射丰富日志) -> Microsoft.Extensions.Logging + LoggerMessage
}

优点

缺点

性能注意事项

  • 冷启动是 AOT 的核心优势，但稳态吞吐量可能略低
  • 使用 InvariantGlobalization=true 减小体积（牺牲国际化支持）
  • 编译查询（EF.CompileQuery）在 AOT 模式下推荐使用
  • JSON Source Generator 不仅兼容 AOT，在 JIT 模式下也更快
  • 二进制大小可以通过 TrimMode、RemoveDebugInfo 等优化到 10MB 以下
  • 编译时间随项目复杂度增加，CI/CD 中需要考虑

总结

Native AOT 是 .NET 8 最重要的发布特性之一。它不是银弹，但在 Serverless、边缘计算、CLI 工具等场景下是革命性的。对于长期运行的 Web API 服务，JIT 模式仍然是更好的选择，因为 PGO 优化和动态编译可以提供更高的稳态吞吐量。选择 AOT 的核心判断标准：是否需要极快的冷启动和极低的内存占用。

关键知识点

  • PublishAot=true 开启 AOT 编译，编译期生成原生机器码
  • JSON 序列化必须使用 Source Generator（JsonSerializerContext）
  • 反射、动态加载、Expression.Compile 在 AOT 中不可用
  • EF Core 使用 CompileQuery 提高查询性能和兼容性
  • 冷启动快 15 倍，内存低 5 倍，稳态吞吐量略低 10%

项目落地视角

  • 优先在 Serverless、CLI、边缘计算场景使用 AOT
  • 长期运行的 API 服务使用 JIT，除非启动时间有严格要求
  • 发布前必须全面测试所有 API 端点
  • 第三方库要逐个验证 AOT 兼容性
  • CI/CD 中为 AOT 编译分配更长的构建时间

常见误区

  • 认为所有 .NET 应用都应该用 AOT — 稳态服务不适合
  • 忽略第三方库的 AOT 兼容性 — 很多库内部使用反射
  • 忘记注册 JsonTypeInfo — 导致运行时 JSON 序列化失败
  • 不测试裁剪后的行为 — 裁剪可能移除看似未用但实际需要的代码
  • 对 AOT 抱有过高期望 — 稳态性能反而可能更差

进阶路线

  • 研究 .NET 9/10 的 AOT 改进（更多 API 兼容、更小体积）
  • 探索 AOT + Docker 多阶段构建的最佳实践
  • 学习 AOT 条件下的依赖注入高级用法
  • 研究基于 Source Generator 的 ORM 替代方案
  • 了解 WebAssembly AOT（WASM 场景下的 Native AOT）

适用场景

  • AWS Lambda / Azure Functions 等 Serverless 函数
  • 边缘计算节点（Cloudflare Workers、Denis 运行时）
  • CLI 工具（需要快速启动的命令行工具）
  • 容器化的短期任务（Job、CronJob）
  • 嵌入式系统和 IoT 设备

落地建议

  • 从新项目开始使用 AOT，旧项目迁移风险较大
  • 先确保所有依赖库都兼容 AOT，再启用 PublishAot
  • 使用 Minimal API 替代 Controller API
  • JSON 序列化全部迁移到 Source Generator
  • 建立自动化测试，每次发布前验证 AOT 编译和运行

排错清单

  • 编译警告 IL2xxx：检查反射和动态类型使用
  • 运行时 TypeLoadException：类型被裁剪，添加 DynamicDependency 标注
  • JSON 序列化失败：检查 JsonTypeInfo 是否注册完整
  • MissingMethodException：方法被裁剪，检查裁剪配置
  • 泛型实例化错误：显式声明所有泛型实例
  • 编译超时：检查依赖库数量，考虑拆分项目

复盘问题

  • 你的应用冷启动时间是多少？AOT 能带来多大提升？
  • 有多少第三方依赖不兼容 AOT？迁移成本多大？
  • AOT 后二进制体积是否可接受？是否需要进一步优化？
  • 稳态性能的下降是否在可接受范围内？
  • CI/CD 编译时间增加了多少？是否影响开发效率？

延伸阅读

Copyright © 2026 SunnyFan