AOT - 粽子的WPF开发分享

AOT 简介

AOT (Ahead-of-Time) 编译是 .NET 的一项重要技术，它可以在编译时将代码编译成本机代码，从而提高应用程序的启动速度和运行性能。

什么是 AOT？

AOT 编译与传统的 JIT (Just-In-Time) 编译不同：

JIT 编译：代码在运行时被编译为机器码，首次执行时会有延迟
AOT 编译：代码在编译时就被编译为机器码，运行时直接执行

AOT 的优势

快速启动

无需 JIT 编译，应用启动速度显著提升

更小的内存占用

不需要 JIT 编译器运行时，内存占用更少

更好的性能

本机代码执行效率更高，性能更稳定

代码保护

编译为本机代码，更难反编译

跨平台支持

支持 Windows、Linux、macOS 等多个平台

独立部署

可以生成不依赖 .NET 运行时的独立可执行文件

AOT vs JIT 对比

特性	JIT 编译	AOT 编译
启动速度	较慢（首次运行需要编译）	快速（直接执行）
运行时性能	优秀（经过优化的 JIT）	优秀（本机代码）
内存占用	较高（包含 JIT 编译器）	较低（无 JIT 编译器）
文件大小	较小（IL 代码）	较大（本机代码）
灵活性	高（支持动态代码生成）	受限（不支持动态代码生成）
部署	需要 .NET 运行时	可独立部署

💡 何时使用 AOT？

需要快速启动的应用（如工具、实用程序）
对启动时间敏感的场景
需要独立部署的应用
对内存占用有严格要求的场景
需要保护代码不被轻易反编译的应用

快速开始

让我们开始使用 AOT 编译 WPF 应用程序。

1. 创建 WPF 项目

# 创建新的 WPF 项目
dotnet new wpf -n WpfAotApp
cd WpfAotApp

2. 配置项目文件

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net8.0-windows</TargetFramework>
    <Nullable>enable</Nullable>
    <UseWPF>true</UseWPF>
    
    <!-- 启用 AOT 编译 -->
    <PublishAot>true</PublishAot>
    
    <!-- 设置全球化模式 -->
    <InvariantGlobalization>true</InvariantGlobalization>
  </PropertyGroup>
</Project>

3. 发布 AOT 应用

# 发布为 AOT 应用
dotnet publish -c Release -r win-x64 --self-contained

# 发布为独立 AOT 应用（不依赖 .NET 运行时）
dotnet publish -c Release -r win-x64 --self-contained true -p:PublishAot=true

# 发布为单文件 AOT 应用
dotnet publish -c Release -r win-x64 --self-contained true -p:PublishAot=true -p:PublishSingleFile=true

4. 验证 AOT 编译

# 检查生成的文件
dir bin\Release\net8.0-windows\win-x64\publish\

# 运行 AOT 应用
.\bin\Release\net8.0-windows\win-x64\publish\WpfAotApp.exe

5. 查看编译信息

# 使用 dumpbin 查看导入的 DLL（需要 Visual Studio）
dumpbin /IMPORTS WpfAotApp.exe

# 如果看到 mscoree.dll，说明不是纯 AOT
# 如果只看到系统 DLL，说明是纯 AOT

配置选项

AOT 编译提供了多种配置选项，可以根据需求进行调整。

基本配置

<PropertyGroup>
    <!-- 启用 AOT 编译 -->
    <PublishAot>true</PublishAot>
    
    <!-- 目标框架 -->
    <TargetFramework>net8.0-windows</TargetFramework>
    
    <!-- 运行时标识符 -->
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
    
    <!-- 是否独立部署 -->
    <SelfContained>true</SelfContained>
</PropertyGroup>

高级配置

<PropertyGroup>
    <!-- 单文件发布 -->
    <PublishSingleFile>true</PublishSingleFile>
    
    <!-- 剪裁未使用的代码 -->
    <PublishTrimmed>true</PublishTrimmed>
    
    <!-- 剪裁级别 -->
    <TrimMode>link</TrimMode>
    
    <!-- 内嵌 PDB 符号 -->
    <DebugType>embedded</DebugType>
    
    <!-- 优化级别 -->
    <OptimizationPreference>Speed</OptimizationPreference>
    
    <!-- 并行编译 -->
    <EnableAotAnalyzer>true</EnableAotAnalyzer>
</PropertyGroup>

剪裁模式

<!-- copy: 不剪裁，包含所有代码 -->
<TrimMode>copy</TrimMode>

<!-- link: 剪裁未使用的代码（默认） -->
<TrimMode>link</TrimMode>

<!-- partial: 部分剪裁，保留更多代码 -->
<TrimMode>partial</TrimMode>

<!-- full: 完全剪裁，可能破坏某些功能 -->
<TrimMode>full</TrimMode>

剪裁警告

<!-- 控制剪裁警告级别 -->
<TrimMode>link</TrimMode>
<SuppressTrimAnalysisWarnings>false</SuppressTrimAnalysisWarnings>

<!-- 特定程序集的剪裁设置 -->
<ItemGroup>
    <TrimmerRootAssembly Include="MyAssembly" />
    <TrimmerRootDescriptor Include="MyDescriptors.xml" />
</ItemGroup>

全球化设置

<!-- 不变全球化（减少文件大小） -->
<InvariantGlobalization>true</InvariantGlobalization>

<!-- 预定义全球化 -->
<PredefinedCulturesOnly>true</PredefinedCulturesOnly>

<!-- 包含的文化 -->
<IncludeSpecificCultures>zh-CN;en-US</IncludeSpecificCultures>

限制与注意事项

AOT 编译有一些限制，需要注意并正确处理。

不支持的功能

⚠️ 主要限制

动态代码生成：不支持 Reflection.Emit、动态编译等
部分反射：某些反射 API 受限，可能无法访问所有类型
动态加载：不支持动态加载程序集
某些第三方库：依赖反射或动态代码的库可能不兼容
WPF 的 AOT 支持：WPF 的 AOT 支持仍在发展中，某些功能可能受限

反射限制

// ❌ 不支持：动态创建类型
var type = Type.GetType("MyNamespace.MyClass");
var instance = Activator.CreateInstance(type);

// ✅ 支持：使用已知类型
var instance = new MyClass();

// ❌ 不支持：动态获取属性
var property = type.GetProperty("PropertyName");
var value = property.GetValue(instance);

// ✅ 支持：直接访问属性
var value = instance.PropertyName;

使用 DynamicallyAccessedMembers

using System.Diagnostics.CodeAnalysis;

// 标记需要动态访问的成员
public class MyClass
{
    [DynamicallyAccessedMembers(
        DynamicallyAccessedMemberTypes.PublicProperties)]
    public static void ProcessType<T>()
    {
        var type = typeof(T);
        var properties = type.GetProperties();
        // 现在可以安全地访问属性
    }
}

// 或者在方法参数上标记
public void ProcessObject(
    [DynamicallyAccessedMembers(
        DynamicallyAccessedMemberTypes.PublicProperties)]
    Type type)
{
    var properties = type.GetProperties();
}

使用 TrimmerRootAssembly

<!-- 在项目文件中标记需要保留的程序集 -->
<ItemGroup>
    <TrimmerRootAssembly Include="MyAssembly" />
    <TrimmerRootAssembly Include="ThirdPartyAssembly" />
</ItemGroup>

使用描述符文件

<!-- LinkerDescriptor.xml -->
<linker>
    <assembly fullname="MyAssembly">
        <type fullname="MyAssembly.MyClass" preserve="all" />
        <type fullname="MyAssembly.AnotherClass">
            <method name="MyMethod" preserve="all" />
        </type>
    </assembly>
</linker>

<!-- 在项目文件中引用 -->
<ItemGroup>
    <TrimmerRootDescriptor Include="LinkerDescriptor.xml" />
</ItemGroup>

WPF 特定限制

⚠️ WPF AOT 限制

某些 WPF 功能可能不完全支持 AOT
第三方 WPF 控件库可能需要额外配置
动态资源加载可能受限
某些动画效果可能需要调整

常见问题

问题 1：AOT 编译失败

# 错误信息
error IL3055: Using 'dynamic' requires the 'Microsoft.CSharp' runtime 
which is not compatible with native AOT.

# 解决方案
# 避免使用 dynamic 类型
# 使用具体类型或 object 代替

问题 2：运行时异常

# 错误信息
System.NotSupportedException: 'Dynamic code generation is not 
supported in AOT.'

# 解决方案
# 1. 检查是否使用了 Reflection.Emit
# 2. 使用 Source Generators 代替动态代码生成
# 3. 使用表达式树代替动态编译

问题 3：类型未找到

# 错误信息
System.TypeLoadException: Could not load type 'MyType' from assembly.

# 解决方案
# 1. 使用 DynamicallyAccessedMembers 标记类型
# 2. 在 TrimmerRootAssembly 中包含程序集
# 3. 使用描述符文件保留类型

问题 4：文件大小过大

# 解决方案
# 1. 启用剪裁
<PublishTrimmed>true</PublishTrimmed>

# 2. 使用更严格的剪裁模式
<TrimMode>link</TrimMode>

# 3. 使用不变全球化
<InvariantGlobalization>true</InvariantGlobalization>

# 4. 排除不需要的程序集
<ItemGroup>
    <TrimmerRemoveAssemblyPaths Include="path\to\unused.dll" />
</ItemGroup>

问题 5：性能不如预期

# 解决方案
# 1. 检查是否使用了反射
# 2. 使用性能分析工具找出瓶颈
# 3. 考虑使用 PGO（Profile-Guided Optimization）
# 4. 优化热路径代码

最佳实践

1. 避免动态代码

// ❌ 避免
var type = Type.GetType(className);
var instance = (MyInterface)Activator.CreateInstance(type);

// ✅ 推荐
switch (className)
{
    case "MyClass1":
        instance = new MyClass1();
        break;
    case "MyClass2":
        instance = new MyClass2();
        break;
}

2. 使用 Source Generators

// 使用 CommunityToolkit.Mvvm 的 Source Generator
public partial class ViewModel : ObservableObject
{
    [ObservableProperty]
    private string _name;
    
    // 自动生成属性和通知代码
}

3. 标记动态访问

using System.Diagnostics.CodeAnalysis;

public class Serializer
{
    public static void Serialize<T>(
        [DynamicallyAccessedMembers(
            DynamicallyAccessedMemberTypes.PublicProperties |
            DynamicallyAccessedMemberTypes.PublicFields)]
        T obj)
    {
        var type = typeof(T);
        var properties = type.GetProperties();
        // 安全地访问属性
    }
}

4. 使用依赖注入

// 使用 DI 容器代替反射
var services = new ServiceCollection();
services.AddTransient<IMyService, MyService>();
services.AddTransient<MainWindow>();

var serviceProvider = services.BuildServiceProvider();
var mainWindow = serviceProvider.GetRequiredService<MainWindow>();

5. 测试 AOT 构建

# 在 CI/CD 中测试 AOT 构建
dotnet publish -c Release -r win-x64 --self-contained -p:PublishAot=true

# 运行测试
dotnet test

# 检查生成的文件
ls -lh bin/Release/net8.0-windows/win-x64/publish/

6. 监控剪裁警告

<!-- 启用剪裁分析 -->
<PropertyGroup>
    <PublishTrimmed>true</PublishTrimmed>
    <TrimMode>link</TrimMode>
    <SuppressTrimAnalysisWarnings>false</SuppressTrimAnalysisWarnings>
</PropertyGroup>

7. 优化启动性能

// 延迟初始化
public class MainViewModel
{
    private readonly Lazy<IDataService> _dataService;
    
    public MainViewModel()
    {
        _dataService = new Lazy<IDataService>(() => 
            new DataService());
    }
    
    public IDataService DataService => _dataService.Value;
}

💡 AOT 开发建议

在开发早期就考虑 AOT 兼容性
使用静态类型避免 dynamic
定期测试 AOT 构建
关注剪裁警告并及时处理
使用性能分析工具优化代码
保持依赖项更新，使用支持 AOT 的库