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 für .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;
Imports Newtonsoft.Json
$vbLabelText   $csharpLabel

JSON wird mit Newtonsoft.JSON analysiert

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 diese JSON-Zeichenkette mithilfe der Methode JsonConvert.DeserializeObject<T>() in ein C#-Objekt parsen, wobei T der Typ des Objekts ist, das wir erstellen möchten. 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)
$vbLabelText   $csharpLabel

Das Objekt person enthält nun die Werte aus der JSON-Zeichenkette.

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. In diesem Fall verwenden wir die Klasse File aus dem Namespace System.IO.

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);
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)
$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);
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)
$vbLabelText   $csharpLabel

Arbeiten mit Arrays

In einigen Fällen wird Ihr JSON Arrays enthalten. Beispielsweise 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 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]
$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 Wert Age unseres Objekts Person aktualisieren.

jsonObject["Age"] = 31; // Update the age
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
Dim updatedJson As String = 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);
}
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
$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");
    }
}
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 Class
$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;
Imports 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);
Dim jsonString As String = File.ReadAllText("data.json")
Dim reportData = JsonConvert.DeserializeObject(Of Dictionary(Of String, String))(jsonString)
$vbLabelText   $csharpLabel

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

Als nächstes generieren wir eine HTML-Vorlage unter Verwendung der Daten von reportData. Die Schlüssel aus dem Wörterbuch reportData 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>";
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>"
$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, konvertieren damit das HTML in ein PDF und speichern anschließend 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");
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("Report.pdf")
$vbLabelText   $csharpLabel

Newtonsoft Jsonpath (So funktioniert es für Entwickler): 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 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)
$vbLabelText   $csharpLabel

Diese Software erstellt ein Wörterbuch namens person mit den Schlüsseln "FirstName", "LastName", "PhoneNumber", "Email" und "City" sowie den 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;
Dim doc = PdfDocument.FromFile("myPdfForm.pdf")
Dim form = doc.Form
$vbLabelText   $csharpLabel

Wir können nun das Wörterbuch person 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"];
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");
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 zum Parsen von JSON-Daten und IronPDF zum Bearbeiten von PDF-Dokumenten verwenden können.

Newtonsoft Jsonpath (So funktioniert es für Entwickler): 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;
Dim pdf = IronPdf.PdfDocument.FromFile("document.pdf")
Dim metadata = pdf.MetaData
$vbLabelText   $csharpLabel

Serialisieren Sie diese Daten anschließend mithilfe von 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)
$vbLabelText   $csharpLabel

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

Newtonsoft Jsonpath (So funktioniert es für Entwickler): 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

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an