How to declare same interface in separate library

Question

I need to have the same interface declared in multiple assemblies - but not reference a common library.

I have identical definitions of the interface, but am getting this error when I try to create an instance of it from another application:

Unable to cast object of type 'myFilter' to type 'DirectShow.IBaseFilter'

(myFilter is declared like: public class myfilter : DirectSow.IBaseFilter...)

The source object is registered using RegAsm.exe

Both assemblies have the declaration:

[ComImport, System.Security.SuppressUnmanagedCodeSecurity,
Guid("56a86895-0ad4-11ce-b03a-0020af0ba770"),
InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IBaseFilter : IMediaFilter
...

The code is copied, so the IMediaFilter and all other declarations are exactly the same.

I try to create an instance of the object using this:

 Type type = Type.GetTypeFromCLSID(new Guid("A3927399-E3AE-41E2-B094-0EA815CC9B9C"));
 IBaseFilter filter = (IBaseFilter)Activator.CreateInstance(type);

How can I cast an object across assemblies?

Answer 1

By definition: you can't. Two separate interfaces what are nothing to do with each other never will be "is a" relationship with each other even they have "same" named and identical members.

The professional solution is separate the interfaces in a standalone assembly, then reference this assembly as many other assemblies as you want. All other is considered hacking (in C#/.NET).

To apply the described solution in this particular case you'll need 2 or 3 assemblies:

Assembly #1: (which "defines" the interface). This "defining" is a COM interface import this particular case:

 [ComImport, System.Security.SuppressUnmanagedCodeSecurity,
 Guid("56a86895-0ad4-11ce-b03a-0020af0ba770"),
 InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
 public interface IBaseFilter : IMediaFilter

Assembly #2: Refers to Assembly #1, and contains a class which implements the interface

Assembly #3: Refers to Assembly #1 and #2, and can access and use/cast the class in Assembly #2. Do not (re)import the interface here. That would be an identical but completely "other" interface for .NET even it has the very same member signatures.

I think the Assembly #1 and #2 could merged in one. Make sure both the interface declaration and class definition are both public. The key is not import twice the COM interface instead import once and refer to it.

Edit: Reflecting to the comment:

Do not confuse COM interfaces and classes with .NET interfaces. (btw the comment mentions a class id not an interface id, which are two different things in COM.)

Accessing COM classes and interfaces in .NET are highly supported via an interop layer. The interop layer does all conversions and marshalling for you, and you access the COM component via a convenient .NET interface. However this interface are defined in an (interop) assambly, and those assemblies (for well known, and often used COM components) are distributed, or part of the download of the original COM stuff. So literally they are on every machine where they needed.

Also a concept difference, that in COM the client (referring component) refers to the server (referenced component) by only a guid (this is the class id), then asks a polymorphic implementation of an interface by also with only a guid. So the client can use a component's particular interface by knowing only two guids, and executing 1-2 COM OS call. This is black boxed for you in the interop layer. In .NET the binding between the client and the server are much stronger.

If you would like to define such kind of interface then you must do the same: somehow define the interface in one assembly then distribute it with every machine where other assemblies are using the interface and referencing this interface.

Options in case you do not accept the best practice:

• You could use reflection to achieve similar looser binding, but in this case that's considered hacking and seems to be unnecessary. Be prepared that your method names and class names will be strings, or at least not typing them correctly will not cause compile error, but will cause runtime errors.

• You can also define and implement COM components in .NET, but I don't think this is the goal. COM is a legacy (and cool) technology what was very progressive (and not understood/criticized) in its time, but this was more than a quarter century ago (when it was introduced)

Answer 2

(This is the solution of the question author DanW)

In the DLL: Make assembly COM-Visible = checked

using System;
using System.Runtime.InteropServices;

namespace ComExport
{
    [ComImport]
    [Guid("EAA4976A-45C3-4BC5-BC0B-E474F4C3C83F")]
    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    [TypeIdentifier()]
    public interface ComClass1Interface
    {
        string DoCall();
    }

    [Guid("0D53A3E8-E51A-49C7-944E-E72A2064F938")]
    [ClassInterface(ClassInterfaceType.AutoDual)]
    public class ComClass1 : ComClass1Interface
    {
        public string DoCall()
        {
            return "internal function called";
        }
        public override string ToString()
        {
            return "comclass1.tostring";
        }
    }
}

then in the EXE

using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace ComExportTester
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

            this.Load += (o1, e) => Close();

            Type t;
            object o;
            ComExport.ComClass1Interface i1;
            string s = "";
            try
            {
                t = Type.GetTypeFromCLSID(new Guid("0D53A3E8-E51A-49C7-944E-E72A2064F938"));
                s += "Type found \t: " + (t == null ? "no" : "yes") + "\n";
                o = t == null ? null : Activator.CreateInstance(t);
                s += "object created \t: " + (o == null ? "no" : o.ToString()) + "\n";
                i1 = o as ComExport.ComClass1Interface;
                s += "interface cast \t: " + (i1 == null ? "no" : "yes") + "\n";
                if (i1 != null)
                    s += i1.DoCall() + "\n";
            }
            catch (Exception x)
            {
                s += x.Message + "\n";
            }
            MessageBox.Show(s);
        }
    }
}
namespace ComExport
{
    [ComImport]
    [Guid("EAA4976A-45C3-4BC5-BC0B-E474F4C3C83F")]
    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    [TypeIdentifier()]
    public interface ComClass1Interface
    {
        string DoCall();
    }
}

in both:

set x86 or x64 (compiling and running in "Any CPU" mode throws a "not registered" exception!)