Share via

App-Konfiguration

  • Artikel

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

Blazor-for-ASP-NET-Web-Forms-Developers eBook cover thumbnail.

Die primäre Methode zum Laden der App-Konfiguration in Web Forms besteht im Verwenden von Einträgen in der web.config-Datei, entweder auf dem Server oder in einer zugehörigen Konfigurationsdatei, auf die von web.config verwiesen wird. Sie können das statische ConfigurationManager-Objekt für die Interaktion mit App-Einstellungen, Datenrepository-Verbindungszeichenfolgen und anderen erweiterten Konfigurationsanbietern verwenden, die der App hinzugefügt sind. Es ist üblich, Interaktionen mit der App-Konfiguration wie im folgenden Code zu beobachten:

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

Mit ASP.NET Core and serverseitigem Blazor KÖNNTE die web.config-Datei vorhanden sein, 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 nun an, wie die Konfiguration erfasst wird und wie Sie weiterhin über eine web.config-Datei auf Konfigurationsinformationen zugreifen können.

Konfigurationsquellen

ASP.NET Core erkennt, dass es viele Konfigurationsquellen gibt, die Sie möglicherweise für Ihre App verwenden möchten. Das Framework versucht, Ihnen standardmäßig das beste dieser Features anzubieten. Die Konfiguration wird aus 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 wird in der Cloud unterstützt, um die Konfiguration von Apps für Operatoren und Entwickler zu vereinfachen. ASP.NET Core ist von der Umgebung abhängig und weiß, ob Sie in ihrer Production oder Development-Umgebung ausgeführt wird. Der Umgebungsindikator wird in der ASPNETCORE_ENVIRONMENT-Systemumgebungsvariablen 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.js-Datei (sofern vorhanden)
  2. appSettings. {ENVIRONMENT_NAME}. JSON-Datei, sofern vorhanden
  3. Benutzergeheimnisdatei auf Datenträger, falls vorhanden
  4. Umgebungsvariablen
  5. Befehlszeilenargumente

appsettings.json-Format und Zugriff

Die appsettings.json-Datei kann hierarchisch sein, wobei die Werte wie im folgenden 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 section1-Wert des Objektliterals key0 zu.

Benutzergeheimnisse

Benutzergeheimnisse 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 werden.
  • Einer bestimmten App zugeordnet.
  • Werden mit dem .NET CLI user-secrets-Befehl verwaltet.

Konfigurieren Sie Ihre App für die Speicherung von Geheimnissen durch Ausführen des folgenden user-secrets-Befehls:

dotnet user-secrets init

Mit dem vorangehenden Befehl wird der Projektdatei ein UserSecretsId-Element hinzugefügt. Das Element enthält eine GUID, die verwendet wird, um der App Geheimnisse zuzuordnen. Anschließend können Sie mit dem set-Befehl ein Geheimnis definieren. Beispiel:

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

Der vorherige Befehl macht den Parent:ApiKey-Konfigurationsschlüssel auf der Workstation eines Entwicklers mit dem 12345-Wert verfügbar.

Weitere Informationen zum Erstellen, Speichern und Verwalten von Benutzergeheimnissen finden Sie im Dokument sichere Speicherung von App-Geheimnissen in der Entwicklung in ASP.NET Core.

Umgebungsvariablen

Die nächste Gruppe von Werten, die in Ihre App-Konfiguration geladen werden, sind die Umgebungsvariablen des Systems. Alle Einstellungen der Einstellungen Ihres Systems sind nun über die Konfigurations-API zugänglich. Hierarchische Werte werden vereinfacht und durch Doppelpunkte getrennt, wenn Sie in der App gelesen werden. Allerdings lassen einige Betriebssysteme Doppelpunkte im Namen der Umgebungsvariablen nicht zu. ASP.NET Core umgeht diese Einschränkung, indem Werte, die doppelte Unterstriche (__) aufweisen, beim Zugriff in einen Doppelpunkt umgewandelt werden. Der Parent:ApiKey-Wert aus dem obigen Abschnitt „Benutzergeheimnisse“ kann mit der Umgebungsvariablen Parent__ApiKey überschrieben werden.

Befehlszeilenargumente

Die Konfiguration kann auch als Befehlszeilenargumente bereitgestellt werden, wenn Ihre Ap gestartet wird. Verwenden Sie die Notation Doppelstrich (--) oder Schrägstrich (/), um den Namen des festzulegenden Konfigurationswerts und den Wert anzugeben, der konfiguriert werden soll. 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ückgabe von web.config

Wenn Sie Ihre App für Windows auf IIS bereitgestellt haben, konfiguriert die web.config-Datei weiterhin IIS, um Ihre App zu verwalten. Standardmäßig fügt IIS einen Verweis auf das ASP.NET Core-Modul (ANCM) hinzu. Bei ANCM handelt es sich um ein natives IIS-Modul, das Ihre App anstelle des Kestrel-Webservers hostet. 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>

Die App-spezifische Konfiguration kann definiert werden, indem ein environmentVariables-Element imaspNetCore -Element geschachtelt wird. Die in diesem Abschnitt definierten Werte werden in der ASP.NET Core-App als Umgebungsvariablen angezeigt. Die Umgebungsvariablen werden während dieses Segments des App-Starts entsprechend 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>

Lesen der Konfiguration in der App

ASP.NET Core stellt die App-Konfiguration über die IConfiguration-Schnittstelle bereit. Diese Konfigurationsschnittstelle sollte von Ihren Blazor-Komponenten, Blazor-Seiten und jeder anderen ASP.NET Core verwalteten Klasse angefordert werden, die Zugriff auf die Konfiguration benötigen. Das ASP.NET Core-Framework füllt diese Schnittstelle automatisch mit der zuvor konfigurierten aufgelösten Konfiguration auf. Auf einer Blazor-Seite oder dem Razor-Markup einer Komponente können Sie das IConfiguration-Objekt wie folgt mit einer @inject-Direktive am Anfang der .razor-Datei einfügen:

@inject IConfiguration Configuration

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

Sie können einzelne Konfigurationseinstellungen lesen, indem Sie die Hierarchie der Konfigurationseinstellung angeben, die als Indexer-Parameter gesucht wurde:

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

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

Stark typisierte Konfiguration

Mit Web Forms war es möglich, einen stark typisierten Konfigurationstyp zu erstellen, der vom ConfigurationSection-Typ und den zugeordneten Typen geerbt wurde. Mit ConfigurationSection können Sie einige Geschäftsregeln und die Verarbeitung für diese Konfigurationswerte 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.
  • Sollten public-Eigenschaften enthalten, die mit den Eigenschaften und Typverweisen für die Konfigurationsstruktur, die Sie erfassen möchten, identisch sind.

Für das vorherige appsettings.jszum-Beispiel könnten 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 aufgefüllt werden, indem der Startup.ConfigureServices-Methode die folgende Zeile hinzugefügt wird (oder an der entsprechenden Position in Program.cs, unter Verwendung der builder.Services-Eigenschaft anstelle von services):

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 ergibt den MyConfig-Wert, der von den Konfigurationseinstellungen aufgefüllt wird.

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

Weitere Informationen zu den Optionen finden Sie im DokumentOptionsmuster in ASP.NET Core.

ZurückWeiter