Newtonsoft Jsonpath (Comment ça marche pour les développeurs)

Si vous avez déjà travaillé avec des données JSON dans .NET, vous avez probablement rencontré la fonctionNewtonsoft.Json un framework JSON très populaire et très performant pour .NET. Ce tutoriel vise à aider les débutants et les utilisateurs intermédiaires à comprendre et à utiliser efficacement cette puissante bibliothèque, en mettant l'accent sur ses références système, sa documentation et toutes les mises à jour pertinentes.

Pour commencer

Pour commencer à utiliser Newtonsoft.Json, vous devez d'abord l'installer dans votre projet .NET. Cela peut se faire par le biais de NuGet, le gestionnaire de paquets .NET. Dans la console du gestionnaire de paquets NuGet, tapez :

Install-Package Newtonsoft.Json

Une fois l'installation réussie, ajoutez la bibliothèque à votre projet .NET en ajoutant l'instruction using suivante :

using Newtonsoft.Json;

using Newtonsoft.Json;

Imports Newtonsoft.Json

Analyse JSON avec Newtonsoft.JSON (en anglais)

L'analyse JSON consiste essentiellement à convertir une chaîne au format JSON en une structure de données utilisable dans votre application .NET. Avec Newtonsoft.Json, le processus est simple.

Examinons un exemple d'objet JSON pour une personne :

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

Nous pouvons analyser cette chaîne JSON en un objet C# à l'aide de la fonction JsonConvert.DeserializeObject<T>() où T est le type de l'objet que nous voulons créer. Dans ce cas, nous allons créer une classe Person et analyser le JSON dans cette classe.

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)

Maintenant, l'objet person contiendra les valeurs de la chaîne JSON.

Travailler avec des fichiers JSON

Vous aurez souvent besoin de lire ou d'écrire des données JSON depuis ou vers un fichier. Voyons comment nous pouvons le faire avec Newtonsoft.Json. Dans ce cas, nous utiliserons la classe File de l'espace de noms System.IO.

Pour lire un fichier JSON et l'analyser en un objet :

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)

Pour écrire un objet dans un fichier 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)

Travailler avec des tableaux

Dans certains cas, votre JSON comprendra des tableaux. Par exemple, un objet Person peut avoir un tableau de Friends :

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

Vous pouvez utiliser la boucle foreach pour itérer sur le tableau 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]

Modifier et écrire JSON

Newtonsoft.Json facilite la modification et l'écriture de JSON. Supposons que vous ayez besoin de mettre à jour la valeur Age de notre objet Person.

jsonObject ["Age"] = 31; // update the age

jsonObject ["Age"] = 31; // update the age

jsonObject ("Age") = 31 ' update the age

Puis l'écrire à nouveau dans une chaîne de caractères :

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

LINQ to JSON

Newtonsoft.Json fournit également des fonctionnalités permettant d'interroger et de manipuler des objets JSON à l'aide de LINQ(Langue Requête intégrée). Cette fonction est très puissante car elle vous permet d'utiliser tous les opérateurs LINQ standard pour interroger un objet JSON, comme vous le feriez avec XML ou une collection d'objets.

Voici un exemple qui montre comment vous pouvez récupérer les noms de tous les amis de moins de 30 ans :

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

Introduction à IronPDF

En savoir plus sur IronPDF est une bibliothèque populaire dans l'écosystème .NET qui permet aux développeurs decréer, modifier et extraire des données de fichiers PDF. Il est incroyablement polyvalent et fonctionne bien avec d'autres bibliothèques, notamment Newtonsoft.Json.

Supposons que nous ayons besoin de données JSON et que nous souhaitions créer un rapport PDF à partir de ces données. Nous pouvons utiliser Newtonsoft.Json pour analyser les données JSON et IronPDF pour créer le PDF. Voyons comment procéder.

Installation d'IronPDF

Comme Newtonsoft.Json, IronPDF est également disponible via NuGet. Vous pouvez l'installer en utilisant la commande suivante :

Install-Package IronPdf

Vous pouvez ensuite l'inclure dans votre projet en ajoutant :

using IronPdf;

using IronPdf;

Imports IronPdf

Cas d'utilisation 1 : Création d'un PDF à partir de données JSON

En référence à ce cas d'utilisation, nous allons montrer comment utiliser Newtonsoft.Json et IronPDF pour générer un rapport PDF à partir de données JSON. Cela pourrait être particulièrement utile pour les applications qui créent des rapports dynamiques basés sur des données stockées dans un format JSON.

Voici un exemple de fichier JSON avec lequel nous allons travailler :

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

Ces données JSON représentent un simple rapport de ventes.

La première étape consiste à lire le fichier JSON, nommé ici "data.json", et à l'analyser en un dictionnaire à l'aide de 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)

Après avoir exécuté ce code, nous pensons que vous aurez un dictionnaire appelé reportData qui contient des paires clé-valeur qui représentent les propriétés et leurs valeurs dans le fichier JSON.

Ensuite, nous générons un modèle HTML en utilisant les données de reportData. Les clés du dictionnaire reportData sont utilisées pour insérer les valeurs appropriées dans le 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>"

Enfin, nous utilisons IronPDF pour convertir le code HTML en document PDF. Nous utilisons ChromePdfRenderer pour créer un moteur de rendu PDF, l'utiliser pour convertir le HTML en PDF, puis enregistrer le 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")

Cas d'utilisation 2 Formulaire JSON vers PDF

Dans ce cas d'utilisation, nous lirons des données JSON pour remplir les champs d'un formulaire dans un document PDF. Pour cet exemple, considérons que nous avons les données JSON suivantes :

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

Ce JSON représente les informations personnelles d'une personne.

Tout d'abord, nous utilisons Newtonsoft.Json pour lire les données JSON du fichier et les analyser dans un dictionnaire :

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)

Ce logiciel crée un dictionnaire appelé "personne" dont les clés sont "Prénom", "Nom", "Numéro de téléphone", "Courriel" et "Ville", ainsi que les valeurs correspondantes.

Ensuite, nous ouvrons le document PDF en utilisant IronPDF et nous obtenons le formulaire :

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

Nous pouvons maintenant utiliser le dictionnaire person pour remplir les champs du formulaire dans le document 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")

Chaque champ du formulaire est associé à une clé du dictionnaire de la personne.

Enfin, nous enregistrons le formulaire PDF rempli :

doc.SaveAs("myPdfForm_filled.pdf");

doc.SaveAs("myPdfForm_filled.pdf");

doc.SaveAs("myPdfForm_filled.pdf")

Cette méthode crée un nouveau document PDF dont les champs du formulaire sont remplis avec les données du fichier JSON.

Ceci démontre comment vous pouvez utiliser efficacement Newtonsoft.Json pour analyser des données JSON et IronPDF pour manipuler des documents PDF.

Cas d'utilisation 3 Métadonnées PDF vers JSON

Tout d'abord, utilisez IronPDF pour extraire les métadonnées du 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

Ensuite, sérialisez ces données dans une chaîne JSON en utilisant 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)

Dans ce code, l'objet metadata contient des propriétés comme Author, Title, CreateDate, etc. Ces propriétés sont sérialisées dans une chaîne JSON et écrites dans un fichier nommé "metadata.json"

La combinaison de Newtonsoft.Json et d'IronPDF vous permet de convertir des données entre des fichiers PDF et JSON, répondant ainsi à un large éventail de cas d'utilisation.

Conclusion

En conclusion, Newtonsoft.Json et IronPDF constituent ensemble une solution puissante et flexible pour manipuler des données JSON et générer des fichiers PDF dans .NET. En analysant les données JSON en objets ou dictionnaires .NET avec Newtonsoft.Json, nous pouvons manipuler ces données et les utiliser dans divers contextes, comme le remplissage de formulaires PDF ou la génération de rapports PDF dynamiques à partir de modèles. IronPDF rend le processus de création et de gestion des PDF simple et efficace.

Cet article présente les bibliothèques en mettant en évidence certaines de leurs fonctionnalités de base. Cependant, les deux bibliothèques ont beaucoup plus à offrir. Nous vous recommandons vivement de consulter leur documentation détaillée pour découvrir en profondeur leurs fonctionnalités et leurs capacités.

Si vous souhaitez essayer IronPDF, ils proposent une offre de service deessai gratuit d'IronPDF vous pouvez ainsi explorer ses caractéristiques et évaluer s'il répond à vos besoins avant de l'acheter. Lorsque vous décidez de poursuivre avec IronPDF, la licence commence àOptions de licence d'IronPDF la traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les fonctionnalités et les avantages de ces outils de développement. Vous disposez ainsi des outils et de l'assistance nécessaires pour générer, gérer et manipuler efficacement des fichiers PDF dans vos projets .NET.