Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
Si alguna vez has trabajado con datos JSON en .NET, probablemente te habrás encontrado con la funciónNewtonsoft.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.
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
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 clase
Persona` 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.
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)
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]
Newtonsoft.Json facilita la modificación y escritura de JSON. Digamos que necesitas actualizar el valor Age
de nuestro objeto Person
.
jsonObject ["Age"] = 31; // update the age
jsonObject ["Age"] = 31; // update the age
jsonObject ("Age") = 31 ' update the age
Y luego escribirlo de nuevo a 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
Dim updatedJson As String = jsonObject.ToString()
File.WriteAllText(path, updatedJson) ' write back to the file
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
Más información sobre IronPDF es una biblioteca muy popular en el ecosistema .NET que permite a los desarrolladorescrear, 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.
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
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")
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.
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.
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 unaprueba gratuita de IronPDF 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 enOpciones de licencia de IronPDF que incluye el acceso continuado a todas las funciones de las que hablamos, así como soporte y 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.
9 productos API .NET para sus documentos de oficina