c# - netcore - Configuración de ASP.NET Core para la aplicación de consola.NET Core

run asp net core from command line

Question

ASP.NET Core admite un nuevo sistema de configuración como se ve aquí: https://docs.asp.net/en/latest/fundamentals/configuration.html

¿Este modelo también es compatible con las aplicaciones de consola .NET Core?

Si no, ¿qué es alternativo al modelo anterior app.config y ConfigurationManager ?

Answer 1

Es algo como esto, para una aplicación de consola central dotnet 2.x:

        using Microsoft.Extensions.Configuration;
        using Microsoft.Extensions.DependencyInjection;
        using Microsoft.Extensions.Logging;

        [...]
        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .AddEnvironmentVariables()
            .Build();
        var serviceProvider = new ServiceCollection()
            .AddLogging(options => options.AddConfiguration(configuration).AddConsole())
            .AddSingleton<IConfiguration>(configuration)
            .AddSingleton<SomeService>()
            .BuildServiceProvider();
        [...]
        await serviceProvider.GetService<SomeService>().Start();

El podría inyectar ILoggerFactory, IConfiguration en SomeService .

Answer 2

Estaba equivocado. Puede usar el nuevo ConfigurationBuilder desde una aplicación de consola netcore.

Consulte https://docs.asp.net/en/latest/fundamentals/configuration.html para ver un ejemplo.

Sin embargo, solo el núcleo aspnet tiene una inyección de dependencia lista para usar, por lo que no tiene la capacidad de tener configuraciones de configuración fuertemente tipadas e inyectarlas automáticamente usando IOptions .

Answer 3

Para una aplicación de consola .NET Core 2.0, hice lo siguiente:

1. Cree un nuevo archivo llamado appsettings.json en la raíz del proyecto (el nombre del archivo puede ser cualquier cosa)
2. Agregue mi configuración específica a ese archivo como json. Por ejemplo:

{
  "myKey1" :  "my test value 1", 
  "myKey2" :  "my test value 2", 
  "foo" :  "bar" 
}

3. Configure para copiar el archivo al directorio de salida cada vez que se construya el proyecto (en VS -> Explorador de soluciones -> haga clic con el botón derecho en el archivo -> seleccione ''Propiedades'' -> Avanzado -> Copiar al directorio de salida -> seleccione ''Copiar siempre'')

4. Instale el siguiente paquete nuget en mi proyecto:

   • Microsoft.Extensions.Configuration.Json

5. Agregue lo siguiente a Program.cs (o donde se encuentre Main() ):

   static void Main(string[] args)
   {
       var builder = new ConfigurationBuilder()
           .SetBasePath(Directory.GetCurrentDirectory())
           .AddJsonFile("appsettings.json");
   
       var configuration = builder.Build();
   
       // rest of code...
   }

6. Luego lea los valores utilizando cualquiera de las siguientes formas:

   string myKey1 = configuration["myKey1"];
   Console.WriteLine(myKey1);
   
   string foo = configuration.GetSection("foo").Value;
   Console.WriteLine(foo);

Más información: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration?tabs=basicconfiguration#simple-configuration

Answer 4

Puede usar este fragmento de código. Incluye Configuración y DI.

public class Program
{
    public static ILoggerFactory LoggerFactory;
    public static IConfigurationRoot Configuration;

    public static void Main(string[] args)
    {
        Console.OutputEncoding = Encoding.UTF8;

        string environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");

        if (String.IsNullOrWhiteSpace(environment))
            throw new ArgumentNullException("Environment not found in ASPNETCORE_ENVIRONMENT");

        Console.WriteLine("Environment: {0}", environment);

        var services = new ServiceCollection();

        // Set up configuration sources.
        var builder = new ConfigurationBuilder()
            .SetBasePath(Path.Combine(AppContext.BaseDirectory))
            .AddJsonFile("appsettings.json", optional: true);
        if (environment == "Development")
        {

            builder
                .AddJsonFile(
                    Path.Combine(AppContext.BaseDirectory, string.Format("..{0}..{0}..{0}", Path.DirectorySeparatorChar), $"appsettings.{environment}.json"),
                    optional: true
                );
        }
        else
        {
            builder
                .AddJsonFile($"appsettings.{environment}.json", optional: false);
        }

        Configuration = builder.Build();

        LoggerFactory = new LoggerFactory()
            .AddConsole(Configuration.GetSection("Logging"))
            .AddDebug();

        services
            .AddEntityFrameworkNpgsql()
            .AddDbContext<FmDataContext>(o => o.UseNpgsql(connectionString), ServiceLifetime.Transient);

        services.AddTransient<IPackageFileService, PackageFileServiceImpl>();

        var serviceProvider = services.BuildServiceProvider();

        var packageFileService = serviceProvider.GetRequiredService<IPackageFileService>();

        ............
    }
}

Ah, y no olvides agregar el proyecto. Json

{
  "version": "1.0.0-*",
  "buildOptions": {
    "emitEntryPoint": true,
    "copyToOutput": {
      "includeFiles": [
        "appsettings.json",
        "appsettings.Integration.json",
        "appsettings.Production.json",
        "appsettings.Staging.json"
      ]
    }
  },

  "publishOptions": {
    "copyToOutput": [
      "appsettings.json",
      "appsettings.Integration.json",
      "appsettings.Production.json",
      "appsettings.Staging.json"
    ]
  },
...
}

Answer 5

Si usa Microsoft.Extensions.Hosting (versión 2.1.0+) para alojar su aplicación de consola y la aplicación asp.net core, todas sus configuraciones se inyectan con los HostBuilder ConfigureAppConfiguration y ConfigureHostConfiguration HostBuilder . Aquí está la demostración sobre cómo agregar appsettings.json y las variables de entorno:

    var hostBuilder = new HostBuilder()
        .ConfigureHostConfiguration(config =>
        {
            config.AddEnvironmentVariables();

            if (args != null)
            {
                // enviroment from command line
                // e.g.: dotnet run --environment "Staging"
                config.AddCommandLine(args);
            }
        })
        .ConfigureAppConfiguration((context, builder) =>
        {
            var env = context.HostingEnvironment;
            builder.SetBasePath(AppContext.BaseDirectory)
            .AddJsonFile("appsettings.json", optional: false)
            .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
            // Override config by env, using like Logging:Level or Logging__Level
            .AddEnvironmentVariables();

        })
        ... // add others, logging, services
        //;

Para compilar el código anterior, debe agregar estos paquetes:

<PackageReference Include="Microsoft.Extensions.Configuration" Version="2.1.0" />
<PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="2.1.0" />
<PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="2.1.0" />
<PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.1.0" />
<PackageReference Include="Microsoft.Extensions.Hosting" Version="2.1.0" />

Answer 6

var directoryInfo = Directory.GetParent(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.FullName).FullName;
            var builder = new ConfigurationBuilder()
                .SetBasePath(directoryInfo)
                .AddJsonFile("appsettings.json",  true, true)
                .Build();