QuickOPC-COM C++: Configuring EasyDAClient ItemChanged

Overview: What Breaks When You Leave the Sample's main()

The shipped QuickOPC-COM C++ samples (for example the ReadMultipleItems Win32 console project) do everything inside _tmain: CoInitialize(NULL), create the client, read, exit. That structure hides three problems that appear the moment you wrap the client in your own class:

1. The COM smart pointer becomes a class member, so its lifetime is no longer bounded by the function that called CoInitialize.
2. Callbacks (the ItemChanged event) require a connection-point sink and an apartment that can actually deliver the call — a console main() with no message pump will silently never fire an STA event.
3. Item IDs arrive from your application as std::string/std::wstring, not as literals, so every call needs a defined BSTR conversion path.

The type library reference used by the samples is:

#import "libid:FAB7A1E3-3B79-4292-9C3A-DF39A6F65EC1" version(5.2)  // EasyOpcLib

Everything below assumes that same library version. If your installed build exposes a different version attribute, change the version() clause or drop it and let #import take the latest registered one; a mismatch here produces a compile-time "cannot find type library" error, not a runtime fault.

Step 1 — Split the Declaration from the Instantiation

Put the #import in the precompiled header so the generated .tlh/.tli wrapper is produced once and every translation unit sees identical types. Do not put using namespace EasyOpcLib; in a public header — fully qualify instead, otherwise the smart-pointer typedefs collide with anything else in your project namespace.

pch.h / stdafx.h

#include <atlbase.h>
#include <atlcom.h>
#include <atlsafe.h>
#include <comutil.h>
#import "libid:FAB7A1E3-3B79-4292-9C3A-DF39A6F65EC1" version(5.2)  // EasyOpcLib

OPC_Client.h — declaration only. No CreateInstance in a header.

#pragma once
#include "pch.h"
#include <string>

class OPC_Client
{
public:
    OPC_Client();
    ~OPC_Client();

    HRESULT Initialize();          // creates the COM object
    void    Shutdown();            // releases it deterministically
    HRESULT ReadItem(const std::wstring& serverClass,
                     const std::wstring& itemId,
                     VARIANT& value);
private:
    EasyOpcLib::IEasyDAClientPtr m_client;   // _com_ptr_t member, empty until Initialize()
    bool m_comInitialized;
};

OPC_Client.cpp — instantiation lives here.

#include "pch.h"
#include "OPC_Client.h"

OPC_Client::OPC_Client() : m_comInitialized(false) {}

HRESULT OPC_Client::Initialize()
{
    HRESULT hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
    if (hr == RPC_E_CHANGED_MODE) { /* thread already in an STA - accept it */ }
    else if (FAILED(hr)) return hr;
    else m_comInitialized = true;

    hr = m_client.CreateInstance(__uuidof(EasyOpcLib::EasyDAClient));
    return hr;
}

void OPC_Client::Shutdown()
{
    m_client = NULL;                       // Release() BEFORE CoUninitialize
    if (m_comInitialized) { ::CoUninitialize(); m_comInitialized = false; }
}

OPC_Client::~OPC_Client() { Shutdown(); }

Step 2 — std::string, BSTR and the Argument Arrays

The COM interface takes BSTR. Use _bstr_t (from <comutil.h>, already included by the samples) as the conversion vehicle — it owns the allocation and frees it on scope exit.

HRESULT OPC_Client::ReadItem(const std::wstring& serverClass,
                             const std::wstring& itemId, VARIANT& value)
{
    if (m_client == NULL) return E_POINTER;
    try {
        _variant_t v = m_client->ReadItemValue(_bstr_t(L""),
                                               _bstr_t(serverClass.c_str()),
                                               _bstr_t(itemId.c_str()));
        return ::VariantCopy(&value, &v);
    }
    catch (const _com_error& e) { return e.Error(); }
}

Multi-item calls take a SAFEARRAY of argument objects — that is why the shipped sample includes <atlsafe.h>. Build it with CComSafeArray<VARIANT>, populating each element with an IDispatch* wrapped in a VARIANT:

CComSafeArray<VARIANT> args(2);
EasyOpcLib::_DAItemGroupArgumentsPtr a1(__uuidof(EasyOpcLib::DAItemGroupArguments));
a1->ServerClass = _bstr_t(L"OPCLabs.KitServer.2");
a1->ItemDescriptor->ItemId = _bstr_t(L"Simulation.Random");
args.SetAt(0, _variant_t((IDispatch*)a1));

Step 3 — Wiring the ItemChanged Event Sink

Subscriptions are asynchronous: the client raises ItemChanged through a connection point on the outgoing (source) dispinterface. In C++ you implement the sink yourself. ATL's IDispEventSimpleImpl is the lowest-friction route because it avoids re-parsing the type library at compile time.

1. Find the source interface IID and the ItemChanged DISPID in the generated .tlh (or with the Visual Studio Object Browser against EasyOpcLib 5.2).
2. Derive your class from IDispEventSimpleImpl<1, OPC_Client, &IID_of_source_interface>.
3. Declare the sink map with SINK_ENTRY_INFO using that DISPID and an _ATL_FUNC_INFO describing the parameter list (typically VT_EMPTY return, VT_DISPATCH sender, VT_DISPATCH event-args).
4. Call DispEventAdvise(m_client) after CreateInstance and DispEventUnadvise(m_client) before releasing.
5. Only then call the subscribe method with your item arguments and a requested update rate (the samples use 1000 ms against OPCLabs.KitServer.2, items Simulation.Random and Trends.Ramp (1 min)).

class OPC_Client :
    public CComObjectRootEx<CComMultiThreadModel>,
    public IDispEventSimpleImpl<1, OPC_Client, &__uuidof(EasyOpcLib::DEasyDAClientEvents)>
{
public:
    BEGIN_SINK_MAP(OPC_Client)
        SINK_ENTRY_INFO(1, __uuidof(EasyOpcLib::DEasyDAClientEvents),
                        DISPID_ITEMCHANGED, &OnItemChanged, &s_itemChangedInfo)
    END_SINK_MAP()

    void __stdcall OnItemChanged(IDispatch* sender, IDispatch* eventArgs);
private:
    static _ATL_FUNC_INFO s_itemChangedInfo;
};

_ATL_FUNC_INFO OPC_Client::s_itemChangedInfo =
    { CC_STDCALL, VT_EMPTY, 2, { VT_DISPATCH, VT_DISPATCH } };

Substitute the real source-interface name and DISPID constant from your .tlh; the names above are placeholders for whatever the type library declares.

Why events never arrive

Step 4 — IntelliSense Errors vs. Real Build Errors

Red squiggles under IEasyDAClientPtr, _bstr_t conversions or #import-generated types are usually IntelliSense artifacts: the IntelliSense engine does not always consume the compiler-generated .tlh/.tli from the intermediate directory. Distinguish the two before you spend time on it:

1. Run Build > Rebuild Solution and read the Output window, not the Error List. The Error List merges IntelliSense diagnostics with compiler diagnostics.
2. Real compiler errors start with Cnnnn (for example C2065, C2039) and carry a file/line from cl.exe. IntelliSense-only entries are tagged IntelliSense: or Enn.
3. If the build succeeds and only IntelliSense complains, close the solution, delete the .vs folder (or the legacy .sdf/ipch files), reopen, and let the database rebuild. If it still complains, ignore it.
4. Confirm the wrapper actually generated: the .tlh must exist in $(IntDir) after a rebuild. If it does not, the #import failed and you have a genuine registration/version problem.

Verification Procedure

1. Build for a single platform (x86 or x64) and confirm .tlh generation.
2. Call Initialize() and log the HRESULT; a non-zero value stops everything downstream.
3. Do a synchronous read of a known-good simulated tag first (Simulation.Random) to prove connectivity, security and bitness before adding subscriptions.
4. Add the sink, advise, subscribe at 1000 ms, and log every callback with a timestamp. Confirm the interval matches the requested rate — a much slower rate points to the server's own group update behaviour, not the client.
5. Stress the shutdown path: create and destroy your wrapper class 100 times in a loop. Leaks or exit-time crashes here expose lifetime ordering bugs that never surface in a single-shot console sample.

FAQ