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;
}