wake-up-neo.com

Wie setze ich den Umgebungsnamen (IHostingEnvironment.EnvironmentName)?

Das standardmäßige ASP.NET Core-Webprojekt enthält solche Zeilen in Startup.cs:

if (string.Equals(env.EnvironmentName, "Development", StringComparison.OrdinalIgnoreCase))
{
    app.UseBrowserLink();
    app.UseErrorPage(ErrorPageOptions.ShowAll);
}
else
{
    app.UseErrorHandler("/Home/Error");
}

Nach meinem Verständnis ist der Umgebungsname eine neue Möglichkeit, mit der Entwicklungs-/Produktionsumgebung umzugehen. In Release Build-Konfiguration ändert sich dies jedoch nicht. Was ist also der Weg, um ein anderes EnvironmentName einzustellen?

Ich kann mir vorstellen, dass es in "Befehle" als Parameter für den Server gesetzt werden sollte.

51
tsdaemon

launchsettings.json

Unter Eigenschaften> launchsettings.json

Genau wie dieser:

    {
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:1032/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Production"
      }
    },
    "WebAppNetCore": {
      "commandName": "Project",
      "launchBrowser": true,
      "launchUrl": "http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "web": {
      "commandName": "web",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}
10
clark wu

Nach RC2

Wie kann man also einen anderen EnvironmentName einstellen?

Legen Sie die Umgebungsvariable ASPNETCORE_ENVIRONMENT fest.

Es gibt viele Möglichkeiten, diese Umgebungsvariable einzustellen. Dazu gehören ein launchSettings.json-Profil und andere umgebungsspezifische Möglichkeiten . Hier sind einige Beispiele.

Von einer Konsole:

// PowerShell
> $env:ASPNETCORE_ENVIRONMENT="Development"

// Windows Command Line
> SET ASPNETCORE_ENVIRONMENT=Development

// Bash
> ASPNETCORE_ENVIRONMENT=Development

In den App-Einstellungen einer Azure-Webanwendung:

 Set Environment Name in Azure

Vor dem RC2

Ich kann mir vorstellen, dass es in "Befehle" als Parameter für den Server gesetzt werden sollte.

Das ist wahr. Fügen Sie in Ihrem project.json --ASPNET_ENV production als Parameter für den Server hinzu.

"commands": {
  "web": "Microsoft.AspNet.Hosting --ASPNET_ENV production --server Microsoft.AspNet.Server.WebListener --server.urls http://localhost:5001"
}

Wenn Sie nun dnx . web von der Befehlszeile aus ausführen, wird ASPNET_ENVproduction sein.

Relevanter ASP.NET Core-Hosting-Quellcode

Die WebHostBuilder kombiniert "ASPNETCORE_" mit dem WebHostDefaults.EnvironmentKey zu "ASPNETCORE_environment". Es unterstützt auch die alten Schlüssel.

WebHostDefaults.cs

namespace Microsoft.AspNetCore.Hosting
{
    public static class WebHostDefaults
    {
        public static readonly string ApplicationKey = "applicationName";
        public static readonly string StartupAssemblyKey = "startupAssembly";

        public static readonly string DetailedErrorsKey = "detailedErrors";
        public static readonly string EnvironmentKey = "environment";
        public static readonly string WebRootKey = "webroot";
        public static readonly string CaptureStartupErrorsKey = "captureStartupErrors";
        public static readonly string ServerUrlsKey = "urls";
        public static readonly string ContentRootKey = "contentRoot";
    }
}

WebHostBuilder.cs

_config = new ConfigurationBuilder()
    .AddEnvironmentVariables(prefix: "ASPNETCORE_")
    .Build();

if (string.IsNullOrEmpty(GetSetting(WebHostDefaults.EnvironmentKey)))
{
    // Try adding legacy environment keys, never remove these.
    UseSetting(WebHostDefaults.EnvironmentKey, 
        Environment.GetEnvironmentVariable("Hosting:Environment") 
        ?? Environment.GetEnvironmentVariable("ASPNET_ENV"));
}

Rückwärtskompatibilität

Der Umgebungsschlüssel wird mit der Umgebungsvariable ASPNETCORE_ENVIRONMENT festgelegt. ASPNET_ENV und Hosting:Environment werden weiterhin unterstützt, erzeugen jedoch eine veraltete Meldungswarnung.

https://docs.asp.net/de/latest/migration/rc1-to-rtm.html

Standardwert

Der Standardwert ist "Produktion" und wird hier festgelegt.

64
Shaun Luttin

Sie legen die Umgebung fest, indem Sie eine Umgebungsvariable mit dem Namen ASPNET_ENV..__ definieren. Wenn Sie beispielsweise SET ASPNET_ENV=Release freigeben möchten.

Es kann auch funktionieren, wenn Sie ASPNET_ENV=Release als Parameter an die Befehle übergeben, aber ich kann es jetzt nicht überprüfen.

So wird es implementiert: https://github.com/aspnet/Hosting/blob/217f9ca3d3ccf59ea06e6555820974ba9c3b5932/src/Microsoft.AspNet.Hosting/ConfigureEnvironment.cs

15

Ich hatte das gleiche problem Um unabhängig von Umgebungsvariablen und web.config zu sein, habe ich eine .json-Datei wie folgt erstellt (ich habe sie env settings.json genannt):

{
  // Possible string values reported below.
  // - Production
  // - Staging
  // - Development
  "ASPNETCORE_ENVIRONMENT": "Staging"
}

Dann habe ich in Program.cs hinzugefügt:

public class Program
{
    public static void Main(string[] args)
    {
        var currentDirectoryPath = Directory.GetCurrentDirectory();
        var envSettingsPath = Path.Combine(currentDirectoryPath, "envsettings.json");
        var envSettings = JObject.Parse(File.ReadAllText(envSettingsPath));
        var enviromentValue = envSettings["ASPNETCORE_ENVIRONMENT"].ToString();

        var webHostBuilder = new WebHostBuilder()
            .UseKestrel()
            .CaptureStartupErrors(true)
            .UseSetting("detailedErrors", "true")
            .UseContentRoot(currentDirectoryPath)
            .UseIISIntegration()
            .UseStartup<Startup>();

        // If none is set it use Operative System hosting enviroment
        if (!string.IsNullOrWhiteSpace(enviromentValue)) 
        {
            webHostBuilder.UseEnvironment(enviromentValue);
        }

        var Host = webHostBuilder.Build();

        Host.Run();
    }
}

Wenn Sie VS-Funktionen bevorzugen (z. B. VS 2017), können Sie auf der Registerkarte Debug der Projekteigenschaften Umgebungsvariablen hinzufügen. In den neuesten ASP.NET Core-Versionen (nach RC2) sollten Sie beispielsweise die Variable ASPNETCORE_ENVIRONMENT festlegen.

 enter image description here

Als Ergebnis wird die launchSettings.json-Datei im Ordner Properties des entsprechenden Projekts erstellt (oder aktualisiert). Daher ist es einfach, diese Datei in Ihrer Quellcodeverwaltungslösung zu speichern und von Entwicklern gemeinsam zu nutzen (im Gegensatz zu anderen Lösungen) mit SETSETX befehlen) 

Hinweis: Standardmäßig hat der neueste ASP.NET Core die Umgebung auf Production festgelegt. Zu VS-Zwecken müssen Sie also in VS nur ASPNETCORE_ENVIRONMENT auf Development setzen (siehe Abbildung oben). Wenn Sie Ihren Code lokal mit der Staging-Umgebung ausführen möchten, sollten Sie ASPNETCORE_ENVIRONMENT auf Staging setzen. Wenn Sie ihn in einer Produktionsumgebung ausführen möchten, entfernen Sie diese Variable oder setzen Sie den Wert auf Production.

Um es zusammenzufassen: Stellen Sie einfach sicher, dass im Debug-Dialogfeld die Werte _/Development, Staging oder Production verwendet werden (nicht 'Dev' oder irgendetwas anderes), um die Umgebung einzustellen und verschiedene Erweiterungen zum Laufen zu bringen.

Siehe auch relevanten Quellcode aus ASP.NET Core:

namespace Microsoft.AspNetCore.Hosting
{
  /// <summary>Commonly used environment names.</summary>
  public static class EnvironmentName
  {
    public static readonly string Development = "Development";
    public static readonly string Staging = "Staging";
    public static readonly string Production = "Production";
  }
}

namespace Microsoft.AspNetCore.Hosting
{
  /// <summary>
  /// Extension methods for <see cref="T:Microsoft.AspNetCore.Hosting.IHostingEnvironment" />.
  /// </summary>
  public static class HostingEnvironmentExtensions
  {
    /// <summary>
    /// Checks if the current hosting environment name is "Development".
    /// </summary>
    /// <param name="hostingEnvironment">An instance of <see cref="T:Microsoft.AspNetCore.Hosting.IHostingEnvironment" />.</param>
    /// <returns>True if the environment name is "Development", otherwise false.</returns>
    public static bool IsDevelopment(this IHostingEnvironment hostingEnvironment)
    {
      if (hostingEnvironment == null)
        throw new ArgumentNullException("hostingEnvironment");
      return hostingEnvironment.IsEnvironment(EnvironmentName.Development);
    }

    /// <summary>
    /// Checks if the current hosting environment name is "Staging".
    /// </summary>
    /// <param name="hostingEnvironment">An instance of <see cref="T:Microsoft.AspNetCore.Hosting.IHostingEnvironment" />.</param>
    /// <returns>True if the environment name is "Staging", otherwise false.</returns>
    public static bool IsStaging(this IHostingEnvironment hostingEnvironment)
    {
      if (hostingEnvironment == null)
        throw new ArgumentNullException("hostingEnvironment");
      return hostingEnvironment.IsEnvironment(EnvironmentName.Staging);
    }

    /// <summary>
    /// Checks if the current hosting environment name is "Production".
    /// </summary>
    /// <param name="hostingEnvironment">An instance of <see cref="T:Microsoft.AspNetCore.Hosting.IHostingEnvironment" />.</param>
    /// <returns>True if the environment name is "Production", otherwise false.</returns>
    public static bool IsProduction(this IHostingEnvironment hostingEnvironment)
    {
      if (hostingEnvironment == null)
        throw new ArgumentNullException("hostingEnvironment");
      return hostingEnvironment.IsEnvironment(EnvironmentName.Production);
    }

    /// <summary>
    /// Compares the current hosting environment name against the specified value.
    /// </summary>
    /// <param name="hostingEnvironment">An instance of <see cref="T:Microsoft.AspNetCore.Hosting.IHostingEnvironment" />.</param>
    /// <param name="environmentName">Environment name to validate against.</param>
    /// <returns>True if the specified name is the same as the current environment, otherwise false.</returns>
    public static bool IsEnvironment(this IHostingEnvironment hostingEnvironment, string environmentName)
    {
      if (hostingEnvironment == null)
        throw new ArgumentNullException("hostingEnvironment");
      return string.Equals(hostingEnvironment.EnvironmentName, environmentName, StringComparison.OrdinalIgnoreCase);
    }
  }
}
4
Evereq

In ASP.NET Core RC2 wurde der Variablenname in ASPNETCORE_ENVIRONMENT geändert.

z.B. In Windows können Sie diesen Befehl auf dem Staging-Server ausführen (mit Administratorrechten).

SETX ASPNETCORE_ENVIRONMENT "Staging" /M

Dies muss nur einmal ausgeführt werden. Danach wird der Server immer als Staging-Server betrachtet.

Wenn Sie in der Eingabeaufforderung auf diesem Server einen dotnet run ausführen, wird Hosting environment: Staging angezeigt.

3
Rubanov

Wenn Sie denken, von wo aus dieser Wert genommen wird, dann ist es statisch und der Standardwert ist Entwicklung.

https://github.com/aspnet/Hosting/blob/dev/src/Microsoft.AspNet.Hosting/HostingEnvironment.cs

Wenn Sie sich den Variablentyp IHostingEnviroment ansehen, handelt es sich um Microsoft.AspNet.Hosting.HostingEnvrioment.

Es gibt zwei Möglichkeiten, die Sie jetzt je nach dynamischer Konfiguration ändern können.

  1. Sie können die Schnittstelle IHostingEnvironment implementieren und dafür einen eigenen Typ verwenden. Sie können den Wert aus der Config-Datei lesen.

  2. Sie können die Schnittstelle verwenden. Sie können diese Variable direkt hier aktualisieren.

    public Startup(IHostingEnvironment env)
    {
    // Setup configuration sources.
    Configuration = new Configuration()
        .AddJsonFile("config.json").AddEnvironmentVariables();
    
    Configuration.Set("ASPNET_ENV","Your own value");    
    }
    

    Wenn Sie sich Dienste in ConfigureServices ansehen, gibt es standardmäßig eine Liste von Diensten, die standardmäßig konfiguriert wird, und eine davon ist IConfigureHostingEnviroment. Die Standardimplementierung ist eine interne Klasse, sodass Sie nicht direkt darauf zugreifen können. Sie können jedoch den Schlüssel ASPNET_ENV festlegen und diesen Wert lesen.

https://github.com/aspnet/Hosting/blob/dev/src/Microsoft.AspNet.Hosting/ConfigureHostingEnvironment.cs

3
dotnetstep
  1. Setzen Sie in Azure auf der Konfigurationsseite der Web-App die Variable ASPNET_ENV environment.

  2. Ändern Sie web.config mit Ihrem eigenen IIS oder anderen Hosting-Providern, um Argumente für den Befehl "web" aufzunehmen:

    <configuration>
     <system.webServer>
      <handlers>
        <add name="httpplatformhandler" path="*" verb="*" modules="httpPlatformHandler" resourceType="Unspecified" />
      </handlers>
      <httpPlatform processPath="..\approot\web.cmd" arguments="--ASPNET_ENV Development" stdoutLogEnabled="false" stdoutLogFile="..\logs\stdout.log" startupTimeLimit="3600"></httpPlatform>
     </system.webServer>
    </configuration>
    
  3. Während der Entwicklung (wenn Sie den Quellcode ändern können) können Sie auch die Datei Microsoft.AspNet.Hosting.json in einem Stamm Ihres Projekts erstellen und die Variable ASPNET_ENV festlegen.

    { "ASPNET_ENV": "Test" }

3

wenn Sie dies einstellen müssen, ohne den Code zu ändern, geben Sie über die Eingabeaufforderung im Stammverzeichnis des Projektquellenordners Folgendes ein: 

set ASPNET_ENV=Debug
2
Andrew Smith

In VsCode füge Folgendes zu launch.json hinzu

{
    "version": "0.2.0",
    "configurations": [
        {
            ...
            "env": {
                "ASPNETCORE_ENVIRONMENT": "Development"
            }
        },
        ...
    ]
}
0
Tim Abell

Hier ist eine weitere Möglichkeit, die Variable und switch ASPNETCORE_ENVIRONMENT in VS2017 festzulegen (zusätzliche Anmerkung zur @ clark-wu-Antwort):

 enter image description here

Hinweis: launchSettings.json hat in meinem Fall zwei Profile: "IISExpress" und "Project", in denen ASPNETCORE_ENVIRONMENT definiert ist.

{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:10000/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "launchUrl": "api/entities",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development" // <-- related to IIS Express profile
      }
    },
    "Project": {
      "commandName": "Project",
      "launchBrowser": true,
      "launchUrl": "api/entities",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Production" // <-- related to Project profile
      },
      "applicationUrl": "http://localhost:10000/"
    }
  }
}

Offizielle Dokumentation : Sie können ASPNETCORE_ENVIRONMENT auf einen beliebigen Wert festlegen. Das Framework unterstützt jedoch drei Werte: Entwicklung, Staging und Produktion. Wenn ASPNETCORE_ENVIRONMENT nicht festgelegt ist, wird standardmäßig Production verwendet.

0
Anton Lyhin