Return to Answer

A couple of points:

• DI increases complexity, usually by increasing the number of classes since responsibilities are separated more, which is not always beneficial
• Your code will be (somewhat) coupled to the dependency injection framework you use (or more generally how you decide to implement the DI pattern)
• DI containers or approaches that perform type resolving generally incure a slight runtime penalty (very negligible, but it's there)

Generally, the benefit of decoupling makes each task simpler to read and understand, but increases the complexity of orchestrating the more complex tasks.

A couple of points:

• DI increases complexity, usually by increasing the number of classes since responsibilities are separated more, which is not always beneficial
• Your code will be (somewhat) coupled to the dependency injection framework you use (or more generally how you decide to implement the DI pattern)
• DI containers or approaches that perform type resolving generally incur a slight runtime penalty (very negligible, but it's there)

Generally, the benefit of decoupling makes each task simpler to read and understand, but increases the complexity of orchestrating the more complex tasks.

A couple of points:

• DI increases complexity, usually by increasing the number of classes since responsibilities are separated more, which is not always beneficial
• Your code will be (somewhat) coupled to the dependency injection framework you use (or more generally how you decide to implement the DI pattern)
• DI containers or approaches that perform type resolving generally incure a slight runtime penalty (very negligible, but it's there)

Generally, the benefit of decoupling make each task simpler to read and understand, but increases the complexity of orchestrating the more complex tasks.

A couple of points:

• DI increases complexity, usually by increasing the number of classes since responsibilities are separated more, which is not always beneficial
• Your code will be (somewhat) coupled to the dependency injection framework you use (or more generally how you decide to implement the DI pattern)
• DI containers or approaches that perform type resolving generally incure a slight runtime penalty (very negligible, but it's there)

Generally, the benefit of decoupling makes each task simpler to read and understand, but increases the complexity of orchestrating the more complex tasks.

A couple of points:

• It increases complexity, usually by increasing the number of classes since responsibilities are separated more, which is not always beneficial
• Your code will be (somewhat) coupled to the dependency injection framework you use
• It incures a runtime penalty (negligible, but it's there)

Generally, the benefit of decoupling make each task simpler to read and understand, but increases the complexity of orchestrating the more complex tasks.

A couple of points:

• DI increases complexity, usually by increasing the number of classes since responsibilities are separated more, which is not always beneficial
• Your code will be (somewhat) coupled to the dependency injection framework you use (or more generally how you decide to implement the DI pattern)
• DI containers or approaches that perform type resolving generally incure a slight runtime penalty (very negligible, but it's there)

Generally, the benefit of decoupling make each task simpler to read and understand, but increases the complexity of orchestrating the more complex tasks.