blocked in IConnectionPoint::Advise

that's great, very appreciate it, will try and back to "Accept answer"

one question, how to handle the multiple-thread safe for m_pcpMgr, m_pcpConn, g_pAgileNlm?

and what will happened if stop the thread2 before thread1 finished?

one question, how to handle the multiple-thread safe for m_pcpMgr, m_pcpConn, g_pAgileNlm?

I don't understand what you are asking here. What do you mean by "handle"? Those three variables contain IAgileReference interface pointers. Basically, they are used to store marshaling data for later use.

and what will happened if stop the thread2 before thread1 finished?

Again, I don't understand your question.

The system creates the main thread when the sample process is started. In the sample this thread creates the Main STA. Other than that, the sample code creates two threads for very specific purposes.

In the sample code the thread that creates the MTA, instantiates the NetworkListManger, the sink , finds the connection point interfaces and performs the Advise is exits after it has done its job.

While the process is running any MTA thread on which events are received is created and managed by the system.

When its time to stop receiving events the sample creates an MTA thread and does the work to call IConnectionPoint::Unadvise on the saved connection point interfaces. Afterwards, this thread exits and then the MTA is shut down.

What I mean is, in my app's scenario, after triggering start, there's a high chance that stop will be triggered almost immediately. In this situation, we need to consider how to handle the timing and concurrency of the two threads.

What I mean is, in my app's scenario, after triggering start, there's a high chance that stop will be triggered almost immediately. In this situation, we need to consider how to handle the timing and concurrency of the two threads.

In your scenario I would use a different design. Use a single MTA thread to do all the work to receive the events but do NOT let it exit. For example, after it has called IConnectionPoint::Advise to sink events it can call WaitForSingleObject to wait on an event object that is signaled when its time to stop receiving events. When execution resumes the thread can call IConnectionPoint::Unadvise to disconnect its sink, cleanup and exit.

thanks very much, let me try

one question:
if move Advise off the main thread to a dedicated STA worker with its own message loop. This can keep UI responsive, but It may also cause worker thread blocks. right? any solution to fundamentally fix COM blocks?

@Lowell Liu The Network List Manager is registered with ThreadingModel=Both so it can be instantiated in either the STA or the MTA. If you instantiate it on an MTA thread you can avoid STA issues.

For example, following is a minimal console application to demonstrate. Note that the MTA thread on which the COM object was created and used to call Advise is different from the thread on which notifications are received -

#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <netlistmgr.h>
#include <conio.h>

#include <stdio.h>
#include <tchar.h>
#include <new>

class CNetworkEventsSink : public INetworkListManagerEvents
{
public:
    IFACEMETHODIMP QueryInterface(REFIID riid, PVOID *ppv)
    {
		HRESULT hr{ E_NOINTERFACE };

		if (!ppv)
			return E_POINTER;

		*ppv = nullptr;

		if (riid == IID_IUnknown)
		{
			*ppv = static_cast<IUnknown*>(this);
			AddRef();
			hr = S_OK;
		}
		else if(riid == IID_INetworkListManagerEvents)
		{
			*ppv = static_cast<INetworkListManagerEvents*>(this);
			AddRef();
			hr = S_OK;
        }

		return hr;
    }

	IFACEMETHODIMP_(ULONG) AddRef()
	{
		return InterlockedIncrement(&m_cRef);
	}

	IFACEMETHODIMP_(ULONG) Release()
	{
		long cRef = InterlockedDecrement(&m_cRef);
		if (!cRef)
			delete this;
		return cRef;
	}

	IFACEMETHODIMP ConnectivityChanged(NLM_CONNECTIVITY newConnectivity)
	{
		printf_s("In %s on thread id %d\n", __FUNCTION__, GetCurrentThreadId());;

		if (newConnectivity == NLM_CONNECTIVITY_DISCONNECTED)
			printf("Connectivity Disconnected\n");

		if (newConnectivity & NLM_CONNECTIVITY_IPV4_NOTRAFFIC)
			printf("No IPV4 Traffic\n");

		if (newConnectivity & NLM_CONNECTIVITY_IPV6_NOTRAFFIC)
			printf("No IPV6 Traffic\n");

		if (newConnectivity & NLM_CONNECTIVITY_IPV4_SUBNET)
			printf("IPV4 Subnet\n");

		if (newConnectivity & NLM_CONNECTIVITY_IPV4_LOCALNETWORK)
			printf("IPV4 Local Network\n");

		if (newConnectivity & NLM_CONNECTIVITY_IPV4_INTERNET)
			printf("IPV4 Internet\n");

		if (newConnectivity & NLM_CONNECTIVITY_IPV6_SUBNET)
			printf("IPV6 Subnet\n");

		if (newConnectivity & NLM_CONNECTIVITY_IPV6_LOCALNETWORK)
			printf("IPV6 Local Network\n");

		if (newConnectivity & NLM_CONNECTIVITY_IPV6_INTERNET)
			printf("IPV6 Internet\n");

		return S_OK;
	}

private:
	LONG m_cRef{ 1 };
};

HRESULT CreateSink(INetworkListManagerEvents **ppSink)
{
	CNetworkEventsSink* p = new (std::nothrow) CNetworkEventsSink;
	if (!p)
		return E_OUTOFMEMORY;
	auto hr = p->QueryInterface(IID_PPV_ARGS(ppSink));
	p->Release();
	return hr;
}

int main()
{
	DWORD cookie{};

	printf("The main thread id is %d\n", GetCurrentThreadId());
	auto hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
	if (SUCCEEDED(hr))
	{
		INetworkListManager* pnlm{};
		hr = CoCreateInstance(CLSID_NetworkListManager, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pnlm));
		if (SUCCEEDED(hr))
		{
			IConnectionPointContainer* pcpc{};
			hr = pnlm->QueryInterface(&pcpc);
			if (SUCCEEDED(hr))
			{
				IConnectionPoint* pcp{};
				hr = pcpc->FindConnectionPoint(__uuidof(INetworkListManagerEvents), &pcp);
				if (SUCCEEDED(hr))
				{
					INetworkListManagerEvents* pSink{};
					hr = CreateSink(&pSink);
					hr = pcp->Advise(pSink, &cookie);
					if (SUCCEEDED(hr))
					{
						printf("Change network state to see events, Hit a key to exit\n");
						_getch();

						hr = pcp->Unadvise(cookie);
						pSink->Release();
					}
					pcp->Release();
				}
				pcpc->Release();
			}
			pnlm->Release();
		}
	}
    return 0;
}

thanks @RLWA32
I am using FindConnectionPoint(IID_INetworkConnectionEvents, &_pConnectionPoint)

Does the above method also apply to IID_INetworkConnectionEvents?

Does the above method also apply to IID_INetworkConnectionEvents?

Yes. Of course, the sink would need to be conformed to that source interface.