Appkonfiguration

Tips/Råd

Det här innehållet är ett utdrag ur e-boken, Blazor för ASP NET Web Forms Developers for Azure, tillgängligt på .NET Docs eller som en kostnadsfri nedladdningsbar PDF som kan läsas offline.

Ladda ned PDF

Det primära sättet att läsa in appkonfigurationen i Webbformulär är med poster i web.config-filen – antingen på servern eller en relaterad konfigurationsfil som refereras av web.config. Du kan använda det statiska ConfigurationManager objektet för att interagera med appinställningar, anslutningssträngar för datalagringsplatser och andra utökade konfigurationsproviders som läggs till i appen. Det är vanligt att se interaktioner med appkonfigurationen enligt följande kod:

var configurationValue = ConfigurationManager.AppSettings["ConfigurationSettingName"];
var connectionString = ConfigurationManager.ConnectionStrings["MyDatabaseConnectionName"].ConnectionString;

Med ASP.NET Core och serversidan Blazorkan web.config-filen finnas om appen finns på en Windows IIS-server. Det finns dock ingen ConfigurationManager interaktion med den här konfigurationen och du kan ta emot mer strukturerad appkonfiguration från andra källor. Nu ska vi ta en titt på hur konfigurationen samlas in och hur du fortfarande kan komma åt konfigurationsinformation från en web.config fil.

Konfigurationskällor

ASP.NET Core inser att det finns många konfigurationskällor som du kanske vill använda för din app. Ramverket försöker erbjuda dig det bästa av dessa funktioner som standard. Konfigurationen läses och aggregeras från dessa olika källor av ASP.NET Core. Senare inlästa värden för samma konfigurationsnyckel har företräde framför tidigare värden.

ASP.NET Core har utformats för att vara molnmedveten och göra konfigurationen av appar enklare för både operatörer och utvecklare. ASP.NET Core är miljömedveten och vet om den körs i din Production- eller Development-miljö. Miljöindikatorn anges i ASPNETCORE_ENVIRONMENT systemmiljövariabeln. Om inget värde har konfigurerats körs appen som standard i Production miljön.

Appen kan utlösa och lägga till konfiguration från flera källor baserat på miljöns namn. Som standard läses konfigurationen in från följande resurser i den ordning som anges:

1. appsettings.json fil, om den finns
2. appsettings. {ENVIRONMENT_NAME}.json fil, om den finns
3. Filen med användarhemligheter på disken, om den finns
4. Miljövariabler
5. Kommandoradsargument

appsettings.json format och åtkomst

Den appsettings.json filen kan vara hierarkisk med värden strukturerade som följande JSON:

{
  "section0": {
    "key0": "value",
    "key1": "value"
  },
  "section1": {
    "key0": "value",
    "key1": "value"
  }
}

När konfigurationssystemet får föregående JSON, plattar det ut underordnade värden och hänvisar till deras fullständigt kvalificerade hierarkiska sökvägar. Ett kolontecken (:) separerar varje egenskap i hierarkin. Konfigurationsnyckeln section1:key0 kommer till exempel åt objektliteralens section1key0 värde.

Användarhemligheter

Användarhemligheter är:

• Konfigurationsvärden som lagras i en JSON-fil på utvecklarens arbetsstation, utanför mappen apputveckling.
• Läser bara in när det körs i Development miljön.
• Associerad med en specifik app.
• Hanteras med .NET CLI:s user-secrets kommando.

Konfigurera din app för lagring av hemligheter genom att user-secrets köra kommandot:

dotnet user-secrets init

Föregående kommando lägger till ett UserSecretsId element i projektfilen. Elementet innehåller ett GUID som används för att associera hemligheter med appen. Du kan sedan definiera en hemlighet med set kommandot . Till exempel:

dotnet user-secrets set "Parent:ApiKey" "12345"

Föregående kommando gör konfigurationsnyckeln Parent:ApiKey tillgänglig på en utvecklares arbetsstation med värdet 12345.

Mer information om hur du skapar, lagrar och hanterar användarhemligheter finns i dokumentet Säker lagring av apphemligheter under utveckling i ASP.NET Core .

Miljövariabler

Nästa uppsättning värden som läses in i appkonfigurationen är systemets miljövariabler. Alla miljövariabler i systemet är nu tillgängliga för dig via konfigurations-API:et. Hierarkiska värden plattas ut och avgränsas med kolontecken när de läss i appen. Vissa operativsystem tillåter dock inte miljövariabelnamn för kolontecken. ASP.NET Core åtgärdar den här begränsningen genom att konvertera värden som har dubbla understreck (__) till ett kolon när de används. Värdet Parent:ApiKey från avsnittet användarhemligheter ovan kan åsidosättas med miljövariabeln Parent__ApiKey.

Kommandoradsargument

Konfigurationen kan också anges som kommandoradsargument när appen startas. Använd notationen double-dash (--) eller forward-slash (/) för att ange namnet på det konfigurationsvärde som ska anges och det värde som ska konfigureras. Syntaxen liknar följande kommandon:

dotnet run CommandLineKey1=value1 --CommandLineKey2=value2 /CommandLineKey3=value3
dotnet run --CommandLineKey1 value1 /CommandLineKey2 value2
dotnet run Parent:ApiKey=67890

Återkomsten av web.config

Om du har distribuerat appen till Windows på IIS konfigurerar web.config-filen fortfarande IIS för att hantera din app. Som standard lägger IIS till en referens till ASP.NET Core Module (ANCM). ANCM är en intern IIS-modul som är värd för din app i stället för Kestrel-webbservern. Det här web.config avsnittet liknar följande XML-kod:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <location path="." inheritInChildApplications="false">
    <system.webServer>
      <handlers>
        <add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModuleV2" resourceType="Unspecified" />
      </handlers>
      <aspNetCore processPath=".\MyApp.exe"
                  stdoutLogEnabled="false"
                  stdoutLogFile=".\logs\stdout"
                  hostingModel="inprocess" />
    </system.webServer>
  </location>
</configuration>

Appspecifik konfiguration kan definieras genom att kapsla ett environmentVariables element i elementet aspNetCore . De värden som definieras i det här avsnittet visas för ASP.NET Core-appen som miljövariabler. Miljövariablerna läses in korrekt under det segmentet av applikationsstarten.

<aspNetCore processPath="dotnet"
      arguments=".\MyApp.dll"
      stdoutLogEnabled="false"
      stdoutLogFile=".\logs\stdout"
      hostingModel="inprocess">
  <environmentVariables>
    <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Development" />
    <environmentVariable name="Parent:ApiKey" value="67890" />
  </environmentVariables>
</aspNetCore>

Läs konfiguration i appen

ASP.NET Core tillhandahåller appkonfiguration via IConfiguration gränssnittet. Det här konfigurationsgränssnittet ska begäras av dina Blazor komponenter, Blazor sidor och andra ASP.NET Core-hanterade klass som behöver åtkomst till konfigurationen. ASP.NET Core-ramverket fyller automatiskt i det här gränssnittet med den konfiguration som konfigurerades tidigare. På en Blazor sida eller en komponents Razor-markering kan du infoga IConfiguration objektet med ett @inject direktiv överst i .razor-filen så här:

@inject IConfiguration Configuration

Den här föregående instruktionen IConfiguration gör objektet tillgängligt som Configuration variabel i resten av Razor-mallen.

Enskilda konfigurationsinställningar kan läsas genom att ange den konfigurationsinställningshierarki som söks som en indexerareparameter:

var mySetting = Configuration["section1:key0"];

Du kan hämta hela konfigurationsavsnitt med hjälp av GetSection-metoden för att hämta en samling nycklar på en specifik plats, med en syntax liknande GetSection("section1") för att hämta konfigurationen för avsnitt1 från det tidigare exemplet.

Starkt skriven konfiguration

Med Webbformulär var det möjligt att skapa en starkt typad konfigurationstyp som ärvts från ConfigurationSection typen och tillhörande typer. ConfigurationSection gjorde det möjligt för dig att konfigurera vissa affärsregler och bearbetning för dessa konfigurationsvärden.

I ASP.NET Core kan du ange en klasshierarki som ska ta emot konfigurationsvärdena. Dessa klasser:

• Behöver inte ärva från en förälderklass.
• Bör innehålla public egenskaper som matchar egenskaperna och typreferenserna för den konfigurationsstruktur som du vill avbilda.

För det tidigare appsettings.json exemplet kan du definiera följande klasser för att samla in värdena:

public class MyConfig
{
    public MyConfigSection section0 { get; set;}

    public MyConfigSection section1 { get; set;}
}

public class MyConfigSection
{
    public string key0 { get; set; }

    public string key1 { get; set; }
}

Den här klasshierarkin kan fyllas i genom att lägga till Startup.ConfigureServices följande rad i metoden (eller lämplig plats i Program.cs med egenskapen builder.Services i stället för services):

services.Configure<MyConfig>(Configuration);

I resten av appen kan du lägga till en indataparameter i klasser eller ett @inject direktiv i Razor-mallar av typen IOptions<MyConfig> för att få de starkt inskrivna konfigurationsinställningarna. Egenskapen IOptions<MyConfig>.Value ger det MyConfig värde som fylls i från konfigurationsinställningarna.

@inject IOptions<MyConfig> options
@code {
    var MyConfiguration = options.Value;
    var theSetting = MyConfiguration.section1.key0;
}

Mer information om funktionen Alternativ finns i mönstret Alternativ i ASP.NET Core-dokumentet .

FöregåendeNästa