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 para .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.
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:
Después de una instalación exitosa, agrega la biblioteca a tu proyecto .NET añadiendo la siguiente declaración using:
using Newtonsoft.Json;Imports Newtonsoft.JsonNewtonsoft.JSONEl 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# utilizando el método JsonConvert.DeserializeObject<t>() donde T es el tipo del 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 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 person contendrá los valores de la cadena JSON.
A menudo necesitarás leer o escribir datos JSON de o hacia un archivo. Veamos cómo podemos hacer eso con Newtonsoft.Json. Usaremos la clase File del espacio de nombres System.IO en este caso.
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);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);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)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
}
]
}Puedes usar 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);
}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 debe ser reemplazado por un JObject real inicializado desde el JSON.
Newtonsoft.Json hace que sea fácil modificar y escribir JSON. Supongamos que necesitas actualizar el valor de Age de nuestro objeto Person.
jsonObject["Age"] = 31; // Update the agejsonObject("Age") = 31 ' Update the ageY luego escribirlo de nuevo en una cadena:
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 debe ser reemplazado por un JObject real inicializado desde el 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);
}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 debe ser reemplazado por un JObject real inicializado desde el JSON.
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");
}
}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 ClassSupongamos 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.
Al igual que Newtonsoft.Json, IronPDF también está disponible a través de NuGet. Puedes instalarlo utilizando el siguiente comando:
Luego puedes incluirlo en tu proyecto añadiendo:
using IronPdf;Imports IronPdfEn 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);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, tendrás 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 usan 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>";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>"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 guardar el 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")
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);Dim jsonString As String = File.ReadAllText("data.json")
Dim person = JsonConvert.DeserializeObject(Of Dictionary(Of String, String))(jsonString)Este software crea un diccionario llamado person con claves "FirstName," "LastName," "PhoneNumber," "Email," y "City" y sus valores correspondientes.
A continuación, abrimos el documento PDF usando IronPdf y obtenemos el formulario:
var doc = PdfDocument.FromFile("myPdfForm.pdf");
var form = doc.Form;Dim doc = PdfDocument.FromFile("myPdfForm.pdf")
Dim form = doc.FormAhora podemos usar el diccionario person para llenar 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")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")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.
Primero, usa IronPDF para extraer los metadatos del PDF:
var pdf = IronPdf.PdfDocument.FromFile("document.pdf");
var metadata = pdf.MetaData;Dim pdf = IronPdf.PdfDocument.FromFile("document.pdf")
Dim metadata = pdf.MetaDataLuego, serializamos estos datos en una cadena 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)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."
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.
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.
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, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
