Thanks for the questions. I will start with the quotation from the Concepts document:

12.15 Multithreading and Synchronization
The EasyDAClient, EasyAEClient and EasyUAClient objects and all their related helper objects are thread-safe.
In QuickOPC.NET and QuickOPC-UA, if you are hooking to the event notifications provided by the EasyDAClient , EasyAEClient or EasyUAClient component, or processing these notifications in your callback methods, make sure that you understand how the component generates these events and what threading issues it may involve. This is how it works:
The EasyDAClient, EasyAEClient or EasyUAClient object has a SynchronizationContext property. This property can either be set to a null reference, or to an instance of SystemThreading.SynchronizationContext class. When the SynchronizationContext is set to a null reference, EasyDAClient, EasyAEClient or EasyUAClient calls any event handlers or callback methods on its own internal thread, which is possibly different from any threads that you have in your application. When the SynchronizationContext is set to a concrete instance, the synchronization model implemented by this object is used. The EasyDAClient, EasyAEClient or EasyUAClient then typically uses the Post method of this synchronization context to invoke event handlers in your application.
When the EasyDAClient, EasyAEClient or EasyUAClient object is initially created, it attempts to obtain the synchronization context from the current thread (the thread that is executing the constructor). As a result, if the thread constructing the EasyDAClient, EasyAEClient or EasyUAClient object has a synchronization context associated with it, it will become the value of the SynchronizationContext property. Otherwise, the SynchronizationContext property will be set to a null reference. This way, the synchronization context propagates from the constructing thread.
Access to Windows Forms controls is not inherently thread safe. If you have two or more threads manipulating the state of a control, it is possible to force the control into an inconsistent state. Other thread-related bugs are also possible, such as race conditions and deadlocks. It is important to make sure that access to your controls is performed in a thread-safe way. Thanks to the mechanism described above, this is done automatically for you, provided that the constructor of the EasyDAClient, EasyAEClient or EasyUAClient object is called on the form’s main thread, as is the case if you place the EasyDAClient , EasyAEClient or EasyUAClient component on the form’s design surface in Visual Studio. This works because by default, Windows Forms sets the synchronization context of the form’s main thread to a properly initialized instance of System.Windows.Forms.WindowsFormsSynchronizationContext object.
Similarly, Windows Presentation Foundation (WPF) applications use System.Windows.Threading.DispatcherSynchronizationContext to achieve the same thing.
If your application is not based on the above frameworks, or is using them in an unusual way, you may have to take care of the synchronization issues related to event notification yourself, either by directly coding the synchronization mechanism, or by implementing and using a class derived from SystemThreading.SynchronizationContext.
In QuickOPC.NET and QuickOPC-UA, objects in the Forms namespaces follow the general Windows Forms rules and conventions, meaning that any public static (Shared in Visual Basic) type members are thread-safe. Any instance members are not guaranteed to be thread safe.
[...]

In general, your question is about the guarantees we give you regarding the thread identity and timing (synchronization) of the event handler calls. The short answer is a) when the SynchronizationContext is not null, the guarantees are given by the SynchronizationContext, and b) when the SynchronizationContext is null, we give you no guarantees: the event handlers can be called on any thread and at any time.

In this sense, it is irrelevant HOW we actually do it; your code should follow the guarantees that are given (or are *not* given), because the presence or absence of guarantees will stay constant in any foreseeable future version, while the exact implementation may change.

I think that the current implementation has an unmanaged thread at its core; the thread pulls messages from an internal queue and dispatches them to the event receivers. In this process, it switches to a managed thread. Even if we keep using the same unmanaged thread, it may be that the switch to a managed thread may use a different thread each time. I have not actually looked into it and verified this, because it is not relevant - we do not give the guarantee. If, however, you are making e.g. a Windows Forms app and the SynchronizationContext is set properly (which happens automatically when the component is created on the main UI thread), then your event handlers should be called always on the same thread - and it should be the main UI thread, with message pump etc., and the ability to directly access UI controls.

Best regards