Appsettings.json automatisch für Entwicklungs- und Release-Umgebungen im asp.net-Kern festlegen?

Ich habe in meinem einige Werte appsettings.jsonfür Dinge wie Datenbankverbindungszeichenfolgen, Webapi-Speicherorte und dergleichen definiert, die sich für Entwicklungs-, Staging- und Live-Umgebungen unterscheiden.

Gibt es eine Möglichkeit, mehrere appsettings.jsonDateien (wie appsettings.live.jsonusw. usw.) zu haben und die asp.net-App nur anhand der von ihr ausgeführten Build-Konfiguration zu wissen, welche verwendet werden soll?

Sie können die bedingte Kompilierung verwenden:

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
    .SetBasePath(env.ContentRootPath)
    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
#if SOME_BUILD_FLAG_A
    .AddJsonFile($"appsettings.flag_a.json", optional: true)
#else
    .AddJsonFile($"appsettings.no_flag_a.json", optional: true)
#endif
    .AddEnvironmentVariables();
    this.configuration = builder.Build();
}

Ich habe Screenshots einer Arbeitsumgebung hinzugefügt, da es mich mehrere Stunden Forschung und Entwicklung gekostet hat.

1. Fügen Sie Ihrer launch.jsonDatei zunächst einen Schlüssel hinzu .

   Siehe den folgenden Screenshot, den ich Developmentals meine Umgebung hinzugefügt habe.

   

2. Erstellen Sie dann in Ihrem Projekt eine neue appsettings.{environment}.jsonDatei, die den Namen der Umgebung enthält.

   Suchen Sie im folgenden Screenshot nach zwei verschiedenen Dateien mit den Namen:

   • appsettings.Development.Json
   • appSetting.json

   
   

3. Und schließlich konfigurieren Sie es für Ihre StartUpKlasse wie folgt:

   public Startup(IHostingEnvironment env)
   {
       var builder = new ConfigurationBuilder()
           .SetBasePath(env.ContentRootPath)
           .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
           .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
           .AddEnvironmentVariables();
   
       Configuration = builder.Build();
   }
   

4. Und endlich können Sie es über die Befehlszeile wie folgt ausführen:

   dotnet run --environment "Development"
   

   Wo "Development"ist der Name meiner Umgebung?

Update für .NET Core 3.0+

1. Sie können Folgendes verwenden CreateDefaultBuilder, um automatisch ein Konfigurationsobjekt zu erstellen und an Ihre Startklasse zu übergeben:

   WebHost.CreateDefaultBuilder(args).UseStartup<Startup>();
   

   public class Startup
   {
       public Startup(IConfiguration configuration) // automatically injected
       {
           Configuration = configuration;
       }
       public IConfiguration Configuration { get; }
       /* ... */
   }
   

2. CreateDefaultBuilderEnthält automatisch die entsprechende Datei. Fügen Sie daher für jede Umgebung eine separate App-Einstellungsdatei hinzu:appsettings.Environment.json

   

3. Legen Sie dann die ASPNETCORE_ENVIRONMENT Umgebungsvariable beim Ausführen / Debuggen fest

So legen Sie Umgebungsvariablen fest

Abhängig von Ihrer IDE gibt es einige Stellen, an denen Dotnet-Projekte traditionell nach Umgebungsvariablen suchen:

• Gehen Sie für Visual Studio zu Projekt> Eigenschaften> Debug> Umgebungsvariablen:

  

• Bearbeiten Sie für Visual Studio-Code.vscode/launch.json > env:

  

• Mit Starteinstellungen , Bearbeiten Properties/launchSettings.json>environmentVariables :

  

  Welche kann auch aus der Symbolleiste in Visual Studio ausgewählt werden

  

• Verwenden Sie bei Verwendung der Dotnet-CLI die entsprechende Syntax für Festlegen von Umgebungsvariablen Ihr Betriebssystem

  Hinweis : Wenn eine App mit dotnet run gestartet wird , launchSettings.jsonwird sie gelesen, falls verfügbar, und die environmentVariablesEinstellungen in launchSettings.json überschreiben Umgebungsvariablen.

Wie funktioniert das Host.CreateDefaultBuilder?

.NET Core 3.0 wurde Host.CreateDefaultBuilderunter Plattformerweiterungen hinzugefügt , die eine Standardinitialisierung bereitstellen, IConfigurationdie die Standardkonfiguration für die App in der folgenden Reihenfolge bereitstellt:

1. appsettings.jsonVerwenden des JSON-Konfigurationsanbieters .
2. appsettings.Environment.jsonVerwenden des JSON-Konfigurationsanbieters . Zum Beispiel:
   • appsettings.Production.json oder
   • appsettings.Development.json
3. App-Geheimnisse, wenn die App in der Entwicklungsumgebung ausgeführt wird.
4. Umgebungsvariablen mit dem Konfigurationsanbieter für Umgebungsvariablen .
5. Befehlszeilenargumente mit dem Befehlszeilenkonfigurationsanbieter .

Weiterführende Literatur - MS Docs

• App-Start in ASP.NET Core
• Konfiguration in ASP.NET Core
• Verwenden Sie mehrere Umgebungen in ASP.NET Core

In ASP.NET Core sollten Sie lieber Umgebungsvariablen verwenden, anstatt die Konfiguration für die richtige appsettings.json zu erstellen

1. Klicken Sie mit der rechten Maustaste auf Ihr Projekt> Eigenschaften> Debug> Umgebungsvariablen

   

2. ASP.NET Core verwendet die entsprechende Datei appsettings.json:

   

3. Jetzt können Sie diese Umgebungsvariable folgendermaßen verwenden:

   public Startup(IHostingEnvironment env)
   {
       var builder = new ConfigurationBuilder()
           .SetBasePath(env.ContentRootPath)
           .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
           .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
           .AddEnvironmentVariables();
   
       Configuration = builder.Build();
   }
   

Hinweis : Wenn Sie die Antwort von @ Dmitry verwenden , können Probleme auftreten, z. beim Überschreiben von appsettings.json-Werten in Azure.

Sie können Umgebungsvariablen und die ConfigurationBuilderKlasse in Ihrem StartupKonstruktor folgendermaßen verwenden:

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
    .SetBasePath(env.ContentRootPath)
    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
    .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
    .AddEnvironmentVariables();
    this.configuration = builder.Build();
}

Anschließend erstellen Sie eine appsettings.xxx.jsonDatei für jede benötigte Umgebung, wobei "xxx" der Umgebungsname ist. Beachten Sie, dass Sie alle globalen Konfigurationswerte in Ihre "normale" appsettings.jsonDatei einfügen und nur die umgebungsspezifischen Elemente in diese neuen Dateien einfügen können.

Jetzt benötigen Sie nur noch eine Umgebungsvariable ASPNETCORE_ENVIRONMENTmit einem bestimmten Umgebungswert ("live", "staging", "Production" usw.). Sie können diese Variable in Ihren Projekteinstellungen für Ihre Entwicklungsumgebung angeben, und natürlich müssen Sie sie auch in Ihren Staging- und Produktionsumgebungen festlegen. Wie Sie es dort machen, hängt davon ab, um welche Umgebung es sich handelt.

UPDATE: Ich habe gerade festgestellt, dass Sie die appsettings.xxx.jsonbasierend auf Ihrer aktuellen Build-Konfiguration auswählen möchten . Dies kann mit meiner vorgeschlagenen Lösung nicht erreicht werden, und ich weiß nicht, ob es einen Weg gibt, dies zu tun. Die Methode "Umgebungsvariable" funktioniert jedoch und könnte genauso gut eine gute Alternative zu Ihrem Ansatz sein.

Nur ein Update für Benutzer von .NET Core 2.0. Sie können die Anwendungskonfiguration nach dem Aufruf von CreateDefaultBuilder:

public class Program
{
   public static void Main(string[] args)
   {
      BuildWebHost(args).Run();
   }

   public static IWebHost BuildWebHost(string[] args) =>
      WebHost.CreateDefaultBuilder(args)
             .ConfigureAppConfiguration(ConfigConfiguration)
             .UseStartup<Startup>()
             .Build();

   static void ConfigConfiguration(WebHostBuilderContext ctx, IConfigurationBuilder config)
   {
            config.SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("config.json", optional: false, reloadOnChange: true)
                .AddJsonFile($"config.{ctx.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true);

   }
 }

1. Erstellen Sie mehrere Dateien wie:appSettings.$(Configuration).json

   • appSettings.staging.json
   • appSettings.production.json

2. Erstellen Sie ein Pre-Build-Ereignis für das Projekt, das die entsprechende Datei kopiert in appSettings.json:

   copy appSettings.$(Configuration).json appSettings.json
   

3. Nur appSettings.jsonin Ihrem Config Builder verwenden:

   var builder = new ConfigurationBuilder()
               .SetBasePath(env.ContentRootPath)
               .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
               .AddEnvironmentVariables();
   
   Configuration = builder.Build();
   

Sie können die Konfigurationsnamen als das hinzufügen ASPNETCORE_ENVIRONMENTder , launchSettings.jsonwie unten

  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:58446/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "environmentVariables": {
        ASPNETCORE_ENVIRONMENT": "$(Configuration)"
      }
    }
  }

Dies ist die Version, die für mich funktioniert, wenn ich eine Konsolen-App ohne Webseite verwende:

var builder = new ConfigurationBuilder()
             .SetBasePath(Directory.GetCurrentDirectory())
             .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
             .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json", optional: true);

            IConfigurationRoot configuration = builder.Build();
            AppSettings appSettings = new AppSettings();
            configuration.GetSection("AppSettings").Bind(appSettings);

Die Datei .vscode / launch.json wird nur von Visual Studio sowie von der Datei /Properties/launchSettings.json verwendet. Verwenden Sie diese Dateien nicht in der Produktion.

Die Datei launchSettings.json:

1. Wird nur auf der lokalen Entwicklungsmaschine verwendet.
2. Wird nicht bereitgestellt.

3. enthält Profileinstellungen.

   • In launchSettings.json festgelegte Umgebungswerte überschreiben die in der Systemumgebung festgelegten Werte

So verwenden Sie beispielsweise eine Datei 'appSettings.QA.json'. Sie können 'ASPNETCORE_ENVIRONMENT' verwenden. Folgen Sie den unteren Schritten.

1. Fügen Sie eine neue Umgebungsvariable auf dem Hostcomputer hinzu und nennen Sie sie 'ASPNETCORE_ENVIRONMENT'. Setzen Sie den Wert auf 'QA'.
2. Erstellen Sie eine Datei 'appSettings.QA.json' in Ihrem Projekt. Fügen Sie hier Ihre Konfiguration hinzu.
3. Bereitstellung auf dem Computer in Schritt 1. Bestätigen Sie, dass 'appSettings.QA.json' bereitgestellt wurde.
4. Laden Sie Ihre Website. Erwarten Sie, dass hier appSettings.QA.json verwendet wird.