Freigeben über

App-Konfiguration

Tipp

Diese Inhalte sind ein Auszug aus dem eBook „Blazor for ASP NET Web Forms Developers for Azure“, verfügbar unter .NET Docs oder als kostenlos herunterladbare PDF-Datei, die offline gelesen werden kann.

PDF herunterladen

Miniaturansicht des Deckblatts des eBooks „Blazor for ASP NET Web Forms Developers for Azure“.

Die primäre Möglichkeit zum Laden der App-Konfiguration in Web Forms besteht aus Einträgen in der web.config-Datei – entweder auf dem Server oder in einer zugehörigen Konfigurationsdatei, auf die von web.configverwiesen wird. Sie können das statische ConfigurationManager Objekt verwenden, um mit App-Einstellungen, Datenreppository-Verbindungszeichenfolgen und anderen erweiterten Konfigurationsanbietern zu interagieren, die der App hinzugefügt werden. Es ist typisch, Interaktionen mit der App-Konfiguration zu sehen, wie im folgenden Code zu sehen:

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

Mit ASP.NET Core und serverseitig Blazor ist die web.config Datei möglicherweise vorhanden, wenn Ihre App auf einem Windows IIS-Server gehostet wird. Es gibt jedoch keine ConfigurationManager Interaktion mit dieser Konfiguration, und Sie können eine strukturiertere App-Konfiguration aus anderen Quellen erhalten. Sehen wir uns an, wie die Konfiguration gesammelt wird und wie Sie weiterhin auf Konfigurationsinformationen aus einer web.config Datei zugreifen können.

Konfigurationsquellen

ASP.NET Core erkennt, dass es viele Konfigurationsquellen gibt, die Sie für Ihre App verwenden möchten. Das Framework versucht, Ihnen standardmäßig das Beste aus diesen Features zu bieten. Die Konfiguration wird von diesen verschiedenen Quellen durch ASP.NET Core gelesen und aggregiert. Später geladene Werte für denselben Konfigurationsschlüssel haben Vorrang vor früheren Werten.

ASP.NET Core wurde entwickelt, um cloudfähig zu sein und die Konfiguration von Apps für Operatoren und Entwickler zu vereinfachen. ASP.NET Core ist umgebungsbewusst und erkennt, ob es in Ihrer Production-Umgebung oder Development-Umgebung ausgeführt wird. Der Umgebungsindikator wird in der Systemumgebungsvariablen ASPNETCORE_ENVIRONMENT festgelegt. Wenn kein Wert konfiguriert ist, wird die App standardmäßig in der Production Umgebung ausgeführt.

Ihre App kann basierend auf dem Namen der Umgebung eine Konfiguration aus mehreren Quellen initiieren und hinzufügen. Standardmäßig wird die Konfiguration aus den folgenden Ressourcen in der aufgeführten Reihenfolge geladen:

  1. appsettings.json Datei, falls vorhanden
  2. appsettings. {ENVIRONMENT_NAME}.json Datei, falls vorhanden
  3. Datei mit geheimen Benutzerschlüsseln auf dem Datenträger, falls vorhanden
  4. Umgebungsvariablen
  5. Befehlszeilenargumente

appsettings.json-Format und Zugriff

Die appsettings.json Datei kann hierarchisch sein, wobei Werte wie der folgende JSON strukturiert sind:

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

Wenn das Konfigurationssystem mit dem vorangehenden JSON dargestellt wird, werden untergeordnete Werte vereinfacht und auf die vollqualifizierten hierarchischen Pfade verwiesen. Ein Doppelpunkt (:) trennt jede Eigenschaft in der Hierarchie. Beispielsweise greift der Konfigurationsschlüssel section1:key0 auf den Wert des section1 Objektliterals key0 zu.

Benutzergeheimnisse

Geheime Benutzerschlüssel sind:

  • Konfigurationswerte, die in einer JSON-Datei auf der Arbeitsstation des Entwicklers außerhalb des App-Entwicklungsordners gespeichert sind.
  • Wird nur geladen, wenn sie in der Development Umgebung ausgeführt wird.
  • Einer bestimmten App zugeordnet.
  • Werden mit dem .NET CLI user-secrets-Befehl verwaltet.

Konfigurieren Sie Ihre App für die Speicherung geheimer Schlüssel, indem Sie den user-secrets Befehl ausführen:

dotnet user-secrets init

Mit dem vorherigen Befehl wird der Projektdatei ein UserSecretsId Element hinzugefügt. Das Element enthält eine GUID, die verwendet wird, um geheime Schlüssel mit der App zu verknüpfen. Anschließend können Sie einen geheimen Schlüssel mit dem set Befehl definieren. Beispiel:

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

Mit dem vorherigen Befehl wird der Parent:ApiKey Konfigurationsschlüssel auf der Arbeitsstation eines Entwicklers mit dem Wert 12345verfügbar.

Weitere Informationen zum Erstellen, Speichern und Verwalten von geheimen Benutzerschlüsseln finden Sie im Abschnitt zum sicheren Speichern geheimer App-Schlüssel in der Entwicklung in ASP.NET Core-Dokument .

Umgebungsvariablen

Der nächste Satz von Werten, die in Ihre App-Konfiguration geladen wurden, ist die Umgebungsvariablen des Systems. Auf alle Umgebungsvariableneinstellungen Ihres Systems kann jetzt über die Konfigurations-API zugegriffen werden. Hierarchische Werte werden vereinfacht und durch Doppelpunkte getrennt, wenn Sie in der App gelesen werden. Einige Betriebssysteme erlauben jedoch keine Umgebungsvariablennamen, die das Zeichen Doppelpunkt enthalten. ASP.NET Core behebt diese Einschränkung durch Konvertieren von Werten mit doppelten Unterstrichen (__) in einen Doppelpunkt, wenn auf sie zugegriffen wird. Der Parent:ApiKey Wert aus dem obigen Abschnitt mit den geheimen Benutzerschlüsseln kann mit der Umgebungsvariable Parent__ApiKeyüberschrieben werden.

Befehlszeilenargumente

Die Konfiguration kann auch als Befehlszeilenargumente bereitgestellt werden, wenn Ihre App gestartet wird. Verwenden Sie den Doppeltstrich (--) oder den Schrägstrich (/), um den Namen des festzulegenden Konfigurationswerts und des zu konfigurierenden Werts anzugeben. Die Syntax ähnelt den folgenden Befehlen:

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

Die Rückkehr von web.config

Wenn Sie Ihre App in Windows unter IIS bereitgestellt haben, konfiguriert die web.config Datei IIS weiterhin für die Verwaltung Ihrer App. Standardmäßig fügt IIS einen Verweis auf das ASP.NET Core Module (ANCM) hinzu. ANCM ist ein systemeigenes IIS-Modul, in dem Ihre App anstelle des Kestrel-Webservers gehostet wird. Dieser web.config Abschnitt ähnelt dem folgenden XML-Markup:

<?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>

App-spezifische Konfiguration kann durch das Schachteln eines environmentVariables-Elements in einem aspNetCore-Element definiert werden. Die in diesem Abschnitt definierten Werte werden der ASP.NET Core-App als Umgebungsvariablen angezeigt. Die Umgebungsvariablen werden während dieses Abschnitts des App-Starts angemessen geladen.

<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>

Konfiguration in der App lesen

ASP.NET Core stellt die App-Konfiguration über die IConfiguration Schnittstelle bereit. Diese Konfigurationsschnittstelle sollte von Ihren Blazor Komponenten, Blazor Seiten und allen anderen ASP.NET Core-verwalteten Klasse angefordert werden, die Zugriff auf die Konfiguration benötigt. Das ASP.NET Core-Framework wird diese Schnittstelle automatisch mit der zuvor ermittelten und konfigurierten Konfiguration befüllen. Auf einer Blazor Seite oder dem Razor-Markup einer Komponente können Sie das IConfiguration Objekt wie folgt mit einer @inject Direktive oben in die RAZOR-Datei einfügen:

@inject IConfiguration Configuration

Diese vorangehende Anweisung macht das IConfiguration-Objekt in der gesamten Razor-Vorlage als Configuration-Variable verfügbar.

Einzelne Konfigurationseinstellungen können gelesen werden, indem Sie die Konfigurationseinstellungshierarchie angeben, die als Indexerparameter gesucht wird:

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

Sie können ganze Konfigurationsabschnitte abrufen, indem Sie die GetSection Methode verwenden, um eine Sammlung von Schlüsseln an einem bestimmten Speicherort mit einer Syntax abzurufen, die dem Abrufen der Konfiguration für Abschnitt1 aus dem vorherigen Beispiel ähnelt GetSection("section1") .

Stark typisierte Konfiguration

Mit Web Forms war es möglich, einen stark typisierten Konfigurationstyp zu erstellen, der vom ConfigurationSection-Typ und den zugehörigen Typen geerbt hat. Ein ConfigurationSection ermöglichte, bestimmte Geschäftsregeln und Verarbeitungen für diese Konfigurationswerte zu konfigurieren.

In ASP.NET Core können Sie eine Klassenhierarchie angeben, die die Konfigurationswerte empfängt. Diese Klassen:

  • Müssen nicht von einer übergeordneten Klasse erben.
  • Eigenschaften sollten public enthalten, die den Eigenschaften und Typreferenzen der Konfigurationsstruktur entsprechen, die Sie erfassen möchten.

Für das frühere appsettings.json Beispiel können Sie die folgenden Klassen definieren, um die Werte zu erfassen:

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; }
}

Diese Klassenhierarchie kann gefüllt werden, indem der Methode die folgende Zeile Startup.ConfigureServices hinzugefügt wird (oder an einem geeigneten Ort in Program.cs, wobei die builder.Services-Eigenschaft anstelle von services verwendet wird).

services.Configure<MyConfig>(Configuration);

Im Rest der App können Sie den Klassen einen Eingabeparameter oder eine @inject-Direktive in Razor-Vorlagen des Typs IOptions<MyConfig> hinzufügen, um die stark typisierten Konfigurationseinstellungen zu erhalten. Die IOptions<MyConfig>.Value Eigenschaft liefert den MyConfig Wert, der aus den Konfigurationseinstellungen aufgefüllt wird.

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

Weitere Informationen zur Optionsfunktion finden Sie im Dokument Optionsmuster in ASP.NET Core.

ZurückWeiter