20.

Dependency injection
Vad vi går igenom
 Vad är Dependency Injection?

 Services

 Middleware

 Konfigurationsfiler
Vad är tanken med Core?

 Kunna sätta upp projekt som är anpassade till exakt det

som behövs. Get mindre och mer slimmade applikationer.

 Uppbyggt modulärt med paket till skillnad från tidigare

när hela .NET framework måste vara installerat.

 Finns genom olika paket möjlighet att konfigurera för

olika plattformar. Inte låst till Microsoft miljö tex som
tidigare genom System.Web som bara var kopplad till IIS.
Vad är dependency injection (DI)?
 Ett design pattern för att hantera dependencies
(kopplingar) mellan olika delar i en applikation. Inte
bundet till Core utan används i många olika
sammanhang.

 Grundtanken är att objekt skapas utanför klassen och

injectas i klassen istället för att skapas där.

 Ger en mindre hård koppling mellan olika klasser och de

tjänster som man vill använda i en klass tex Identity eller
Entity framework kan injectas till klassen.
Vad är dependency injection (DI)?

 Att minska kopplingen och beroendet mellan olika objekt

är något man strävar efter i de flesta applikationer

 Finns inbyggt i Core vilket inte fanns i tidigare

versioner av .NET. Finns även möjlighet att använda
externa ramverk för detta tex Unity, StructureMap
eller Ninject.

 Ger även mycket större möjligheter att jobba med

enhetstestning av applikationen.
Typer av dependency injection
 Det finns tre olika typer av DI. Det vanligaste sättet är
via konstruktorn sk constructor injection. Då skickas
objekt in via konstruktorn när en klass instansieras.

 För setter injection (kallas även property injection)

skickas objekt in (sätts) via publika properties i klassen
istället. Fördelen är att objekt inte alltid behöver
injektas utan det går att göra det bara när de behövs.

 Används interface baserad injection innebär det att

klassen implementerar ett interface. Sedan kan
antingen konstruktorn eller properties användas för att
injekta objekt.
Dependency injection container

 För att använda DI måste det finnas en sk container

som sätter upp de tjänster som kan injectas.

 Den fungerar globalt i applikationen dvs objekt sätts

upp och skapas på bara ett ställe . Där skapas objekt
upp som sedan kan injektas i olika klasser.

 Containern hanterar hela livscykeln för objektet dvs

även avallokering (dispose) . Detta skall inte göras i
klassen som injectar objektet.
Dependency injection container
Går att styra om objektet sätts upp en gång och återan-
vänds (Singleton) eller att nya objekt skapas upp varje
gång det skall användas (Transient).

//Sätter upp DI som skapar helt nytt objekt

services.AddTransient<IEmailSender, EmailSender>();

//Sätter upp DI som återanvänder samma objekt

services.AddSingleton<ILogger, Logger>();

//Sätter upp DI som återanvänder samma objekt

under en och samma request
services.AddScoped<IService, Service>();
Dependency injection container
 Den inbyggda containern i Core skapas från och med
NET6 i Program.cs.

 Här sätts de tjänster upp som kan användas för

applika-tionen. Dessa kan sedan injectas i olika klasser
för att användas, i detta fall EF.
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<PersonDBContext>(options =>
options.UseSqlServer(connectionstring));
Middleware

 När en request skickas till en applikation måste den

först tas emot. Detta görs genom en sk Request
pipeline.

 I ett Core projekt sätts denna också från och med

NET6 upp i Program.cs.

 I denna pipeline läggs Middleware som representerar

de tjänster som skall vara med och hantera requesten.
Olika saker sker i en bestämd ordning efter varandra i
denna pipeline.
Middleware
Objektet som heter app går igenom alla tjänster i denna
request pipeline. Detta exempel är ett projekt som
innehåller MVC och Identity (hantering av användare/
behörigheter)
var app = builder.Build();

app.UseStaticFiles();
app.UseIdentity();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
Konfigurationsfiler

 Inställningar i ett projekt bör samlas för att lättare få

överblick och kunna ändra dessa. Detta görs i en
konfigurationsfil som inte är kompilerad kod.
 Tidigare användes web.config ( som är i XML format)
för att hantera alla inställningar i ett ASP.NET projekt.
 Nu går det att sätta upp en eller flera filer som
hanterar konfigurering i ett projekt. Det vanliga är att
dessa är i json format tex appsettings.json som är den
inbyggda configfilen.
Konfigurationsfiler
Om det finns värden i appsettings.json filen

"ConnectionStrings": {
"Default": ”Server=localhost;Database=MyDB;Trusted_Connection=True"
},
"MyConfig": {
”Myvalue": ”123" }

Kan dessa läsas i Program.cs

string value = Configuration.GetSection("MyConfig")
.GetSection("MyValue").Value;

string connectionstring =
builder.Configuration.GetConnectionString(”Default");
Länkar

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection

https://medium.com/volosoft/asp-net-core-dependency-injection-best-practices-tips-
tricks-c6e9c67f9d96

https://www.codementor.io/@mrfojo/c-with-dependency-injection-k2qfxbb8q

https://www.dotnettricks.com/learn/dependencyinjection/implementation-asp-net-core-mvc

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/static-files

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration

//om ni vill lära er ännu mer om repositorys i ASPNET core

https://codewithmukesh.com/blog/repository-pattern-in-aspnet-core/
Demo