Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Ajuda do .NET
  4. Newtonsoft Jsonpath
AJUDA DO .NET

Newtonsoft Jsonpath (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

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 for .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.

Começando

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:

Install-Package Newtonsoft.Json

Após a instalação bem-sucedida, adicione a biblioteca ao seu projeto .NET incluindo a seguinte declaração using:

using Newtonsoft.Json;
using Newtonsoft.Json;
Imports Newtonsoft.Json
$vbLabelText   $csharpLabel

Analisando JSON com Newtonsoft.JSON

A 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, criaremos uma classe Person e analisaremos o JSON para dentro dela.

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 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)
$vbLabelText   $csharpLabel

Agora, o objeto person conterá os valores da string JSON.

Trabalhando com arquivos JSON

Você frequentemente precisará ler ou gravar dados JSON de ou para um arquivo. Vamos ver como podemos fazer isso com o Newtonsoft.Json. Neste caso, usaremos a classe File do namespace System.IO.

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);
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)
$vbLabelText   $csharpLabel

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);
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)
$vbLabelText   $csharpLabel

Trabalhando com Matrizes

Em alguns casos, seu JSON incluirá matrizes. Por exemplo, um objeto Person pode ter uma matriz 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);
}
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]
$vbLabelText   $csharpLabel

Nota: jsonObject deve ser substituído por um JObject real inicializado a partir do JSON.

Modificando e escrevendo 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 age
jsonObject["Age"] = 31; // Update the age
jsonObject("Age") = 31 ' Update the age
$vbLabelText   $csharpLabel

E depois escreva-o de volta em uma string:

string updatedJson = jsonObject.ToString();
File.WriteAllText(path, updatedJson); // Write back to the file
string updatedJson = jsonObject.ToString();
File.WriteAllText(path, updatedJson); // Write back to the file
Dim updatedJson As String = jsonObject.ToString()
File.WriteAllText(path, updatedJson) ' Write back to the file
$vbLabelText   $csharpLabel

Nota: jsonObject deve ser substituído por um JObject real inicializado a partir do JSON.

LINQ para 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);
}
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 name
$vbLabelText   $csharpLabel

Nota: jsonObject deve ser substituído por um JObject real inicializado a partir do JSON.

Introdução ao IronPDF

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");
    }
}
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 Class
$vbLabelText   $csharpLabel

Vamos 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.

Instalação do IronPDF

Assim como o Newtonsoft.Json, o IronPDF também está disponível através do NuGet. Você pode instalá-lo usando o seguinte comando:

Install-Package IronPdf

Em seguida, você pode incluí-lo em seu projeto adicionando:

using IronPdf;
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Caso de uso 1: Criação de PDF a partir de dados JSON

Neste 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);
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)
$vbLabelText   $csharpLabel

Após executar este código, você terá um dicionário chamado reportData contendo pares de 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>";
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>"
$vbLabelText   $csharpLabel

Por fim, utilizamos o IronPDF para converter o código HTML em um documento PDF. Usamos ChromePdfRenderer para criar um renderizador de PDF, usamos esse renderizador para converter o HTML em PDF e, em seguida, salvamos o PDF:

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("Report.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")
$vbLabelText   $csharpLabel

Newtonsoft Jsonpath (Como funciona para desenvolvedores): Figura 1

Caso de uso 2: Formulário JSON para 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);
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)
$vbLabelText   $csharpLabel

Este software cria um dicionário chamado person com as 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;
var doc = PdfDocument.FromFile("myPdfForm.pdf");
var form = doc.Form;
Dim doc = PdfDocument.FromFile("myPdfForm.pdf")
Dim form = doc.Form
$vbLabelText   $csharpLabel

Agora 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"];
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")
$vbLabelText   $csharpLabel

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");
doc.SaveAs("myPdfForm_filled.pdf")
$vbLabelText   $csharpLabel

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 o Newtonsoft.Json para analisar dados JSON e o IronPDF para manipular documentos PDF.

Newtonsoft Jsonpath (Como funciona para desenvolvedores): Figura 2

Caso de uso 3: Metadados de PDF para JSON

Primeiro, utilize o IronPDF para extrair os metadados do PDF:

var pdf = IronPdf.PdfDocument.FromFile("document.pdf");
var metadata = pdf.MetaData;
var pdf = IronPdf.PdfDocument.FromFile("document.pdf");
var metadata = pdf.MetaData;
Dim pdf = IronPdf.PdfDocument.FromFile("document.pdf")
Dim metadata = pdf.MetaData
$vbLabelText   $csharpLabel

Em seguida, serialize esses dados em uma string JSON usando Newtonsoft.Json:

string jsonString = JsonConvert.SerializeObject(metadata, Formatting.Indented);
File.WriteAllText("metadata.json", jsonString);
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)
$vbLabelText   $csharpLabel

Neste código, o objeto metadata contém propriedades como Author, Title, CreateDate, etc. Estas são serializadas em uma string JSON e gravadas em um arquivo chamado "metadata.json".

Newtonsoft Jsonpath (Como funciona para desenvolvedores): Figura 3

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.

Conclusão

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 .

Perguntas frequentes

Como faço para instalar o Newtonsoft.Json para trabalhar com JSON no .NET?

Você pode instalar a biblioteca Newtonsoft.Json em seu projeto .NET usando o Gerenciador de Pacotes NuGet. Execute o comando Install-Package Newtonsoft.Json no Console do Gerenciador de Pacotes. Após a instalação, inclua-a em seu projeto com using Newtonsoft.Json; .

Para que serve JsonConvert.DeserializeObject()?

O método JsonConvert.DeserializeObject() é usado para analisar dados JSON em objetos .NET. Ele converte cadeias de caracteres JSON em objetos do tipo T, permitindo que você trabalhe com dados JSON em suas aplicações C#.

Como posso manipular dados JSON usando LINQ?

LINQ to JSON é um recurso fornecido pelo Newtonsoft.Json que permite consultar e manipular objetos JSON usando a sintaxe LINQ. Isso é útil para filtrar ou pesquisar dados JSON de forma eficiente em seus aplicativos .NET.

Como faço para gerar um relatório em PDF a partir de dados JSON?

Para gerar um relatório em PDF a partir de dados JSON, primeiro converta o JSON em objetos .NET usando o Newtonsoft.Json. Em seguida, crie um modelo HTML usando esses dados. Utilize ChromePdfRenderer do IronPDF para converter o modelo HTML em um documento PDF.

Posso preencher formulários PDF usando dados JSON?

Sim, você pode preencher formulários PDF com dados JSON, analisando o JSON e transformando-o em um dicionário usando o Newtonsoft.Json. Em seguida, preencha os campos do formulário PDF com esses dados usando o IronPDF e, por fim, salve o documento PDF preenchido.

Como posso converter metadados de PDF para JSON?

Extraia os metadados de um PDF usando o IronPDF e converta-os em uma string JSON usando o Newtonsoft.Json. Esse processo permite armazenar e manipular facilmente os metadados de PDFs em formato JSON.

Quais são as vantagens de usar Newtonsoft.Json e IronPDF em conjunto?

Utilizar o Newtonsoft.Json com o IronPDF em uma aplicação .NET proporciona uma maneira integrada de lidar com dados JSON e gerar ou manipular arquivos PDF, facilitando tarefas como geração dinâmica de relatórios, preenchimento de formulários e intercâmbio de dados.

Como faço para ler e gravar arquivos JSON em .NET?

Para ler um arquivo JSON, use File.ReadAllText para carregar a string JSON e, em seguida, analise-a com JsonConvert.DeserializeObject . Para gravar JSON, serialize um objeto usando JsonConvert.SerializeObject e salve-o com File.WriteAllText .

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

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 ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim