Configuración

En algún punto en el desarrollo de tu aplicación web, necesitaras algún lugar para almacenar algunas opciones/configuraciones. Existen varias formas de lograr esto, pero la forma recomendada es a través de la configuración de la aplicación encontrada en .NET Framework, Discutiremos el como esto funciona en este artículo.

appsettings.json y Web.config

Si has trabajado con una versión anterior de ASP.NET, antes de que "Core Framework" fuera liberada, deberías estar familiarizado con los archivo Web.config. Estos se usaban anteriormente para almacenar opciones de configuración, y aún son usados en "ASP.NET Core Framework", pero su uso es mayormente para configuraciones que serán usadas for el servidor web y no mucho por la misma aplicación.

En el "Core Framework" de hoy, el lugar más común para almacenar las configuraciones de la aplicación es en el archivo appsettings.json. Como el nombre lo indica, este archivo esta en el formato JSON, mientras que el archivo Web.config es basado en XML.

Cuando se crea una nueva aplicación "ASP.NET Core MVC" en Visual Studio, e incluso usando una plantilla vacía, un archivo appsettings.json será creado. Este contendrá algunas opciones por defecto relacionadas al login, etc., y se verá mas o menos como esto:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}

No entraré en detalles sobre el formato JSON - tal vez ya lo conozcas si has trabajado con JavaScript, pero si no, podrás ver que está basado en pares clave/valor: Una clave (p.ej. "AllowedHosts"), luego dos puntos y luego el valor (en este caso "*"). El valor puede ser un string o un objeto conteniendo mas claves/valores, como puedes ver en el objeto "Logging".

Eres libre de editar estos pares clave/valore o agregar nuevos. Entonces, por ejemplo, si deseas agregar una configuración que contenga el título del sitio web, puedes, simplemente, agregarlo al archivo appsettings.jason como esto:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "WebsiteTitle": "My ASP.NET Core MVC Website"
}

Como puedes ver, es fácil agregar información en este simple formato.

Accediendo a las opciones desde el archivo appsettings.json

Hecho esto, hablemos de como acceder a tus opciones. En realidad depende de donde las necesites, entonces hablemos de las distintas posibilidades.

Accediendo a appsettings.jason desde el controlador

La framawork pasará automáticamente tus opciones de configuración a los Controladores, a través de un método llamado "Dependency Injection" (DI), pero solo si has especificado un constructor con un parámetro del tipo IConfiguration. Primero asegúrate de incluir el nombre de espacio Microsoft.Extensions.Configuration.

using Microsoft.Extensions.Configuration;

Esto te permitirá en uso específico del constructor, como sigue:

public class HomeController : Controller  
{  
    private readonly IConfiguration _configuration;  
    public HomeController(IConfiguration configuration)  
    {  
    _configuration = configuration;  
    }
    ....

Al guardar una referencia al objeto IConfiguration, puedes ahora acceder a las opciones de configuración a través de cualquier método en tu Controlador, como esto;

public IActionResult Index()
{
    return Content("Welcome to " + _configuration.GetValue<string>("WebsiteTitle"));
}

En este caso, usamos el método GetValue() para obtener los valores que almacenamos en el archivo appsettings.json.

Accediendo a appsettings.json desde la clase Startup

Algunas opciones son necesarias cuando tu aplicación comienza. Hemos hablado previamente un poco sobre la clase Startup, encontrada en el archivo Startup.cs, el que es usado para varias cosas en una aplicación "ASP.NET Core". Acceder a tus opciones desde uno de los métodos de Startup, p.ej. ConfigureServices() o Configure(), es tan fácil como hacerlo desde dentro del Controlador. De hecho, el enfoque es exactamente el mismo:

public class Startup  
{  
    private readonly IConfiguration _configuration;  
    public Startup(IConfiguration configuration)  
    {  
    _configuration = configuration;  
    }  
    public void ConfigureServices(IServiceCollection services)  
    {  
    string websiteTitle = _configuration.GetValue<string>("WebsiteTitle"));  
    services.AddMvc();          
    }
    ....

Accediendo a appsettings.json desde una vista

ya que vimos como acceder a las opciones de aplicación desde en Controlador, puedes, por su puesto, pasar esto a las vistas desde ahí. Sin embargo, algunas veces es más fácil accesarlos directamente desde tu vista, ya sea desde una vista regular o p.ej. una vista de diseño. Esto también es hecho usando "Dependency Injection", como en el siguiente ejemplo:

@using Microsoft.Extensions.Configuration
@inject IConfiguration Configuration

<h1>Index</h1>

Welcome to @(Configuration.GetValue<string>("WebsiteTitle"))

Secciones

Hasta aquí, solo hemos almacenado un simple string en nuestro archivo appsetting.json, pero como ya he mencionado al comienzo, un valor JSON puede, fácilmente, ser un objeto, permitiéndote almacenar múltiples valores bajo la misma clave. Así por ejemplo, si queríamos almacenar más información relacionada a nuestro sitio web y no solamente el título, podríamos cambiar nuestra entrada en el archivo appsettings.json a algo como esto:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "Website": {
    "Title": "My ASP.NET Core MVC Website",
    "Version": 1.01
  }
}

Como se puede ver, tenemos ahora información de nuestro sitio web en un objeto que contiene dos propiedades: Título y Versión. Esto tendrá, por su puesto, más sentido si tuviéramos más propiedades, pero esto es suficiente para ilustrar como trabaja.

Un objeto en el formato JSON traducido a sección cuando quieres recuperar sus propiedades. Así es que necesitamos recuperar la sección ("Website") antes de que podamos acceder a una de las propiedades, aquí un ejemplo:

@using Microsoft.Extensions.Configuration
@inject IConfiguration Configuration

<h1>Index</h1>

Welcome to @(Configuration.GetSection("Website").GetValue<string>("Title"))
<br />
Version: @(Configuration.GetSection("Website").GetValue<string>("Version"))

La información de "website" ha sido agrupada ahora en su propia sección - esto es especialmente útil si tienes un MONTON de parámetros en tu archivo appsettings.json.

Sumario

Como hemos visto en este artículo, es muy fácil trabajar con el mecanismo de configuración de "ASP.NET Framework", haciéndote fácil el acceso y almacenamiento de las configuraciones de la aplicación. Sin embargo, el enfoque que hemos usado es la versión simple, donde usamos strings codificados al acceder a las diferentes secciones y configuraciones. Esto, generalmente, no es recomendado - en su lugar deberíamos usar el patron Options, que se basa en el mecanismo de configuración. Aprenderemos mas de esto en el siguiente artículo.