Hi all,
I have client C++ application, which connects to whatever automation server.
For it, I wrote simple UtAtomation class which encapsulates IDispatch
interfeace.
Everything works good, but if user manually unloads Automation server, and
continue to work with our application, he/she gets messages likes as  "RPC
is unavailable...".
How my application may recognize that server has been unloaded ?

My solution is :

static UtAutomation* m_pAutomation;

className:method {

// init UtAutomation, create object ,save in the class members
IUknown*,IDispatch*...
       m_pAutomation = new UtAutomation("..");
       ASSERT(m_pAutomation, UtIncorrectCodeError);
       result = m_pAutomation -> CreateObject();

   >>    ..........here goes automation scripts.....

here additional worker thread runs, whith the next thread procedure :
{
// check whether server still running
      while(m_pAutomation -> isServerLoaded(false)) {;}

// send message to main thread - server has been unloaded , do something
::PostMessage(*(HWND*) pWin,WM_WORD_UNLOADED_BY_USER,0,0);
   return 0;

bool UtAutomation::isServerLoaded(bool i_showError)
{
    IUnknown     *pUnknownInterface;
    if (!m_pUnknownInterface) return false;

    HRESULT hr;
    hr = ::GetActiveObject (m_classID, NULL,&pUnknownInterface);
    if (FAILED(hr) || pUnknownInterface != m_pUnknownInterface)
    {
      if (m_pUnknownInterface) m_pUnknownInterface->Release();
      if (m_pDispatchInterface) m_pDispatchInterface->Release();
      if (i_showError)
          MessageBox(0,"COM Server has been unloaded.","Automation
Error",MB_OK);
      return false;
    }
    return true;

Any advice gratefully accepted. Thanks...

--
Tim Hill -- Windows NT MVP

(Pursuant to US Code, Title 47, Chapter 5, Subchapter II, 227, any and all
nonsolicited commercial E-mail sent to this address is subject to a download
and archival fee in the amount of $1000 US.  E-mailing denotes acceptance of
these terms.)

As far as shutdown is concerned, there have been several "guidelines"
suggested by MS, most of which are contradictory. The general rule that I
follow, and which seems to make most sense of these guidelines, is that if
the server supports multiple distinct objects, then you should follow the
rule I specified. If the server only supports a single object, then you
should shut down as soon as the user requests it. It's more or less
equivalent to the old SDI/MDI thing. It's not documented as such, but
reading between the lines I think this is what the MFC guys had in mind, for
example.

--
Tim Hill -- Windows NT MVP

(Pursuant to US Code, Title 47, Chapter 5, Subchapter II, 227, any and all
nonsolicited commercial E-mail sent to this address is subject to a download
and archival fee in the amount of $1000 US.  E-mailing denotes acceptance of
these terms.)

Note The end user has explicit control over the lifetime of an application, even if there are external locks on it. That is, if a
user decides to close the application (File, Exit), it must shut down. In the presence of external locks (such as the lock set by
CoLockObjectExternal), the application can call the CoDisconnectObject function to force these connections to close prior to
shutdown.

and last time I test, InternetExplorer just works in this way. It shutdown itself even if
other applicaiton has a connection / instance pointer to it.

I'm looking forward to see all the automation server capable applicaiton
will follow that guideline.