Automatycznie ustawić plik appsettings.json dla środowisk deweloperskich i wydań w asp.net core?

Zdefiniowałem w moich wartościach appsettings.jsontakie rzeczy, jak parametry połączenia z bazą danych, lokalizacje webapi i tym podobne, które są różne dla środowisk programistycznych, tymczasowych i na żywo.

Czy istnieje sposób, aby mieć wiele appsettings.jsonplików (np. appsettings.live.jsonItp.) I mieć aplikację asp.net po prostu „wiedzieć”, którego użyć na podstawie uruchomionej konfiguracji kompilacji?

Możesz użyć kompilacji warunkowej:

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

Dodałem zrzuty ekranu ze środowiska pracy, ponieważ kosztowało mnie to kilka godzin badań i rozwoju.

1. Najpierw dodaj klucz do swojego launch.jsonpliku.

   Zobacz poniższy zrzut ekranu, dodałem Developmentjako moje środowisko.

   

2. Następnie w swoim projekcie utwórz nowy appsettings.{environment}.jsonplik zawierający nazwę środowiska.

   Na poniższym zrzucie ekranu poszukaj dwóch różnych plików o nazwach:

   • appsettings.Development.Json
   • appSetting.json

   
   

3. Na koniec skonfiguruj go do swojej StartUpklasy w następujący sposób:

   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. I w końcu możesz uruchomić go z wiersza poleceń w następujący sposób:

   dotnet run --environment "Development"
   

   gdzie "Development"jest nazwa mojego środowiska.

Aktualizacja dla .NET Core 3.0+

1. Możesz użyć, CreateDefaultBuilderktóry automatycznie zbuduje i przekaże obiekt konfiguracyjny do Twojej klasy startowej:

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

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

2. CreateDefaultBuilderautomatycznie dołącza odpowiedni plik, więc dodaj oddzielny plik appsettings dla każdego środowiska:appsettings.Environment.json

   

3. Następnie ustaw ASPNETCORE_ENVIRONMENT zmienną środowiskową podczas uruchamiania / debugowania

Jak ustawić zmienne środowiskowe

W zależności od IDE istnieje kilka miejsc, w których projekty dotnet tradycyjnie szukają zmiennych środowiskowych:

• W przypadku programu Visual Studio przejdź do projektu> właściwości> debugowania> zmienne środowiskowe:

  

• W przypadku programu Visual Studio Code edytuj .vscode/launch.json> env:

  

• Korzystając z Ustawień uruchamiania , edytuj Properties/launchSettings.json> environmentVariables:

  

  Które można również wybrać z paska narzędzi w programie Visual Studio

  

• Korzystając z interfejsu wiersza polecenia dotnet , użyj odpowiedniej składni do ustawiania zmiennych środowiskowych dla systemu operacyjnego

  Uwaga : gdy aplikacja jest uruchamiana przy użyciu dotnet run , launchSettings.jsonjest odczytywana, jeśli jest dostępna, a environmentVariablesustawienia w launchSettings.json zastępują zmienne środowiskowe.

Jak Host.CreateDefaultBuilder działa?

.NET Core 3.0 dodane w Host.CreateDefaultBuilderramach rozszerzeń platformy, które zapewnią domyślną inicjalizację, IConfigurationktóra zapewnia domyślną konfigurację aplikacji w następującej kolejności:

1. appsettings.jsonprzy użyciu dostawcy konfiguracji JSON .
2. appsettings.Environment.jsonprzy użyciu dostawcy konfiguracji JSON . Na przykład:
   • appsettings.Production.json lub
   • appsettings.Development.json
3. Sekrety aplikacji gdy aplikacja działa w środowisku programistycznym.
4. Zmienne środowiskowe korzystające z dostawcy konfiguracji zmiennych środowiskowych .
5. Argumenty wiersza polecenia przy użyciu dostawcy konfiguracji wiersza polecenia .

Dalsza lektura - MS Docs

• Uruchamianie aplikacji w ASP.NET Core
• Konfiguracja w ASP.NET Core
• Użyj wielu środowisk w ASP.NET Core

W ASP.NET Core należy raczej używać zmiennych środowiskowych zamiast konfiguracji kompilacji dla prawidłowego appsettings.json

1. Kliknij prawym przyciskiem myszy projekt> Właściwości> Debugowanie> Zmienne środowiskowe

   

2. ASP.NET Core użyje odpowiedniego pliku appsettings.json:

   

3. Teraz możesz użyć tej zmiennej środowiskowej w następujący sposób:

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

Uwaga : jeśli użyjesz odpowiedzi @ Dmitry , możesz napotkać problemy, np. podczas zastępowania wartości appsettings.json na platformie Azure.

Możesz użyć zmiennych środowiskowych i ConfigurationBuilderklasy w swoim Startupkonstruktorze w następujący sposób:

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

Następnie tworzysz appsettings.xxx.jsonplik dla każdego potrzebnego środowiska, gdzie „xxx” to nazwa środowiska. Pamiętaj, że możesz umieścić wszystkie globalne wartości konfiguracyjne w swoim „normalnym”appsettings.json pliku i umieścić w tych nowych plikach tylko elementy specyficzne dla środowiska.

Teraz potrzebujesz tylko zmiennej środowiskowej wywoływanej ASPNETCORE_ENVIRONMENTz określoną wartością środowiskową („na żywo”, „staging”, „produkcja”, cokolwiek). Możesz określić tę zmienną w ustawieniach projektu dla swojego środowiska programistycznego i oczywiście musisz ustawić ją również w środowisku pomostowym i produkcyjnym. Sposób, w jaki to robisz, zależy od tego, jakie to jest środowisko.

AKTUALIZACJA: Właśnie zdałem sobie sprawę, że chcesz wybrać na appsettings.xxx.jsonpodstawie bieżącej konfiguracji kompilacji . Nie da się tego osiągnąć za pomocą proponowanego przeze mnie rozwiązania i nie wiem, czy jest na to sposób. Jednak metoda „zmiennych środowiskowych” działa i równie dobrze może być dobrą alternatywą dla twojego podejścia.

Tylko aktualizacja dla użytkowników .NET core 2.0, możesz określić konfigurację aplikacji po wywołaniu 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. Utwórz wiele plików, takich jak:appSettings.$(Configuration).json

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

2. Utwórz wydarzenie przed kompilacją w projekcie, które kopiuje odpowiedni plik do appSettings.json:

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

3. Używaj tylko appSettings.jsonw swoim Config Builder:

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

Można dodać nazwę konfiguracji jak ASPNETCORE_ENVIRONMENTw launchSettings.jsonjak poniżej

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

Ta wersja działa u mnie podczas korzystania z aplikacji konsoli bez strony internetowej:

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

Plik .vscode / launch.json jest używany tylko przez program Visual Studio, a także plik /Properties/launchSettings.json. Nie używaj tych plików w środowisku produkcyjnym.

Plik launchSettings.json:

1. Jest używany tylko na lokalnym komputerze deweloperskim.
2. Nie jest wdrożony.

3. zawiera ustawienia profilu.

   • Wartości środowiskowe ustawione w launchSettings.json zastępują wartości ustawione w środowisku systemowym

Na przykład, aby użyć pliku „appSettings.QA.json”. Możesz użyć „ASPNETCORE_ENVIRONMENT”. Wykonaj poniższe kroki.

1. Dodaj nową zmienną środowiskową na komputerze hosta i nazwij ją „ASPNETCORE_ENVIRONMENT”. Ustaw jego wartość na „QA”.
2. Utwórz plik „appSettings.QA.json” w swoim projekcie. Dodaj swoją konfigurację tutaj.
3. Wdróż na komputerze w kroku 1. Upewnij się, że „appSettings.QA.json” jest wdrożona.
4. Załaduj swoją witrynę. Spodziewaj się użycia tutaj appSettings.QA.json.