(The library is called MyObjX and the object is called MyObj):

in C++:

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;
using namespace Interop::MyObjX;
using namespace System::Runtime::InteropServices;

[STAThread]
int _tmain()
{
    MyObjClass* emb = __gc new MyObjClass();
    return 0;
}

//in unmanaged c++ (I first added the myobj.IDL file with the contents of
its type library in COM / object viewer, and then compiled it to produce
myobj_i.c and myobj_h.h

#include <tchar.h>
#include <objbase.h>
#include <comdef.h>
#include "myobj_h.h"

void GetPrediction()
{
    HRESULT hr = CoInitialize(NULL);
    _MyObj* ip;
    try
    {
    hr = CoCreateInstance(CLSID_MyObj, NULL, CLSCTX_INPROC_SERVER, IID__MyObj,
(void**)&ip);
    }
    catch(_com_error e)
    {
        const _TCHAR* s = e.ErrorMessage();
    }
    CoUninitialize();
}

// in C# (which works):

using System;
using MyObjX;

namespace UseEmbCsharp
{
    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class Class1
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static int Main(string[] args)
        {
            MyObjX.MyObjClass p = new MyObjClass();
            return 0;
        }
    }
}

That's what I thought. This is why it baffles me.

I can't see what differences there could be - if you can think of any,
please let me know! I've added the [STAThread] attribute to the main of the
MC++ project just like the C# one, and it still doesn't work. I don't know
how to set this for UMC++ - but I think it's more likely to be a security
thing than a threading thing - as the exception that is thrown completely
ignores try..catch handlers, and the COM object is protected with a dongle.
But it is installed completely correctly and legally, and the dongle is
plugged in, and as I say, it works from all languages but ANY breed of
C++.... it's completely weird......

An apartment type mismatch is only going to be a problem if the COM marshalling code (proxy/stub) is not installed properly. This error is a COM error relating to a privileged instruction attempting to be used. It is often in relation to the proxy/stub dll (that has the interface marshalling code in it) being out of step with the definition of the interface the COM object has implemented.

Regards

Richard Blewett - DevelopMentor
http://staff.develop.com/richardb/weblog

  nntp://news.microsoft.com/microsoft.public.dotnet.languages.csharp/<Ogp4wiFsEHA.2340@TK2MSFTNGP11.phx.gbl>

Bonj,

This seems highly unlikely to me, as the mechanism in .NET ultimately
uses the same mechanism that C++ uses. Can you show how you are doing it in
.NET and how you are doing it in C++? Perhaps you are not setting up the
environment or the apartment correctly, and this could be the source of your
problems.

Hope this helps.

Not really, because it isn't a standard one - it's a third party custom
software, and is protected with a dongle. I have emailed the company that
produces it to ask them but whether they'll know or be able to tell me I
don't know. However I have got it fully legally installed and the dongle is
installed on my pc. The strangest thing is it works from VB.NET, VB6 and C#,
just not from any brand of C++.

The code I have been using is this:

#import "c:\program files\emblem modeller 3\MyObjx.dll"
#include <tchar.h>

int _tmain(int argc, _TCHAR* argv[])
{
    CoInitialize(NULL);
    MyObjX::_MyObjPtr model;
    HRESULT hr = model.CreateInstance(__uuidof(MyObjX::MyObj));
    if(hr == S_OK) MessageBox(NULL, _T("EMB Model successfully created"),
_T("COM test"), MB_OK); //it never is.
    CoUninitialize();
}