Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. .NET Ayuda
  4. Newtonsoft Jsonpath
.NET AYUDA

Newtonsoft Jsonpath (Cómo funciona para desarrolladores)

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
Actualizado:

Si alguna vez has trabajado con datos JSON en .NET, probablemente te hayas encontrado con la biblioteca Newtonsoft.Json, un marco JSON popular de alto rendimiento for .NET. Este tutorial tiene como objetivo ayudar a los principiantes y usuarios intermedios a entender y usar eficazmente esta poderosa biblioteca, centrándose en sus referencias de sistema, documentación y cualquier actualización de lanzamiento relevante.

Empezando

Para empezar a usar Newtonsoft.Json, primero necesitas instalarlo en tu proyecto .NET. Esto se puede hacer a través de NuGet, el gestor de paquetes de .NET. En la Consola del Administrador de Paquetes NuGet, escribe:

Install-Package Newtonsoft.Json

Después de una instalación exitosa, agrega la biblioteca a tu proyecto .NET añadiendo la siguiente declaración using:

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

Analizando JSON con Newtonsoft.JSON

El análisis de JSON es esencialmente el proceso de convertir una cadena en formato JSON en una estructura de datos utilizable en tu aplicación .NET. Con Newtonsoft.Json, el proceso es sencillo.

Veamos un objeto JSON de ejemplo para una persona:

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

Podemos analizar esta cadena JSON en un objeto C# usando el método JsonConvert.DeserializeObject<t>() donde T es el tipo de objeto que queremos crear. En este caso, crearemos una clase Person y analizaremos 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);
$vbLabelText   $csharpLabel

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

Trabajar con archivos JSON

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

Para leer un archivo JSON y analizarlo 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);
$vbLabelText   $csharpLabel

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

Trabajar con matrices

En algunos casos, tu JSON incluirá arreglos. Por ejemplo, un objeto Person podría tener una matriz de Friends:

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

Puede utilizar el bucle foreach para iterar sobre la matriz 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);
}
$vbLabelText   $csharpLabel

Nota: jsonObject debe reemplazarse con un JObject real inicializado desde el JSON.

Modificación y escritura de JSON

Newtonsoft.Json hace que sea fácil modificar y escribir JSON. Digamos que necesita actualizar el valor Age de nuestro objeto Person.

jsonObject["Age"] = 31; // Update the age
jsonObject["Age"] = 31; // Update the age
$vbLabelText   $csharpLabel

Y luego escribirlo de nuevo en una cadena:

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

Nota: jsonObject debe reemplazarse con un JObject real inicializado desde el JSON.

LINQ a JSON

Newtonsoft.Json también proporciona funcionalidad para consultar y manipular objetos JSON utilizando LINQ (Language Integrated Query). Esto es muy poderoso ya que te permite usar todos los operadores estándar de LINQ para consultar un objeto JSON tal como lo harías con XML o una colección de objetos.

Aquí hay un ejemplo que muestra cómo puedes obtener los nombres de todos los Friends menores de 30:

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

Nota: jsonObject debe reemplazarse con un JObject real inicializado desde el JSON.

Introducción a IronPDF

Conoce IronPDF es una biblioteca 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 perfectamente con otras bibliotecas, incluida Newtonsoft.Json.

IronPDF se destaca en la conversión de HTML a PDF, asegurando la preservación precisa de los diseños y estilos originales. Es perfecto para crear PDFs a partir de contenido basado en la web como informes, facturas y documentación. Con soporte para archivos HTML, URLs y cadenas HTML en bruto, IronPDF produce fácilmente documentos PDF de alta calidad.

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

Supongamos que tenemos un requisito donde tenemos datos JSON y queremos crear un informe PDF a partir de esos datos. Podemos usar Newtonsoft.Json para analizar los datos JSON e IronPDF para crear el PDF. Veamos cómo podemos hacer esto.

Instalación de IronPDF

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

Install-Package IronPdf

Luego puedes incluirlo en tu proyecto añadiendo:

using IronPdf;
using IronPdf;
$vbLabelText   $csharpLabel

Caso de uso 1: Creación de PDF a partir de datos JSON

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

Aquí hay un archivo JSON de ejemplo con el que trabajaremos:

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

Estos datos JSON representan un informe de ventas simple.

El primer paso es leer el archivo JSON, llamado 'data.json' aquí, y analizarlo 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);
$vbLabelText   $csharpLabel

Después de ejecutar este código, tendrá 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>";
$vbLabelText   $csharpLabel

Finalmente, usamos IronPDF para convertir el código HTML en un documento PDF. Usamos ChromePdfRenderer para crear un renderizador de PDF, lo usamos para convertir el HTML a PDF y luego guardamos 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");
$vbLabelText   $csharpLabel

Newtonsoft Jsonpath (Cómo funciona para desarrolladores): Figura 1

Caso de uso 2: Formulario de JSON a PDF

En este caso de uso, leeremos datos JSON para completar 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"
}

Estos datos JSON representan información personal de una persona.

Primero, usamos Newtonsoft.Json para leer los datos JSON del archivo y analizarlos 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);
$vbLabelText   $csharpLabel

Este software crea un diccionario llamado person con las claves "FirstName," "LastName," "PhoneNumber," "Email," y "City" y sus valores correspondientes.

A continuación, abrimos el documento PDF usando IronPdf y obtenemos el formato:

var doc = PdfDocument.FromFile("myPdfForm.pdf");
var form = doc.Form;
var doc = PdfDocument.FromFile("myPdfForm.pdf");
var form = doc.Form;
$vbLabelText   $csharpLabel

Ahora podemos usar el diccionario person para completar 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"];
$vbLabelText   $csharpLabel

Cada campo del formulario está asociado con una clave del diccionario del person.

Finalmente, guardamos el formulario PDF completado:

doc.SaveAs("myPdfForm_filled.pdf");
doc.SaveAs("myPdfForm_filled.pdf");
$vbLabelText   $csharpLabel

Este método creará un nuevo documento PDF con los campos del formulario completados 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.

Newtonsoft Jsonpath (Cómo funciona para desarrolladores): Figura 2

Caso de uso 3: Metadatos PDF a JSON

Primero, usa 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;
$vbLabelText   $csharpLabel

Luego, serialice estos datos en una cadena 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);
$vbLabelText   $csharpLabel

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

Newtonsoft Jsonpath (Cómo funciona para desarrolladores): Figura 3

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

Conclusión

Para concluir, juntos, Newtonsoft.Json e IronPDF proporcionan una solución poderosa y flexible para manejar datos JSON y generar archivos PDF en .NET. Al analizar datos JSON en objetos o diccionarios de .NET con Newtonsoft.Json, podemos manipular esos datos y usarlos en varios contextos, como llenar formularios PDF o generar informes PDF dinámicos a partir de plantillas. IronPDF hace que el proceso de crear y gestionar PDFs sea sencillo y eficiente.

Este artículo introdujo las bibliotecas, destacando alguna de sus funcionalidades principales. Sin embargo, ambas bibliotecas tienen mucho más que ofrecer. Recomendamos encarecidamente revisar su amplia documentación para profundizar en sus características y capacidades.

Si estás interesado en probar IronPDF, ofrecen una prueba gratuita de IronPDF para que puedas explorar sus características y evaluar si satisface tus necesidades antes de comprar. Una vez que decidas continuar con IronPDF, la licencia comienza en Opciones de Licencias de IronPDF que incluye acceso continuo a todas las características que discutimos y soporte y actualizaciones. Esto asegura que tienes las herramientas y asistencia para generar, gestionar y manipular efectivamente archivos PDF en tus proyectos .NET.

Preguntas Frecuentes

¿Cómo instalo Newtonsoft.Json para trabajar con JSON en .NET?

Puedes instalar la biblioteca Newtonsoft.Json en tu proyecto .NET utilizando el Administrador de Paquetes NuGet. Ejecuta el comando Install-Package Newtonsoft.Json en la Consola del Administrador de Paquetes. Una vez instalado, inclúyelo en tu proyecto con using Newtonsoft.Json;.

¿Para qué se utiliza JsonConvert.DeserializeObject()?

El método JsonConvert.DeserializeObject() se utiliza para analizar datos JSON en objetos .NET. Convierte cadenas JSON en objetos del tipo T, permitiéndote trabajar con datos JSON en tus aplicaciones C#.

¿Cómo puedo manipular datos JSON usando LINQ?

LINQ to JSON es una característica proporcionada por Newtonsoft.Json, que te permite consultar y manipular objetos JSON usando la sintaxis de LINQ. Esto es útil para filtrar o buscar datos JSON de manera eficiente dentro de tus aplicaciones .NET.

¿Cómo genero un informe PDF a partir de datos JSON?

Para generar un informe PDF a partir de datos JSON, primero convierte el JSON en objetos .NET usando Newtonsoft.Json. Luego, crea una plantilla HTML usando estos datos. Usa el ChromePdfRenderer de IronPDF para convertir la plantilla HTML en un documento PDF.

¿Puedo llenar formularios PDF usando datos JSON?

Sí, puedes llenar formularios PDF con datos JSON analizando el JSON en un diccionario usando Newtonsoft.Json, luego ingresando estos datos en los campos del formulario PDF usando IronPDF, antes de guardar el documento PDF llenado.

¿Cómo puedo convertir metadatos de PDF a JSON?

Extrae los metadatos de un PDF usando IronPDF y conviértelos en una cadena JSON usando Newtonsoft.Json. Este proceso te permite almacenar y manipular fácilmente metadatos de PDF en formato JSON.

¿Cuáles son las ventajas de usar Newtonsoft.Json e IronPDF juntos?

Usar Newtonsoft.Json con IronPDF en una aplicación .NET proporciona una forma fluida de manejar datos JSON y generar o manipular archivos PDF, facilitando tareas como generación de informes dinámicos, llenado de formularios e intercambio de datos.

¿Cómo leo y escribo archivos JSON en .NET?

Para leer un archivo JSON, utiliza File.ReadAllText para cargar la cadena JSON, luego análízala con JsonConvert.DeserializeObject. Para escribir JSON, serializa un objeto usando JsonConvert.SerializeObject y guárdalo con File.WriteAllText.

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
  Chatea con el equipo de ingeniería ahora
Director de Tecnología

Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me