Hvordan bruke alternativmønsteret i ASP.NET Core

Når du arbeider i ASP.NET Core, vil du ofte spesifisere programmets innstillinger, lagre dem i en fil og deretter hente disse innstillingene når applikasjonen trenger dem. Vanligvis vil du registrere avhengighetene dine i ConfigureServices-metoden i oppstartsklassen. Du kan spesifisere programmets innstillinger i appsettings.json eller en annen .json-fil og deretter dra nytte av avhengighetsinjeksjon gjennom IOptions for å lese disse innstillingene i applikasjonen.

Alternativmønstrene gir en elegant måte å legge til inntastede innstillinger i ASP.NET Core-applikasjonen. Alternativmønsteret, som er en utvidelse på toppen av IServiceCollection-grensesnittet, utnytter klasser for å representere en gruppe relaterte innstillinger. Denne artikkelen snakker om alternativmønsteret, hvorfor det er nyttig, og hvordan det kan brukes til å jobbe med konfigurasjonsdata i ASP.NET Core.

For å jobbe med kodeeksemplene som er gitt i denne artikkelen, bør du ha Visual Studio 2019 installert på systemet ditt. Hvis du ikke allerede har en kopi, kan du laste ned Visual Studio 2019 her.

Opprett et ASP.NET Core API-prosjekt

Først og fremst, la oss lage et ASP.NET Core-prosjekt i Visual Studio. Forutsatt at Visual Studio 2019 er installert i systemet ditt, følger du trinnene som er beskrevet nedenfor for å opprette et nytt ASP.NET Core API-prosjekt i Visual Studio.

Start Visual Studio IDE.
Klikk på "Opprett nytt prosjekt."
I vinduet "Opprett nytt prosjekt" velger du "ASP.NET Core Web Application" fra listen over maler som vises.
Klikk på Neste.
I vinduet “Konfigurer ditt nye prosjekt” som vises, angir du navnet og stedet for det nye prosjektet.
Klikk på Opprett.
I vinduet "Create New ASP.NET Core Web Application" velger du .NET Core som kjøretid og ASP.NET Core 3.0 (eller nyere) fra rullegardinlisten øverst. Jeg bruker ASP.NET Core 3.1 her.
Velg “API” som prosjektmal for å opprette et nytt ASP.NET Core API-program.
Forsikre deg om at avmerkingsboksene "Aktiver Docker-støtte" og "Konfigurer for HTTPS" ikke er merket av da vi ikke bruker disse funksjonene her.
Forsikre deg om at autentisering er angitt som “ingen godkjenning”, da vi heller ikke bruker autentisering.
Klikk på Opprett.

Dette vil opprette et nytt ASP.NET Core API-prosjekt i Visual Studio. Velg Controllers-løsningsmappen i Solution Explorer-vinduet, og klikk "Legg til -> Controller ..." for å opprette en ny kontroller som heter DefaultController. Vi bruker dette prosjektet i de påfølgende delene av denne artikkelen.

Implementere alternativmønsteret i ASP.NET Core

For å bruke alternativmønsteret i ASP.NET Core, trenger du pakken Microsoft.Extensions.Options.ConfigurationExtensions. Forresten refererer ASP.NET Core-applikasjoner implisitt Microsoft.Extensions.Options.ConfigurationExtensions-pakken som standard.

Når du bruker alternativmønsteret, vil du vanligvis bruke klasser til å representere en gruppe relaterte innstillinger. Når du isolerer konfigurasjonsinnstillingene i separate klasser, følger applikasjonen følgende prinsipper:

Separasjon av bekymringer: Innstillingene som brukes i forskjellige moduler i applikasjonen er frikoplet fra hverandre.
Grensesnitt-segregeringsprinsipp: Klassene som representerer disse innstillingene, avhenger bare av konfigurasjonsinnstillingene de vil bruke.

Skriv nå følgende innstillinger i appsettings.json-filen.

"DatabaseSettings": {

"Server": "localhost",

"Provider": "SQL Server",

"Database": "DemoDb",

"Port": 23,

"Brukernavn": "sa",

"Passord": "Joydip123"

}

Merk at konfigurasjonsklassen din skal ha offentlige get and set-egenskaper. Vi vil dra nytte av følgende klasse for å lese disse innstillingene snart.

 offentlig klasse DatabaseSettings
    {
  public string Server {get; sett; }
  public string Provider {get; sett; }
  public string Database {get; sett; }
  offentlig int Port {get; sett; }
  offentlig streng UserName {get; sett; }
  offentlig streng Passord {get; sett; }
    }

Du kan nå bruke Konfigurer utvidelsesmetoden til IServiceCollection for å binde innstillingsklassen din til konfigurasjonen din, som vist i kodebiten gitt nedenfor.

offentlig ugyldighet ConfigureServices (IServiceCollection-tjenester)
{
  tjenester.AddControllers ();
  tjenester. konfigurer
  (opsjoner => Configuration.GetSection ("DatabaseSettings"). Bind (alternativer));
}

Les konfigurasjonsdata i kontrolleren i ASP.NET Core

Vi vil nå dra nytte av DefaultController vi opprettet tidligere for å demonstrere hvordan vi kan lese konfigurasjonsdata i kontrolleren. IOptions-grensesnittet eksponerer en verdi-egenskap som kan brukes til å hente forekomsten av innstillingsklassen.

Følgende kodebit viser hvordan du kan bruke klassen DatabaseSettings i kontrolleren din som heter DefaultController. Legg merke til hvordan avhengighetsinjeksjon (konstruktørinjeksjon i dette eksemplet) har blitt brukt her.

offentlig klasse DefaultController: ControllerBase
{
  private DatabaseSettings _settings;
  offentlig DefaultController (IOptions-innstillinger)
   {
  _settings = innstillinger. verdi;
   }
  // Handlingsmetoder
}

Håndheve regler for konfigurasjoner i ASP.NET Core

Du kan også håndheve visse regler som vist i kodebiten nedenfor. Legg merke til hvordan en forekomst av hjelperklassen for SQL Server eller MySQL blir lagt til som en singleton her.

tjenester.Konfigurer (alternativer =>
 {
  if (options.Provider.ToLower (). Trim (). Equals ("sqlserver"))
     {
  services.AddSingleton (ny SqlDbHelper ());
     }
  annet hvis (options.Provider.ToLower (). Trim (). Lik ("mysql"))
     {
  services.AddSingleton (ny MySqlDbHelper ());
     }
 });

Støtte for sterkt skrevet konfigurasjon er en flott funksjon i ASP.NET Core som gjør det mulig å bruke skillet mellom bekymringer og prinsipper for separasjon av grensesnitt. I et fremtidig innlegg her på alternativmønsteret, vil jeg snakke om konfigurasjonsvalidering og konfigurasjon som kan lastes inn på nytt, med spesielt fokus på IOptionsMonitor-grensesnittet. Inntil da kan du lese mer om alternativmønsteret i Microsofts online dokumentasjon her.