[COM] Is the runtime supposed to call ComWrappers.ComputeVTables if the object is an RCW?

[savatia]

Hi folks, I'm trying to pass my interface IFoo to an exported function [DllImport("CppProject")] static extern int FooFunction(IFoo foo); but I'm hitting a slight issue. During marshalling, the runtime asks my ComWrapper for the Vtable. I'm able to generate the Vtbale and pass it to the runtime. Problem is, when the exported FooFunction is called, it passes a completely made up pointer to the IFoo instance, but the Vtable is correct. What am I doing wrong?

[ComImport]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[Guid("C859BA31-821B-4947-A04F-5C30C6A94B82")]
public interface IFoo
{
    [PreserveSig]
    int Bar([In][MarshalAs(UnmanagedType.LPStr)] string Message);
}

public class FooComWrapper : IFoo
{
    public struct IFooVtbl
    {
        public IntPtr Bar;
    }

    public IntPtr Instance { get; }
    public IFooVtbl Vtbl { get; }

    public delegate int BarDelegate(IntPtr ptrThis, [MarshalAs(UnmanagedType.LPStr)] string Message);
    public BarDelegate BarFunction { get; set; }

    public FooComWrapper(IntPtr ptr)
    {
        Instance = ptr;
        unsafe
        {
            Vtbl = Marshal.PtrToStructure<IFooVtbl>(new nint(*(void**)ptr.ToPointer()));
            BarFunction = Marshal.GetDelegateForFunctionPointer<BarDelegate>(Vtbl.Bar);
        }
    }

    public int Bar(string Message)
    {
        return BarFunction(Instance, Message);
    }
}

public class FooComWrappers : ComWrappers
{
    protected override unsafe ComInterfaceEntry* ComputeVtables(object obj, CreateComInterfaceFlags flags, out int count)
    {
        ComInterfaceEntry* entry = null;
        count = 0;

        if (obj is FooComWrapper foo)
        {
            // What do I do here lmao?
            count = 1;
            entry = (ComInterfaceEntry*)RuntimeHelpers.AllocateTypeAssociatedMemory(typeof(FooComWrappers), sizeof(ComInterfaceEntry));
            entry->Vtable = *(IntPtr*)foo.Instance.ToPointer();
            entry->IID = typeof(IFoo).GUID;
        }

        return entry;
    }

    protected override object? CreateObject(nint externalComObject, CreateObjectFlags flags)
    {
        return new FooComWrapper(externalComObject);
    }

    protected override void ReleaseObjects(IEnumerable objects)
    {
        throw new NotImplementedException();
    }
}

public static class Program
{
    [DllImport("CppProject")] static extern int FooFactory(out IntPtr ptr);
    [DllImport("CppProject")] static extern int FooFunction(IFoo foo);

    [SupportedOSPlatform("Windows")]
    public static void Main(string[] args)
    {
        ComWrappers.RegisterForMarshalling(new FooComWrappers());
        if (FooFactory(out IntPtr ptrFoo) == 0)
        {
            if (Marshal.GetObjectForIUnknown(ptrFoo) is IFoo foo)
            {
                foo.Bar("RCW");
                _ = FooFunction(foo);      // <<<<<< Pointer passed here to unmanaged function is incorrect but computed vtable is correct
            }
        }
    }
}

[AaronRobinsonMSFT]

/cc @dotnet/interop-contrib

@jkoritzinsky Is Marshal.GetObjectForIUnknown() properly implemented on native AOT?

[savatia]

Is there a workaround for my scenario?

For more context, I'm trying to use ComWrappers with NativeAOT. All the interfaces I'm using are declared in an external library so I can't change them (although I can generate the wrappers), some of them have functions that have COM interface parameters.

[AaronRobinsonMSFT]

Oh right. I forgot about the unwrapping logic.

Is there a workaround for my scenario?

The workaround would be to use the ComWrappers instance directly or call ComWrappers.TryGetComInstance() to get the original pointer.

[savatia]

I would love for a way to override GetOrCreateComInterfaceForObject. I rather not use ComWrappers directly because it would require rewriting a bunch of already existing code and I can't use TryGetComInstance directly because I need to pass the interface object not a pointer.

Anyway, seems this is not entirely supported for now so I'll close this thread.

[jkoritzinsky]

We have a fix for this in #115436.

[savatia]

Thanks! This is going to help me avoid creating CCWs for RCWs, thus preventing this unfortunate callstack: