`DISP_E_UNKNOWNNAME` for non-default interface members

[mediawolf]

Description

My server object implements two interfaces with one being default.
I can access members of the default interface but not of the non-default one.
Instead, I get Unknown name. (0x80020006 (DISP_E_UNKNOWNNAME)) on such access.

Reproduction Steps

My server exposes such COM object:

[ComVisible(true)]
[CLSCompliant(true)]
[ProgId("MyCompany.MyObject")]
[Guid("{CF824E95-642E-4F8D-8CD1-F67BC588B107}")]
[ClassInterface(ClassInterfaceType.None)]
[ComDefaultInterface(typeof(IFirst))]
public sealed class MyObject : IFirst, ISecond
{
    public void Invoke1() {}
    public void Invoke2() {}
}

[ComVisible(true)]
[CLSCompliant(true)]
[Guid("{59DAED5B-726B-4DDD-8F07-9236382038F7}")]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface IFirst
{
    void Invoke1();
}

[ComVisible(true)]
[Guid("{88C3FF65-0155-48A9-917D-E96DFAC8409B}")]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface ISecond
{
    void Invoke2();
}

My client does this:

var myObjectType = Type.GetTypeFromProgID("MyCompany.MyObject", throwOnError: true)!;
dynamic first = Activator.CreateInstance(myObjectType);
first.Invoke1(); // works well
var second = (ISecond)first; // get to an explicit interface implementation
second.Invoke2(); // throws COMException with DISP_E_UNKNOWNNAME

I followed a solution from "Custom wrappers" section of Generating Metadata.

Expected behavior

I can access members of non-default interfaces of COM objects.

Actual behavior

I get COMException with DISP_E_UNKNOWNNAME on access of non-default interface members of COM objects.

Regression?

Works in .NET Framework and .NET 8. Not working since .NET 9.

Known Workarounds

No response

Configuration

Windows 11
.NET 8.0.404
.NET 9.0.308
.NET 10.0.100

Other information

No response

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/interop-contrib
See info in area-owners.md if you want to be subscribed.

[AaronRobinsonMSFT]

A complete repo that passes on .NET 8 and fails on .NET 10 is below.

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

Activation.RegisterClassFactory(new MarshalBuiltInNewInstance<MyObject>());

var myObjectType = Type.GetTypeFromCLSID(typeof(MyObject).GUID, throwOnError: true)!;
dynamic first = Activator.CreateInstance(myObjectType)!;
first.Invoke1(); // works well
var second = (ISecond)first; // get to an explicit interface implementation
second.Invoke2();

[ComVisible(true)]
[CLSCompliant(true)]
[ProgId("MyCompany.MyObject")]
[Guid("CF824E95-642E-4F8D-8CD1-F67BC588B107")]
[ClassInterface(ClassInterfaceType.None)]
[ComDefaultInterface(typeof(IFirst))]
public sealed class MyObject : IFirst, ISecond
{
    public void Invoke1() { }
    public void Invoke2() { }
}

[ComVisible(true)]
[CLSCompliant(true)]
[Guid("59DAED5B-726B-4DDD-8F07-9236382038F7")]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface IFirst
{
    void Invoke1();
}

[ComVisible(true)]
[Guid("88C3FF65-0155-48A9-917D-E96DFAC8409B")]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface ISecond
{
    void Invoke2();
}

//
// Dynamic registration
//

[GeneratedComInterface]
[Guid("00000001-0000-0000-C000-000000000046")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
internal partial interface IClassFactory
{
    void CreateInstance(
        [MarshalAs(UnmanagedType.Interface)] object? pUnkOuter,
        in Guid riid,
        out IntPtr ppvObject);

    void LockServer([MarshalAs(UnmanagedType.Bool)] bool fLock);
}

[GeneratedComClass]
internal partial class ClassFactory : IClassFactory
{
    private readonly IMarshalNewInstance _newInstance;
    public ClassFactory(IMarshalNewInstance newInstance)
    {
        _newInstance = newInstance;
    }

    public unsafe void CreateInstance([MarshalAs(UnmanagedType.Interface)] object? pUnkOuter, in Guid riid, out nint ppvObject)
    {
        Debug.Assert(pUnkOuter is null);
        ppvObject = nint.Zero;

        nint ccw = _newInstance.Create();
        try
        {
            int hr = Marshal.QueryInterface(ccw, in riid, out ppvObject);
            Marshal.ThrowExceptionForHR(hr);
        }
        finally
        {
            Marshal.Release(ccw);
        }
    }

    public void LockServer([MarshalAs(UnmanagedType.Bool)] bool fLock)
    {
    }
}

public interface IMarshalNewInstance
{
    Guid Clsid { get; }
    nint Create();
}

public class MarshalBuiltInNewInstance<T> : IMarshalNewInstance where T : class, new()
{
    public Guid Clsid => typeof(T).GUID;
    public unsafe nint Create()
    {
        T instance = new();
        return Marshal.GetIUnknownForObject(instance);
    }
}

public class MarshalSourceGeneratorNewInstance<T> : IMarshalNewInstance where T : class, new()
{
    public Guid Clsid => typeof(T).GUID;
    public unsafe nint Create()
    {
        T instance = new();
        return (nint)ComInterfaceMarshaller<T>.ConvertToUnmanaged(instance);
    }
}

public static partial class Activation
{
    public static unsafe void RegisterClassFactory(IMarshalNewInstance newInstance)
    {
        ClassFactory factory = new(newInstance);
        nint factoryPtr = (nint)ComInterfaceMarshaller<ClassFactory>.ConvertToUnmanaged(factory);

        try
        {
            const uint CLSCTX_INPROC_SERVER = 1;
            const uint REGCLS_MULTIPLEUSE = 1;
            Guid clsid = newInstance.Clsid;
            int hr = CoRegisterClassObject(
                in clsid,
                factoryPtr,
                CLSCTX_INPROC_SERVER,
                REGCLS_MULTIPLEUSE,
                out nint _);
            Marshal.ThrowExceptionForHR(hr);
        }
        finally
        {
            Marshal.Release(factoryPtr);
        }
    }

    [LibraryImport("ole32")]
    private static partial int CoRegisterClassObject(
        in Guid rclsid,
        nint pUnk,
        uint dwClsContext,
        uint flags,
        out nint lpdwRegister);
}