tutorial - Uso de IConfiguration en la biblioteca de clases C#

asp.net core web api

Question

Estoy construyendo una biblioteca de clase usando C # y Core .NET. Estoy tratando de usar la configuración de un archivo config.json . Aquí están los contenidos de ese archivo:

config.json

{
  "emailAddress":"[email protected]"
}

En un intento de usar config.json para mi configuración, estoy haciendo referencia a Microsoft.Framework.ConfigurationModel.Json en mi archivo project.json . En mi código, tengo lo siguiente:

MyClass.cs

using Microsoft.Framework.ConfigurationModel;
public class MyClass
{
  public string GetEmailAddress()
  {
//    return ConfigurationManager.AppSettings["emailAddress"];  This is the approach I had been using since .NET 2.0
    return ?;  // What goes here?
  }
}

Desde .NET 2.0, he estado usando ConfigurationManager.AppSettings["emailAddress"] . Sin embargo, ahora estoy tratando de aprender cómo hacerlo de la nueva manera a través de IConfiguration . Mi problema es que esta es una biblioteca de clase. Por esa razón, no estoy seguro de cómo, ni dónde, ni cuándo se carga el archivo de configuración. En .NET tradicional, solo necesitaba nombrar un archivo web.config para proyectos ASP.NET y app.config para otros proyectos. Ahora, no estoy seguro. Tengo tanto un proyecto ASP.NET MVC 6 como un proyecto XUnit. Por lo tanto, estoy tratando de averiguar cómo usar config.json en ambos escenarios.

¡Gracias!

Answer 1

Las bibliotecas de clases de IMO deben ser independientes de los datos de configuración de la aplicación. En general, el consumidor de la biblioteca es el que se preocupa por tales detalles. Sí, esto no siempre es cierto (por ejemplo, si tiene una clase que realiza cifrado / descifrado RSA, es posible que desee alguna configuración privada para permitir la clave privada gen / almacenamiento), pero en su mayor parte, es cierto.

Por lo tanto, en general, trate de mantener la configuración de la aplicación fuera de la biblioteca de la clase y haga que el consumidor proporcione dicha información. En su comentario, menciona una cadena de conexión a una base de datos. Este es un ejemplo perfecto de los datos que se mantendrán FUERA de una biblioteca de clase. A la biblioteca no le debe importar a qué base de datos está llamando para leer, solo que necesita leer de uno. Ejemplo a continuación (me disculpo si hay algunos errores ya que estoy escribiendo esto sobre la marcha desde la memoria):

Biblioteca

Clase de biblioteca que usa una cadena de conexión

public class LibraryClassThatNeedsConnectionString
{
    private string connectionString;

    public LibraryClassThatNeedsConnectionString(string connectionString)
    {
        this.connectionString = connectionString;
    }

    public string ReadTheDatabase(int somePrimaryKeyIdToRead)
    {
        var result = string.Empty;

        // Read your database and set result

        return result;
    }
}

Solicitud

appsettings.json

{
  "DatabaseSettings": {
    "ConnectionString": "MySuperCoolConnectionStringWouldGoHere"
  }
}

DatabaseSettings.cs

public class DatabaseSettings
{
    public string ConnectionString { get; set; }
}

Startup.cs

public class Startup
{
    public Startup(IHostingEnvironment env)
    {
        Configuration = new ConfigurationBuilder()
                        .SetBasePath(env.ContentRootPath)
                        .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                        .AddEnvironmentVariables()
                        .Build();
    }

    public IConfigurationRoot Configuration { get; }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        // Setup logging
        // Configure app

    }

    public void ConfigureServices(IServiceCollection services)
    {
        // Configure services
        services.Configure<DatabaseSettings>(Configuration.GetSection("DatabaseSettings"));
        services.AddOptions();
    }
}

Clase que usa la clase de biblioteca para leer la base de datos

public class ClassThatNeedsToReadDatabaseUsingLibrary
{
    private DatabaseSettings dbSettings;
    private LibraryClassThatNeedsConnectionString libraryClassThatNeedsConnectionString;

    public ClassThatNeedsToReadDatabaseUsingLibrary(IOptions<DatabaseSettings> dbOptions)
    {
        this.dbSettings = dbOptions.Value;
        this.libraryClassThatNeedsConnectionString = new LibraryClassThatNeedsConnectionString(this.dbSettings.ConnectionString);
    }

    public string ReadDatabaseUsingClassLibrary(int somePrimaryKeyIdToRead)
    {
        return this.libraryClassThatNeedsConnectionString.ReadTheDatabase(somePrimaryKeyIdToRead);
    }
}

TL; DR

Intente evitar el uso de la configuración de la aplicación en una biblioteca de clases. En su lugar, haga que la biblioteca de su clase sea independiente de dichos ajustes y permita que el consumidor los apruebe.

Answer 2

No sé si funciona en una biblioteca core.net, pero en mi aplicación mvc6 lo uso de esta manera:

public class Startup
{
    public static IConfigurationRoot Configuration;

    public Startup(IApplicationEnvironment appEnv)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(appEnv.ApplicationBasePath)
            .AddJsonFile("config.json")
            .AddEnvironmentVariables();

        Configuration = builder.Build(); 
    }
}

luego, si necesito llamar la información en config.jason a través de la aplicación, hago esto: es decir, en un método de controlador:

var email = Startup.Configuration["AppSettings:SiteEmailAddress"];

cadena sql en mi clase WonderContext:

var connString = Startup.Configuration["AppSettings:WonderContextConnection"];

Answer 3

Nunca lo usé, pero una búsqueda rápida me llevó a esto ...

var configuration = new Configuration();
configuration.AddJsonFile(“config.json”);
var emailAddress = configuration.Get("emailAddress");

Tal vez podrías intentar eso.

Answer 4

Primero en su archivo .csproj , agregue un objetivo que sea estricto en el proceso de compilación , consulte el enlace para ver más opciones si lo siguiente no se ajusta a sus necesidades, como publicación

<Target Name="AddConfig" AfterTargets="AfterBuild">
    <Copy SourceFiles="config.json" DestinationFolder="$(OutDir)" />
</Target>

puedes usarlo de la siguiente manera

using Microsoft.Framework.ConfigurationModel;
using Microsoft.Extensions.Configuration;
using System;

public class MyClass {
    public string GetEmailAddress() {
        //For example purpose only, try to move this to a right place like configuration manager class
        string basePath= System.AppContext.BaseDirectory;
        IConfigurationRoot configuration= new ConfigurationBuilder()
            .SetBasePath(basePath)
            .AddJsonFile("config.json")
            .Build();

        return configuration.Get("emailAddress");
    }
}