Se você já trabalhou com dados JSON em .NET, provavelmente já se deparou com a biblioteca Newtonsoft.Json , uma estrutura JSON popular e de alto desempenho para .NET. Este tutorial tem como objetivo ajudar usuários iniciantes e intermediários a entender e usar esta poderosa biblioteca de forma eficaz, com foco em suas referências de sistema, documentação e quaisquer atualizações de versão relevantes.
Para começar a usar o Newtonsoft.Json, primeiro você precisa instalá-lo em seu projeto .NET . Isso pode ser feito através do NuGet, o gerenciador de pacotes do .NET . No console do Gerenciador de Pacotes NuGet , digite:
Após a instalação bem-sucedida, adicione a biblioteca ao seu projeto .NET incluindo a seguinte declaração using:
using Newtonsoft.Json;Imports Newtonsoft.JsonNewtonsoft.JSONA análise sintática de JSON é essencialmente o processo de converter uma string em formato JSON em uma estrutura de dados utilizável em sua aplicação .NET . Com o Newtonsoft.Json, o processo é simples.
Vejamos um exemplo de objeto JSON para uma pessoa:
{
"Name": "Iron Developer",
"Age": 30,
"Email": "irondeveloper@ironsoftware.com"
}Podemos analisar esta string JSON em um objeto C# usando o método JsonConvert.DeserializeObject<t>() onde T é o tipo do objeto que queremos criar. Neste caso, vamos criar uma classe Person e analisar o JSON para ela.
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
public string Email { get; set; }
}
string jsonString = "JSON string here";
Person person = JsonConvert.DeserializeObject<Person>(jsonString);Public Class Person
Public Property Name() As String
Public Property Age() As Integer
Public Property Email() As String
End Class
Private jsonString As String = "JSON string here"
Private person As Person = JsonConvert.DeserializeObject(Of Person)(jsonString)Agora, o objeto person conterá os valores da string JSON.
Você frequentemente precisará ler ou gravar dados JSON de ou para um arquivo. Vamos ver como podemos fazer isso com o Newtonsoft.Json. Usaremos a classe File do namespace System.IO neste caso.
Para ler um arquivo JSON e analisá-lo para transformá-lo em um objeto:
string path = "path to your json file";
string jsonString = File.ReadAllText(path);
Person person = JsonConvert.DeserializeObject<Person>(jsonString);Dim path As String = "path to your json file"
Dim jsonString As String = File.ReadAllText(path)
Dim person As Person = JsonConvert.DeserializeObject(Of Person)(jsonString)Para escrever um objeto em um arquivo JSON:
Person person = new Person()
{
Name = "John Doe",
Age = 30,
Email = "johndoe@example.com"
};
string path = "path to your json file";
string jsonString = JsonConvert.SerializeObject(person);
File.WriteAllText(path, jsonString);Dim person As New Person() With {
.Name = "John Doe",
.Age = 30,
.Email = "johndoe@example.com"
}
Dim path As String = "path to your json file"
Dim jsonString As String = JsonConvert.SerializeObject(person)
File.WriteAllText(path, jsonString)Em alguns casos, seu JSON incluirá matrizes. Por exemplo, um objeto Person pode ter um array de Friends:
{
"Name": "John Doe",
"Friends": [
{
"Name": "Jane Doe",
"Age": 28
},
{
"Name": "Billy",
"Age": 25
}
]
}Você pode usar o loop foreach para iterar sobre o array JSON:
JArray friends = (JArray)jsonObject["Friends"];
foreach (JObject friend in friends)
{
string friendName = (string)friend["Name"];
Console.WriteLine(friendName);
}Dim friends As JArray = CType(jsonObject("Friends"), JArray)
For Each [friend] As JObject In friends
Dim friendName As String = CStr([friend]("Name"))
Console.WriteLine(friendName)
Next [friend]Nota: jsonObject deve ser substituído por um JObject real inicializado a partir do JSON.
O Newtonsoft.Json facilita a modificação e a escrita de JSON. Digamos que você precise atualizar o valor Age do nosso objeto Person.
jsonObject["Age"] = 31; // Update the agejsonObject("Age") = 31 ' Update the ageE depois escreva-o de volta em uma string:
string updatedJson = jsonObject.ToString();
File.WriteAllText(path, updatedJson); // Write back to the fileDim updatedJson As String = jsonObject.ToString()
File.WriteAllText(path, updatedJson) ' Write back to the fileNota: jsonObject deve ser substituído por um JObject real inicializado a partir do JSON.
O Newtonsoft.Json também oferece funcionalidades para consultar e manipular objetos JSON usando LINQ (Language Integrated Query). Isso é muito poderoso, pois permite usar todos os operadores LINQ padrão para consultar um objeto JSON da mesma forma que você faria com XML ou uma coleção de objetos.
Aqui está um exemplo de como você pode obter os nomes de todos os amigos com menos de 30 anos:
var youngFriends = jsonObject["Friends"].Where(f => (int)f["Age"] < 30)
.Select(f => (string)f["Name"]);
foreach (string name in youngFriends)
{
Console.WriteLine(name);
}Imports System
Dim youngFriends = jsonObject("Friends").Where(Function(f) CInt(Math.Truncate(f("Age"))) < 30).Select(Function(f) CStr(f("Name")))
For Each name As String In youngFriends
Console.WriteLine(name)
Next nameNota: jsonObject deve ser substituído por um JObject real inicializado a partir do JSON.
Saiba mais sobre o IronPDF , uma biblioteca popular no ecossistema .NET que permite aos desenvolvedores criar, editar e extrair dados de arquivos PDF . É incrivelmente versátil e funciona perfeitamente com outras bibliotecas, incluindo Newtonsoft.Json.
O IronPDF se destaca na conversão de HTML para PDF , garantindo a preservação precisa dos layouts e estilos originais. É perfeito para criar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. Com suporte para arquivos HTML, URLs e strings HTML brutas, o IronPDF produz facilmente documentos PDF de alta qualidade.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim renderer = New ChromePdfRenderer()
' 1. Convert HTML String to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' 2. Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' 3. Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End ClassVamos supor que temos um requisito em que possuímos dados JSON e queremos criar um relatório em PDF a partir desses dados. Podemos usar o Newtonsoft.Json para analisar os dados JSON e o IronPDF para criar o PDF. Vamos ver como podemos fazer isso.
Assim como o Newtonsoft.Json, o IronPDF também está disponível através do NuGet. Você pode instalá-lo usando o seguinte comando:
Em seguida, você pode incluí-lo em seu projeto adicionando:
using IronPdf;Imports IronPdfNeste caso de uso, demonstraremos como usar Newtonsoft.Json e IronPDF para gerar um relatório em PDF a partir de dados JSON. Isso pode ser particularmente útil para aplicações que criam relatórios dinâmicos com base em dados armazenados em formato JSON.
Aqui está um exemplo de arquivo JSON com o qual trabalharemos:
{
"Title": "Sales Report",
"Month": "August",
"Year": "2023",
"TotalSales": "10000",
"ItemsSold": "500"
}Esses dados JSON representam um relatório de vendas simples.
O primeiro passo é ler o arquivo JSON, chamado aqui de 'data.json', e analisá-lo para transformá-lo em um dicionário usando o Newtonsoft.Json:
string jsonString = File.ReadAllText("data.json");
var reportData = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonString);Dim jsonString As String = File.ReadAllText("data.json")
Dim reportData = JsonConvert.DeserializeObject(Of Dictionary(Of String, String))(jsonString)Após a execução deste código, você terá um dicionário chamado reportData contendo pares chave-valor representando as propriedades e seus valores no arquivo JSON.
Em seguida, geramos um modelo HTML usando os dados de reportData. As chaves do dicionário reportData são usadas para inserir os valores apropriados no HTML:
string htmlContent = $@"
<html>
<head><title>{reportData["Title"]}</title></head>
<body>
<h1>{reportData["Title"]}</h1>
<p>Month: {reportData["Month"]}</p>
<p>Year: {reportData["Year"]}</p>
<p>Total Sales: {reportData["TotalSales"]}</p>
<p>Items Sold: {reportData["ItemsSold"]}</p>
</body>
</html>";Dim htmlContent As String = $"
<html>
<head><title>{reportData("Title")}</title></head>ignoreignore<body><h1>{reportData("Title")}</h1><p>Month: {reportData("Month")}</p><p>Year: {reportData("Year")}</p><p>Total Sales: {reportData("TotalSales")}</p><p>Items Sold: {reportData("ItemsSold")}</p></body></html>"Por fim, utilizamos o IronPDF para converter o código HTML em um documento PDF. Usamos ChromePdfRenderer para criar um renderizador de PDF, usá-lo para converter o HTML em um PDF e depois salvar o PDF:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("Report.pdf");Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("Report.pdf")
Neste caso de uso, leremos dados JSON para preencher campos de formulário em um documento PDF. Para este exemplo, vamos considerar que temos os seguintes dados JSON:
{
"FirstName": "John",
"LastName": "Smith",
"PhoneNumber": "+19159969739",
"Email": "John@email.com",
"City": "Chicago"
}Este JSON representa informações pessoais de uma pessoa.
Primeiro, usamos Newtonsoft.Json para ler os dados JSON do arquivo e analisá-los em um dicionário:
string jsonString = File.ReadAllText("data.json");
var person = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonString);Dim jsonString As String = File.ReadAllText("data.json")
Dim person = JsonConvert.DeserializeObject(Of Dictionary(Of String, String))(jsonString)Este software cria um dicionário chamado person com chaves "FirstName," "LastName," "PhoneNumber," "Email," e "City" e seus valores correspondentes.
Em seguida, abrimos o documento PDF usando IronPdf e obtemos o formulário:
var doc = PdfDocument.FromFile("myPdfForm.pdf");
var form = doc.Form;Dim doc = PdfDocument.FromFile("myPdfForm.pdf")
Dim form = doc.FormAgora podemos usar o dicionário person para preencher os campos do formulário no documento PDF:
form.Fields[0].Value = person["FirstName"];
form.Fields[1].Value = person["LastName"];
form.Fields[2].Value = person["PhoneNumber"];
form.Fields[3].Value = person["Email"];
form.Fields[4].Value = person["City"];form.Fields(0).Value = person("FirstName")
form.Fields(1).Value = person("LastName")
form.Fields(2).Value = person("PhoneNumber")
form.Fields(3).Value = person("Email")
form.Fields(4).Value = person("City")Cada campo do formulário está associado a uma chave do dicionário da pessoa .
Por fim, salvamos o formulário PDF preenchido:
doc.SaveAs("myPdfForm_filled.pdf");doc.SaveAs("myPdfForm_filled.pdf")Este método criará um novo documento PDF com os campos do formulário preenchidos com os dados do arquivo JSON.
Isso demonstra como você pode usar efetivamente Newtonsoft.Json para analisar dados JSON e IronPDF para manipular documentos PDF.
Primeiro, utilize o IronPDF para extrair os metadados do PDF:
var pdf = IronPdf.PdfDocument.FromFile("document.pdf");
var metadata = pdf.MetaData;Dim pdf = IronPdf.PdfDocument.FromFile("document.pdf")
Dim metadata = pdf.MetaDataEntão, serialize esses dados em uma string JSON usando Newtonsoft.Json:
string jsonString = JsonConvert.SerializeObject(metadata, Formatting.Indented);
File.WriteAllText("metadata.json", jsonString);Dim jsonString As String = JsonConvert.SerializeObject(metadata, Formatting.Indented)
File.WriteAllText("metadata.json", jsonString)Neste código, o objeto metadata contém propriedades como Author, Title, CreateDate, etc. Estas são serializadas em uma string JSON e escritas em um arquivo chamado "metadata.json".
A combinação do Newtonsoft.Json com o IronPDF permite converter dados entre arquivos PDF e JSON, atendendo a uma ampla gama de casos de uso.
Em resumo, Newtonsoft.Json e IronPDF juntos fornecem uma solução poderosa e flexível para manipular dados JSON e gerar arquivos PDF em .NET. Ao analisar dados JSON e convertê-los em objetos ou dicionários .NET com Newtonsoft.Json, podemos manipular esses dados e usá-los em diversos contextos, como preencher formulários PDF ou gerar relatórios PDF dinâmicos a partir de modelos. O IronPDF torna o processo de criação e gerenciamento de PDFs simples e eficiente.
Este artigo apresentou as bibliotecas, destacando algumas de suas principais funcionalidades. No entanto, ambas as bibliotecas têm muito mais a oferecer. Recomendamos vivamente que consulte a sua extensa documentação para uma análise aprofundada das suas funcionalidades e capacidades.
Se você estiver interessado em experimentar o IronPDF, eles oferecem um IronPDF de teste gratuito para que você possa explorar seus recursos e avaliar se ele atende às suas necessidades antes de comprar. Após decidir continuar com o IronPDF, o licenciamento começa em Opções de Licenciamento do IronPDF , que inclui acesso contínuo a todos os recursos que discutimos, além de suporte e atualizações. Isso garante que você tenha as ferramentas e a assistência necessárias para gerar, gerenciar e manipular arquivos PDF de forma eficaz em seus projetos .NET .
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
