Before I got this book I thought that I had a fairly good understanding of what Dependency Injection (DI) was all about but when I opened the book and found out there were 500+ pages I thought that I obviously didn’t know a lot!
When you take a closer look at the contents you find that its split into 4 parts:
- DI Catalog
- DIY DI
- DI Containers
The book is structured so that a complete newcomer to DI could read the book cover to cover and learn all about it or if you already have experience you can jump to the parts that you don’t know about or your knowledge isn’t that in depth.
The introduction is a little more than it sounds as it comprises 3 chapters starting with introducing DI itself before moving on to DI fundamentals and DI containers.
These 3 chapters give anybody who doesn’t know anything about DI a through grounding in what DI is, how DI works and what DI containers are for and how to use them.
You will also be introduced in these chapters to 2 themes that run throughout the book, the first being how to create a sauce béarnaise and how it has similarities with DI, and the second is Mary Rowan a developer who is creating an application and we can see how DI helps in that process.
This section introduces you to a lot of the theory around DI listing patterns and anti-patterns and it covers how to refactor code to be able to use DI.
The chapters on patterns & anti-patterns give you the name and details of each and are backed up with code examples so you can see how each is implemented, and in the case of anti-patterns what you can do to alleviate the problem.
The third chapter is devoted to refactoring existing code towards DI and covers a load of scenarios such as cyclic dependencies and constructor over injection to name two.
This section details how you can implement DI yourself, otherwise known as “poor mans DI”, and runs through the 3 key concepts: Object Composition, Object Lifetime and Interception.
Each concept has a chapter devoted to it with Mark explaining the concept and then showing how you can code it yourself increasing the complexity of the code as each chapter progresses.
The chapter on Object Composition in particular shows you how it works with various technologies such as console applications, Asp.Net MVC, Asp.Net Webforms, etc.
The final section of the book takes you through some of the more well known DI Containers and how they satisfy the concepts laid out in the previous section.
This section differs from the others in that it has 6 chapters rather than 3 with each DI container having its own chapter, the containers currently covered are:
- Castle Windsor
- Spring. NET
This book provides everything you need to know about DI ranging from what it is, through patterns for implementing and key concepts, to covering various DI containers that are available today and whilst the book is aimed at the .Net world I believe that it would be useful to any developer that wants to implement DI it whatever language they use.
This isn’t just a theoretical book as every step of the way demonstrates each subject covered with code examples so that you can see how you actually use the subject in question rather than having to try and work it out for yourself, yes the code is ‘demo’ code but you can easily see how you actually implement what is being discussed.
The only niggle I have is that the DI Container Ninject isn’t covered in the book, this was specifically mentioned in the MEAP forums for the book and Mark said the reason for this was he was unaware of it until after he had completed the DI containers section and it was too late to add further content. A poster on the forum suggested Mark could create a separate downloadable chapter on it to which Mark said it sounded like a good idea.
This book is not due to be published until July but is available now through the Manning Early Access Program (MEAP) and Mark has said that the content is now basically complete and the remaining changes are likely to be typographical.
Many thanks to Manning Books and Mark Seeman for the opportunity to review this book.