使用 CsWin32 和 ComWrappers 实现 COM 接口

根本概念

CsWin32 是微软开辟的一个 C# 的源天生器，可以按需天生 C# PInvoke 代码，也支持天生体系的 COM 接口界说。
ComWrappers 是 dotnet 5 引入的新的和 COM api 互操纵的组件。
天生支持 AOT 的 COM 接口

使用 CsWin32 天生 COM 接口界说时，默认会天生使用 Builtin COM Interop 技能的代码，这种接口使用 ComImportAttribute 修饰，不支持 Native AOT。
CsWin32 提供了一个开关，在 NativeMethods.json 中设置 { "allowMarshaling": false }，可以使 CsWin32 天生更为原始的 COM 接口。
CsWin32 天生的 IClassFactory 接口

1. using winmdroot = global::Windows.Win32;
2. namespace Windows.Win32
3. {
4.         namespace System.Com
5.         {
6.                 [Guid("00000001-0000-0000-C000-000000000046")]
7.                 [SupportedOSPlatform("windows5.0")]
8.                 [global::System.CodeDom.Compiler.GeneratedCode("Microsoft.Windows.CsWin32", "0.3.183+73e6125f79.RR")]
9.                 internal unsafe partial struct IClassFactory
10.                         :IVTable<IClassFactory,IClassFactory.Vtbl>,IComIID                {
12.             // 对 IUnknown 和 IClassFactory 接口指针的函数调用的包装
14.                         [OverloadResolutionPriority(1)]
15.                         internal unsafe winmdroot.Foundation.HRESULT QueryInterface(in global::System.Guid riid, out void* ppvObject)
16.                         {
17.                                 fixed (void** ppvObjectLocal = &ppvObject)
18.                                 {
19.                                         fixed (global::System.Guid* riidLocal = &riid)
20.                                         {
21.                                                 winmdroot.Foundation.HRESULT __result = this.QueryInterface(riidLocal, ppvObjectLocal);
22.                                                 return __result;
23.                                         }
24.                                 }
25.                         }
27.                         public unsafe winmdroot.Foundation.HRESULT QueryInterface(global::System.Guid* riid, void** ppvObject)
28.                         {
29.                                 return ((delegate *unmanaged [Stdcall]<IClassFactory*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT>)lpVtbl[0])((IClassFactory*)Unsafe.AsPointer(ref this), riid, ppvObject);
30.                         }
32.                         public uint AddRef()
33.                         {
34.                                 return ((delegate *unmanaged [Stdcall]<IClassFactory*,uint>)lpVtbl[1])((IClassFactory*)Unsafe.AsPointer(ref this));
35.                         }
37.                         public uint Release()
38.                         {
39.                                 return ((delegate *unmanaged [Stdcall]<IClassFactory*,uint>)lpVtbl[2])((IClassFactory*)Unsafe.AsPointer(ref this));
40.                         }
42.                         /// <inheritdoc cref="CreateInstance(winmdroot.System.Com.IUnknown*, global::System.Guid*, void**)"/>
43.                         [OverloadResolutionPriority(1)]
44.                         internal unsafe winmdroot.Foundation.HRESULT CreateInstance(winmdroot.System.Com.IUnknown* pUnkOuter, in global::System.Guid riid, out void* ppvObject)
45.                         {
46.                                 fixed (void** ppvObjectLocal = &ppvObject)
47.                                 {
48.                                         fixed (global::System.Guid* riidLocal = &riid)
49.                                         {
50.                                                 winmdroot.Foundation.HRESULT __result = this.CreateInstance(pUnkOuter, riidLocal, ppvObjectLocal);
51.                                                 return __result;
52.                                         }
53.                                 }
54.                         }
56.             // 将 COM 接口方法调用转发到托管对象方法调用的包装
58.                         [UnmanagedCallersOnly(CallConvs = new []{
59. typeof(CallConvStdcall)}
60. )]
61.                         private static winmdroot.Foundation.HRESULT CreateInstance(IClassFactory* pThis, [Optional] winmdroot.System.Com.IUnknown* pUnkOuter, global::System.Guid* riid, void** ppvObject)
62.                         {
63.                                 try
64.                                 {
65.                                         winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
66.                                         if (__hr.Failed)
67.                                         {
68.                                                 return __hr;
69.                                         }
70.                                         return __object.CreateInstance(pUnkOuter, riid, ppvObject);
71.                                 }
72.                                 catch (Exception ex)
73.                                 {
74.                                         return (winmdroot.Foundation.HRESULT)ex.HResult;
75.                                 }
76.                         }
78.                         public unsafe winmdroot.Foundation.HRESULT CreateInstance([Optional] winmdroot.System.Com.IUnknown* pUnkOuter, global::System.Guid* riid, void** ppvObject)
79.                         {
80.                                 return ((delegate *unmanaged [Stdcall]<IClassFactory*,winmdroot.System.Com.IUnknown* ,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT>)lpVtbl[3])((IClassFactory*)Unsafe.AsPointer(ref this), pUnkOuter, riid, ppvObject);
81.                         }
83.                         [UnmanagedCallersOnly(CallConvs = new []{
84. typeof(CallConvStdcall)}
85. )]
86.                         private static winmdroot.Foundation.HRESULT LockServer(IClassFactory* pThis, winmdroot.Foundation.BOOL fLock)
87.                         {
88.                                 try
89.                                 {
90.                                         winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
91.                                         if (__hr.Failed)
92.                                         {
93.                                                 return __hr;
94.                                         }
95.                                         return __object.LockServer(fLock);
96.                                 }
97.                                 catch (Exception ex)
98.                                 {
99.                                         return (winmdroot.Foundation.HRESULT)ex.HResult;
100.                                 }
101.                         }
103.                         public winmdroot.Foundation.HRESULT LockServer(winmdroot.Foundation.BOOL fLock)
104.                         {
105.                                 return ((delegate *unmanaged [Stdcall]<IClassFactory*,winmdroot.Foundation.BOOL ,winmdroot.Foundation.HRESULT>)lpVtbl[4])((IClassFactory*)Unsafe.AsPointer(ref this), fLock);
106.                         }
108.                         internal unsafe global::Windows.Win32.Foundation.HRESULT QueryInterface<T>(out T* ppv)
109. where T : unmanaged
111.                         {
112.                                 Guid guid = typeof(T).GUID;
113.                                 void* pv;
114.                                 var hr = this.QueryInterface(&guid, &pv);
115.                                 if (hr.Succeeded)
117.                                 {
118.                                         ppv = (T*)pv;
119.                                 }
120.                                 else
122.                                 {
123.                                         ppv = null;
124.                                 }
126.                                 return hr;
127.                         }
129.             // IClassFactory 接口的函数表定义
131.                         internal struct Vtbl
132.                         {
133.                                 internal delegate *unmanaged [Stdcall]<IClassFactory*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT> QueryInterface_1;
135.                                 internal delegate *unmanaged [Stdcall]<IClassFactory*,uint> AddRef_2;
137.                                 internal delegate *unmanaged [Stdcall]<IClassFactory*,uint> Release_3;
139.                                 internal delegate *unmanaged [Stdcall]<IClassFactory*,winmdroot.System.Com.IUnknown* ,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT> CreateInstance_4;
141.                                 internal delegate *unmanaged [Stdcall]<IClassFactory*,winmdroot.Foundation.BOOL ,winmdroot.Foundation.HRESULT> LockServer_5;
142.                         }
144.             // 使用生成的函数逻辑填充函数表
146.                         public static void PopulateVTable(Vtbl* vtable)
147.                         {
148.                                 vtable->CreateInstance_4 = &CreateInstance;
149.                                 vtable->LockServer_5 = &LockServer;
150.                         }
152.             // COM 接口指针中的函数表指针
154.                         private void** lpVtbl;
156.             // 接口的 GUID
158.                         internal static readonly Guid IID_Guid = new Guid(0x00000001, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
160.                         static ref readonly Guid IComIID.Guid                        {
161.                                                                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
162. get
163.                                 {
164.                                         ReadOnlySpan<byte> data = new byte[]                                        {
165. 0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46                                        };
166.                                         return ref Unsafe.As<byte,Guid>(ref MemoryMarshal.GetReference(data));
167.                                 }
168.                         }
170.             // COM 接口对等的 C# 接口定义
172.                         [Guid("00000001-0000-0000-C000-000000000046"),InterfaceType(ComInterfaceType.InterfaceIsIUnknown),ComImport()]
173.                         [SupportedOSPlatform("windows5.0")]
174.                         internal interface Interface
175.                         {
176.                                 [PreserveSig()]
177.                                 unsafe winmdroot.Foundation.HRESULT CreateInstance([Optional] winmdroot.System.Com.IUnknown* pUnkOuter, global::System.Guid* riid, void** ppvObject);
179.                                                                 [PreserveSig()]
180. winmdroot.Foundation.HRESULT LockServer(winmdroot.Foundation.BOOL fLock);
181.                         }
182.                 }
183.         }
184. }

复制代码

天生的 COM 接口是一个结构体，它表达了 COM 接口规范中界说的内存结构，即 COM 接口指针是指向虚函数指针表的指针。
结构体有以下几部门：

• IUnknown 和 IClassFactory 接口方法的函数指针调用的包装。
  
• 使用 C# 实现 COM 接口时，将 COM 接口方法调用转发到托管对象方法调用的包装。
  
• IClassFactory 接口的函数表对应的结构体界说。
  
• 使用添补函数表结构的封装。
  
• COM 接口指针中的函数表指针。
  
• 更容易访问的接口 GUID 属性。
  
• COM 接口对等的 C# 接口界说。
  

使用天生的 COM 接口界说操纵传入的 COM 接口指针

使用这个结构体的方式很简朴，将 COM 接口指针直接转换成此结构体指针，就能调用此中的实例方法了。

1. unsafe void Test(nint punk)
2. {
3.     if (Marshal.QueryInterface(punk, in IClassFactory.IID_Guid, out var ppv) == 0)
4.     {
5.         try
6.         {
7.             var pClassFactory = (IClassFactory*)ppv;
8.             pClassFactory->LockServer(true);
9.             // ...
10.             pClassFactory->Release();
11.         }
12.         finally
13.         {
14.             Marshal.Release(ppv);
15.         }
16.     }
17. }

复制代码

使用 C# 编写支持 AOT 的 COM 对象

编写 COM 对象时情况轻微有些复杂。dotnet 8 时引入了 StrategyBasedComWrappers 和ComWrappers 源天生器，可以使用 GeneratedComClassAttribute 编写 COM 对象，但干系的接口界说都须要在源码中提供，没办法使用 CsWin32 已经整理好的接口界说。
幸亏 CsWin32 提供了和 ComWrappers 互操纵的接口，颠末亿点点简朴的设置就能复用上述天生的 COM 接口界说了。
参考 ComWrappers 文档，创建托管对象包装器最告急的一部门就是通过 ComWrappers.ComputeVtables 方法向运行时提供目标 COM 接口的 GUID 和函数表界说。
上文分析了 CsWin32 天生的 COM 接口界说的内容，此中有接口 GUID，接口函数表结构，将调用转发到托管对象调用的接口函数实现，也就是说我们只须要将这些东西组合在一起，就能将 CsWin32 和 ComWrappers 团结使用了。
我们以 IStream 为例，托管实现参考 WPF 中的 ManagedIStream。
起首我们编写一些辅助代码用以天生 ComWrappers 所需的 ComInterfaceEntry。
参考 ComInterfaceTable，此中 IComIID 接口界说了接口 GUID 静态属性，IVTable 提供了静态函数表指针属性，它从 IVTable 接口中获取静态的指向 COM 接口函数表的指针。

1. internal readonly unsafe struct ComInterfaceTable
2. {
3.     public ComWrappers.ComInterfaceEntry* Entries { get; init; }
4.     public int Count { get; init; }
6.     /// <summary>
7.     ///  Create an interface table for the given interface.
8.     /// </summary>
9.     public static ComInterfaceTable Create<TComInterface>()
10.         where TComInterface : unmanaged, IComIID, IVTable
11.     {
12.         Span<ComWrappers.ComInterfaceEntry> entries = AllocateEntries<TComInterface>(1);
13.         entries[0] = GetEntry<TComInterface>();
15.         return new()
16.         {
17.             Entries = (ComWrappers.ComInterfaceEntry*)Unsafe.AsPointer(ref entries[0]),
18.             Count = entries.Length
19.         };
20.     }
22.     [MethodImpl(MethodImplOptions.AggressiveInlining)]
23.     private static Span<ComWrappers.ComInterfaceEntry> AllocateEntries<T>(int count)
24.     {
25.         Span<ComWrappers.ComInterfaceEntry> entries = new(
26.             (ComWrappers.ComInterfaceEntry*)RuntimeHelpers.AllocateTypeAssociatedMemory(typeof(T), sizeof(ComWrappers.ComInterfaceEntry) * (count + 1)),
27.             count);
28.         return entries;
29.     }
31.     [MethodImpl(MethodImplOptions.AggressiveInlining)]
32.     private static ComWrappers.ComInterfaceEntry GetEntry<TComInterface>() where TComInterface : unmanaged, IComIID, IVTable
33.         => new()
34.         {
35.             Vtable = (nint)TComInterface.VTable,
36.             IID = *GetIID<TComInterface>()
37.         };
39.     // https://github.com/dotnet/winforms/blob/f020fe71f615cb51aa61970f5aaa757bb981499e/src/System.Private.Windows.Core/src/Windows/Win32/System/Com/IID.cs#L32
40.     private static Guid* GetIID<T>() where T : unmanaged, IComIID
41.         => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in T.Guid));
42. }

复制代码

接下来须要将 COM 接口的函数表与托管对象关联的接口。参考 IManagedWrapper。

1. internal unsafe interface IManagedWrapper
2. {
3.     ComInterfaceTable GetComInterfaceTable();
4. }
6. internal unsafe interface IManagedWrapper<TComInterface> : IManagedWrapper
7.     where TComInterface : unmanaged, IVTable, IComIID
8. {
9.     // Allocates a ComInterfaceTable include VTable for the given interface type.
10.     private static ComInterfaceTable InterfaceTable { get; set; } = ComInterfaceTable.Create<TComInterface>();
12.     ComInterfaceTable IManagedWrapper.GetComInterfaceTable() => InterfaceTable;
13. }

复制代码

第一次读取 IVTable 接口中的函数表指针时，它会分配一段内存，而且将函数表中的函数指针指向 CsWin32 天生的静态方法，参考 IVTable`2.cs 和 ComHelpers.cs。
COM 体系中通过 IUnknown 接口界说的 QueryInterface、AddRef、Release 三个方法提供范例转换和引用计数管理功能，这部门我们须要对接到 ComWrappers 上，以将引用计数和 dotnet gc 关联起来。
访问 IVTable 接口天生函数表时会主动调用 ComHelpers.PopulateIUnknown， ComHelpers.PopulateIUnknown 内部会调用 ComHelpers.PopulateIUnknownImpl，我们可以通过此方法和 ComWrappers 的运行时部门关联。参考 WinFormsComWrappers。

1. namespace Windows.Win32
2. {
3.     unsafe partial class ComHelpers
4.     {
5.         // Populate vtable using IUnknown method implemented by ComWrappers
6.         static partial void PopulateIUnknownImpl<TComInterface>(IUnknown.Vtbl* vtable) where TComInterface : unmanaged
7.         {
8.             ComWrappers.GetIUnknownImpl(out nint fpQueryInterface, out nint fpAddRef, out nint fpRelease);
10.             vtable->QueryInterface_1 = (delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void*, HRESULT>)fpQueryInterface;
11.             vtable->AddRef_2 = (delegate* unmanaged[Stdcall]<IUnknown*, uint>)fpAddRef;
12.             vtable->Release_3 = (delegate* unmanaged[Stdcall]<IUnknown*, uint>)fpRelease;
13.         }
14.     }
15. }

复制代码

随后实现我们自界说的 ComWrappers，让运行时可以从我们的 C# 范例中读取 COM 接口函数表，并将天生的 RCW 和托管对象关联起来。参考 WinFormsComWrappers。

1. public class CustomComWrappers : ComWrappers
2. {
3.     protected override unsafe ComWrappers.ComInterfaceEntry* ComputeVtables(object obj, CreateComInterfaceFlags flags, out int count)
4.     {
5.         if (obj is not IManagedWrapper vtables)
6.         {
7.             Debug.Fail("object does not implement IManagedWrapper");
8.             count = 0;
9.             return null;
10.         }
12.         // Bind the vtables for the interfaces implemented by the object.
13.         ComInterfaceTable table = vtables.GetComInterfaceTable();
14.         count = table.Count;
16.         return table.Entries;
17.     }
19.     protected override object? CreateObject(nint externalComObject, CreateObjectFlags flags)
20.     {
21.         throw new NotImplementedException();
22.     }
24.     protected override void ReleaseObjects(IEnumerable objects)
25.     {
26.         throw new NotImplementedException();
27.     }
28. }

复制代码

如今我们有了全部的根本办法，可以开始编写 ManagedIStream 了。这里只展示范例界说，具体方法实现不再赘述。

1. public class ManagedIStream : IManagedWrapper<IStream>, IStream.Interface
2. {
3.     //...
4. }
6. // 创建 ComWrappers
7. var comWrappers = new CustomComWrappers();
9. // 创建内存流
10. var stream = new MemoryStream(100);
11. stream.Write([1, 2, 3, 4, 5, 6, 7, 8, 9]);
13. // 创建托管包装器
14. var wrapper = new ManagedIStream(stream);
16. // 使用 ComWrappers 创建托管包装器的 COM 指针，注意此时返回的是 IUnknown 而非 IStream
17. var punk = (IUnknown*)comWrappers.GetOrCreateComInterfaceForObject(
18.     wrapper,
19.     CreateComInterfaceFlags.None);
21. punk->QueryInterface<IStream>(out var pStream).ThrowOnFailure();
23. // 此时 pStream 可以传递给其他 COM 接口使用。

复制代码

查察全部代码 https://gist.github.com/cnbluefire/7438e4c062f34b89e6855ad57605219a。