web-dev-qa-db-fra.com

Comment obtenir l'environnement d'hébergement de développement/intermédiaire/production dans ConfigureServices

Comment obtenir l'environnement d'hébergement de développement/intermédiaire/production dans la méthode ConfigureServices dans Démarrage

public void ConfigureServices(IServiceCollection services)
{
    // Which environment are we running under?
}

La méthode ConfigureServices ne prend qu'un seul paramètre IServiceCollection.

asp.net-coreasp.net-core-mvc
86
Muhammad Rehan Saeed

vous pouvez facilement y accéder dans ConfigureServices, il suffit de la conserver dans une propriété au cours de la méthode de démarrage qui est appelée en premier et qui la transmet, puis vous pouvez accéder à la propriété à partir de ConfigureServices

public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
    ...your code here...
    CurrentEnvironment = env;
}

private IHostingEnvironment CurrentEnvironment{ get; set; } 

public void ConfigureServices(IServiceCollection services)
{
    string envName = CurrentEnvironment.EnvironmentName;
    ... your code here...
}
115
Joe Audette

TL; DR

Définissez une variable d’environnement appelée ASPNETCORE_ENVIRONMENT avec le nom de l’environnement (par exemple, Production). Ensuite, faites l'une des deux choses suivantes:

  • Injectez IHostingEnvironment dans Startup.cs, puis utilisez-le (env ici) pour vérifier: env.IsEnvironment("Production"). Ne pas vérifier en utilisant env.EnvironmentName == "Production"!
  • Utilisez des classes Startup distinctes ou des fonctions ConfigureConfigureServices individuelles. Si une classe ou les fonctions correspondent à ces formats, ils seront utilisés à la place des options standard de cet environnement .
    • Startup{EnvironmentName}()(toute la classe) || exemple: StartupProduction()
    • Configure{EnvironmentName}() || exemple: ConfigureProduction()
    • Configure{EnvironmentName}Services() || exemple: ConfigureProductionServices()

Explication complète

La documentation .NET Core décrit comment procéder . Utilisez une variable d’environnement appelée ASPNETCORE_ENVIRONMENT définie sur l’environnement souhaité, vous avez alors le choix.

Vérifier le nom de l'environnement

À partir de la documentation :

Le service IHostingEnvironment fournit l'abstraction principale pour travailler avec des environnements. Ce service est fourni par la couche d'hébergement ASP.NET et peut être injecté dans votre logique de démarrage via Dependency Injection. Le modèle de site Web ASP.NET Core de Visual Studio utilise cette approche pour charger les fichiers de configuration spécifiques à l’environnement (le cas échéant) et pour personnaliser les paramètres de traitement des erreurs de l’application. Dans les deux cas, ce comportement est obtenu en faisant référence à l'environnement actuellement spécifié en appelant EnvironmentName ou IsEnvironment sur l'instance de IHostingEnvironment transmise à la méthode appropriée.

_/NOTE: Vérifier la valeur actuelle de env.EnvironmentName n'est pas recommandé!

Si vous devez vérifier si l'application est en cours d'exécution dans un environnement particulier, utilisez env.IsEnvironment("environmentname") car elle ignorera correctement la casse (au lieu de vérifier si env.EnvironmentName == "Development" par exemple).

Utilisez des classes séparées

À partir de la documentation :

Lorsqu'une application ASP.NET Core démarre, la classe Startup est utilisée pour amorcer l'application, charger ses paramètres de configuration, etc. ( en savoir plus sur le démarrage ASP.NET ). Toutefois, s'il existe une classe nommée Startup{EnvironmentName} (par exemple StartupDevelopment) et que la variable d'environnement ASPNETCORE_ENVIRONMENT correspond à ce nom, cette classe Startup est utilisée à la place. Ainsi, vous pouvez configurer Startup pour le développement, mais avoir une StartupProduction distincte qui serait utilisée lorsque l'application est exécutée en production. Ou vice versa.

Outre l'utilisation d'une classe Startup entièrement séparée en fonction de l'environnement actuel, vous pouvez également ajuster la configuration de l'application dans une classe Startup. Les méthodes Configure() et ConfigureServices() prennent en charge des versions spécifiques à l'environnement similaires à la classe Startup elle-même, de la forme Configure{EnvironmentName}() et Configure{EnvironmentName}Services(). Si vous définissez une méthode ConfigureDevelopment(), elle sera appelée à la place de Configure() lorsque l'environnement est défini sur développement. De même, ConfigureDevelopmentServices() serait appelé à la place de ConfigureServices() dans le même environnement.

36
vaindil

Dans .NET Core 2.0 MVC app/Microsoft.AspNetCore.All v2.0.0, vous pouvez avoir une classe de démarrage spécifique à l'environnement, telle que décrite par @vaindil mais je n'aime pas cette approche.

Vous pouvez également injecter IHostingEnvironment dans le constructeur StartUp. Vous n'avez pas besoin de stocker la variable d'environnement dans la classe Program.

public class Startup
{
    private readonly IHostingEnvironment _currentEnvironment;
    public IConfiguration Configuration { get; private set; }

    public Startup(IConfiguration configuration, IHostingEnvironment env)
    {
        _currentEnvironment = env;
        Configuration = configuration;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        ......

        services.AddMvc(config =>
        {
            // Requiring authenticated users on the site globally
            var policy = new AuthorizationPolicyBuilder()
                .RequireAuthenticatedUser()
                .Build();
            config.Filters.Add(new AuthorizeFilter(policy));

            // Validate anti-forgery token globally
            config.Filters.Add(new AutoValidateAntiforgeryTokenAttribute());

            // If it's Production, enable HTTPS
            if (_currentEnvironment.IsProduction())      // <------
            {
                config.Filters.Add(new RequireHttpsAttribute());
            }            
        });

        ......
    }
}
14
David Liang

Ceci peut être accompli sans propriétés supplémentaires ni paramètres de méthode, comme ceci:

public void ConfigureServices(IServiceCollection services)
{
    IServiceProvider serviceProvider = services.BuildServiceProvider();
    IHostingEnvironment env = serviceProvider.GetService<IHostingEnvironment>();

    if (env.IsProduction()) DoSomethingDifferentHere();
}
7
edicius6

L'environnement d'hébergement provient de la variable d'environnement ASPNET_ENV, disponible au démarrage à l'aide de la méthode d'extension IHostingEnvironment.IsEnvironment, ou de l'une des méthodes pratiques correspondantes d'IsDevelopment ou d'IsProduction. Enregistrez ce dont vous avez besoin dans Startup () ou dans l’appel ConfigureServices:

var foo = Environment.GetEnvironmentVariable("ASPNET_ENV");
4
Jeff Dunlop

par les docs

Configure et ConfigureServices prennent en charge les versions spécifiques à l’environnement de la forme Configure {EnvironmentName} et Configure {EnvironmentName} Services:

Vous pouvez faire quelque chose comme ça ...

public void ConfigureProductionServices(IServiceCollection services)
{
    ConfigureCommonServices(services);

    //Services only for production
    services.Configure();
}

public void ConfigureDevelopmentServices(IServiceCollection services)
{
    ConfigureCommonServices(services);

    //Services only for development
    services.Configure();
}

public void ConfigureStagingServices(IServiceCollection services)
{
    ConfigureCommonServices(services);

    //Services only for staging
    services.Configure();
}

private void ConfigureCommonServices(IServiceCollection services)
{
    //Services common to each environment
}
2
Shoe

Dans Dotnet Core 2.0, le constructeur de démarrage n'attend qu'un paramètre IConfiguration.

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

Comment lire l’environnement d’hébergement là-bas?

public class Program
{
    public static IHostingEnvironment HostingEnvironment { get; set; }

    public static void Main(string[] args)
    {
        // Build web Host
        var Host = BuildWebHost(args);

        Host.Run();
    }

    public static IWebHost BuildWebHost(string[] args)
    {
        return new WebHostBuilder()
            .UseConfiguration(new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("hosting.json", optional: true)
                .Build()
            )
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .ConfigureAppConfiguration((hostingContext, config) =>
            {
                var env = hostingContext.HostingEnvironment;

                // Assigning the environment for use in ConfigureServices
                HostingEnvironment = env; // <---

                config
                  .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                  .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);

                if (env.IsDevelopment())
                {
                    var appAssembly = Assembly.Load(new AssemblyName(env.ApplicationName));
                    if (appAssembly != null)
                    {
                        config.AddUserSecrets(appAssembly, optional: true);
                    }
                }

                config.AddEnvironmentVariables();

                if (args != null)
                {
                    config.AddCommandLine(args);
                }
            })
            .ConfigureLogging((hostingContext, builder) =>
            {
                builder.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
                builder.AddConsole();
                builder.AddDebug();
            })
            .UseIISIntegration()
            .UseDefaultServiceProvider((context, options) =>
            {
                options.ValidateScopes = context.HostingEnvironment.IsDevelopment();
            })
            .UseStartup<Startup>()
            .Build();
    }

Ant le lit ensuite dans ConfigureServices comme ceci:

public IServiceProvider ConfigureServices(IServiceCollection services)
{
    var isDevelopment = Program.HostingEnvironment.IsDevelopment();
}
1
toralux

Je voulais intégrer l'environnement dans l'un de mes services. C'est vraiment facile à faire! Je viens de l'injecter au constructeur comme ceci:

    private readonly IHostingEnvironment _hostingEnvironment;

    public MyEmailService(IHostingEnvironment hostingEnvironment)
    {
        _hostingEnvironment = hostingEnvironment;
    }

Maintenant, plus tard dans le code, je peux faire ceci:

if (_hostingEnvironment.IsProduction()) {
    // really send the email.
}
else {
    // send the email to the test queue.
}
1
Jess

Si vous avez besoin de tester ceci quelque part dans votre base de code qui n'a pas d'accès facile à IHostingEnvironment, un autre moyen simple de le faire est le suivant:

bool isDevelopment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development";
1
Patrick