33
votes

Comment obtenir des valeurs de AppSettings.json dans une application de console utilisant .NET Core?

Je crée une application de console utilisant .NET Core 3.1 et je voudrais avoir un JSON AppSettings pour charger tous Environnement, chemins, variables, ... au début de l'exécution, puis obtenir des valeurs d'autres classes de bibliothèque. J'ai créé une classe «Paramètres» avec les données incluses dans les appsettings JSON. C'est ce que j'ai déjà en regardant dans les tutoriels, mais je ne suis pas en mesure d'obtenir de valeur.

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

Je ne peux pas faire un principal principal car je ne sais pas comment initialiser. ..Qu'est-ce que je rate? Je pense que je suis allé en rond depuis quelque chose de aussi facile. Merci d'avance! Remarque: J'ai besoin d'obtenir ces variables d'une autre classe de bibliothèque, pas dans la principale. Je ne sais pas comment initialiser la «configuration» dans d'autres classes afin de l'utiliser. Merci

.net-core c# startup appsettings

2 commentaires

Est-ce que cela répond à votre question? comment lire les valeurs des applsettings à partir des valeurs des applsettings à partir des valeurs des appsetting un fichier .json dans ASP.net Core

Pour .net 6 et plus, voir mon Répondez bien en dessous

6 Réponses :

42
votes

Votre exemple consiste à mélanger certaines approches Core Net ASP qui s'attendent à ce que votre code soit hébergé. Pour résoudre le problème minimal d'obtenir des options ou des paramètres à partir d'une configuration JSON, considérez ce qui suit:

un fichier config.json , défini sur "Copier dans le répertoire de sortie" afin qu'il soit inclus avec le build:

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

L'approche suivante chargera le contenu du fichier JSON, puis liera le contenu à deux classes d'options / paramètres de type forte, qui peuvent être beaucoup plus propres que Value-by-Value:

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

4 commentaires

Merci pour la réponse! Le problème est que j'ai besoin d'obtenir ces variables dans une autre classe de bibliothèque, pas dans la principale. Je ne sais pas comment initialiser la «configuration» dans d'autres classes afin de l'utiliser. Merci

@Javil Vous pouvez placer ces classes paramètres / options ou l'objet iconfiguration lui-même dans une instance globale statique, ou vous pouvez envisager d'utiliser l'injection de dépendance et un conteneur IOC (soit le noyau net ASP, soit l'un de votre choix) pour injecter correctement Ces options dans les autres classes s'attendent à les consommer.

Article plus ancien, mais pertinent pour la question secondaire posée: andrewlock.net/…

Si vous souhaitez utiliser la méthode AddenvironmentVariables , vous devez installer Ce package

13
votes

J'ai eu le même problème avec .NET Core et j'ai trouvé que cette solution fonctionnait bien:

J'ai ces appsettings.json

            var aH = new AppSettingsHandler("appsettings.json");
            var aS = aH.GetAppSettings();
            var myPath = aS.DataBase.PathToDatabases;

J'ai créé une classe AppSettingShandler.cs

    public class LoginCredentialsConfiguration
    {
        public string ClientId { get; set; }
        public string ClientSecret { get; set; }
        public string TenantId { get; set; }
    }

Ensuite, vous avez besoin d'une classe "modèle" pour AppSettings:

    public class AppSettings
    {
        public LoginCredentialsConfiguration LoginCredentials { get; set; }
        public DatabaseConfiguration DataBase { get; set; }
        public GeneralConfiguration General { get; set; }
    }

et une classe de modèle pour chacune des sous-classes incluses, je n'en en exempte qu'une ici:

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

Dans votre classe Program.cs, vous pouvez maintenant obtenir les paramètres de l'AppSettings.json comme ceci:

    {
      "App": 
      {
        "LoginCredentials": 
        {
           "ClientId": "xxx",
           "ClientSecret": "xxx",
           "TenantId": "xxx"
        },
        "DataBase": 
        {
            "PathToDatabases": "xxx"
        },
        "General": 
        {
           "PathToLogFiles": "xxx"
        }
      }

    }

Bien sûr, vous pouvez modifier ce code afin qu'il corresponde à vos exigences, i. e., vous devez définir vos propres classes et sous-classes et bien sûr, vous pouvez étendre l'AppSettingShandler.cs en obtenant également d'autres sections de l'appsettings.json.

3 commentaires

setBasepath () n'existe plus dans .NET Core 5. Quelle est l'alternative?

Installez les packages NuGet Microsoft.Extensions.Configuration.json et Microsoft.Extensions.Configuration.Binder

17
votes

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

utile!

AppSettings.json (après ajouter AppSettings.json, accédez à la propriété et marquez le fichier comme copie dans le répertoire)

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

2.Package nécessaire

dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.Json

Program.cs

{
  "ConnectionString": "Server=localhost;Database=tempDB;Uid=<dbUserName>;Pwd=<dbPassword>",
  "Smtp": {
    "Host": "smtp.gmail.com",
    "Port": "587",
    "Username": "<YourGmailUserName>",
    "Password": "<YourGmailPassword>",
    "From": "Your Name"
  }
}

0 commentaires

6
votes

pour commencer avec Visual Studio 2022 et .NET 6.

Créez un nouveau projet de console.

Ajoutez un fichier appsettings.json au projet.

Cliquez avec le bouton droit, sélectionnez les propriétés et assurez-vous qu'elle est copiée dans le répertoire de sortie.

Modifiez le fichier pour ressembler à quelque chose comme ça.

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

Modifiez votre fichier CSPROJ de projet pour inclure microsoft.extensions.configuration / A> et son co-json compteur package. Voir ci-dessous, notez également le fichier appsettings.json.

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

Et enfin votre fichier programme.cs ressemblera à ceci.

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

3 commentaires

Votre message est bon, sauf qu'il manque de mentionner le package "Microsoft.Extensions.Configuration.json" qui est également nécessaire pour lire les fichiers de configuration JSON

J'ai également inclus le fichier CS PROF XML, mais il n'apparaissait pas en quelque sorte. Vérifie maintenant.

Sur Visual Studio 2022 version 17.2.2, Microsoft.Extensions.Configuration, JSON Auto inclus dans le projet. Nous pouvons mettre à jour la version à partir d'outils -> nutget packageManager

3
votes

J'ai essayé les suivants et cela a bien fonctionné.

1- Ajoutez votre lancementSettings.json à votre projet sous Propriétés dossier.
2- Ajoutez vos fichiers appsettings à votre projet pour chaque environnement.
3- Ajoutez vos fichiers AppSettings à vos .csproj comme indiqué ci-dessous.
4- Ensuite, vous pouvez injecter et atteindre iconfiguration qui lit le fichier AppSettings en fonction de l'environnement via le code ci-dessous.

public class ConnectionService
{
    private readonly IConfiguration _configuration;

    public ConnectionService(IConfiguration configuration)
    {
        _configuration = configuration;
    }
}

LaunchSettings.json

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

Vous devez ajouter vos fichiers AppSettings dans votre fichier .csproj

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

0 commentaires

0
votes

J'utilise dotnet 6. Il vous suffit d'appeler CreatefaultBuilder sur l'hôte.

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

où ConsoleHostedService implémente ihostedService.

en appelant configureServices Il fera ce dont vous avez besoin.

1 commentaires

Remarque spéciale, quel que soit le fichier de paramètres que vous ajoutez, n'oubliez pas de définir l'option pour copier la sortie dans le répertoire pour toujours copier. Voir suivant pour référence stackoverflow.com/questions/4596508/… .