Newtonsoft Jsonpath (Wie es für Entwickler funktioniert)

Wenn Sie jemals mit JSON-Daten in .NET gearbeitet haben, sind Sie wahrscheinlich schon auf das Newtonsoft.Json bibliothek, einem beliebten und leistungsstarken JSON-Framework für .NET. Dieses Tutorial soll Anfängern und fortgeschrittenen Anwendern helfen, diese leistungsstarke Bibliothek effektiv zu verstehen und zu nutzen. Der Schwerpunkt liegt dabei auf den Systemreferenzen, der Dokumentation und allen relevanten Aktualisierungen.

Erste Schritte

Um Newtonsoft.Json verwenden zu können, müssen Sie es zunächst in Ihr .NET-Projekt installieren. Dies kann über NuGet, den .NET-Paketmanager, erfolgen. Geben Sie in der NuGet-Paketmanager-Konsole ein:

Install-Package Newtonsoft.Json

Nach erfolgreicher Installation fügen Sie die Bibliothek in Ihr .NET-Projekt ein, indem Sie die folgende using-Anweisung hinzufügen:

using Newtonsoft.Json;

using Newtonsoft.Json;

Imports Newtonsoft.Json

Parsing von JSON mit "Newtonsoft.JSON

Das Parsen von JSON ist im Wesentlichen der Prozess der Konvertierung einer Zeichenkette im JSON-Format in eine verwendbare Datenstruktur in Ihrer .NET-Anwendung. Mit Newtonsoft.Json ist der Prozess sehr einfach.

Schauen wir uns ein JSON-Beispielobjekt für eine Person an:

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

Wir können diese JSON-Zeichenfolge in ein C#-Objekt parsen, indem wir die Funktion JsonConvert.DeserializeObject<T>()methode, wobei **T`** der Typ des Objekts ist, das wir erstellen wollen. In diesem Fall erstellen wir eine Klasse "Person" und parsen das JSON in diese Klasse.

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)

Das Objekt "Person" enthält nun die Werte aus der JSON-Zeichenfolge.

Arbeiten mit JSON-Dateien

Sie werden oft JSON-Daten aus einer Datei lesen oder in eine Datei schreiben müssen. Sehen wir uns an, wie wir das mit Newtonsoft.Json tun können. In diesem Fall verwenden wir die Klasse File aus dem System.IO-Namespace.

Lesen einer JSON-Datei und Parsen in ein Objekt:

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)

So schreiben Sie ein Objekt in eine JSON-Datei:

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)

Arbeiten mit Arrays

In einigen Fällen wird Ihr JSON Arrays enthalten. Zum Beispiel könnte ein "Person"-Objekt eine Reihe von "Freunden" haben:

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

Sie können die Schleife "Foreach" verwenden, um das JSON-Array zu durchlaufen:

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]

Ändern und Schreiben von JSON

Newtonsoft.Json macht es einfach, JSON zu ändern und zu schreiben. Nehmen wir an, Sie müssen den Wert "Alter" unseres Objekts "Person" aktualisieren.

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

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

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

Und schreiben Sie sie dann in eine Zeichenkette zurück:

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 zu JSON

Newtonsoft.Json bietet auch Funktionen zur Abfrage und Manipulation von JSON-Objekten mit LINQ (Sprache Integrierte Abfrage). Dies ist sehr leistungsfähig, da Sie alle Standard-LINQ-Operatoren verwenden können, um ein JSON-Objekt genauso abzufragen, wie Sie es mit XML oder einer Sammlung von Objekten tun würden.

Das folgende Beispiel zeigt, wie Sie die Namen aller Freunde, die jünger als 30 sind, abrufen können:

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

Einführung in IronPDF

IronPDF ist eine beliebte Bibliothek im .NET-Ökosystem, mit der Entwickler erstellenbearbeiten und Daten aus PDF-Dateien extrahieren. Es ist unglaublich vielseitig und lässt sich gut mit anderen Bibliotheken, einschließlich Newtonsoft.Json, kombinieren.

Nehmen wir an, wir haben eine Anforderung, bei der wir JSON-Daten haben und aus diesen Daten einen PDF-Bericht erstellen möchten. Wir können Newtonsoft.Json für das Parsen der JSON-Daten und IronPDF für die Erstellung der PDF-Datei verwenden. Wir wollen sehen, wie wir das machen können.

Installation von IronPDF

Wie Newtonsoft.Json ist auch IronPDF über NuGet verfügbar. Sie können es mit dem folgenden Befehl installieren:

Install-Package IronPdf

Dann können Sie es durch Hinzufügen in Ihr Projekt aufnehmen:

using IronPdf;

using IronPdf;

Imports IronPdf

Anwendungsfall 1 PDF-Erstellung aus JSON-Daten

In Bezug auf diesen Anwendungsfall wird gezeigt, wie Newtonsoft.Json und IronPDF verwendet werden, um einen PDF-Bericht aus JSON-Daten zu erstellen. Dies kann insbesondere für Anwendungen nützlich sein, die dynamische Berichte auf der Grundlage von Daten erstellen, die in einem JSON-Format gespeichert sind.

Hier ist eine Beispiel-JSON-Datei, mit der wir arbeiten werden:

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

Diese JSON-Daten stellen einen einfachen Verkaufsbericht dar.

Der erste Schritt besteht darin, die JSON-Datei, hier "data.json" genannt, zu lesen und sie mit Newtonsoft.Json in ein Wörterbuch zu parsen:

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)

Nach der Ausführung dieses Codes erwarten wir, dass Sie ein Wörterbuch mit dem Namen reportData haben, das Schlüssel-Wert-Paare enthält, die die Eigenschaften und ihre Werte in der JSON-Datei darstellen.

Als nächstes wird eine HTML-Vorlage mit den Daten aus "reportData" erstellt. Die Schlüssel aus dem Wörterbuch reportData werden verwendet, um die entsprechenden Werte in den HTML-Code einzufügen:

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>"

Schließlich verwenden wir IronPDF, um den HTML-Code in ein PDF-Dokument zu konvertieren. Wir verwenden "ChromePdfRenderer", um einen PDF-Renderer zu erstellen, den HTML-Code in ein PDF-Dokument umzuwandeln und das PDF-Dokument zu speichern:

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")

Anwendungsfall 2 JSON zu PDF Formular

In diesem Anwendungsfall werden wir JSON-Daten lesen, um Formularfelder in einem PDF-Dokument auszufüllen. Für dieses Beispiel nehmen wir an, dass wir die folgenden JSON-Daten haben:

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

Dieses JSON stellt persönliche Informationen zu einer Person dar.

Zunächst verwenden wir "Newtonsoft.Json", um die JSON-Daten aus der Datei zu lesen und in ein Wörterbuch zu parsen:

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)

Diese Software erstellt ein Wörterbuch mit der Bezeichnung Person mit den Schlüsseln Vorname, Nachname, Telefonnummer, E-Mail und Stadt und den entsprechenden Werten.

Als Nächstes öffnen wir das PDF-Dokument mit "IronPDF" und rufen das Formular auf:

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

Wir können nun das Wörterbuch "Person" verwenden, um die Formularfelder im PDF-Dokument zu füllen:

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")

Jedes Formularfeld ist mit einem Schlüssel aus dem Wörterbuch der Person verbunden.

Schließlich speichern wir das ausgefüllte PDF-Formular:

doc.SaveAs("myPdfForm_filled.pdf");

doc.SaveAs("myPdfForm_filled.pdf");

doc.SaveAs("myPdfForm_filled.pdf")

Mit dieser Methode wird ein neues PDF-Dokument erstellt, in dem die Formularfelder mit den Daten aus der JSON-Datei ausgefüllt sind.

Hier wird demonstriert, wie man effektiv Newtonsoft.Json zum Parsen von JSON-Daten und IronPDF zur Bearbeitung von PDF-Dokumenten einsetzen kann.

Anwendungsfall 3 PDF-Metadaten in JSON

Verwenden Sie zunächst IronPDF, um die Metadaten aus der PDF-Datei zu extrahieren:

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

Anschließend serialisieren Sie diese Daten mit "Newtonsoft.Json" in einen JSON-String:

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)

In diesem Code enthält das Objekt "metadata" Eigenschaften wie "Autor", "Titel", "Erstellungsdatum" usw. Diese werden in eine JSON-Zeichenkette serialisiert und in eine Datei namens "metadata.json" geschrieben

Die Kombination von Newtonsoft.Json und IronPDF ermöglicht Ihnen die Konvertierung von Daten zwischen PDF-Dateien und JSON und erfüllt damit eine Vielzahl von Anwendungsfällen.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass Newtonsoft.Json und IronPDF zusammen eine leistungsstarke und flexible Lösung für die Verarbeitung von JSON-Daten und die Generierung von PDF-Dateien in .NET bieten. Durch das Parsen von JSON-Daten in .NET-Objekte oder Wörterbücher mit Newtonsoft.Json können wir diese Daten manipulieren und in verschiedenen Kontexten verwenden, z.B. zum Ausfüllen von PDF-Formularen oder zur Erstellung dynamischer PDF-Berichte aus Vorlagen. IronPDF macht die Erstellung und Verwaltung von PDFs einfach und effizient.

Dieser Artikel stellt die Bibliotheken vor und hebt einige ihrer Hauptfunktionen hervor. Beide Bibliotheken haben aber noch viel mehr zu bieten. Wir empfehlen dringend, die ausführliche Dokumentation zu lesen, um einen tieferen Einblick in die Funktionen und Möglichkeiten zu erhalten.

Wenn Sie IronPDF ausprobieren möchten, bieten sie eine kostenloser Testso können Sie sich vor dem Kauf über die Funktionen informieren und beurteilen, ob das Gerät Ihren Anforderungen entspricht. Wenn Sie sich für IronPDF entscheiden, beginnt die Lizenzierung bei $749, was den fortlaufenden Zugriff auf alle besprochenen Funktionen sowie Support und Updates beinhaltet. Dadurch wird sichergestellt, dass Sie über die Werkzeuge und die Unterstützung verfügen, um PDF-Dateien in Ihren .NET-Projekten effektiv zu erzeugen, zu verwalten und zu bearbeiten.