All high-level classes must depend only on Interfaces
-
raddevus wrote:
how many developers really know that concept
I would have assumed devs with some experience would be aware of this. In our shop it's a given because you can't write a unit test with a mocked dependency without using this paradigm. :) It's also one of our pre-interview phone screen questions. There's another subtle aspect to this, though: when using MEF, you can encounter a run-time failure (error constructing a service class) when any dependency in the chain fails to construct because of a missing [Export] attribute on a class in the dependency hierarchy. I didn't want our devs to have to manually check for this so I wrote a tool that reflects the codebase and identifies these broken classes. /ravi
My new year resolution: 2048 x 1536 Home | Articles | My .NET bits | Freeware ravib(at)ravib(dot)com
-
I'm very interested in feedback on this. Yes, it's somewhat related to my latest article[^], but I'm going through what I explain below, right now.. What if you were going to design some new service or app and you were told:
Development Manger:
"All high-level classes must depend only on Interfaces."
What if I told you that and was entirely serious. Would you balk? or think, "Yes, that is the way it is and should be." After that your manager says,
Development Manager:
"Something else will decide how to build the implementation which will fulfill the Interfaces."
Would that sound normal to you, or completely crazy? Or somewhere in between? The Implications Do you honestly understand the implications? No Implementation Code One of the implications is that the code Service or App you are creating basically has no implementation code in it. (Or very little.) Why? Because your high-level app only depends on easily-replaceable Interfaces. That means if you want to see the implementation, you'll need to go to the Library (probably a separate project) which contains the implementation that is used to fulfill the Interface. How do you feel about that? Do you know how crazy it is to look at project that has been designed this way? Have you ever experience a project that is carried out like this? Why I'm Thinking About This Even More? I have just completed 50 pages (of a total of 241) of the very old book (2013) DependencyInjection With Unity (free PDF or EPUB at link)[^].
-
Another corollary that a comment triggered,
Quote:
Create a facade around any API that you are using to protect your code from changes in the API.
quote
Create a facade around any API that you are using to protect your code from changes in the API.
A great idea that no one ever does. Ok, not no one, but it is done more rarely than it should be. Also, there are physical limitations to it. We use a 3rd party component that has 100s methods. We should wrap the component but it gonna take a while. :)
-
quote
Create a facade around any API that you are using to protect your code from changes in the API.
A great idea that no one ever does. Ok, not no one, but it is done more rarely than it should be. Also, there are physical limitations to it. We use a 3rd party component that has 100s methods. We should wrap the component but it gonna take a while. :)
-
Ravi Bhavnani wrote:
That's one of the tenets of dependency injection because it makes for a testable and extensible design.
Those are buzz words however. It is like saying that the code should be 'readable'. Has anyone measured, objective measurements, how successful that is? How do you create a design that is 'extensible' when you do not know what business will be like in 5 years? Or 20? What are you testing exactly? How do you measure it? Are bugs in production compared to those in QA and those in development? Does your testing cover not only simple unit testing but complex scenarios? What above fail over testing? What about production (not QA) testing? Do you have actual injection scenarios that test different scenarios. This is possible in certain situations such as in performance testing specific code. But it must be plan for and then actually used in an ongoing way.
jschell wrote:
Those are buzz words however. It is like saying that the code should be 'readable'.
Requiring dependencies be defined as interfaces simply means their implementations can be changed at any time, as long as they adhere to the contract of the interface. That makes it possible to inject mocks (for testing) and improve/extend the functionality of a dependency without having to rewrite the consumer. It's basic software engineering, not rocket science or a buzz word. /ravi
My new year resolution: 2048 x 1536 Home | Articles | My .NET bits | Freeware ravib(at)ravib(dot)com
-
Sorry, the code is owned by my company so can't be shared. :( /ravi
My new year resolution: 2048 x 1536 Home | Articles | My .NET bits | Freeware ravib(at)ravib(dot)com
-
Whoever gave that directive is a man after my own heart. It's extreme, to be sure. Realistic to literally follow 100% of the time? Probably not. But as an aspiration, a philosophy - absolutely. If you do this, you will be able to grow and scale your products effortlessly for decades - basically for as long as the programming language you use is supported - without a rewrite. Nuget packages, even entire application frameworks will come and go, yet your core code will be snug as a bug in a rug, wrapped in layers of abstraction that shield it from the chaos. When your favorite library is deprecated, revealed to have a critical vulnerability, or the vendor jacks up the price on you, you scoff at how simple it is to assign someone to find a replacement and write the wrapper layer - *completely independently of everyone else*. Your customer tells you the application you designed for Azure now needs to run on AWS? "No problem", you say, "give me a week." Microsoft decides to make 100 new breaking changes to ASP.NET Core? Bah! The upgrade takes an hour. You will never be stuck relying on proprietary technology outside of your control ever again. The term "technical debt" won't even be part of your vocabulary. So yes. Those who know, do this.
Peter Moore - Chicago wrote:
If you do this, you will be able to grow and scale your products effortlessly for decades - basically for as long as the programming language you use is supported
And have you actually done that? I have worked on multiple legacy products and never seen anything like that. At a minimum I can't see it happening in any moderate to large business unless the following was true - Dedicated high level architect (at least director level) whose job is technical not marketing. The person enforces the design. - Same architect for a very long time. With perhaps a couple other architects trained solely by that individual. - Very strict controls on bringing in new idioms/frameworks. - Very likely extensive business requirements to support multiple different configurations. From the beginning. That would insure the initial design actually supports that. What I have seen is even in a company started with a known requirement to support multiple different implementations in rapid order (about a year) new hires decided to implement their own generalized interface on top of the original design without accounting for all the known (not hypothetical) variants. Making the addition of the newer variants into a kludge of code to fit on top of what the new hires did.
-
I appreciate the feedback. You're summary is a good one and related to one of the key points made by the MS Unity Application Block PDF that I read, right after my original post.
Quote:
When You Shouldn’t Use Dependency Injection Dependency injection is not a silver bullet. There are reasons for not using it in your application, some of which are summarized in this section. • Dependency injection can be overkill in a small application, introducing additional complexity and requirements that are not appropriate or useful. • In a large application, it can make it harder to understand the code and what is going on because things happen in other places that you can’t immediately see, and yet they can fundamentally affect the bit of code you are trying to read. There are also the practical difficulties of browsing code like trying to find out what a typical implementation of the ITenantStore interface actually does. This is particularly relevant to junior developers and developers who are new to the code base or new to dependency injection.
It's interesting because "theoretically" I absolutely love the idea of DI, IoC and writing everything to an Interface. But, if you like to look at code, it is quite terrible. There's a project where this has been carried out that is a small(ish) project which has about 8 dependencies (all are Interfaces & the implementations are in separate DLL projects). To look at the code or debug-step the code you need to create a VStudio solution with the 8 projects as included Projects and then you can step into the code of one or the other. It's a lot of overhead. And, yes, I agree with what you said about team size too. If you have nine different people working on each item (1 on the main service and 8 on each dependency) then breaking up is good.
-
If you don't DI on a large project, how are you doing unit/int tests? Sure, small project, whatever, but...
-
jschell wrote:
Those are buzz words however. It is like saying that the code should be 'readable'.
Requiring dependencies be defined as interfaces simply means their implementations can be changed at any time, as long as they adhere to the contract of the interface. That makes it possible to inject mocks (for testing) and improve/extend the functionality of a dependency without having to rewrite the consumer. It's basic software engineering, not rocket science or a buzz word. /ravi
My new year resolution: 2048 x 1536 Home | Articles | My .NET bits | Freeware ravib(at)ravib(dot)com
Ravi Bhavnani wrote:
It's basic software engineering, not rocket science or a buzz word.
Sigh...yes I understand how it is supposed to work. I also understand in detail how Agile, Waterfall, project planning, work life balance and even designs are supposed to work. The question is not about what should happen but whether it is actually happening. Does it provide actual value that offsets the complexity.
-
A 1:1 mapping is not what I was envisioning. (Beginners might miss that joke! What’s the point?) Facade/Wrapper/Adapter/Proxy/etc
englebart wrote:
Facade/Wrapper/Adapter/Proxy/etc
Yes but then all of those are classes also. And thus those two require an interface... Myself I am joking but I remember quite a few years ago someone posting somewhere that all the classes in the application were required to have an interface and a factory.
-
englebart wrote:
Facade/Wrapper/Adapter/Proxy/etc
Yes but then all of those are classes also. And thus those two require an interface... Myself I am joking but I remember quite a few years ago someone posting somewhere that all the classes in the application were required to have an interface and a factory.
A facade should be the simplest requirements needed for your code’s clients. If the library I am using has 5 classes and hundreds of methods/properties, my facade could be as simple as one class with 5 properties and 1 method. Since my facade has a hard dependency on the library, I would use an interface so that my consumers do NOT have a compile time dependency on the library. Like I said earlier, (possibly paraphrased) if you find yourself wrapping everything 1:1, then just accept the hard dependency and ship! ship! The facade might be added later (YAGNI) as well as only if the next major update to the library has breaking changes. Without the facade I would have 70 projects to change. With the facade I have one project to change. I do agree with the release often philosophy. A lot of this depends on team size, pace, code stability, etc. And maybe IDE? Creating an interface from a class or a class from an interface should not take more than a second. Right click… Someone earlier mentioned they were stuck on VS2013. Yuck!
-
Ravi Bhavnani wrote:
It's basic software engineering, not rocket science or a buzz word.
Sigh...yes I understand how it is supposed to work. I also understand in detail how Agile, Waterfall, project planning, work life balance and even designs are supposed to work. The question is not about what should happen but whether it is actually happening. Does it provide actual value that offsets the complexity.
jschell wrote:
Does it provide actual value that offsets the complexity.
Yes, I believe it provides several benefits (at the cost of slightly increasing the size of the project and lines of code):
- Contractual obligation Interfaces define a contract that classes must adhere to. By requiring a class to implement an interface, you ensure that it provides specific functionalities or behaviors as defined by that interface. This promotes consistency and predictability in your codebase.
- Polymorphism Interfaces enable polymorphic behavior in C#. When a class implements an interface, instances of that class can be treated as instances of the interface. This allows for greater flexibility in designing systems where different objects can be used interchangeably based on their common interface.
- Code reusability By implementing interfaces, classes can share common functionality without being directly related in terms of inheritance. This promotes code reuse and modular design, as multiple classes can implement the same interface to provide similar behavior.
- Decoupling and DI Interfaces facilitate loose coupling between components. Code that depends on interfaces is not tied to specific implementations, making it easier to change or extend functionality without affecting other parts of the codebase. This also enables dependency injection, where objects are passed into a class via interfaces, allowing for easier testing and maintenance.
- Design patterns Interfaces are integral to many design patterns such as Strategy, Observer and Factory. Requiring classes to implement interfaces enables the use of these patterns, leading to more maintainable and scalable code.
- Documentation and readability Interfaces serve as documentation for the expected behavior of classes. When a class implements an interface, it's clear what functionality it provides without needing to inspect the implementation details ("what vs. how"). This improves code readability and makes it easier for devs to understand and work with the codebase.
/ravi
My new year resolution: 2048 x 1536 Home | Articles | My .NET bits | Freeware
-
I'm very interested in feedback on this. Yes, it's somewhat related to my latest article[^], but I'm going through what I explain below, right now.. What if you were going to design some new service or app and you were told:
Development Manger:
"All high-level classes must depend only on Interfaces."
What if I told you that and was entirely serious. Would you balk? or think, "Yes, that is the way it is and should be." After that your manager says,
Development Manager:
"Something else will decide how to build the implementation which will fulfill the Interfaces."
Would that sound normal to you, or completely crazy? Or somewhere in between? The Implications Do you honestly understand the implications? No Implementation Code One of the implications is that the code Service or App you are creating basically has no implementation code in it. (Or very little.) Why? Because your high-level app only depends on easily-replaceable Interfaces. That means if you want to see the implementation, you'll need to go to the Library (probably a separate project) which contains the implementation that is used to fulfill the Interface. How do you feel about that? Do you know how crazy it is to look at project that has been designed this way? Have you ever experience a project that is carried out like this? Why I'm Thinking About This Even More? I have just completed 50 pages (of a total of 241) of the very old book (2013) DependencyInjection With Unity (free PDF or EPUB at link)[^].
I program since more than 40 years and develop software since more than 30 years. 15 years ago I heard first time about DI containers, and since 10 years I use IODA as principle to avoid DI containers. Only integration classes are allowed to call other operations. If you put the whole logic into operation-classes, with no logic in data-classes and integration-classes (only something like "rail-switches" in integrations), then separate input- and output- from logical operations, than you do not need to discuss those things like DI any longer. I use derivation very rarely, combination of classes is my favorite. But I use also actions and closures. You don't have to hide every operation class behind an interface, but it can be helpful. Consider: By using of interfaces you can not longer jump to the executed code by just pressing "F12" in Developer Studio. There is no universal answer to this question, it just depends on ... What is IODA? See here: https://www.infoq.com/news/2015/05/ioda-architecture/[^]
-
I program since more than 40 years and develop software since more than 30 years. 15 years ago I heard first time about DI containers, and since 10 years I use IODA as principle to avoid DI containers. Only integration classes are allowed to call other operations. If you put the whole logic into operation-classes, with no logic in data-classes and integration-classes (only something like "rail-switches" in integrations), then separate input- and output- from logical operations, than you do not need to discuss those things like DI any longer. I use derivation very rarely, combination of classes is my favorite. But I use also actions and closures. You don't have to hide every operation class behind an interface, but it can be helpful. Consider: By using of interfaces you can not longer jump to the executed code by just pressing "F12" in Developer Studio. There is no universal answer to this question, it just depends on ... What is IODA? See here: https://www.infoq.com/news/2015/05/ioda-architecture/[^]
Fantastic and interesting reply. Thanks so much for sharing your experience here. Interesting that you specifically avoid DI.
Ralf Peine 2023 wrote:
By using of interfaces you can not longer jump to the executed code by just pressing "F12" in Developer Studio.
That is definitely one of the problems that I encounter with DI. It is a pain that the implementation is always somewhere else which you have to track down. Must say though, that I downloaded VSTudio 2023 to help with this and now it can (as you would hope) navigate to the exact implementation -- even if the code is in another dll it will use reflection to show you the code. Very good.
-
That's maybe the most important reason for DI. And your question is the perfect question to get the bottom of the mystery of whether or not people are really using DI. :thumbsup:
I've had a big hand in building about 30-40 microservices which all tend to more or less follow this convention. I do think "favor composition over inheritance" is a very strong win. I do not appreciate 3 levels of abstraction to do anything. But you get into CQRS and suddenly that's your world. We only have one that went real heavy on that and it's the one I probably hate the most. It was NOT appreciated that I should liken that to spaghetti code of old just on a newer plate. It doesn't help one bit that the typical way this is done obviates any simpler way of doing by design. Scope keywords are wielded as cudgels to keep you in line. The "simple" ctors - they're all internal/private - so do the abstractions or do nothing. I think if I wanted all of that I would use XML comments to highlight that *maybe* something should be done in the more complex of the ways but otherwise not design things in such a way to make it very difficult to do so simply (ditch all this scoping).
-
jschell wrote:
Does it provide actual value that offsets the complexity.
Yes, I believe it provides several benefits (at the cost of slightly increasing the size of the project and lines of code):
- Contractual obligation Interfaces define a contract that classes must adhere to. By requiring a class to implement an interface, you ensure that it provides specific functionalities or behaviors as defined by that interface. This promotes consistency and predictability in your codebase.
- Polymorphism Interfaces enable polymorphic behavior in C#. When a class implements an interface, instances of that class can be treated as instances of the interface. This allows for greater flexibility in designing systems where different objects can be used interchangeably based on their common interface.
- Code reusability By implementing interfaces, classes can share common functionality without being directly related in terms of inheritance. This promotes code reuse and modular design, as multiple classes can implement the same interface to provide similar behavior.
- Decoupling and DI Interfaces facilitate loose coupling between components. Code that depends on interfaces is not tied to specific implementations, making it easier to change or extend functionality without affecting other parts of the codebase. This also enables dependency injection, where objects are passed into a class via interfaces, allowing for easier testing and maintenance.
- Design patterns Interfaces are integral to many design patterns such as Strategy, Observer and Factory. Requiring classes to implement interfaces enables the use of these patterns, leading to more maintainable and scalable code.
- Documentation and readability Interfaces serve as documentation for the expected behavior of classes. When a class implements an interface, it's clear what functionality it provides without needing to inspect the implementation details ("what vs. how"). This improves code readability and makes it easier for devs to understand and work with the codebase.
/ravi
My new year resolution: 2048 x 1536 Home | Articles | My .NET bits | Freeware
-
jschell wrote:
Far as I can tell you are still telling me about what is is supposed to do.
Sorry, I don't understand. Software engineering best practices don't magically do anything by themself. Developers have to use them correctly in order to benefit from them. Your statement is a bit like saying "Object oriented design has no benefits because it doesn't do what it's supposed to do." If you don't use object oriented programming principles correctly, you're not going to enjoy any of its benefits. It's the same with agile development practices (which IMHO very few organizations follow correctly). /ravi
My new year resolution: 2048 x 1536 Home | Articles | My .NET bits | Freeware ravib(at)ravib(dot)com
-
Whoever gave that directive is a man after my own heart. It's extreme, to be sure. Realistic to literally follow 100% of the time? Probably not. But as an aspiration, a philosophy - absolutely. If you do this, you will be able to grow and scale your products effortlessly for decades - basically for as long as the programming language you use is supported - without a rewrite. Nuget packages, even entire application frameworks will come and go, yet your core code will be snug as a bug in a rug, wrapped in layers of abstraction that shield it from the chaos. When your favorite library is deprecated, revealed to have a critical vulnerability, or the vendor jacks up the price on you, you scoff at how simple it is to assign someone to find a replacement and write the wrapper layer - *completely independently of everyone else*. Your customer tells you the application you designed for Azure now needs to run on AWS? "No problem", you say, "give me a week." Microsoft decides to make 100 new breaking changes to ASP.NET Core? Bah! The upgrade takes an hour. You will never be stuck relying on proprietary technology outside of your control ever again. The term "technical debt" won't even be part of your vocabulary. So yes. Those who know, do this.
Spot on, Peter. /ravi
My new year resolution: 2048 x 1536 Home | Articles | My .NET bits | Freeware ravib(at)ravib(dot)com
-
Peter Moore - Chicago wrote:
If you do this, you will be able to grow and scale your products effortlessly for decades - basically for as long as the programming language you use is supported
And have you actually done that? I have worked on multiple legacy products and never seen anything like that. At a minimum I can't see it happening in any moderate to large business unless the following was true - Dedicated high level architect (at least director level) whose job is technical not marketing. The person enforces the design. - Same architect for a very long time. With perhaps a couple other architects trained solely by that individual. - Very strict controls on bringing in new idioms/frameworks. - Very likely extensive business requirements to support multiple different configurations. From the beginning. That would insure the initial design actually supports that. What I have seen is even in a company started with a known requirement to support multiple different implementations in rapid order (about a year) new hires decided to implement their own generalized interface on top of the original design without accounting for all the known (not hypothetical) variants. Making the addition of the newer variants into a kludge of code to fit on top of what the new hires did.
jschell wrote:
At a minimum I can't see it happening in any moderate to large business unless the following was true - Dedicated high level architect (at least director level) whose job is technical not marketing. The person enforces the design.
You make a good point. It takes an experienced technical team to lay down guidelines like these. Over the past 20 years I've worked mostly at early stage companies with very experienced small teams, each of which was tasked with implementing portions of a larger complex product. Because requirements are almost always less known early in a product's evolution, using the technique of enforcing interface definitions allows the code to naturally evolve as the requirements change and become more solidified. Coupled with a strict regimen of writing automated unit and integration tests, defensive programming designs like these increase the chances of developing a complex app with fewer bugs. /ravi
My new year resolution: 2048 x 1536 Home | Articles | My .NET bits | Freeware ravib(at)ravib(dot)com