ASP.NET Core support a new configuration system as seen here: https://docs.asp.net/en/latest/fundamentals/configuration.html
Is this model also supported in .NET Core console applications?
If not what is alternate to the previous app.config
and ConfigurationManager
model?
This question is related to
c#
.net-core
configuration
console-application
On .Net Core 3.1 we just need to do these:
static void Main(string[] args)
{
var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
}
Using SeriLog will look like:
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();
}
}
}
}
And the Serilog appsetings.json section for generating one file daily will look like:
"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"
}
}
]
}
I was mistaken. You can use the new ConfigurationBuilder
from a netcore console application.
See https://docs.asp.net/en/latest/fundamentals/configuration.html for an example.
However, only aspnet core has dependency injection out of the box so you don't have the ability to have strongly typed configuration settings and automatically inject them using IOptions
.
If you use Microsoft.Extensions.Hosting
(version 2.1.0+) to host your console app and asp.net core app, all your configurations are injected with HostBuilder
's ConfigureAppConfiguration
and ConfigureHostConfiguration
methods. Here's the demo about how to add the appsettings.json
and environment variables:
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
//;
In order to compile above code, you need to add these packages:
<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" />
You can use LiteWare.Configuration library for that. It is very similar to .NET Framework original ConfigurationManager
and works for .NET Core/Standard. Code-wise, you'll end up with something like:
string cacheDirectory = ConfigurationManager.AppSettings.GetValue<string>("CacheDirectory");
ulong cacheFileSize = ConfigurationManager.AppSettings.GetValue<ulong>("CacheFileSize");
Disclaimer: I am the author of LiteWare.Configuration.
If you use .netcore 3.1 the simplest way use new configuration system to call CreateDefaultBuilder
method of static class Host
and configure application
public class Program
{
public static void Main(string[] args)
{
Host.CreateDefaultBuilder(args)
.ConfigureAppConfiguration((context, config) =>
{
IHostEnvironment env = context.HostingEnvironment;
config.AddEnvironmentVariables()
// copy configuration files to output directory
.AddJsonFile("appsettings.json")
// default prefix for environment variables is DOTNET_
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddCommandLine(args);
})
.ConfigureServices(services =>
{
services.AddSingleton<IHostedService, MySimpleService>();
})
.Build()
.Run();
}
}
class MySimpleService : IHostedService
{
public Task StartAsync(CancellationToken cancellationToken)
{
Console.WriteLine("StartAsync");
return Task.CompletedTask;
}
public Task StopAsync(CancellationToken cancellationToken)
{
Console.WriteLine("StopAsync");
return Task.CompletedTask;
}
}
You need set Copy to Output Directory = 'Copy if newer' for the files appsettings.json
and appsettings.{environment}.json
Also you can set environment variable {prefix}ENVIRONMENT (default prefix is DOTNET) to allow choose specific configuration parameters.
.csproj file:
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>netcoreapp3.1</TargetFramework>
<RootNamespace>ConsoleApplication3</RootNamespace>
<AssemblyName>ConsoleApplication3</AssemblyName>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.Configuration" Version="3.1.7" />
<PackageReference Include="Microsoft.Extensions.Hosting" Version="3.1.7" />
</ItemGroup>
<ItemGroup>
<None Update="appsettings.Development.json">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
<None Update="appsettings.json">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
</ItemGroup>
more details .NET Generic Host
Just piling on... similar to Feiyu Zhou's post. Here I'm adding the machine name.
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>();
}
It's something like this, for a dotnet 2.x core console application:
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();
The you could inject ILoggerFactory, IConfiguration in the SomeService
.
Install these packages:
Code:
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 Class:
public class MySettingsConfig
{
public string Url { get; set; }
public string Name { get; set; }
}
For a .NET Core 2.0 console app, I did the following:
{ "myKey1" : "my test value 1", "myKey2" : "my test value 2", "foo" : "bar" }
Configure to copy the file to the output directory whenever the project is built (in VS -> Solution Explorer -> right-click file -> select 'Properties' -> Advanced -> Copy to Output Directory -> select 'Copy Always')
Install the following nuget package in my project:
Add the following to Program.cs (or wherever Main()
is located):
static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var configuration = builder.Build();
// rest of code...
}
Then read the values using either of the following ways:
string myKey1 = configuration["myKey1"];
Console.WriteLine(myKey1);
string foo = configuration.GetSection("foo").Value;
Console.WriteLine(foo);
Source: Stackoverflow.com