Em aplicações .NET Core, o arquivo appsettings.json é o local padrão para armazenar configurações. Este artigo explora como ler e modificar essas configurações, tanto programaticamente quanto diretamente no arquivo JSON.

Configuração Inicial em Aplicações Web/APIs (Startup.cs / Program.cs)

No contexto de projetos ASP.NET Core, a injeção de dependência via IConfiguration é o método mais comum para acessar as configurações. A construção do objeto de configuração é tipicamente realizada na classe Startup (para versões mais antigas do .NET Core) ou diretamente em Program.cs (para .NET 6+ e superior).

public class Startup
{
    public IConfiguration ConfigApp { get; }

    public Startup(IWebHostEnvironment ambienteWeb)
    {
        ConfigApp = new ConfigurationBuilder()
            .SetBasePath(ambienteWeb.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
            .AddJsonFile($"appsettings.{ambienteWeb.EnvironmentName}.json", optional: true, reloadOnChange: true)
            .AddEnvironmentVariables()
            .Build();
    }
    // ... outros métodos como ConfigureServices, Configure
}

O método .AddJsonFile("nome.json", optional: true, reloadOnChange: true) é crucial, pois permite que o arquivo de configuração seja recarregado automaticamente se houver alterações, sem a necessidade de reiniciar a aplicação. O parâmetro optional: true significa que a ausência do arquivo não causará um erro durante o carregamento.

Configuração em Bibliotecas ou Aplicações Console

Para cenários fora de um host web (como bibliotecas de classe ou aplicações console), você pode construir o objeto de configuração manualmente para carregar as configurações de appsettings.json:

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

// ...

var construtorConfig = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
    .AddJsonFile("appsettings.Desenvolvimento.json", optional: true, reloadOnChange: true);

var configuracaoApp = construtorConfig.Build();

// Exemplo de leitura de uma chave:
string valorChaveSecreta = configuracaoApp["JwtSettings:SecretKey"];
// Console.WriteLine($"Chave Secreta: {valorChaveSecreta}");

Este padrão garante flexibilidade para carregar configurações de diversas fontes, incluindo variáveis de ambiente e arquivos JSON específicos do ambiente, mantendo o recurso de recarregamento automático.

Leitura de Valores de Configuração

Utilizando Microsoft.Extensions.Configuration

Uma vez que o objeto IConfiguration (ou configuracaoApp no exemplo da biblioteca) é construído, a leitura dos valores é simples e direta. As chaves são acessadas usando a sintaxe de dois pontos para seções aninhadas:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;

public class ControleConfiguracao : Controller
{
    private readonly IConfiguration _configuracaoGlobal;

    public ControleConfiguracao(IConfiguration config)
    {
        _configuracaoGlobal = config;
    }

    public IActionResult ObterChaveDeConfig()
    {
        // Assumindo que appsettings.json tenha uma estrutura como {"ConfigGeral": {"ChaveLicenca": "xyz"}}
        string chaveLicenca = _configuracaoGlobal["ConfigGeral:ChaveLicenca"];
        ViewData["InfoConfig"] = $"Valor da Chave de Licença: {chaveLicenca}";
        return View();
    }
}

Este método é o preferido para acessar configurações definidas nos arquivos appsettings.json, pois se integra ao sistema de configuração do .NET Core, que gerencia prioridades entre diferentes fontes e recarregamento automático.

Leitura Direta de Arquivo JSON com Newtonsoft.Json

Em alguns cenários, pode ser necessário ler diretamente o conteúdo de um arquivo JSON que não faz parte do sistema de configuração padrão do .NET ou para realizar uma manipulação mais granular do JSON. Para isso, a biblioteca Newtonsoft.Json é uma ferramenta poderosa.

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.IO;
using Microsoft.AspNetCore.Hosting; // Para IWebHostEnvironment
using Microsoft.AspNetCore.Mvc;

public class AnalisadorJsonController : Controller
{
    private readonly IWebHostEnvironment _ambienteWeb;

    public AnalisadorJsonController(IWebHostEnvironment ambienteWeb)
    {
        _ambienteWeb = ambienteWeb;
    }

    public IActionResult LerAppsettingsComNewtonsoft()
    {
        string caminhoArquivoConfig = Path.Combine(_ambienteWeb.ContentRootPath, "appsettings.json");
        string conteudoArquivo = System.IO.File.ReadAllText(caminhoArquivoConfig);
        JObject objetoJson = JObject.Parse(conteudoArquivo);

        // Acessa um valor aninhado
        string chaveServico = (string)objetoJson["ServiceSettings"]["EndpointKey"];

        ViewData["ResultadoLeituraDireta"] = $"Chave do Endpoint (Newtonsoft.Json): {chaveServico}";
        return View();
    }
}

Este método oferece controle total sobre a estrutura JSON, permitindo navegar e extrair qualquer dado de forma programática.

Modificação do Arquivo appsettings.json

A alteração programática do arquivo appsettings.json em tempo de execução deve ser feita com cautela, pois pode sobrescrever formatação existente e remover comentários. Se a alteração for inevitável, Newtonsoft.Json pode ser utilizado para ler, modificar o objeto JSON em memória e então persisitr as alterações de volta ao disco.

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.IO;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;

public class GerenciadorConfigController : Controller
{
    private readonly IWebHostEnvironment _ambienteWeb;

    public GerenciadorConfigController(IWebHostEnvironment ambienteWeb)
    {
        _ambienteWeb = ambienteWeb;
    }

    public IActionResult AtualizarChaveNoArquivo()
    {
        string caminhoDoArquivo = Path.Combine(_ambienteWeb.ContentRootPath, "appsettings.json");
        string jsonOriginal = System.IO.File.ReadAllText(caminhoDoArquivo);
        JObject objetoConfig = JObject.Parse(jsonOriginal);

        // Modifica um valor existente ou adiciona um novo.
        // Ex: modificando a chave "LogLevel" dentro de "Logging" -> "LogLevel"
        if (objetoConfig["Logging"] != null && objetoConfig["Logging"]["LogLevel"] != null)
        {
            objetoConfig["Logging"]["LogLevel"]["Default"] = "Warning";
            objetoConfig["Logging"]["LogLevel"]["Microsoft.AspNetCore"] = "Warning";
        }
        else // Se a seção "Logging" ou "LogLevel" não existir, cria-as
        {
            objetoConfig["Logging"] = new JObject(
                new JProperty("LogLevel", new JObject(
                    new JProperty("Default", "Information"),
                    new JProperty("Microsoft.AspNetCore", "Warning")
                ))
            );
        }

        // Escreve o JSON modificado de volta ao arquivo, com indentação para legibilidade
        System.IO.File.WriteAllText(caminhoDoArquivo, objetoConfig.ToString(Formatting.Indented));

        ViewData["StatusModificacao"] = "Configuração do LogLevel atualizada para 'Warning' no arquivo!";
        return View();
    }
}

É importante notar que, embora reloadOnChange: true recarregue o arquivo, a modificação direta pode levar à perda de comentários e à re-formatação do arquivo JSON, impactando a legibilidade para desenvolvedores. Para configurações que mudam frequentemente ou são específicas do usuário, é geralmente mais robusto usar um banco de dados ou um serviço de configuração dedicado, em vez de modificar appsettings.json diretamente.