I have not tested with all these scenarios, and frankly, the answer is beyond what a standard managed library (like QuickOPC) can or is supposed to do.

According to articles on the Web (e.g. those listed further below), a standard .NET console app behavior after Ctrl+C would be that the finalizers do not run, and therefore cleanup will not be processed. There may be a way to change this behavior; it's up to you to do so, if required.

A process termination ("kill", e.g. from Task Manager, or by other means) is a process termination. That means, to my knowledge, it is (by definition) impossible to attach any handling to it - otherwise it wouldn't be a process termination.

We do not have an event indicating a cleanup. But you can relatively safely assume that if any other finalizers in the app domain run, that ours ran as well.

Some related links:

• gotooverflow.com/question/7993/what-happens-when-i-interrupt...ole-application-with-control-c
• www.codeproject.com/Articles/16164/Managed-Application-Shutdown
• msdn.microsoft.com/en-us/library/windows/desktop/ms682541%28...px?f=255&MSPPError=-2147217396

Best regards

Well, the answer is "it depends". It depends on the kind of crash - and there are many of them.

If, for example, a regular .NET exception is unhandled and terminates the program, the CLR usually finalizes all objects (although it gives no guarantee), and as part of that, our EasyXXClient objects will unsubscribe and disconnect orderly. There are other crashes possible that are worse than that, and in such case the above may not happen. In some cases, I believe, nothing can be done at all; in some cases, you may try to improve on that, but that would be up to you.

Note that COM/DCOM helps with the cleanup as well. For example, if you are connecting to a remote server, and either the client or the server crasher or becomes unaccessible (long network interruption), DCOM will eventually (roughly after 6 minutes) give up on any outstanding calls, will declare the client or server side "dead", and *also* call a proper number of IUnknown::Release()-s on the interfaces of the remaining COM objects. This assures proper cleanup even in case of crash. I am not sure whether this is happening with local connections as well, though.

Best regards