Book Image

Dependency Injection in .NET Core 2.0

By : Marino Posadas, Tadit Dash
Book Image

Dependency Injection in .NET Core 2.0

By: Marino Posadas, Tadit Dash

Overview of this book

<p><span id="description" class="sugar_field">.NET Core provides more control than ever over web application architectures. A key point of this software architecture is that it's based on the use of Dependency Injection as a way to properly implement the Dependency Inversion principle proposed in the SOLID principles established by Robert C. Martin</span>.</p> <p><span id="description" class="sugar_field">With the advent of .NET Core, things have become much simpler with Dependency Injection built into the system. This book aims to give you a profound insight into writing loosely-coupled code using the latest features available in .NET Core. It talks about constructors, parameter, setters, and interface injection, explaining in detail, with the help of examples, which type of injection to use in which situation. It will show you how to implement a class that creates other classes with associated dependencies, also called IoC containers, and then create dependencies for each MVC component of ASP.NET Core. You'll learn to distinguish between IoC containers, the use of Inversion of Control, and DI itself, since DI is just a way of implementing IoC via these containers. You'll also learn how to build dependencies for other frontend tool such as Angular. You will get to use the in-built services offered by .NET Core to create your own custom dependencies.</span></p> <p><span class="sugar_field"><span id="description" class="sugar_field">Towards the end, we'll talk about some patterns and anti-patterns for Dependency Injection along with some techniques to refactor legacy applications and inject dependencies.</span></span></p>

Related Content you might be interested in

Current Title:

Small book image
Dependency Injection in .NET Core 2.0
Marino Posadas | Tadit Dash
Nov, 2017 | 436 pages
Small book image
Metaprogramming in C#
Einar Ingebrigtsen
Jun, 2023 | 352 pages
Small book image
Java 9 Dependency Injection
Nilang Patel | Krunal Patel
Apr, 2018 | 246 pages
Small book image
Hands-On Object-Oriented Programming with C#
Raihan Taher
Feb, 2019 | 288 pages
Table of Contents (18 chapters)
Title Page
Title Page
Credits
Credits
About the Authors
About the Authors
About the Reviewer
About the Reviewer
www.PacktPub.com
www.PacktPub.com
Customer Feedback
Customer Feedback
Preface
Preface
Free Chapter
1
The SOLID Principles of Software Design
The SOLID Principles of Software Design
In the beginning
The SOLID principles
Another sample
The Open/Closed principle
Back to our sample
The Liskov Substitution principle
The Interface Segregation principle
Another sample
The Dependency Inversion principle
The (more or less) canonical example
Other ways to implement Dependency Inversion
Summary
2
Dependency Injection and IoC Containers
Dependency Injection and IoC Containers
The Dependency Principle in more detail
Aspects of Dependency Injection
Ways to implement DI
DI containers
Dependency Injection in other frameworks
Summary
3
Introducing Dependency Injection in .NET Core 2.0
Introducing Dependency Injection in .NET Core 2.0
The main characteristics of .NET Core
The main advantages of .NET Core
Dependency Injection in .NET Core
Summary
4
Dependency Injection in ASP.NET Core
Dependency Injection in ASP.NET Core
ASP.NET Core from the command-line tools
The Startup class and Dependency Injection
The New ASP.NET servers
Analyzing the default template
Dependency Injection in ASP.NET Core
Summary
5
Object Composition
Object Composition
Understanding object relationships
Object Composition
Composition versus Aggregation
Composition over Inheritance
Role of Object Composition in Dependency Injection
Composing .NET Core 2.0 Console application
Object Composition in ASP.NET Core MVC 2.0
Summary
6
Object Lifetime
Object Lifetime
Manage the object life cycle
Object lifetime management in .NET Core
Summary
7
Interception
Interception
Introducing Interception
Aspect-oriented programming
Investigating Interception
Intermediate Language (IL) Weaving
Interception in ASP.NET Core
Summary
8
Patterns - Dependency Injection
Patterns - Dependency Injection
Dependency Inversion Principle
Patterns
Summary
9
Anti-Patterns and Misconceptions on Dependency Injection
Anti-Patterns and Misconceptions on Dependency Injection
When does Dependency Injection become an anti-pattern?
Anti-patterns
Summary
10
Dependency Injection in Other JavaScript Frameworks
Dependency Injection in Other JavaScript Frameworks
TypeScript
Architectural changes
Angular
Angular 2+
Summary
11
Best Practices and Other Related Techniques
Best Practices and Other Related Techniques
Tightly coupled systems
Layered architecture
Summary

Dependency Injection in ASP.NET Core

Of course, this behavior is possible thanks to the presence of a DI Container inside the ASP.NET Core engine. The official documentation states it very clearly: if a given type has declared that it has dependencies, and the container has been configured to provide the dependency types, it will create the dependencies as part of creating the requested instance.

The container, in this way, manages an object's lifetime and avoids the need for hard-coded object construction.

Besides other built-in implementations, remember that ASP.NET Core provides a simple DI Container (that we already tested in Chapter 3, Introducing Dependency Injection in .Net Core 2.0), represented by the IServiceProvider interface.

As we mentioned, the place to configure services using that interface in this platform is the ConfigureServices method, which we will analyze in the following section.

Services provided by ASP.NET Core

There's quite a large list of services available inside ASP...

Previous Section
End of Section 6
Next Section