architecture for bubbling events through classes hierarchy

Question

I have a simple application that consists of a console application and a class library. The class library does all of the heavy lifting throughout its few-dozen classes. Some of those classes are internal to the class library, and even if public, I'd rather not have the console application completely aware of them.

So I could have something like:

1. My Program.cs class that is running.
2. My DoSomething.cs class that is being called by Program.cs.
3. My DoSomethingInParticular.cs class that is being called by DoSomething.cs
4. And so on, and so on.

Is there a generally understood way of letting Program.cs be aware of lower changes?

Functionally I'd like to have my console application write out lower level events to the console window, which is where I'm trying to go with this.

Answer 1

A module only knows as much as it knows.

I see 2.1 main paths for you.

1) Make public events in DoSomething that Program can listen to.
Make public events in DoSomethingInParticular that DoSomething can listen to.
When DoSomething receives an event it decides if it is proper for bubbling and transforms it to one event of its own and raises it for Program to receive.

1.1) Put the data carrying structures/classes in the events in another, common, lib. Then when an event is received DoSomething doesn't have to transform it but only decide whether to bubble it or not.

2) Make an event handling lib of its own to handle who receives what.

Without knowing more I would go with 1.1.

HTH