So I have my application consisting of a number of modules in a module hierarchy. Furthermore let's also assume each module is a class and we have a tree of classes where the classes at the top are using the classes below, to make it more simple.
A class A1
at the very bottom may depend on some input parameters. class B1
is above class A1
and is creating and using instances of class A1
. Therefore it has to pass the dependencies needed by the instances of class A1
into them. If it can't create these dependencies from some operations, class B1
now has it's on dependencies but additionally the dependencies of class A1
.
The higher we go the more these dependencies will add up so that the toplevel class
will need to know all the dependencies unless they can be created at a lower level.
This means if class A1
my program is dependent on the current temperature
, I have to pass this to the toplevel class
which then passes it to the next class
and so on until it arrives at the very bottom in class A1
. If I do that, I make the state explicit but it also means that I have methods or classes that take many parameters.
Variables
What if the temperature
is may change while the application is running - is there a way to avoid passing it all the way down the class tree without giving away explicit state? How would you guys handle this?
Constants
What if the temperature
is a constant that will never change while the program is running? Does this give us more options to avoid passing it always as an argument? I could see someone using a global configuration (singleton) but it will make it harder to test right?
I could also pass not the temperature
itself but a configuration object. This would mean class B1
does not receive for example a temperature
and a airpressure
parameter but gets a configuration object passes it to class B1
and class B2
where class B1
only needs the airpressure
and class B2
only needs the temperature
. Is that a good approach? What are the pros/cons?