Better Interop Support for Unmanaged Interfaces

[tannergooding]

Issue:
There is currently support for four interface types:

• Dual (IDispatch and VTBL exposure with IUnknown implicitly as the first set of entries)
• IDispatch
• IInspectable (Windows Runtime)
• IUnknown (VTBL exposure with IUnknown implicitly as the first set of entries)

This makes it difficult to support interfaces which does not inherit from IUnknown (such as ID3D12FunctionReflection) that are returned from another COM Object that does inherit from IUnknown (such as ID3D12LibraryReflection).

Workaround:
In order to support these objects, one must manually implement a structure that wraps a VTBL, such as:

struct ID3D12FunctionParameterReflection
{
    public Vtbl* lpVtbl;        // or: public IntPtr lpVtbl;

    public struct Vtbl
    {
        public IntPtr GetDesc;  // or: public _GetDesc GetDesc;
    }

    public delegate int _GetDesc(ref ID3D12FunctionParameterReflection @this, out D3D12_PARAMETER_DESC pDesc);
}

Doing this can be error prone and requires a lot of manual coding to get the interop working correctly as you have to either Marshal the Vtbl (using PtrToStructure) or Marshal the individual method pointers (using GetDelegateForFunctionPointer) and you must explicitly pass the this parameter to all method calls.

Request:
We should support a fifth interface type:

• Native (VTBL exposure, where IUnknown is not the first set of entries)

Constructing such an interface would then look like:

[InterfaceType(ComInterfaceType.Native)]
public interface ID3D12FunctionParameterReflection
{
    [PreserveSig]
    int GetDesc(
        [Out] out D3D12_PARAMETER_DESC pDesc
    );
}

The above is much simpler, easier to read/follow. However, given that it does not inherit from IUnknown, its lifetime must be explicitly managed (this was already the case with the workaround listed above).

[jkotas]

cc @yizhang82

[yizhang82]

@tannergooding Thanks for your suggestion. Unfortunately allowing ComInterface.Native changes many fundamental assumptions in COM interop implementation in the system:

1. Every COM interop interface derives from IUnknown
2. Every COM object lifetime is controlled by ref-counts
3. Every RCW wrapper's identity corresponds to a IUnknown of the underlying native object

Supporting ComInterface.Native would require adding special cases to every single place that has these assumptions, and potentially slow down the normal case.

Yes, the issues above can be addressed by adding special case. However, as you've pointed out, lifetime is a bigger problem. As there is no way to reliable control the lifetime of those objects, there is no way to guarantee calling such wrappers with those interfaces are safe. If you hand those wrappers out to other callers, how can they be sure it is safe to call them? This means calling those interfaces are fundamentally unsafe.

There might be ways to make this work, but personally I don't think it is worth the additional complexity in the runtime. Instead, it is best to handle these scenarios with interop code generators.

[yizhang82]

@tannergooding I'm going to close this for now. Feel free to reopen this if you disagrees. Thanks!