Question

Something occurs that is more or less expected with normal use of a .NET library you are writing. You need to notify the user/UI/caller that this event has occurred, even though it is expected and not exceptional. Do you:

A) Throw an exception, let the UI catch it and deal with it.

B) Raise some type of event that the UI can listen for.

C) Do something else

Which of the above do you do? If both, what are your guidelines for when to throw an exception vs. raise an event? What are the pros and cons of each?

Edit:

Here is an example I’m facing. My library uses a third party application to print shipping labels by starting the third party application and passing an XML file as an argument, which is processed as a batch type operation. If the third party application is already open by a user, it must be shut down before my library can call it for the batch operation. My library checks to see if the application is running, and if it is, it simply stops and needs to notify the user that they should close the third party application and try again. I fully expect this to happen as part of the normal use of the library. Throw an exception, or raise an event?

Answer 1

Exceptions are different from events because you have to handle them.

If you think the client code just can’t go on, throw an exception (examples: network error, security error, bad input). Otherwise, kindly acknowledge that something has happened by raising an event but don’t force the caller to react immediately.

Also note that events may be raised and handled asynchronously and are not bound to particular caller’s actions, whereas exceptions always get thrown in context of a specific method call. Of course, you can throw exceptions from anywhere but if the client code doesn’t expect them where they occur, they become essentially useless because unhandled.

See also this thread.

---

As for your situation:

Apparently, in your case workflow cannot continue unless the third-party application is closed, and this situation is not exactly normal, meaning it’s more of a technical restriction than a true workflow option. You also can’t let the client code just ignore it. This fits exceptions immediate-response nature.

However, it is also true that this situation is not all-exceptional because on some level it is known and expected.

Because of that, I suggest you do this:

• introduce a CanRunNow property that determines if application is running;
• check this property in client code prior to calling Run method (let’s assume it’s called so);
• in Run method, do the check again, and if this time CanRunNow is false, throw an exception (now this is unexpected!)

This way you give the client code freedom and responsibility to either do a check and stay safe, or to go right ahead (and possibly get an exception). Whatever behavior you choose, make sure to document it!