book

Dependency Injection Principles, Practices, and Patterns

Name: Dependency Injection Principles, Practices, and Patterns
ISBN: 9781617294730

by Steven van Deursen, Mark Seemann

March 2019

Intermediate to advanced

552 pages

16h 57m

English

Manning Publications

Read now

Unlock full access

Dependency Injection
Principles, Practices, and Patterns
brief contents
contents
Praise for the First Edition
front matter
prefaceacknowledgmentsabout this bookWho should read this book?RoadmapCode conventions and downloadsliveBook discussion forumabout the authorsabout the cover illustration
Part 1. Putting Dependency Injection on the map
1 The basics of Dependency Injection: What, why, and how
1.1 Writing maintainable code1.1.1 Common myths about DI1.1.2 Understanding the purpose of DI1.2 A simple example: Hello DI!1.2.1 Hello DI! code1.2.2 Benefits of DI1.3 What to inject and what not to inject1.3.1 Stable Dependencies1.3.2 Volatile Dependencies1.4 DI scope1.4.1 Object Composition1.4.2 Object Lifetime1.4.3 Interception1.4.4 DI in three dimensions1.5 ConclusionSummary
2 Writing tightly coupled code
2.1 Building a tightly coupled application2.1.1 Meet Mary Rowan2.1.2 Creating the data layer2.1.3 Creating the domain layer2.1.4 Creating the UI layer2.2 Evaluating the tightly coupled application2.2.1 Evaluating the dependency graph2.2.2 Evaluating composability2.3 Analysis of missing composability2.3.1 Dependency graph analysis2.3.2 Data access interface analysis2.3.3 Miscellaneous other issues2.4 ConclusionSummary
3 Writing loosely coupled code
3.1 Rebuilding the e-commerce application3.1.1 Building a more maintainable UI3.1.2 Building an independent domain model3.1.3 Building a new data access layer3.1.4 Implementing an ASP.NET Core–specific IUserContext Adapter3.1.5 Composing the application in the Composition Root3.2 Analyzing the loosely coupled implementation3.2.1 Understanding the interaction between components3.2.2 Analyzing the new dependency graphSummary
Part 2. Catalog

4 DI patterns
4.1 Composition Root4.1.1 How Composition Root works4.1.2 Using a DI Container in a Composition Root4.1.3 Example: Implementing a Composition Root using Pure DI4.1.4 The apparent dependency explosion4.2 Constructor Injection4.2.1 How Constructor Injection works4.2.2 When to use Constructor Injection4.2.3 Known use of Constructor Injection4.2.4 Example: Adding currency conversions to the featured products4.2.5 Wrap-up4.3 Method Injection4.3.1 How Method Injection works4.3.2 When to use Method Injection4.3.3 Known use of Method Injection4.3.4 Example: Adding currency conversions to the ProductEntity4.4 Property Injection4.4.1 How Property Injection works4.4.2 When to use Property Injection4.4.3 Known uses of Property Injection4.4.4 Example: Property Injection as an extensibility model of a reusable library4.5 Choosing which pattern to useSummary
5 DI anti-patterns
5.1 Control Freak5.1.1 Example: Control Freak through newing up Dependencies5.1.2 Example: Control Freak through factories5.1.3 Example: Control Freak through overloaded constructors5.1.4 Analysis of Control Freak5.2 Service Locator5.2.1 Example: ProductService using a Service Locator5.2.2 Analysis of Service Locator5.3 Ambient Context5.3.1 Example: Accessing time through Ambient Context5.3.2 Example: Logging through Ambient Context5.3.3 Analysis of Ambient Context5.4 Constrained Construction5.4.1 Example: Late binding a ProductRepository5.4.2 Analysis of Constrained ConstructionSummary
6 Code smells
6.1 Dealing with the Constructor Over-injection code smell6.1.1 Recognizing Constructor Over-injection6.1.2 Refactoring from Constructor Over-injection to Facade Services6.1.3 Refactoring from Constructor Over-injection to domain events6.2 Abuse of Abstract Factories6.2.1 Abusing Abstract Factories to overcome lifetime problems6.2.2 Abusing Abstract Factories to select Dependencies based on runtime data6.3 Fixing cyclic Dependencies6.3.1 Example: Dependency cycle caused by an SRP violation6.3.2 Analysis of Mary’s Dependency cycle6.3.3 Refactoring from SRP violations to resolve the Dependency cycle6.3.4 Common strategies for breaking Dependency cycles6.3.5 Last resort: Breaking the cycle with Property InjectionSummary
Part 3. Pure DI
7 Application composition
7.1 Composing console applications7.1.1 Example: Updating currencies using the UpdateCurrency program7.1.2 Building the Composition Root of the UpdateCurrency program7.1.3 Composing object graphs in CreateCurrencyParser7.1.4 A closer look at UpdateCurrency’s layering7.2 Composing UWP applications7.2.1 UWP composition7.2.2 Example: Wiring up a product-management rich client7.2.3 Implementing the Composition Root in the UWP application7.3 Composing ASP.NET Core MVC applications7.3.1 Creating a custom controller activator7.3.2 Constructing custom middleware components using Pure DISummary
8 Object lifetime
8.1 Managing Dependency Lifetime8.1.1 Introducing Lifetime Management8.1.2 Managing lifetime with Pure DI8.2 Working with disposable Dependencies8.2.1 Consuming disposable Dependencies8.2.2 Managing disposable Dependencies8.3 Lifestyle catalog8.3.1 The Singleton Lifestyle8.3.2 The Transient Lifestyle8.3.3 The Scoped Lifestyle8.4 Bad Lifestyle choices8.4.1 Captive Dependencies8.4.2 Using Leaky Abstractions to leak Lifestyle choices to consumers8.4.3 Causing concurrency bugs by tying instances to the lifetime of a threadSummary
9 Interception
9.1 Introducing Interception9.1.1 Decorator design pattern9.1.2 Example: Implementing auditing using a Decorator9.2 Implementing Cross-Cutting Concerns9.2.1 Intercepting with a Circuit Breaker9.2.2 Reporting exceptions using the Decorator pattern9.2.3 Preventing unauthorized access to sensitive functionality using a DecoratorSummary
10 Aspect-Oriented Programming by design
10.1 Introducing AOP10.2 The SOLID principles10.2.1 Single Responsibility Principle (SRP)10.2.2 Open/Closed Principle (OCP)10.2.3 Liskov Substitution Principle (LSP)10.2.4 Interface Segregation Principle (ISP)10.2.5 Dependency Inversion Principle (DIP)10.2.6 SOLID principles and Interception10.3 SOLID as a driver for AOP10.3.1 Example: Implementing product-related features using IProductService10.3.2 Analysis of IProductService from the perspective of SOLID10.3.3 Improving design by applying SOLID principles10.3.4 Adding more Cross-Cutting Concerns10.3.5 ConclusionSummary
11 Tool-based Aspect-Oriented Programming
11.1 Dynamic Interception11.1.1 Example: Interception with Castle Dynamic Proxy11.1.2 Analysis of dynamic Interception11.2 Compile-time weaving11.2.1 Example: Applying a transaction aspect using compile-time weaving11.2.2 Analysis of compile-time weavingSummary
Part 4. DI Containers
12 DI Container introduction
12.1 Introducing DI Containers12.1.1 Exploring containers’ Resolve API12.1.2 Auto-Wiring12.1.3 Example: Implementing a simplistic DI Container that supports Auto-Wiring12.2 Configuring DI Containers12.2.1 Configuring containers with configuration files12.2.2 Configuring containers using Configuration as Code12.2.3 Configuring containers by convention using Auto-Registration12.2.4 Mixing and matching configuration approaches12.3 When to use a DI Container12.3.1 Using third-party libraries involves costs and risks12.3.2 Pure DI gives a shorter feedback cycle12.3.3 The verdict: When to use a DI ContainerSummary
13 The Autofac DI Container
13.1 Introducing Autofac13.1.1 Resolving objects13.1.2 Configuring the ContainerBuilder13.2 Managing lifetime13.2.1 Configuring instance scopes13.2.2 Releasing components13.3 Registering difficult APIs13.3.1 Configuring primitive Dependencies13.3.2 Registering objects with code blocks13.4 Working with multiple components13.4.1 Selecting among multiple candidates13.4.2 Wiring sequences13.4.3 Wiring Decorators13.4.4 Wiring CompositesSummary
14 The Simple Injector DI Container
14.1 Introducing Simple Injector14.1.1 Resolving objects14.1.2 Configuring the container14.2 Managing lifetime14.2.1 Configuring Lifestyles14.2.2 Releasing components14.2.3 Ambient scopes14.2.4 Diagnosing the container for common lifetime problems14.3 Registering difficult APIs14.3.1 Configuring primitive Dependencies14.3.2 Extracting primitive Dependencies to Parameter Objects14.3.3 Registering objects with code blocks14.4 Working with multiple components14.4.1 Selecting among multiple candidates14.4.2 Wiring sequences14.4.3 Wiring Decorators14.4.4 Wiring Composites14.4.5 Sequences are streamsSummary
15 The Microsoft.Extensions.DependencyInjection DI Container
15.1 Introducing Microsoft.Extensions.DependencyInjection15.1.1 Resolving objects15.1.2 Configuring the ServiceCollection15.2 Managing lifetime15.2.1 Configuring Lifestyles15.2.2 Releasing components15.3 Registering difficult APIs15.3.1 Configuring primitive Dependencies15.3.2 Extracting primitive Dependencies to Parameter Objects15.3.3 Registering objects with code blocks15.4 Working with multiple components15.4.1 Selecting among multiple candidates15.4.2 Wiring sequences15.4.3 Wiring Decorators15.4.4 Wiring CompositesSummary
glossary
resources
Index
Lists of Figures, Tables and Listings
List of IllustrationsList of TablesList of Listings

Overview

Dependency Injection Principles, Practices, and Patterns teaches you to use DI to reduce hard-coded dependencies between application components. You'll start by learning what DI is and what types of applications will benefit from it. Then, you'll work through concrete scenarios using C# and the .NET framework to implement DI in your own projects. As you dive into the thoroughly-explained examples, you'll develop a foundation you can apply to any of the many DI libraries for .NET and .NET Core.

About the Technology
Dependency Injection (DI) is a great way to reduce tight coupling between software components. Instead of hard-coding dependencies, such as specifying a database driver, you make those connections through a third party. Central to application frameworks like ASP.NET Core, DI enables you to better manage changes and other complexity in your software.

About the Book
Dependency Injection Principles, Practices, and Patterns is a revised and expanded edition of the bestselling classic Dependency Injection in .NET. It teaches you DI from the ground up, featuring relevant examples, patterns, and anti-patterns for creating loosely coupled, well-structured applications. The well-annotated code and diagrams use C# examples to illustrate principles that work flawlessly with modern object-oriented languages and DI libraries.

What's Inside

Refactoring existing code into loosely coupled code
DI techniques that work with statically typed OO languages
Integration with common .NET frameworks
Updated examples illustrating DI in .NET Core

About the Reader
For intermediate OO developers.

About the Authors
Mark Seemann is a programmer, software architect, and speaker who has been working with software since 1995, including six years with Microsoft. Steven van Deursen is a seasoned .NET developer and architect, and the author and maintainer of the Simple Injector DI library.

Quotes
Actually three books in one: a really good introduction to DI in .NET, an even better one to DI in general, and an absolutely excellent introduction to OO principles and software design.
- Mikkel Arentoft, Danske Bank

This book is a masterpiece. It’s amazing and fundamental for every software developer who wants to write solid and correct code.
- Emanuele Origgi, Funambol

A marvelous, clear, and exhaustive journey into all aspects of DI in .NET, with very focused and complete real world examples.
- Pasquale Zirpoli, MIED Open Source Initiative

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Unit Testing Principles, Practices, and Patterns

Publisher Resources

ISBN: 9781617294730Publisher Support Publisher Website Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills