104

i'm creating a console application using .NET Core 3.1 and i would like to have an appsettings json to load all environment, paths, variables,... at the beginning of the execution, and then get values from other library classes. I have created a 'Settings' class with the data included in the appsettings json. This is what i have already by looking out in tutorials but i'm not able to get any value.

//Start.cs
public class Startup
{
        public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                .SetBasePath(env.ContentRootPath)
                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                .AddEnvironmentVariables();

            Configuration = builder.Build();
        }

        public IConfiguration Configuration { get; }

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

//Settings.cs
 public class Settings
    {
        public ConnectionStrings ConnectionStrings { get; set; }
        public Logging Logging { get; set; }
        public AppSettings AppSettings { get; set; }
    ...

//A class to use it in other lib
 public class Extractor
    {
        private readonly IConfiguration _configuration;

        public Extractor(IConfiguration configuration) : this()
        {
            _configuration = configuration;
            Init();
        }

        public void Init()
        {
            // Extractor:Min is a variable included in appsettings.json
            Min = _configuration.GetValue<int>("Extractor:Min")
                                  
        }

I cannot make a proper Main as i don't know how to initialize everything...what am i missing? I think i've been going in circles for something that easy. Thanks in advance! NOTE: i need to get those variables from another library class, not in Main. I don't know how to initialize 'configuration' in other classes in order to use it. Thanks

Improve this question
1

7 Answers 7

Reset to default
115

Your example is mixing in some ASP NET Core approaches that expect your code to be hosted. To minimally solve the issue of getting options or settings from a JSON configuration, consider the following:

A config.json file, set to "Copy to Output Directory" so that it is included with the build:

{
  "MyFirstClass": {
    "Option1": "some string value",
    "Option2": 42
  },
  "MySecondClass": {
    "SettingOne": "some string value",
    "SettingTwo": 42
  }
}

The following approach will load the content from the JSON file, then bind the content to two strongly-typed options/settings classes, which can be a lot cleaner than going value-by-value:

using System;
using System.IO;
using Microsoft.Extensions.Configuration;

// NuGet packages:
// Microsoft.Extensions.Configuration.Binder
// Microsoft.Extensions.Configuration.Json

namespace SampleConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            var builder = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("config.json", optional: false);

            IConfiguration config = builder.Build();

            var myFirstClass = config.GetSection("MyFirstClass").Get<MyFirstClass>();
            var mySecondClass = config.GetSection("MySecondClass").Get<MySecondClass>();
            Console.WriteLine($"The answer is always {myFirstClass.Option2}");
        }
    }

    public class MyFirstClass
    {
        public string Option1 { get; set; }
        public int Option2 { get; set; }
    }

    public class MySecondClass
    {
        public string SettingOne { get; set; }
        public int SettingTwo { get; set; }
    }
}
Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

Thanks for the response! The problem is i need to get those variables in another library class, not in Main. I don't know how to initialize 'configuration' in other classes in order to use it. Thanks
@JaviL You can put those settings/options classes or the IConfiguration object itself into a static, global instance, or you can look into using Dependency Injection and an IoC container (either the ASP NET Core one or another of your choice) to properly inject these options into whatever other classes expect to consume them.
If you want to use AddEnvironmentVariables method you need to install this package
I might be dumb, but I don't understand why we have to add classes and modify code as part of reading a config file now. I miss the old app.config days.
@dpberry178 maybe you don't in simple cases, but the ability to layer composition of strongly typed (and validatable) options from multiple configuration sources and inject those into an IOC container with mechanisms for snapshots/change detection is pretty powerful.
|
70

To get started with Visual Studio 2022 and .net 6 follow the steps below. If you have the latest update of Visual Studio 2022(17.4.0 or above), you can create apps with .net 7+ as well in the same lines.

If you want to just use Visual Studio Code and not Visual Studio 2022, scroll down to see the instructions.

  1. Create a new console project.
  2. Add an appsettings.json file to the project.
  3. Right click, select properties and ensure its copied to output directory.

appsettings file properties

  1. Edit the file to look something like this.

     {
   "ConnectionString": "Server=localhost;Database=tempDB;Uid=<dbUserName>;Pwd=<dbPassword>",
   "Smtp": {
     "Host": "smtp.gmail.com",
     "From": "Your Name"
   },
   "MySecondClass": {
     "SettingOne": "some string value",
     "SettingTwo": 82
   }
 }

  2. Edit your project csproj file to include Microsoft.Extensions.Configuration and its json counter part package. See below, note the appsettings.json file as well.

    <Project Sdk="Microsoft.NET.Sdk">

      <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>net6.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
      </PropertyGroup>

      <ItemGroup>
        <PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.0" />
        <PackageReference Include="Microsoft.Extensions.Configuration.json" Version="6.0.0" />
      </ItemGroup>

      <ItemGroup>
        <None Update="appsettings.json">
          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
        </None>
      </ItemGroup>

    </Project>

  1. And finally your program.cs file will look like this.

     using System;
 using System.IO;
 using Microsoft.Extensions.Configuration;

 // See https://aka.ms/new-console-template for more information
 Console.WriteLine("Hello, World!");


 var builder = new ConfigurationBuilder()
                 .AddJsonFile($"appsettings.json", true, true);

 var config = builder.Build();

 var connectionString = config["ConnectionString"];
 var emailHost = config["Smtp:Host"];
 Console.WriteLine($"Connection String is: {connectionString}");
 Console.WriteLine($"Email Host is: {emailHost}");
 var settingTwo = config["MySecondClass:SettingOne"];
 Console.WriteLine(settingTwo);

If you just want to use Visual Studio Code and not Visual Studio 2022 do the following.

  1. Make a directory for a simple-console-app and cd into it.

Make a directory for console app

  1. Execute the following command to create a new console app.
dotnet new console
dotnet run

Create and run the console app

  1. Now open the project in Vs Code by running the following command.

code .

Open in Vs Code

  1. Add a new file appsettings.json and edit it to look something like this.

     {
   "ConnectionString": "Server=localhost;Database=tempDB;Uid=<dbUserName>;Pwd=<dbPassword>",
   "Smtp": {
     "Host": "smtp.gmail.com",
     "From": "Your Name"
   },
   "MySecondClass": {
     "SettingOne": "some string value",
     "SettingTwo": 82
   }
 }

  2. Edit your project csproj file to include Microsoft.Extensions.Configuration and its json counter part package. See below, note the appsettings.json file as well.

    <Project Sdk="Microsoft.NET.Sdk">

      <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>net6.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
      </PropertyGroup>

      <ItemGroup>
        <PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.0" />
        <PackageReference Include="Microsoft.Extensions.Configuration.json" Version="6.0.0" />
      </ItemGroup>

      <ItemGroup>
        <None Update="appsettings.json">
          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
        </None>
      </ItemGroup>

    </Project>

  1. And finally your program.cs file will look like this.

     using System;
 using System.IO;
 using Microsoft.Extensions.Configuration;

 // See https://aka.ms/new-console-template for more information
 Console.WriteLine("Hello, World!");


 var builder = new ConfigurationBuilder()
                 .AddJsonFile($"appsettings.json", true, true);

 var config = builder.Build();

 var connectionString = config["ConnectionString"];
 var emailHost = config["Smtp:Host"];
 Console.WriteLine($"Connection String is: {connectionString}");
 Console.WriteLine($"Email Host is: {emailHost}");
 var settingTwo = config["MySecondClass:SettingOne"];
 Console.WriteLine(settingTwo);

  2. Now time to run. But first do dotnet restore and then dotnet run.

dotnet restore
dotnet run

Restore and Run

Improve this answer

4 Comments

Your post is good, except it lacks to mention "Microsoft.Extensions.Configuration.Json" package which is also required to read json configuration files
I included the cs prof file xml as well, but somehow it did not appear. Check now.
On visual studio 2022 version 17.2.2, Microsoft.Extensions.Configuration,json auto included in the project. We can updated version from tools->NutGet packageManager
The answer will be good for the separate question stackoverflow.com/questions/71954271/…
36

http://www.techtutorhub.com/article/how-to-read-appsettings-json-configuration-file-in-dot-net-core-console-application/83

helpfull !

  1. appsettings.json (after add appsettings.json, go to property and mark the file as copy to out directory)
{
  "ConnectionString": "Server=localhost;Database=tempDB;Uid=<dbUserName>;Pwd=<dbPassword>",
  "Smtp": {
    "Host": "smtp.gmail.com",
    "Port": "587",
    "Username": "<YourGmailUserName>",
    "Password": "<YourGmailPassword>",
    "From": "Your Name"
  }
}

2.package needed

dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.Json
  1. program.cs
using System; 
using Microsoft.Extensions.Configuration;

    class Program
        {
            static void Main(string[] args)
            {
                  var builder = new ConfigurationBuilder()
                   .AddJsonFile($"appsettings.json", true, true);
    
                var config = builder.Build();
                var connectionString = config["ConnectionString"];
                var emailHost = config["Smtp:Host"];
                Console.WriteLine($"Connection String is: {connectionString}");
                Console.WriteLine($"Email Host is: {emailHost}");
                Console.ReadLine();
            }
        }
Improve this answer

Comments

16

I had the same issue with .NET Core and I found this solution to be working well:

  1. I have this appsettings.json
    {
      "App": 
      {
        "LoginCredentials": 
        {
           "ClientId": "xxx",
           "ClientSecret": "xxx",
           "TenantId": "xxx"
        },
        "DataBase": 
        {
            "PathToDatabases": "xxx"
        },
        "General": 
        {
           "PathToLogFiles": "xxx"
        }
      }

    }
  1. I created a class AppSettingsHandler.cs
    public class AppSettingsHandler
    {
        private string _filename;
        private AppSettings _config;

        public AppSettingsHandler(string filename)
        {
            _filename = filename;
            _config = GetAppSettings();
        }

        public AppSettings GetAppSettings()
        {
            var config = new ConfigurationBuilder()
               .SetBasePath(AppContext.BaseDirectory)
               .AddJsonFile(_filename, false, true)
               .Build();

            return config.GetSection("App").Get<AppSettings>();
        }
    }
  1. Then you need a "model" class for AppSettings:
    public class AppSettings
    {
        public LoginCredentialsConfiguration LoginCredentials { get; set; }
        public DatabaseConfiguration DataBase { get; set; }
        public GeneralConfiguration General { get; set; }
    }

and a model class for each of the included sub-classes, I only exemplify one here:

    public class LoginCredentialsConfiguration
    {
        public string ClientId { get; set; }
        public string ClientSecret { get; set; }
        public string TenantId { get; set; }
    }
  1. In your Program.cs class, you can now get the parameters from the appsettings.json like this:
            var aH = new AppSettingsHandler("appsettings.json");
            var aS = aH.GetAppSettings();
            var myPath = aS.DataBase.PathToDatabases;

Of course you can tweak that code so that it will match your requirements, i. e., you have to define your own classes and subclasses and of course you can extend the AppSettingsHandler.cs by also getting other sections of the appsettings.json.

Improve this answer

3 Comments

Thanks for the response! The problem is i need to get those variables in another library class, not in Main. I don't know how to initialize 'configuration' in other classes in order to use it. Thanks
SetBasePath() no longer exists in .net core 5. What is the alternative?
install nuget packages Microsoft.Extensions.Configuration.Json and Microsoft.Extensions.Configuration.Binder
10

I've tried the followings and it's worked fine.

1- Add your launchSettings.json to your project under Properties folder.
2- Add your appsettings files to your project for each environment.
3- Add your appsettings files to your .csproj as shown below.
4- Then you can inject and reach IConfiguration that reads appsettings file according to the environment via below code.

    var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
    
    var configuration =  new ConfigurationBuilder()
         .SetBasePath(Directory.GetCurrentDirectory())
         .AddJsonFile($"appsettings.{environment}.json")
         .AddEnvironmentVariables()
         .AddCommandLine(args)
         .Build();
    
    var serviceProvider = new ServiceCollection()
        .AddSingleton<IConfiguration>(configuration)
        .BuildServiceProvider();
    
    var configurationInstance = serviceProvider.GetService<IConfiguration>();

launchSettings.json

{
  "profiles": {
    "YourProject": {
      "commandName": "Project",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "DEV"
      }
    }
  }
}

You should add your appSettings files in your .csproj file

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Autofac" Version="6.3.0" />
    <PackageReference Include="Microsoft.Extensions.Hosting" Version="6.0.1" />
  </ItemGroup>

  <ItemGroup>
    <None Update="appsettings.DEV.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
    <None Update="appsettings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
    <None Update="appsettings.Production.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
    <None Update="appsettings.QA.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
  </ItemGroup>

</Project>

And you may inject it anywhere

public class ConnectionService
{
    private readonly IConfiguration _configuration;

    public ConnectionService(IConfiguration configuration)
    {
        _configuration = configuration;
    }
}
Improve this answer

8 Comments

any idea how to do this with a dotnet6 console app?
You can use these implementations for .Net6 console app., I've created that example on .Net6 console app. @MC9000
Can you provide a link to that example for .Net6 console?
Sorry, I don't have it but I've shared all details about how to do it. So please check it.
ok. I'm doing some experimenting and more research. When I figure it out how to do this in DN6 for a console app AND inject into a custom class, I'll post it here.
|
1

I am using dotnet 6. You just need to call CreateDefaultBuilder on Host.

await Host
.CreateDefaultBuilder(args)
.ConfigureServices((hostContext, services) => 
{
    services
        .AddHostedService<ConsoleHostedService>();
})
.RunConsoleAsync();

where ConsoleHostedService implements IHostedService.

By calling ConfigureServices it will do what you need.

Improve this answer

4 Comments

Special Note, what ever settings file you add remember to set option to Copy Output to directory to Copy Always. see following for reference stackoverflow.com/questions/4596508/….
Where did you put this code in? Is this a custom class? Can you clarify? I checked the link from MS and it looks like there's a hundred different ways to do this. Is there a "proper" method for setting this all up in DotNet6 for a Console app (not a website)?
@MC9000 would you kindly look at the following github repo to see if this answers your questions. github.com/felipedferreira/ConsoleApp
Important Note is that the appsettings.json needs to change the 'Copy to output options' to 'Copy Always'. Please advise if you need help understanding how this is done.
0

For dotnet 8, it is even easier. In the program.cs just use:

var builder = Host.CreateApplicationBuilder(args);

This adds all preconfigured defaults - more info here: https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.host.createapplicationbuilder?view=net-9.0-pp#microsoft-extensions-hosting-host-createapplicationbuilder(system-string())

Then you can load/bind options quite easily i.e.

var builder = Host.CreateApplicationBuilder(args);
var services = builder.Services;
var config = builder.Configuration;
services.AddOptions<PostgresConfig>()
    .Bind(config.GetSection(PostgresConfig.SectionName));

var postgresConfig = config.GetRequiredSection(PostgresConfig.SectionName).Get<PostgresConfig>();

services.AddDbContextPool<GameStoreContext>(options =>
    options.UseNpgsql(postgresConfig.ConnectionString));
var app = builder.Build();
app.Run();
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.