Question

Imagine the following class:

class A
{
     public event EventHandler AnyEvent;
}

You create an instance of class A, and attach some event handlers. Now if AnyEvent gets raised, I would not assume, that the event handlers are performed on another thread, than the thread I created the object. This would be of prime importance, if you created the object on a GUI thread, and the event handler performs operations on GUI elements. This would force me to use appropriate invocation patterns.

It really becomes evil, if you use interfaces defining events:

interface B
{
     event EventHandler SomeEvent;
}

Now one implementation could raise the event from the original thread, the next from a second thread. This can cause your application to successfully work with the one, and fail with the other implementation.

I think coding should always be transparent – this is not! And if I don’t create another thread, I do not assume, that my methods are performed from any other than my home thread.

Are there any aspects I did not consider? Any that would invalidate my assumption?

Answer 1

Threading is the responsibility the consumer of the class, not the writer of the class, so your assumption is incorrect.

One should assume a class is not thread-safe unless it is documented to be thread-safe. Even most built-in .NET classes are not thread safe unless they say they are.

It is up to the consumer of the class to be aware of threading.