Question

Consider the following general program structure:

• Class A has an instance of Class B as a member variable
• Class B has a collection member variable containing instances of class C
• Events in class A are propagated to the C instances by A simply telling B about the event

What are the design patterns concerning instances of class C talking back to class A?

One option is instances of class C posting notifications to which class A subscribes. Another option is passing a reference to class A “down the chain” (from A to B then from B to each C). This latter option allows instances of C to talk directly to A.

Answer 1

If you mean design patterns literally (i.e. of the GoF variety) then these would be a few relevant options:

• Command: pass a callback to the C items (directly or indirectly through B) so that when they want to talk back to A they can simply invoke this callback — which can even have parameters
• Iterator: B exposes a view of its aggregate collection directly to A; communication between A and C is then made directly
• Mediator: Exposes notifications to which A and C might subscribe to; communication is done by posting events
• Observer: What you already suggested as the first option

If on the other hand you really mean architectural patterns, then typical options are:

• Your first option, A subscribing to C events. At first sight this doesn’t look like an all-around good idea unless the event is extremely useful all the time, because it requires n objects to aggregate a pointer back to the callback which in the worst case they could even use just once.
• Passing references to A is another option, but not a good one if you are going to pollute the public interface of A with methods just so that C can call back to it in very specific scenarios. It can be very effective if A already exposes a suitable interface, but be aware that you might need an adapter class between C calling back to A in order to not tightly couple C to A‘s interface.
• A third option would be A iterating over (a view of) the collection provided by B directly and supplying callbacks to C instances; this has the advantages of being quite loosely coupled and that it will use the least amount of memory, but it might be a bit trickier to code.