Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. Newtonsoft Jsonpath
.NET HILFE

Newtonsoft Jsonpath (Wie es für Entwickler funktioniert)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Wenn Sie jemals mit JSON-Daten in .NET gearbeitet haben, sind Sie wahrscheinlich auf die Newtonsoft.Json-Bibliothek gestoßen, ein beliebtes, leistungsstarkes JSON-Framework for .NET. Dieses Tutorial soll Anfängern und fortgeschrittenen Benutzern helfen, diese leistungsstarke Bibliothek effektiv zu verstehen und zu nutzen, mit einem Fokus auf ihre Systemreferenzen, Dokumentation und relevante Release-Updates.

Einstieg

Um Newtonsoft.Json zu verwenden, müssen Sie es zuerst in Ihr .NET-Projekt installieren. Dies kann über NuGet, den .NET-Paketmanager, erfolgen. Geben Sie in der NuGet-Paketmanager-Konsole folgendes ein:

Install-Package Newtonsoft.Json

Nach erfolgreicher Installation fügen Sie die Bibliothek zu Ihrem .NET-Projekt hinzu, indem Sie die folgende Using-Direktive hinzufügen:

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

JSON-Parsing mit Newtonsoft.JSON

JSON zu parsen bedeutet im Wesentlichen, einen String im JSON-Format in eine nutzbare Datenstruktur in Ihrer .NET-Anwendung umzuwandeln. Mit Newtonsoft.Json ist der Prozess einfach.

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

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

Wir können diesen JSON-String mit der JsonConvert.DeserializeObject<t>() Methode in ein C#-Objekt parsen, wobei T der Typ des Objekts ist, das wir erstellen möchten. In diesem Fall erstellen wir eine Person Klasse und parsen das JSON in diese.

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

Jetzt enthält das person Objekt die Werte aus dem JSON-String.

Arbeiten mit JSON-Dateien

Oft müssen Sie JSON-Daten von oder in eine Datei lesen oder schreiben. Schauen wir uns an, wie wir das mit Newtonsoft.Json machen können. Wir verwenden die File Klasse aus dem System.IO Namensraum in diesem Fall.

Um eine JSON-Datei zu lesen und in ein Objekt zu parsen:

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

Um ein Objekt in eine JSON-Datei zu schreiben:

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

Arbeiten mit Arrays

In einigen Fällen wird Ihr JSON Arrays enthalten. Zum Beispiel könnte ein Person Objekt ein Array von Friends haben:

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

Sie können die foreach Schleife verwenden, um über das JSON-Array zu iterieren:

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

Hinweis: jsonObject sollte durch ein tatsächliches JObject ersetzt werden, das aus dem JSON initialisiert wurde.

JSON modifizieren und schreiben

Newtonsoft.Json macht es einfach, JSON zu modifizieren und zu schreiben. Angenommen, Sie müssen den Age Wert unseres Person Objekts aktualisieren.

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

Und dann schreiben Sie es zurück in einen String:

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

Hinweis: jsonObject sollte durch ein tatsächliches JObject ersetzt werden, das aus dem JSON initialisiert wurde.

LINQ zu JSON

Newtonsoft.Json bietet auch Funktionen zum Abfragen und Bearbeiten von JSON-Objekten mit LINQ (Language Integrated Query). Dies ist sehr leistungsstark, da es Ihnen ermöglicht, alle standardmäßigen LINQ-Operatoren zu verwenden, um ein JSON-Objekt zu durchsuchen, genau wie Sie es bei XML oder einer Sammlung von Objekten tun würden.

Hier ist ein Beispiel, das zeigt, wie Sie die Namen aller Freunde unter 30 Jahren 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);
}
$vbLabelText   $csharpLabel

Hinweis: jsonObject sollte durch ein tatsächliches JObject ersetzt werden, das aus dem JSON initialisiert wurde.

Einführung in IronPDF

Erfahren Sie mehr über IronPDF ist eine beliebte Bibliothek im .NET-Ökosystem, die es Entwicklern ermöglicht, PDF-Dateien zu erstellen, zu bearbeiten und Daten daraus zu extrahieren. Es ist unglaublich vielseitig und arbeitet nahtlos mit anderen Bibliotheken zusammen, einschließlich Newtonsoft.Json.

IronPDF überzeugt in der HTML-zu-PDF-Konvertierung, indem es den originalen Layouts und Stilen präzise erhält. Es ist ideal zur Erstellung von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Mit Unterstützung für HTML-Dateien, URLs und rohe HTML-Strings erstellt IronPDF problemlos hochwertige PDF-Dokumente.

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

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

Installation von IronPDF

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

Install-Package IronPdf

Dann können Sie es in Ihr Projekt einbinden, indem Sie hinzufügen:

using IronPdf;
using IronPdf;
$vbLabelText   $csharpLabel

Anwendungsfall 1: PDF-Erstellung aus JSON-Daten

In diesem Anwendungsfall zeigen wir, wie Sie mit Newtonsoft.Json und IronPDF einen PDF-Bericht aus JSON-Daten erstellen können. Dies könnte besonders nützlich für Anwendungen sein, die dynamische Berichte basierend auf Daten im JSON-Format erstellen.

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', zu lesen und 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);
$vbLabelText   $csharpLabel

Nach der Ausführung dieses Codes haben Sie ein Dictionary namens reportData, das Schlüssel-Wert-Paare enthält, die die Eigenschaften und ihre Werte in der JSON-Datei darstellen.

Als nächstes erzeugen wir eine HTML-Vorlage unter Verwendung der Daten aus reportData. Die Schlüssel aus dem reportData Dictionary werden verwendet, um die entsprechenden Werte in das HTML 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>";
$vbLabelText   $csharpLabel

Zuletzt verwenden wir IronPDF, um den HTML-Code in ein PDF-Dokument zu konvertieren. Wir verwenden ChromePdfRenderer, um einen PDF-Renderer zu erstellen, benutzen ihn, um das HTML in ein PDF zu konvertieren, und speichern dann das 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 (Wie es für Entwickler funktioniert): Abbildung 1

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 folgende JSON-Daten haben:

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

Dieses JSON stellt persönliche Informationen für eine Person dar.

Zuerst verwenden wir Newtonsoft.Json, um die JSON-Daten aus der Datei zu lesen und sie in ein Dictionary 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);
$vbLabelText   $csharpLabel

Diese Software erstellt ein Dictionary namens person mit den Schlüsseln "FirstName," "LastName," "PhoneNumber," "Email," und "City" und deren entsprechenden Werten.

Als nächstes öffnen wir das PDF-Dokument mit IronPdf und erhalten das Formular:

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

Wir können jetzt das person Dictionary verwenden, um die Formularfelder im PDF-Dokument auszufü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"];
$vbLabelText   $csharpLabel

Jedes Formularfeld ist mit einem Schlüssel aus dem Person-Wörterbuch verknüpft.

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

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

Diese Methode erstellt ein neues PDF-Dokument mit den Formularfeldern, die mit den Daten aus der JSON-Datei ausgefüllt sind.

Dies zeigt, wie Sie Newtonsoft.Json effektiv verwenden können, um JSON-Daten zu parsen und IronPDF, um PDF-Dokumente zu manipulieren.

Newtonsoft Jsonpath (Wie es für Entwickler funktioniert): Abbildung 2

Anwendungsfall 3: PDF-Metadaten in JSON

Verwenden Sie zunächst IronPDF, um die Metadaten aus dem PDF zu extrahieren:

var pdf = IronPdf.PdfDocument.FromFile("document.pdf");
var metadata = pdf.MetaData;
var pdf = IronPdf.PdfDocument.FromFile("document.pdf");
var metadata = pdf.MetaData;
$vbLabelText   $csharpLabel

Dann serialisieren wir diese Daten in einen JSON-String unter Verwendung von 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

In diesem Code enthält das metadata Objekt Eigenschaften wie Author, Title, CreateDate usw. Diese werden in einen JSON-String serialisiert und in eine Datei namens "metadata.json" geschrieben.

Newtonsoft Jsonpath (Wie es für Entwickler funktioniert): Abbildung 3

Durch die Kombination von Newtonsoft.Json und IronPDF können Sie Daten zwischen PDF-Dateien und JSON konvertieren und so eine Vielzahl von Anwendungsfällen abdecken.

Abschluss

Abschließend bieten Ihnen Newtonsoft.Json und IronPDF zusammen eine leistungsstarke und flexible Lösung zum Umgang mit JSON-Daten und zur Erstellung von PDF-Dateien in .NET. 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, wie z.B. beim Ausfüllen von PDF-Formularen oder Erstellen dynamischer PDF-Berichte aus Vorlagen. IronPDF macht die Erstellung und Verwaltung von PDFs einfach und effizient.

Dieser Artikel hat die Bibliotheken eingeführt und einige ihrer Kernfunktionen hervorgehoben. Beide Bibliotheken bieten jedoch viel mehr. Wir empfehlen Ihnen dringend, ihre umfangreiche Dokumentation zu lesen, um sich eingehend mit ihren Funktionen und Fähigkeiten zu beschäftigen.

Wenn Sie daran interessiert sind, IronPDF auszuprobieren, bieten sie eine kostenlose Testversion von IronPDF an, damit Sie seine Funktionen erkunden und evaluieren können, ob es Ihren Anforderungen entspricht, bevor Sie es kaufen. Sobald Sie sich entschieden haben, mit IronPDF weiterzumachen, beginnt die Lizenzierung bei IronPDF Licensing Options, die den weiteren Zugang zu allen besprochenen Funktionen und Unterstützung und Updates einschließt. Dies stellt sicher, dass Sie die Werkzeuge und Unterstützung haben, um PDF-Dateien in Ihren .NET-Projekten effektiv zu erstellen, zu verwalten und zu bearbeiten.

Häufig gestellte Fragen

Wie installiere ich Newtonsoft.Json zum Arbeiten mit JSON in .NET?

Sie können die Newtonsoft.Json-Bibliothek in Ihrem .NET-Projekt mit dem NuGet-Paketmanager installieren. Führen Sie den Befehl Install-Package Newtonsoft.Json in der Paket-Manager-Konsole aus. Sobald installiert, binden Sie es in Ihr Projekt ein mit using Newtonsoft.Json;.

Wofür wird JsonConvert.DeserializeObject verwendet?

Die Methode JsonConvert.DeserializeObject() wird verwendet, um JSON-Daten in .NET-Objekte zu parsen. Sie konvertiert JSON-Strings in Objekte vom Typ T, sodass Sie mit JSON-Daten in Ihren C#-Anwendungen arbeiten können.

Wie kann ich JSON-Daten mit LINQ manipulieren?

LINQ to JSON ist eine Funktion, die von Newtonsoft.Json bereitgestellt wird, mit der Sie JSON-Objekte mit LINQ-Syntax abfragen und manipulieren können. Dies ist nützlich, um JSON-Daten innerhalb Ihrer .NET-Anwendungen effizient zu filtern oder zu durchsuchen.

Wie generiere ich einen PDF-Bericht aus JSON-Daten?

Um einen PDF-Bericht aus JSON-Daten zu erstellen, konvertieren Sie zuerst das JSON in .NET-Objekte mit Newtonsoft.Json. Erstellen Sie dann eine HTML-Vorlage unter Verwendung dieser Daten. Verwenden Sie ChromePdfRenderer von IronPDF, um die HTML-Vorlage in ein PDF-Dokument zu konvertieren.

Kann ich PDF-Formulare mit JSON-Daten ausfüllen?

Ja, Sie können PDF-Formulare mit JSON-Daten ausfüllen, indem Sie das JSON mit Newtonsoft.Json in ein Wörterbuch parsen und dann die Felder des PDF-Formulars mit diesen Daten befüllen, bevor Sie das ausgefüllte PDF-Dokument speichern.

Wie kann ich PDF-Metadaten in JSON konvertieren?

Extrahieren Sie die Metadaten aus einem PDF mit IronPDF und konvertieren Sie sie in einen JSON-String mit Newtonsoft.Json. Dieser Prozess ermöglicht es Ihnen, PDF-Metadaten einfach im JSON-Format zu speichern und zu manipulieren.

Was sind die Vorteile der Verwendung von Newtonsoft.Json und IronPDF zusammen?

Die Verwendung von Newtonsoft.Json mit IronPDF in einer .NET-Anwendung bietet eine nahtlose Möglichkeit, JSON-Daten zu handhaben und PDF-Dateien zu erstellen oder zu manipulieren, was Aufgaben wie die dynamische Berichtserstellung, das Ausfüllen von Formularen und den Datenaustausch erleichtert.

Wie lese und schreibe ich JSON-Dateien in .NET?

Um eine JSON-Datei zu lesen, verwenden Sie File.ReadAllText, um den JSON-String zu laden, und parsen Sie ihn dann mit JsonConvert.DeserializeObject. Zum Schreiben von JSON serialisieren Sie ein Objekt mit JsonConvert.SerializeObject und speichern es mit File.WriteAllText.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

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