如何在C ++汇编中使用`#import`和`tlb`文件在C ++中实现COM回调接口？

Question

The following fictive and minimal example explains the question.

You have a C#/.NET library which exports the interface via COM to use from C++.

[C++ Application] --- is using ---> [via COM] [C#/.NET Library]

The library on the C#/.NET side looks like this:

[Guid("example-0000-0000-0000-0000000000000")]
public class MyObj : IMyObj
{
    void SetLogger(ILogger logger);
    void DoSomething(string someArgument);
}

The assembly is compiled and a tlb file is exported called MyObj.tlb . This tlb file is imported in the Application using the #import statement from Visual-C++:

#import "MyObj.tlb" named_guids auto_rename

void someFunc()
{
    MyObjPtr myObj;
    myObj.CreateInstance(CLSID_MyObj);
    // How to set the logger?
    myObj->DoSomething(_bstr_t(L"foo"));
    // ...
}

Everything works really fine, but you would like to enable logging for the C#/.NET library. The internals of the C#/.NET library should be able to send the log messages back to the C++ application in order to use the already existing logging environment there to write log messages.

[C++ Logging System] <--- log message --- [C#/.NET Component]

You already declared the interface for the logger in the C#/.NET component.

[Guid("example-0000-0000-0000-0000000000000")]
public interface ILogger
{
    void WriteLine(string line); 
}

The question is:

(Without using ATL or MFC)

Answer 1

The ILogger interface derives from IDispatch , but the C# interop layer does not actually use the IDispatch interface. Therfore only the IUnknown interface needs to be implemented.

See the section "Limiting the interface in C# to early binding using IUnknown " below, how you can change your C# component to avoid the IDispatch interface completely.

The implementation for the ILogger interface described in the question will look like this:

#import "MyObj.tlb" named_guids auto_rename

class Logger : public ILogger
{
public:
    Logger(MyLogger log)
        : _log(log), _refCount(1)
    {
    }

    virtual ~Logger()
    {
    }

public: // Implement ILogger
    virtual HRESULT __stdcall raw_WriteLine(BSTR message) {
        // Convert BSTR and write to _log.
        return S_OK;
    }

public: // Implement IDispatch
    virtual HRESULT __stdcall GetTypeInfoCount(UINT *pctinfo)
    {
        return E_NOTIMPL;
    }

    virtual HRESULT __stdcall GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
    {
        return E_NOTIMPL;
    }

    virtual HRESULT __stdcall GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
    {
        return E_NOTIMPL;
    }

    virtual HRESULT __stdcall Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
    {
        return E_NOTIMPL;
    }

public: // Implement IUnknown
    virtual HRESULT __stdcall QueryInterface(REFIID riid, void **ppvObject)
    {
        if (riid == IID_IUnknown) {
            *ppvObject = static_cast<IUnknown*>(this); 
            AddRef();
            return S_OK;
        }
        if (riid == IID_IDispatch) {
            *ppvObject = static_cast<IDispatch*>(this); 
            AddRef();
            return S_OK;
        }
        if (riid == IID_ILogger) {
            *ppvObject = static_cast<ILogger*>(this) ;
            AddRef();
            return S_OK;
        }
        *ppvObject = nullptr;
        return E_NOINTERFACE;
    }

    virtual ULONG __stdcall AddRef()
    {
        return InterlockedIncrement(&_refCount);
    }

    virtual ULONG __stdcall Release()
    {
        return InterlockedDecrement(&_refCount);
    }

private:
    MyLogger _log;
    long _refCount;
}

Please note the following important things about this implementation:

• The reference count is just implemented to look like a COM reference count. Because this object will be owned by the C++ application, there is no need to implement the destruction of the object.
• All IDispatch methods just return an error code. They are never called by C# interop. See the section "Working implementation of IDispatch " for details how to implement these methods.
• IN a real project, the imported types form the tlb are all placed in a own namespace.
• The class declaration and implementation should be separated in a header and implementation file.

The code is used like this in the C++ application:

bool MyApp::start()
{
    try {
        HRESULT hresult;
        MyObjPtr myObj;
        hresult = myObj.CreateInstance(CLSID_MyObj);
        if (hresult != S_OK) { 
            return false;
        }
        // Create the logger object which acts as callback for the C# library
        _logger = new Logger(_myLogger);
        // Assign this logger
        myObj->SetLogger(_logger);
    } catch (const _com_error &comError) {
        return false;
    }
}

Limiting the interface in C# to early binding using IUnknown

User Astrotrain pointed out a simplification to remove IDispatch : If your component ist just used by this C++ Application and therefore does not require late binding using the IDispatch interface, you can add the InterfaceType attribute to the interface to remove one binding.

This would look like this in our example:

[InterfaceType(ComInterfaceType.InterfaceIsIUnknown),
 Guid("example-0000-0000-0000-0000000000000")]
public interface ILogger
{
    void WriteLine(string line); 
}

The ILogger interface is now directly derived from IUnknown . Now you can omit all empty implementations of the IDispatch interface.

The downside is your component can only be used from languages which are supporting early binding. If this C++ Application is the only user of your component, this is no problem.

Working implementation of IDispatch

User Paulo Madeira provided a complete example how to implement all IDispatch methods using ITypeInfo . The following example shows the Logger class, omitting all methods which are shown in the example at the begin of this answer. Make sure you read the notes below.

class Logger : public ILogger
{
    // ctor, dtor, ILogger and IUnknown implementation

public: // Implement IDispatch
    virtual HRESULT __stdcall GetTypeInfoCount(UINT *pctinfo)
    {
        if (pctinfo == nullptr) {
            return E_POINTER;
        }
        *pctinfo = (getTypeInfo() != nullptr) ? 1 : 0;
        return S_OK;
    }

    virtual HRESULT __stdcall GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
    {
        if (ppTInfo == nullptr) {
            return E_POINTER;
        }
        *ppTInfo = nullptr;
        if (iTInfo != 0) {
            return DISP_E_BADINDEX;
        }
        ITypeInfoPtr typeInfo(getTypeInfo());
        if (typeInfo == nullptr) {
            return E_NOTIMPL;
        }
        *ppTInfo = typeInfo.Detach();
        return S_OK;
    }

    virtual HRESULT __stdcall GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
    {
        if (rgDispId == nullptr) {
            return E_POINTER;
        }
        *rgDispId = 0;
        if (!IsEqualIID(riid, IID_NULL)) {
            return E_INVALIDARG;
        }
        ITypeInfoPtr typeInfo(getTypeInfo());
        if (typeInfo == nullptr) {
            return E_NOTIMPL;
        }
        if (cNames == 0) {
            return E_INVALIDARG;
        }
        return typeInfo->GetIDsOfNames(rgszNames, cNames, rgDispId);
    }

    virtual HRESULT __stdcall Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
    {
        if (pDispParams == nullptr) {
            return E_POINTER;
        }
        // IDispatch and ITypeInfo allows this to be NULL
        if (pVarResult != nullptr) {
            VariantInit(pVarResult);
        }
        // IDispatch and ITypeInfo allows this to be NULL
        if (pExcepInfo != nullptr) {
            ZeroMemory(pExcepInfo, sizeof(EXCEPINFO));
        }
        // IDispatch allows this to be NULL, ITypeInfo does not
        UINT argErr;
        if (puArgErr == nullptr) {
            puArgErr = &argErr;
        }
        *puArgErr = 0;
        if (!IsEqualIID(riid, IID_NULL)) {
            return E_INVALIDARG;
        }
        ITypeInfoPtr pTypeInfo(getTypeInfo());
        if (pTypeInfo == nullptr) {
            return E_NOTIMPL;
        }
        return pTypeInfo->Invoke(
            static_cast<ILogger*>(this),
            dispIdMember,
            wFlags,
            pDispParams,
            pVarResult,
            pExcepInfo,
            puArgErr);
    }

private:
    static ITypeInfo* getTypeInfo()
    {
        if (!_hasTypeLib) {
            ITypeLibPtr typeLib;
            if (SUCCEEDED(LoadRegTypeLib(LIBID_MyObj, 1, 0, 0, &typeLib))) {
                ITypeInfoPtr typeInfo;
                if (SUCCEEDED(typeLib->GetTypeInfoOfGuid(IID_IDispatch, &typeInfo))) {
                    if (!InterlockedCompareExchange(&_hasTypeLib, 1, 0)) {
                        _typeInfo.Attach(typeInfo.Detach());
                    }
                }
            }
        }
        return _typeInfo.GetInterfacePtr();
    }

private:
    static LONG volatile _hasTypeLib;
    static ITypeInfoPtr _typeInfo;
    // other variables
};

// Static definitions in cpp file:
LONG volatile Logger::_hasTypeLib;
ITypeInfoPtr Logger::_typeInfo;

Note the following things about this example above:

• You have to replace the LIBID_MyObj with the library identifier of your library. It has a similar naming.
• The full implementation is only required if your COM component requires late binding.
• The class declaration and implementation should be separated in a header and implementation file.
• The static_cast<ILogger*>(this) casts are required to make sure the pointer, which is passed as void* pointer, points to the right vtable .