Newtonsoft Jsonpath (Cómo funciona para desarrolladores)

Si alguna vez has trabajado con datos JSON en .NET, probablemente te habrás encontrado con la función Newtonsoft.Json un conocido marco JSON de alto rendimiento para .NET. Este tutorial pretende ayudar a los principiantes y a los usuarios intermedios a comprender y utilizar eficazmente esta potente biblioteca, centrándose en sus referencias de sistema, documentación y cualquier actualización de versiones relevante.

Primeros pasos

Para empezar a utilizar Newtonsoft.Json, primero debe instalarlo en su proyecto .NET. Esto puede hacerse a través de NuGet, el gestor de paquetes .NET. En la consola del gestor de paquetes NuGet, escriba:

Install-Package Newtonsoft.Json

Tras la instalación, añada la biblioteca a su proyecto .NET mediante la siguiente sentencia using:

using Newtonsoft.Json;

using Newtonsoft.Json;

Imports Newtonsoft.Json

Análisis de JSON con Newtonsoft.JSON.

Parsear JSON es esencialmente el proceso de convertir una cadena en formato JSON en una estructura de datos utilizable en su aplicación .NET. Con Newtonsoft.Json, el proceso es sencillo.

Veamos un ejemplo de objeto JSON para una persona:

{
    "Name": "Iron Developer",
    "Age": 30,
    "Email": "irondeveloper@ironsoftware.com"
}

Podemos convertir esta cadena JSON en un objeto C# utilizando la función JsonConvert.DeserializeObject<T>()donde **T** es el tipo del objeto que queremos crear. En este caso, crearemos una clasePersona` y parsearemos el JSON en ella.

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)

Ahora, el objeto persona contendrá los valores de la cadena JSON.

Trabajar con archivos JSON

A menudo necesitarás leer o escribir datos JSON desde o hacia un archivo. Veamos cómo podemos hacerlo con Newtonsoft.Json. En este caso utilizaremos la clase File del espacio de nombres System.IO.

Para leer un archivo JSON y convertirlo en un 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)

Para escribir un objeto en un archivo 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)

Trabajar con matrices

En algunos casos, tu JSON incluirá arrays. Por ejemplo, un objeto Persona puede tener un array de Amigos:

{
    "Name": "John Doe",
    "Friends": [
        {
            "Name": "Jane Doe",
            "Age": 28
        },
        {
            "Name": "Billy",
            "Age": 25
        }
    ]
}

Puedes utilizar el bucle foreach para iterar sobre el 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]

Modificación y escritura de JSON

Newtonsoft.Json facilita la modificación y escritura de JSON. Digamos que necesitas actualizar el valor Age de nuestro objeto Person.

jsonObject ["Age"] = 31; //  actualizar la edad

jsonObject ["Age"] = 31; //  actualizar la edad

jsonObject ("Age") = 31 '  actualizar la edad

Y luego escribirlo de nuevo a una cadena:

string updatedJson = jsonObject.ToString();
File.WriteAllText(path, updatedJson); //  volver a escribir en el archivo

string updatedJson = jsonObject.ToString();
File.WriteAllText(path, updatedJson); //  volver a escribir en el archivo

Dim updatedJson As String = jsonObject.ToString()
File.WriteAllText(path, updatedJson) '  volver a escribir en el archivo

LINQ a JSON

Newtonsoft.Json también proporciona funciones para consultar y manipular objetos JSON mediante LINQ (Idioma Consulta integrada). Esto es muy potente, ya que te permite utilizar todos los operadores LINQ estándar para consultar un objeto JSON de la misma forma que lo harías con XML o una colección de objetos.

Aquí tienes un ejemplo que muestra cómo puedes obtener los nombres de todos los Amigos menores de 30 años:

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

Introducción a IronPDF

IronPDF es una biblioteca muy popular en el ecosistema .NET que permite a los desarrolladores crear editar y extraer datos de archivos PDF. Es increíblemente versátil y funciona bien con otras bibliotecas, incluida Newtonsoft.Json.

Supongamos que tenemos un requisito en el que tenemos datos JSON, y queremos crear un informe PDF a partir de esos datos. Podemos utilizar Newtonsoft.Json para analizar los datos JSON y IronPDF para crear el PDF. Veamos cómo hacerlo.

Instalación de IronPDF

Al igual que Newtonsoft.Json, IronPDF también está disponible a través de NuGet. Puede instalarlo utilizando el siguiente comando:

Install-Package IronPdf

A continuación, puede incluirlo en su proyecto añadiendo:

using IronPdf;

using IronPdf;

Imports IronPdf

Caso práctico 1 Creación de PDF a partir de datos JSON

En referencia a este caso de uso, demostraremos cómo utilizar Newtonsoft.Json e IronPDF para generar un informe PDF a partir de datos JSON. Esto podría ser especialmente útil para aplicaciones que crean informes dinámicos basados en datos almacenados en formato JSON.

He aquí un ejemplo de archivo JSON con el que trabajaremos:

{
    "Title": "Sales Report",
    "Month": "August",
    "Year": "2023",
    "TotalSales": "10000",
    "ItemsSold": "500"
}

Estos datos JSON representan un simple informe de ventas.

El primer paso es leer el archivo JSON, llamado 'data.json' aquí, y parsearlo en un diccionario usando 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)

Después de ejecutar este código, esperamos que tengas un diccionario llamado reportData que contiene pares clave-valor que representan las propiedades y sus valores en el archivo JSON.

A continuación, generamos una plantilla HTML utilizando los datos de reportData. Las claves del diccionario reportData se utilizan para insertar los valores apropiados en el 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>"

Por último, utilizamos IronPDF para convertir el código HTML en un documento PDF. Usamos ChromePdfRenderer para crear un renderizador de PDF, usarlo para convertir el HTML a PDF, y luego guardar el 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")

Caso práctico 2 Formulario de JSON a PDF

En este caso de uso, leeremos datos JSON para rellenar campos de formulario en un documento PDF. Para este ejemplo, consideremos que tenemos los siguientes datos JSON:

{
    "FirstName": "John",
    "LastName": "Smith",
    "PhoneNumber": "+19159969739",
    "Email": "John@email.com",
    "City": "Chicago"
}

Este JSON representa la información personal de una persona.

En primer lugar, utilizamos Newtonsoft.Json para leer los datos JSON del archivo y parsearlos en un diccionario:

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)

Este programa crea un diccionario llamado persona con las claves "Nombre," "Apellido," "NúmeroDeTeléfono," "Correo," y "Ciudad" y sus valores correspondientes.

A continuación, abrimos el documento PDF con IronPdf y obtenemos el formulario:

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

Ahora podemos utilizar el diccionario persona para rellenar los campos del formulario en el 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")

Cada campo del formulario está asociado a una clave del diccionario de personas.

Por último, guardamos el formulario PDF cumplimentado:

doc.SaveAs("myPdfForm_filled.pdf");

doc.SaveAs("myPdfForm_filled.pdf");

doc.SaveAs("myPdfForm_filled.pdf")

Este método creará un nuevo documento PDF con los campos del formulario rellenados con los datos del archivo JSON.

Esto demuestra cómo se puede utilizar eficazmente Newtonsoft.Json para analizar datos JSON y IronPDF para manipular documentos PDF.

Caso práctico 3 Metadatos PDF a JSON

En primer lugar, utilice IronPDF para extraer los metadatos del 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

A continuación, serialice estos datos en una cadena JSON utilizando 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)

En este código, el objeto metadata contiene propiedades como Author, Title, CreateDate, etc. Éstas se serializan en una cadena JSON y se escriben en un archivo llamado "metadata.json".

La combinación de Newtonsoft.Json e IronPDF permite convertir datos entre archivos PDF y JSON, satisfaciendo una amplia gama de casos de uso.

Conclusión

En conclusión, Newtonsoft.Json e IronPDF ofrecen conjuntamente una solución potente y flexible para manejar datos JSON y generar archivos PDF en .NET. Al analizar datos JSON en objetos o diccionarios .NET con Newtonsoft.Json, podemos manipular esos datos y utilizarlos en diversos contextos, como rellenar formularios PDF o generar informes PDF dinámicos a partir de plantillas. IronPDF hace que el proceso de creación y gestión de PDF sea sencillo y eficaz.

Este artículo presenta las bibliotecas, destacando algunas de sus funciones básicas. Sin embargo, ambas bibliotecas tienen mucho más que ofrecer. Recomendamos encarecidamente consultar su extensa documentación para profundizar en sus funciones y capacidades.

Si estás interesado en probar IronPDF, ofrecen una prueba gratuita para que pueda explorar sus características y evaluar si satisface sus necesidades antes de comprarlo. Una vez que decida continuar con IronPDF, la licencia comienza en $749, que incluye el acceso continuo a todas las características que hemos discutido y el apoyo y las actualizaciones. De este modo, dispondrá de las herramientas y la asistencia necesarias para generar, gestionar y manipular archivos PDF con eficacia en sus proyectos .NET.