如何在Native AOT中通过ComWrappers创建并注册对象？

嘿，我之前刚在Native AOT项目里折腾过ComWrappers的使用，踩了好几个坑，现在把亲测有效的步骤分享给你，一步步来就不会错～

首先得明白，Native AOT里没法依赖.NET传统的自动COM封送逻辑，必须通过ComWrappers手动接管托管对象和COM对象之间的转换，这样才能在AOT编译后的原生程序里正常使用COM交互。

第一步：实现自定义的ComWrappers子类 #

你需要重写ComWrappers的三个核心方法，分别处理托管对象转COM、COM对象转托管的逻辑，还有生成COM接口的vtable。这里给你一个带具体场景的示例：

using System;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.Marshalling;

public class MyCustomComWrappers : ComWrappers
{
    // 为托管对象生成对应的COM接口虚拟表（vtable）
    protected override unsafe ComInterfaceEntry* ComputeVtables(object obj, CreateComInterfaceFlags flags, out int count)
    {
        // 只处理我们自己的托管对象类型
        if (obj is MyManagedComTarget managedTarget)
        {
            count = 1;
            // 用GeneratedComInterface自动生成的接口表，不用手动写vtable
            var interfaceEntry = ComInterfaceEntry.Create<IMyComInterface>(managedTarget);
            return (ComInterfaceEntry*)Unsafe.AsPointer(ref interfaceEntry);
        }

        // 其他类型交给默认处理
        return base.ComputeVtables(obj, flags, out count);
    }

    // 从COM指针创建对应的托管包装对象
    protected override object CreateObject(IntPtr externalComPtr, CreateObjectFlags flags)
    {
        // 检查COM对象是否实现了我们需要的接口
        Guid interfaceGuid = typeof(IMyComInterface).GUID;
        if (Marshal.QueryInterface(externalComPtr, ref interfaceGuid, out _) == 0)
        {
            return new MyComWrapper(externalComPtr);
        }

        return base.CreateObject(externalComPtr, flags);
    }

    // 从托管对象创建对应的COM接口指针（可选，base实现已经能处理大部分场景）
    protected override IntPtr CreateComInterfaceForObject(object obj, CreateComInterfaceFlags flags)
    {
        return base.CreateComInterfaceForObject(obj, flags);
    }
}

// 用GeneratedComInterface标记要暴露给COM的接口，.NET会自动生成封送代码
[GeneratedComInterface]
[Guid("替换成你的COM接口唯一GUID")]
internal partial interface IMyComInterface
{
    void ExecuteTask(string taskName);
}

// 实现COM接口的托管类
public class MyManagedComTarget : IMyComInterface
{
    public void ExecuteTask(string taskName)
    {
        Console.WriteLine($"托管对象执行任务：{taskName}");
    }
}

// 用于包装外部COM对象的托管类
public class MyComWrapper : IMyComInterface
{
    private readonly IntPtr _nativeComPtr;

    public MyComWrapper(IntPtr nativePtr)
    {
        _nativeComPtr = nativePtr;
    }

    public void ExecuteTask(string taskName)
    {
        // 这里调用原生COM对象的方法，借助自动生成的封送逻辑
        unsafe
        {
            // 注意：如果用了GeneratedComInterface，也可以用更简洁的方式调用，这里是底层示例
            var vtable = (delegate* unmanaged[Stdcall]<IntPtr, IntPtr, void>)*Marshal.ReadIntPtr(_nativeComPtr);
            IntPtr taskNamePtr = Marshal.StringToHGlobalUni(taskName);
            (*vtable[3])(_nativeComPtr, taskNamePtr); // 假设ExecuteTask是接口的第4个方法（索引从0开始）
            Marshal.FreeHGlobal(taskNamePtr);
        }
    }
}

第二步：在应用启动时注册ComWrappers实例 #

Native AOT应用启动时，必须手动注册你的自定义ComWrappers，否则所有COM交互都会失效。在Main方法开头就做这件事：

public static void Main(string[] args)
{
    // 初始化并注册自定义ComWrappers
    var comWrappers = new MyCustomComWrappers();
    ComWrappers.RegisterForMarshalling(comWrappers);

    // 场景1：把托管对象转成COM指针，给原生COM端调用
    var managedTask = new MyManagedComTarget();
    IntPtr comInterfacePtr = ComWrappers.GetComInterfaceForObject(managedTask, CreateComInterfaceFlags.None);
    // 这里可以把comInterfacePtr传递给原生代码，或者注册到系统COM注册表（如果需要全局访问）

    // 场景2：从原生COM指针获取托管包装对象
    // IntPtr nativeComPtr = ...; // 比如从外部API拿到的COM对象指针
    // var wrapperObject = ComWrappers.GetObjectForComInstance(nativeComPtr, CreateObjectFlags.None) as IMyComInterface;
    // wrapperObject?.ExecuteTask("从COM端发起的任务");

    // 启动你的应用逻辑
    Console.WriteLine("Native AOT COM交互初始化完成！");
}

第三步：配置Native AOT项目的关键属性 #

别忘在你的csproj里加上这两个关键配置，否则AOT编译时会砍掉COM相关的支持：

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net9.0-windows</TargetFramework>
    <PublishAot>true</PublishAot>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <!-- 必须开启这个，Native AOT才会保留COM封送所需的代码 -->
    <EnableComInteropSupport>true</EnableComInteropSupport>
  </PropertyGroup>

  <ItemGroup>
    <!-- 引用GeneratedComInterface所需的包 -->
    <PackageReference Include="System.Runtime.InteropServices.Marshalling" Version="9.0.0" />
  </ItemGroup>
</Project>

几个要注意的坑点 #

• 一定要开<EnableComInteropSupport>true</EnableComInteropSupport>，我当初就是漏了这个，折腾了半天AOT编译后COM调用全失败，查了好久才发现是这个配置的问题。
• GeneratedComInterface是.NET 8及以上版本才有的特性，用它比手动写vtable靠谱太多，能省掉大量的底层封送代码。
• 如果你的场景里需要全局注册COM对象（让其他程序能通过COM CLSID找到你的托管对象），还需要额外处理COM注册表的写入，但Native AOT里得手动做，不能依赖.NET的自动注册。

要是你还有具体的场景问题，比如特定COM接口的转换、复杂对象的封送，随时再问～

内容来源于stack exchange