No desenvolvimento de aplicações .NET, a configuração é um aspecto crucial para garantir que parâmetros importantes sejam acessados de forma eficiente e flexível. O arquivo “appsettings.json” é um dos métodos mais comuns e utilizados para armazenar configurações em projetos .NET, fornecendo uma maneira fácil de manter informações sensíveis e variáveis configuráveis fora do código-fonte.
Estrutura do appsettings.json
Primeiro, vamos começar com um exemplo básico de um arquivo “appsettings.json”. Ele é um arquivo de configuração baseado em JSON que pode armazenar informações como strings de conexão, variáveis de ambiente, e outros parâmetros importantes. Abaixo temos um exemplo:
{
"Logging": {
"LogLevel": {
"Default": "Information",
"System": "Warning",
"Microsoft": "Warning"
}
},
"ConnectionStrings": {
"DefaultConnection": "Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;"
},
"AppSettings": {
"ApplicationName": "Minha Aplicação",
"Version": "1.0.0",
"SupportedCultures": [ "en-US", "pt-BR" ]
}
}
Nesse exemplo, temos três seções principais:
- Logging: Configurações de nível de log.
- ConnectionStrings: Strings de conexão com o banco de dados.
- AppSettings: Informações customizadas da aplicação.
Adicionando o serviço de configuração
Antes de começar a ler as configurações, é importante garantir que o serviço de configuração seja adicionado ao pipeline da sua aplicação. Para aplicações como ASP.NET Core, isso já é configurado automaticamente. Entretanto, para outros tipos de projetos, como aplicações de console, você precisa configurar manualmente o carregamento do “appsettings.json”.
Em uma aplicação de console, você precisa configurar manualmente o carregamento do “appsettings.json” no arquivo “Program.cs”. Isso é feito adicionando o pacote “Microsoft.Extensions.Configuration.Json” e configurando o builder manualmente. Veja como fazer isso:
Install-Package Microsoft.Extensions.Configuration.Json
ou
dotnet add package Microsoft.Extensions.Configuration.Json
Adicione a configuração no “Program.cs”:
using Microsoft.Extensions.Configuration;
class Program
{
static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appSettings.json", optional: true, reloadOnChange: true);
IConfiguration configuration = builder.Build();
var appName = configuration["AppSettings:ApplicationName"];
Console.WriteLine($"Application Name: {appName}");
}
}
Nesse exemplo, estamos configurando manualmente o “ConfigurationBuilder” para carregar as configurações do arquivo “appSettings.json”. Em seguida, usamos a interface “IConfiguration” para acessar os valores. Neste exemplo é necessário criar o arquivo “appSettings.json” na pasta de execução da aplicação.
Lendo configurações com IConfiguration
A forma mais básica de acessar as configurações no .NET é utilizando a interface “IConfiguration”. Ela fornece uma maneira simples de acessar os valores diretamente, seja qual for a estrutura ou tipo do dado. Para o nosso exemplo, vamos supor que queremos acessar a string de conexão com o banco de dados. Podemos fazer isso injetando “IConfiguration” em um controlador da nossa API.
[ApiController]
[Route("api/[controller]")]
public class ConfigController : ControllerBase
{
private readonly IConfiguration _configuration;
public ConfigController(IConfiguration configuration)
{
_configuration = configuration;
}
[HttpGet("GetDatabaseConnection")]
public IActionResult GetDatabaseConnection()
{
var connectionString = _configuration.GetConnectionString("DefaultConnection");
return Ok(connectionString);
}
}
No código acima, utilizamos o método “GetConnectionString” para obter a string de conexão configurada no “appsettings.json”. A interface “IConfiguration” é injetada no construtor da classe e usada para acessar a configuração.
Usando o método GetSection
O método “GetSection” permite acessar uma parte do arquivo “appsettings.json” como uma seção distinta. Isso é útil quando você deseja trabalhar com uma subseção completa, como uma estrutura mais complexa. O valor retornado por “GetSection” ainda é um objeto de configuração, de modo que você pode acessar subseções e valores dentro dela.
var applicationName = _configuration.GetSection("AppSettings")["ApplicationName"];
Aqui, “GetSection(“AppSettings”)” isola a seção “AppSettings” do “appsettings.json”, e então “[“ApplicationName”]” acessa o valor dessa chave dentro da seção.
Acessando diretamente via indexação de chave
Uma segunda abordagem é utilizar a notação de chave com : (dois pontos), permite acessar valores de forma direta sem ter que chamar “GetSection” explicitamente. Essa notação representa a hierarquia no arquivo JSON.
var applicationName = _configuration["AppSettings:ApplicationName"];
Nesse caso, estamos utilizando a chave “AppSettings:ApplicationName” diretamente, o que evita a necessidade de chamar o “GetSection”.
Quando usamos o “IConfiguration” para acessar diretamente as configurações no “appsettings.json” estamos acessando valores manualmente usando strings de chaves. Embora isso funcione bem em aplicações simples, pode se tornar problemático em sistemas maiores, pois como as chaves são passadas como strings, erros de digitação podem ocorrer facilmente. Se o nome de uma chave mudar no “appsettings.json”, seria necessário atualizar manualmente todas as referências ao longo da aplicação, o que aumenta o risco de inconsistências e erros difíceis de detectar.
Mapeando configurações com IOptions
Para resolver esses problemas, o “IOptions<T>” oferece uma abordagem mais robusta e segura. Ao usar “IOptions<T>”, mapeamos as configurações do “appsettings.json” para uma classe fortemente tipada. Isso reduz a chance de erros, pois passamos a usar propriedades fortemente tipadas em vez de strings, e se o nome de uma chave mudar, só precisamos ajustar o mapeamento uma vez na classe de configuração, em vez de em todo o código.
Além disso, usando “IOptions<T>”, o próprio .NET valida a configuração durante o carregamento, o que evita que valores ausentes ou incorretos causem erros silenciosos de tempo de execução.
Mapeamento com IOptions
Primeiro, criamos uma classe que corresponde às seções do arquivo “appsettings.json”. No nosso exemplo, vamos mapear a seção “AppSettings”:
public class AppSettings
{
public string ApplicationName { get; set; }
public string Version { get; set; }
public List<string> SupportedCultures { get; set; }
}
Configurando o IOptions
Agora, vamos configurar o “IOptions<T>” dentro do arquivo “Program.cs” para mapear as configurações para a classe “AppSettings”.
var builder = WebApplication.CreateBuilder(args);
builder.Services.Configure<AppSettings>(builder.Configuration.GetSection("AppSettings"));
O comando “builder.Configuration.GetSection(“AppSettings”)” acessa a seção “AppSettings” do arquivo “appsettings.json” e mapeia suas configurações para a classe “AppSettings” que criamos, tornando essas informações disponíveis de forma estruturada. Em seguida, o “builder.Services.Configure<AppSettings>” registra essa classe no contêiner de dependências da aplicação, permitindo que ela seja injetada em qualquer serviço ou controlador que precise acessar essas configurações.
Acessando as configurações em um controller
Agora que configuramos o “IOptions<T>”, podemos injetá-lo em qualquer lugar da aplicação, como em um controlador de API, para acessar as configurações de forma tipada.
[ApiController]
[Route("api/[controller]")]
public class ConfigController : ControllerBase
{
private readonly IOptions<AppSettings> _appSettings;
public ConfigController(IOptions<AppSettings> appSettings)
{
_appSettings = appSettings;
}
[HttpGet("GetAppSettings")]
public IActionResult GetAppSettings()
{
var appSettings = _appSettings.Value;
return Ok(appSettings);
}
}
O “_appSettings.Value” permite acessar a instância da classe “AppSettings” que foi configurada por meio de “IOptions<AppSettings>”. Ao utilizar essa abordagem, as configurações armazenadas no arquivo “appsettings.json” são carregadas de forma estruturada e podem ser acessadas como uma classe fortemente tipada. No controlador, o valor obtido através de “_appSettings.Value” é utilizado para retornar as configurações da aplicação de maneira organizada.
Acelere a sua carreira conosco!
Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aquiConclusão
Neste artigo, exploramos as diversas formas de acessar e gerenciar configurações no arquivo “appsettings.json”. Discutimos o uso do “IConfiguration” para acessar configurações de forma simples e direta, além de como o “IOptions<T>” pode ser utilizado para um acesso mais eficiente e tipado, com suporte ao monitoramento de mudanças. Agora, você tem o conhecimento necessário para escolher a abordagem mais adequada ao seu projeto, considerando o contexto e as necessidades específicas da sua aplicação.