Re: Firing an event from a worker thread

Hi Alexander,

Thanks, yes you are correct, and if I place AtlWaitWithMessageLoop in
FinalRelease then it does work as long as a post a WM_QUIT message
after it. The other thing I had to do was prevent the event from being
invoked if the application is in the process of being terminated. I
have attached the code, do you think this approach is ok?

Regards,

Chris

template <class T>
class _ITestEvents_EventSink : public IConnectionPointImpl<T,
&DIID__ITestEvents, CComDynamicUnkArray_GIT>
{
public:
int enable_events;

HRESULT Fire_Test()
{
CComVariant varResult;

T* pT = static_cast<T*>(this);
int nConnectionIndex;
int nConnections = m_vec.GetSize();

for (nConnectionIndex = 0; nConnectionIndex < nConnections;
nConnectionIndex++)
{
pT->Lock();
CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
pT->Unlock();
if (enable_events)
{
CComQIPtr< IDispatch, &IID_IDispatch > pDispatch( sp.p );
if (pDispatch.p != NULL)
{
VariantClear(&varResult);
DISPPARAMS disp = { NULL, NULL, 0, 0 };
pDispatch->Invoke(0x1, IID_NULL, LOCALE_USER_DEFAULT,
DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
}
}
}
return varResult.scode;
}
};

/////////////////////////////////////////////////////////////////////////////
// CTest
class ATL_NO_VTABLE CTest :
public CComObjectRootEx<CComSingleThreadModel>,
public CComCoClass<CTest, &CLSID_Test>,
public ISupportErrorInfo,
public IConnectionPointContainerImpl<CTest>,
public _ITestEvents_EventSink< CTest >,
public IPersistImpl<CTest>,
public IDispatchImpl<ITest, &IID_ITest, &LIBID_EXITTESTLib>
{
public:
CTest()
{
semaphore = NULL;
m_hThread = NULL;
keep_going = 0;
enable_events = 0;
}

DECLARE_REGISTRY_RESOURCEID(IDR_TEST)

DECLARE_PROTECT_FINAL_CONSTRUCT()

BEGIN_COM_MAP(CTest)
COM_INTERFACE_ENTRY(ITest)
COM_INTERFACE_ENTRY(IDispatch)
COM_INTERFACE_ENTRY(ISupportErrorInfo)
COM_INTERFACE_ENTRY_IMPL(IConnectionPointContainer)
COM_INTERFACE_ENTRY(IPersist)
END_COM_MAP()

BEGIN_CONNECTION_POINT_MAP(CTest)
CONNECTION_POINT_ENTRY(DIID__ITestEvents)
END_CONNECTION_POINT_MAP()

// ISupportsErrorInfo
STDMETHOD(InterfaceSupportsErrorInfo)(REFIID riid);

// ITest
public:
STDMETHOD(Start)();

HRESULT FinalConstruct();
void FinalRelease();
private:
   static unsigned __stdcall ThreadProc(LPVOID lpParameter);
HANDLE semaphore;
HANDLE m_hThread;
int keep_going;
};

HRESULT
CTest::FinalConstruct()
{
unsigned int threadID;

keep_going = 1;
semaphore = CreateSemaphore(NULL,0,1,NULL);

// create the thread
m_hThread = (HANDLE)_beginthreadex(
NULL,
0,
&ThreadProc,
reinterpret_cast< void* >(this),
0,
&threadID);

//Wait for the thread to signal that it has started
WaitForSingleObject(semaphore, INFINITE);

   return S_OK;
}

void CTest::FinalRelease()
{
OutputDebugString("CTest::FinalRelease()\n");
keep_going = 0;
enable_events = 0;

//Wait for all windows messages to be processed
AtlWaitWithMessageLoop(m_hThread);
//Send another quit message to close the application
::PostThreadMessage(GetCurrentThreadId(), WM_QUIT, 0, 0);

//Wait for it to stop
WaitForSingleObject(semaphore, INFINITE);
CloseHandle(semaphore);
CloseHandle(m_hThread);
}

// the thread function
unsigned __stdcall CTest::ThreadProc(LPVOID lpParameter)
{
   CTest* ptest = reinterpret_cast< CTest* >(lpParameter);
   CoInitializeEx(NULL, COINIT_MULTITHREADED);

ReleaseSemaphore(ptest->semaphore, 1, NULL);

   while (ptest->keep_going)
{
if (ptest->enable_events)
{
ptest->Fire_Test();
}
Sleep(1);
}

   CoUninitialize();

ReleaseSemaphore(ptest->semaphore, 1, NULL);

   return 0;
}

STDMETHODIMP CTest::Start()
{
enable_events = 1;
return S_OK;
}