QueryInterface for custom interface on untyped ComObject always returns E_NOINTERFACE

[smourier]

I'm using .NET 8 (and AOT), my csproj looks this this:

 <Project Sdk="Microsoft.NET.Sdk">
	<PropertyGroup>
		<OutputType>Exe</OutputType>
		<TargetFramework>net8.0</TargetFramework>
		<Nullable>enable</Nullable>
		<PublishAot>true</PublishAot>
		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
	</PropertyGroup>
</Project>

and I also have

[assembly: DisableRuntimeMarshalling]

Let's say I have a native COM object that supports 2 interfaces: IMy1 and IMy2.

Let's say I can get an instance of this COM object using for example a function, like

[LibraryImport("My.dll")]
public static partial int CreateObject(in Guid iid, [MarshalUsing(typeof(UniqueComInterfaceMarshaller<object>))] out object ppv);

(I've tried ComInterfaceMarshaller too)

If I do this:

CreateObject(typeof(IMy1).GUID, out var my1); // works fine
var sw = new StrategyBasedComWrappers();
var unk = sw.GetOrCreateComInterfaceForObject(obj, CreateComInterfaceFlags.None); // works fine
var iid = typeof(IMy2).GUID;
hr = Marshal.QueryInterface(unk, ref iid, out var my2); // E_NOINTERFACE ???

Then hr value is set to E_NOINTERFACE.

This, on the other end, works fine:

[LibraryImport("My.dll")]
public static partial int CreateObject(in Guid iid, out nint ppv);

CreateObject(typeof(IMy1).GUID, out var unk); // works fine
var iid = typeof(IMy2).GUID;
Marshal.QueryInterface(unk, ref iid, out var my2); // works fine

Is this expected? What am I missing? Should I always start with an IntPtr? It looks weird.

[rmsimpson]

This seems like a very COM-ish way to do something in .NET. I have my library declaration defined the same way you have, and I simply do this:

CreateObject(typeof(IMy1).GUID, out var my1);
if (my1 is IMy2 my2)
{
    // do something with my2
}

It'd be helpful to see how the interface is declared as well. Are you using [GeneratedComInterface] ?

	[GeneratedComInterface]
	[Guid("12345678-ABCD-1234-0000-000000000000")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal partial interface IMy1
	{
		void DoSomething();
	}

[smourier]

Yes I use generated GeneratedCominterface. It's COM-ish because well... it's supposed to be COM. What you say is true and your code works, but the problem is I need to pass the object back to native code which fails since it's doing a QueryInterface. Documentation here https://learn.microsoft.com/en-us/dotnet/standard/native-interop/tutorial-comwrappers clearly states this:

Be aware that the returned Managed Object Wrapper from the call to GetOrCreateComInterfaceForObject() is of type IUnknown*. If the native API that's being passed to the wrapper requires a different interface, a Marshal.QueryInterface() for that interface must be performed.

[rmsimpson]

You mentioned AOT. The article you quoted also states:

any wrapper implementation must be careful not to inadvertently introduce cases where AOT breaks down, such as using reflection. The Type.GUID property is an example of where reflection is used, but in a non-obvious way. The Type.GUID property uses reflection to inspect the type's attributes and then potentially the type's name and containing assembly in order to generate its value.

I'm going to assume you've tried this with and without AOT, but I thought I'd mention it anyway. The code I've written for COM using the generators is working well including passing COM objects to native code for callbacks -- but the objects I'm sending to native code are all .NET classes with [GeneratedComClass] attributes, and not objects I've obtained from native code directly.

[smourier]

Even if I run or publish with AOT (and I get zero warning while usually AOT compiler does a good job raising warnings when needed) all guids are fine I can output them, etc.. For me the ComObject should simply delegate QueryInterface calls when it doesn't handle it, but for some reason it doesn't seem it does...

[smourier]

Ok , I finally got it.

Calling this:

var unk = sw.GetOrCreateComInterfaceForObject(obj, CreateComInterfaceFlags.None);

Works fine but is not what I want. I find the doc here https://learn.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.comwrappers.getorcreatecominterfaceforobject a bit ambiguous, it says:

Creates a COM representation of the supplied object that can be passed to a non-managed environment.

So what is does is "create" a Managed Object Wrapper (used to be called CCW) that here doesn't implement interfaces of course, but since the COM object is already a native object we just want it's original (or wrapped) pointer.

And this is available using the ComWrappers.TryGetComInstance(Object, IntPtr) Method:

Determines if the specified managed object is a ComWrappers-created managed wrapper and if so, returns the wrapped unmanaged pointer.

So in my code:

 ComWrappers.TryGetComInstance(obj, out var unk);

IMHO, doc is ambiguous and unclear here and the overall API shape & naming (ComInstance vs ComInterface, etc.) is also a bit strange. This all misses examples.