.NET Core konsol uygulaması için ASP.NET Core yapılandırması

ASP.NET Core, burada görüldüğü gibi yeni bir yapılandırma sistemini destekler: https://docs.asp.net/en/latest/fundamentals/configuration.html

Bu model, .NET Core konsol uygulamalarında da destekleniyor mu?

Değilse, önceki app.configve ConfigurationManagermodele alternatif olan nedir?

Bu kod parçacığını kullanabilirsiniz. Yapılandırma ve DI içerir.

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

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

Oh, ve project.json eklemeyi unutmayın

{
  "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"
    ]
  },
...
}

Bir .NET Core 2.0 konsol uygulaması için aşağıdakileri yaptım:

1. Projenin kökünde appsettings.json adında yeni bir dosya oluşturun (dosya adı herhangi bir şey olabilir)
2. Özel ayarlarımı o dosyaya json olarak ekleyin. Örneğin:

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

3. Proje her oluşturulduğunda dosyayı çıktı dizinine kopyalamak için yapılandırın (VS -> Solution Explorer -> dosyaya sağ tıklayın -> 'Özellikler' -> Gelişmiş -> Çıktı Dizinine Kopyala -> 'Her Zaman Kopyala'yı seçin)

4. Aşağıdaki nuget paketini projeme kurun:

   • Microsoft.Extensions.Configuration.Json

5. Aşağıdakileri Program.cs'ye (veya Main()bulunduğu yere ) ekleyin :

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

6. Ardından aşağıdaki yöntemlerden birini kullanarak değerleri okuyun:

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

Daha fazla bilgi: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration?tabs=basicconfiguration#simple-configuration

Eğer kullanırsanız Microsoft.Extensions.Hostingsizin konsol uygulaması ve asp.net çekirdek uygulamasını barındırmak için (versiyon 2.1.0+), tüm yapılandırmalar ile enjekte edilir HostBuilders' ConfigureAppConfigurationve ConfigureHostConfigurationyöntemlerle. İşte appsettings.jsonve ortam değişkenlerinin nasıl ekleneceğiyle ilgili demo :

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

Yukarıdaki kodu derlemek için şu paketleri eklemeniz gerekir:

<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" />

Yanılmışım. Yeni kullanabilirsiniz ConfigurationBuilderbir netcore konsol uygulamasından.

Örnek için https://docs.asp.net/en/latest/fundamentals/configuration.html adresine bakın .

Bununla birlikte, yalnızca aspnet çekirdeği kutudan bağımlılık enjeksiyonuna sahiptir, bu nedenle güçlü bir şekilde yazılmış yapılandırma ayarlarına sahip olamazsınız ve bunları kullanarak otomatik olarak enjekte edemezsiniz IOptions.

Bir dotnet 2.x çekirdek konsol uygulaması için böyle bir şey:

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

ILoggerFactory, IConfiguration'ı SomeService.

.Net Core 3.1'de sadece şunları yapmamız gerekiyor:

static void Main(string[] args)
{
  var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
}

SeriLog'u kullanmak şöyle görünecektir:

using Microsoft.Extensions.Configuration;
using Serilog;
using System;


namespace yournamespace
{
    class Program
    {

        static void Main(string[] args)
        {
            var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
            Log.Logger = new LoggerConfiguration().ReadFrom.Configuration(configuration).CreateLogger();

            try
            {
                Log.Information("Starting Program.");
            }
            catch (Exception ex)
            {
                Log.Fatal(ex, "Program terminated unexpectedly.");
                return;
            }
            finally
            {
                Log.CloseAndFlush();
            }
        }
    }
}

Günlük olarak bir dosya oluşturmak için Serilog appsetings.json bölümü şöyle görünecektir:

  "Serilog": {
    "MinimumLevel": {
      "Default": "Information",
      "Override": {
        "Microsoft": "Warning",
        "System": "Warning"
      }
    },
    "Using": [ "Serilog.Sinks.Console", "Serilog.Sinks.File" ],
    "WriteTo": [
      {
        "Name": "File",
        "Args": {
          "path": "C:\\Logs\\Program.json",
          "rollingInterval": "Day",
          "formatter": "Serilog.Formatting.Compact.CompactJsonFormatter, Serilog.Formatting.Compact"
        }
      }
    ]
  }

Bunun için LiteWare.Configuration kitaplığını kullanabilirsiniz . Orijinal .NET Framework'e çok benzer ConfigurationManagerve .NET Core / Standard için çalışır. Kod açısından şöyle bir sonuç elde edeceksiniz:

string cacheDirectory = ConfigurationManager.AppSettings.GetValue<string>("CacheDirectory");
ulong cacheFileSize = ConfigurationManager.AppSettings.GetValue<ulong>("CacheFileSize");

Feragatname: LiteWare.Configuration'ın yazarıyım.

Feiyu Zhou'nun gönderisine benzer ... Burada makine adını ekliyorum.

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
          .ConfigureAppConfiguration((context, builder) =>
          {
            var env = context.HostingEnvironment;
            var hostname = Environment.MachineName;
            builder.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
              .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true)
              .AddJsonFile($"appsettings.{hostname}.json", optional: true, reloadOnChange: true);
            builder.AddEnvironmentVariables();
            if (args != null)
            {
              builder.AddCommandLine(args);
            }
          })
        .UseStartup<Startup>();
  }

Bu paketleri kurun:

• Microsoft.Extensions.Configuration
• Microsoft.Extensions.Configuration.Binder
• Microsoft.Extensions.Configuration.EnvironmentVariables
• Microsoft.Extensions.Configuration.FileExtensions
• Microsoft.Extensions.Configuration.Json

Kod:

static void Main(string[] args)
    {
        var environmentName = Environment.GetEnvironmentVariable("ENVIRONMENT");
        Console.WriteLine("ENVIRONMENT: " + environmentName);

        var builder = new ConfigurationBuilder()
           .SetBasePath(Directory.GetCurrentDirectory())
           .AddJsonFile("appsettings.json", false)
           .AddJsonFile($"appsettings.{environmentName}.json", true)
           .AddEnvironmentVariables();

        IConfigurationRoot configuration = builder.Build();
        var mySettingsConfig = configuration.Get<MySettingsConfig>();

        Console.WriteLine("URL: " + mySettingsConfig.Url);
        Console.WriteLine("NAME: " + mySettingsConfig.Name);

        Console.ReadKey();
    }

MySettingsConfig Sınıfı:

public class MySettingsConfig
{
    public string Url { get; set; }
    public string Name { get; set; }
}

Uygulama ayarlarınız şu kadar basit olabilir:

Ayrıca, daha yeniyse uygulama ayarları dosyalarını İçerik / Kopyala olarak ayarlayın: