Alterando o conteúdo de arquivos no formato .json via código C#

O padrão JSON (sigla do inglês “Javascript Object Notation”) é hoje, sem sombra de dúvidas, um dos formatos para representação de dados mais populares. Empregado extensivamente por frameworks JavaScript como o AngularJS e presente em serviços desenvolvidos em conformidade com a arquitetura REST, o uso de JSON vem substituindo progressivamente o formato XML numa ampla gama de cenários. O próprio ASP.NET 5 constitui um bom exemplo disto, com a nova versão desta plataforma Web utilizando arquivos .json no lugar de documentos XML (geralmente identificados pela extensão .config) na representação das configurações de uma aplicação.

Do ponto de vista estrutural, um objeto no formato JSON corresponde a uma sequência de texto em que constam pares de informações. Cada um destes pares possui um identificador (string que determina um nome de propriedade), além de seu respectivo valor.

Este artigo tem por objetivo demonstrar como arquivos com conteúdo no formato JSON podem ser modificados em aplicações .NET, através de um exemplo envolvendo a implementação de uma classe Helper com a linguagem C#.

Exemplo prático

Para a implementação do exemplo descrito nesta seção será utilizado o package Newtonsoft.Json (Imagem 1). Esta biblioteca gratuita simplifica em muito a manipulação de dados no formato JSON, sendo inclusive utilizada pela própria Microsoft em aplicações como projetos baseados na tecnologia Web API.

Imagem 1: Adicionando o package Newtonsoft.Json a um projeto do Visual Studio 2015

Na Listagem 1 está a implementação da classe JSONFileHelper. Este tipo faz uso do package Newtonsoft.Json, sendo possível observar no mesmo:

• A existência de um método chamado “ObterConteudo”, o qual recebe como parâmetro um caminho de arquivo e que produz como resultado um objeto dinâmico (identificada pela palavra chave “dynamic”). Quanto ao funcionamento desta operação, inicialmente será acionado o método ReadAllText da classe File (namespace System.IO) de forma a se obter a string JSON que corresponde ao conteúdo de um arquivo. O texto em questão é então “deserializado”, a partir de uma chamada ao método DeserializeObject do tipo JsonConvert (namespace Newtonsoft.Json);
• A presença do método “SalvarConteudo”. Esta operação recebe como parâmetros o caminho do arquivo que será salvo, uma instância dinâmica com o conteúdo do mesmo, além de um “flag” que identifica se o valor no formato JSON será ou não identado. O enumeration Formatting (namespace Newtonsoft.Json) especifica, por sua vez, se haverá ou não identação no conteúdo de um arquivo (com base no flag “identar”). Já a invocação do método SerializeObject de JsonConvert irá produzir como resultado uma string JSON com o conteúdo que estava associado ao parâmetro “conteudo”. Por fim, a chamada ao método WriteAllText da classe File procederá com a gravação do arquivo que se está alterando.

[code language=”csharp”]
using System.IO;
using Newtonsoft.Json;

namespace JSON.Utils
{
public static class JSONFileHelper
{
public static dynamic ObterConteudo(string caminhoArquivo)
{
string texto = File.ReadAllText(caminhoArquivo);
return JsonConvert.DeserializeObject(texto);
}

public static void SalvarConteudo(string caminhoArquivo,
dynamic conteudo, bool identar)
{
Formatting formatacao = identar ? Formatting.Indented : Formatting.None;
string texto = JsonConvert.SerializeObject(conteudo, formatacao);
File.WriteAllText(caminhoArquivo, texto);
}
}
}
[/code]

Listagem 1: Classe JSONFileHelper

A classe JSONFileHelper será testada utilizando um arquivo chamado teste.json, cujo conteúdo pode ser visualizado na Listagem 2.

[code language=”html”]
{
“CaminhoRelatorios”: “C:\\Reports\\”,
“CaminhoArqTemporarios”: “C:\\Temp\\”,
“Bases”: [
{
“Servidor”: “1.1.0.1”,
“Database”: “Teste”
}
]
}
[/code]

Listagem 2: Arquivo teste.json

O conteúdo de teste.json antes das modificações pode ser visualizado na Imagem 2.

Imagem 2: Arquivo teste.json antes das alterações

Na Listagem 3 encontra-se um exemplo de trecho de código empregado no teste da classe JSONFileHelper:

• Um objeto dinâmico será gerado a partir da invocação do método ObterConteudo de JSONFileHelper;
• O conteúdo da instância obtida será alterado, com isto acontecendo ao se acessar propriedades desta referência por meio de colchetes (“[” e “]”). A atribuição de valores a propriedades que não existiam num primeiro momento (como “CaminhoExecutaveis”) também resultará na geração destes elementos de forma dinâmica;
• Finalmente, a chamada ao método SalvarConteudo de JSONFileHelper resultará na gravação de novos dados no arquivo teste.json.

[code language=”csharp”]
…

string caminhoArquivo = @”C:\temp\teste.json”;
dynamic conteudo = JSONFileHelper.ObterConteudo(caminhoArquivo);

conteudo[“Bases”][0][“Servidor”] = “1.1.0.2”;
conteudo[“CaminhoExecutaveis”] = “C:\\Sistemas\\”;

JSONFileHelper.SalvarConteudo(caminhoArquivo, conteudo, true);

…
[/code]

Listagem 3: Código para teste da classe JSONFileHelper

Ao se executar tal teste o arquivo teste.json será modificado, como indicando na Imagem 3 (em que as alterações foram destacadas em vermelho).

Imagem 3: Arquivo teste.json após as alterações

Conclusão

A intenção com este artigo foi apresentar uma alternativa simples e eficaz para a modificação de arquivos que contenham informações no padrão JSON. Como demonstrado no exemplo prático, a utilização da biblioteca fornecida pela Newtonsoft e de estruturas como tipos dinâmicos do .NET facilitam em muito este processo.

Espero que este conteúdo possa ter sido útil.

Até uma próxima oportunidade!

Referências

Using Type dynamic (C# Programming Guide)
https://msdn.microsoft.com/en-us/library/dd264736.aspx

Json.NET — Newtonsoft
http://www.newtonsoft.com/json