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.
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:
Nach erfolgreicher Installation fügen Sie die Bibliothek zu Ihrem .NET-Projekt hinzu, indem Sie die folgende Using-Direktive hinzufügen:
using Newtonsoft.Json;Imports Newtonsoft.JsonNewtonsoft.JSON analysierenJSON 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 in ein C#-Objekt umwandeln, indem wir die JsonConvert.DeserializeObject<t>()-Methode verwenden, wobei T der Typ des Objekts ist, das wir erstellen möchten. In diesem Fall erstellen wir eine Person-Klasse und wandeln das JSON in diese um.
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)Nun wird das person-Objekt die Werte aus dem JSON-String enthalten.
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-Namespace 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);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)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);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)In einigen Fällen wird Ihr JSON Arrays enthalten. Zum Beispiel könnte ein Person-Objekt ein Array von Friends enthalten:
{
"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);
}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]Hinweis: jsonObject sollte durch ein tatsächliches JObject ersetzt werden, das aus dem JSON initialisiert wurde.
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 agejsonObject("Age") = 31 ' Update the ageUnd dann schreiben Sie es zurück in einen String:
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 fileHinweis: jsonObject sollte durch ein tatsächliches JObject ersetzt werden, das aus dem JSON initialisiert wurde.
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);
}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 nameHinweis: jsonObject sollte durch ein tatsächliches JObject ersetzt werden, das aus dem JSON initialisiert wurde.
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");
}
}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 ClassNehmen 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.
Wie Newtonsoft.Json ist IronPDF auch über NuGet verfügbar. Sie können es mit dem folgenden Befehl installieren:
Dann können Sie es in Ihr Projekt einbinden, indem Sie hinzufügen:
using IronPdf;Imports IronPdfIn 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);Dim jsonString As String = File.ReadAllText("data.json")
Dim reportData = JsonConvert.DeserializeObject(Of Dictionary(Of String, String))(jsonString)Nachdem Sie diesen Code ausgeführt haben, haben Sie ein Wörterbuch namens reportData, das Schlüssel-Wert-Paare enthält, die die Eigenschaften und deren Werte in der JSON-Datei darstellen.
Als Nächstes erstellen wir eine HTML-Vorlage mit den Daten aus reportData. Die Schlüssel aus dem reportData-Wörterbuch 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>";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>"Zuletzt verwenden wir IronPDF, um den HTML-Code in ein PDF-Dokument zu konvertieren. Wir verwenden ChromePdfRenderer, um einen PDF-Renderer zu erstellen, nutzen 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");Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("Report.pdf")
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 in ein Wörterbuch zu analysieren:
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 namens person mit 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;Dim doc = PdfDocument.FromFile("myPdfForm.pdf")
Dim form = doc.FormWir können jetzt das person-Wörterbuch 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")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")Diese Methode erstellt ein neues PDF-Dokument mit den Formularfeldern, die mit den Daten aus der JSON-Datei ausgefüllt sind.
Dies demonstriert, wie Sie Newtonsoft.Json effektiv nutzen können, um JSON-Daten zu analysieren und IronPDF zu verwenden, um PDF-Dokumente zu manipulieren.
Verwenden Sie zunächst IronPDF, um die Metadaten aus dem PDF zu extrahieren:
var pdf = IronPdf.PdfDocument.FromFile("document.pdf");
var metadata = pdf.MetaData;Dim pdf = IronPdf.PdfDocument.FromFile("document.pdf")
Dim metadata = pdf.MetaDataDann serialisieren wir diese Daten in einen JSON-String mit 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)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.
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.
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.
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 Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
