Jeśli kiedykolwiek pracowałeś z danymi JSON w .NET Framework, prawdopodobnie zetknąłeś się z biblioteką Newtonsoft.Json, popularnym, wysokowydajnym frameworkiem JSON dla .NET Framework. Ten samouczek ma na celu pomóc początkującym i średnio zaawansowanym użytkownikom w skutecznym zrozumieniu i wykorzystaniu tej potężnej biblioteki, ze szczególnym uwzględnieniem jej odniesień systemowych, dokumentacji i wszelkich istotnych aktualizacji wydawniczych.
Aby rozpocząć korzystanie z Newtonsoft.Json, należy najpierw zainstalować go w projekcie .NET. Można to zrobić za pomocą NuGet, menedżera pakietów .NET. W konsoli menedżera pakietów NuGet wpisz:
Po pomyślnej instalacji dodaj bibliotekę do swojego projektu .NET, dodając następującą instrukcję using:
using Newtonsoft.Json;Imports Newtonsoft.JsonNewtonsoft.JSONParsowanie JSON to zasadniczo proces przekształcania ciągu znaków w formacie JSON w użyteczną strukturę danych w aplikacji .NET. Dzięki Newtonsoft.Json proces ten jest prosty.
Przyjrzyjmy się przykładowemu obiektowi JSON dla osoby:
{
"Name": "Iron Developer",
"Age": 30,
"Email": "irondeveloper@ironsoftware.com"
}Możemy sparsować ten ciąg JSON do obiektu C# za pomocą metody JsonConvert.DeserializeObject<t>(), gdzie T jest typem obiektu, który chcemy stworzyć. W tym przypadku stworzymy klasę Person i sparsujemy do niej JSON.
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)Teraz obiekt person będzie zawierał wartości z ciągu JSON.
Często trzeba odczytywać lub zapisywać dane JSON z pliku lub do pliku. Zobaczmy, jak można to zrobić za pomocą Newtonsoft.Json. W tym przypadku użyjemy klasy File z przestrzeni nazw System.IO.
Aby odczytać plik JSON i przeanalizować go do postaci obiektu:
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)Aby zapisać obiekt do pliku 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);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)W niektórych przypadkach plik JSON będzie zawierał tablice. Na przykład obiekt Person może mieć tablicę Friends:
{
"Name": "John Doe",
"Friends": [
{
"Name": "Jane Doe",
"Age": 28
},
{
"Name": "Billy",
"Age": 25
}
]
}Możesz użyć pętli foreach, aby iterować przez tablicę JSON:
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]Uwaga: jsonObject powinien zostać zastąpiony rzeczywistym JObject zainicjowanym z JSON.
Newtonsoft.Json ułatwia modyfikowanie i pisanie JSON. Powiedzmy, że musisz zaktualizować wartość Age naszego obiektu Person.
jsonObject["Age"] = 31; // Update the agejsonObject("Age") = 31 ' Update the ageA następnie zapisz to z powrotem do ciągu znaków:
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 fileUwaga: jsonObject powinien zostać zastąpiony rzeczywistym JObject zainicjowanym z JSON.
Newtonsoft.Json zapewnia również funkcje wyszukiwania i manipulowania obiektami JSON przy użyciu LINQ (Language Integrated Query). Jest to bardzo potężne narzędzie, ponieważ pozwala na użycie wszystkich standardowych operatorów LINQ do przeszukiwania obiektu JSON, tak jak w przypadku XML lub kolekcji obiektów.
Oto przykład pokazujący, jak można pobrać nazwiska wszystkich znajomych poniżej 30 roku życia:
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 nameUwaga: jsonObject powinien zostać zastąpiony rzeczywistym JObject zainicjowanym z JSON.
Dowiedz się więcej o IronPDF – popularnej bibliotece w ekosystemie .NET, która pozwala programistom tworzyć, edytować i wyodrębniać dane z plików PDF. Jest niezwykle wszechstronny i płynnie współpracuje z innymi bibliotekami, w tym Newtonsoft.Json.
IronPDF wyróżnia się w konwersji HTML do PDF, zapewniając precyzyjne zachowanie oryginalnych układów i stylów. Idealnie nadaje się do tworzenia plików PDF z treści internetowych, takich jak raporty, faktury i dokumentacja. Dzięki obsłudze plików HTML, adresów URL i surowych ciągów znaków HTML, IronPDF z łatwością tworzy wysokiej jakości dokumenty 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 ClassZałóżmy, że mamy dane w formacie JSON i chcemy utworzyć raport PDF na podstawie tych danych. Do analizowania danych JSON możemy użyć Newtonsoft.Json, a do tworzenia plików PDF — IronPDF. Zobaczmy, jak możemy to zrobić.
Podobnie jak Newtonsoft.Json, IronPDF jest również dostępny za pośrednictwem NuGet. Można go zainstalować za pomocą następującego polecenia:
Następnie możesz włączyć go do swojego projektu, dodając:
using IronPdf;Imports IronPdfW tym przykładzie pokażemy, jak używać Newtonsoft.Json i IronPDF do generowania raportu PDF na podstawie danych JSON. Może to być szczególnie przydatne w przypadku aplikacji, które tworzą dynamiczne raporty na podstawie danych przechowywanych w formacie JSON.
Oto przykładowy plik JSON, nad którym będziemy pracować:
{
"Title": "Sales Report",
"Month": "August",
"Year": "2023",
"TotalSales": "10000",
"ItemsSold": "500"
}Te dane JSON przedstawiają prosty raport sprzedaży.
Pierwszym krokiem jest odczytanie pliku JSON, nazwanego tutaj "data.json", i przeanalizowanie go do słownika przy użyciu Newtonsoft.Json:
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)Po wykonaniu tego kodu będziesz mieć słownik o nazwie reportData zawierający pary klucz-wartość reprezentujące właściwości i ich wartości w pliku JSON.
Następnie generujemy szablon HTML używając danych z reportData. Klucze ze słownika reportData są używane do wstawienia odpowiednich wartości do 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>"Na koniec używamy IronPDF do konwersji kodu HTML na dokument PDF. Używamy ChromePdfRenderer do stworzenia renderera PDF, używamy go do konwersji HTML na PDF, a następnie zapisujemy 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")
W tym przykładzie użycia odczytamy dane JSON, aby wypełnić pola formularza w dokumencie PDF. W tym przykładzie załóżmy, że mamy następujące dane JSON:
{
"FirstName": "John",
"LastName": "Smith",
"PhoneNumber": "+19159969739",
"Email": "John@email.com",
"City": "Chicago"
}Ten plik JSON zawiera dane osobowe danej osoby.
Najpierw używamy Newtonsoft.Json do odczytania danych JSON z pliku i ich parsowania do słownika:
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)To oprogramowanie tworzy słownik o nazwie person z kluczami "FirstName," "LastName," "PhoneNumber," "Email," i "City," oraz ich odpowiadającymi wartościami.
Następnie otwieramy dokument PDF używając IronPdf i pobieramy formularz:
var doc = PdfDocument.FromFile("myPdfForm.pdf");
var form = doc.Form;Dim doc = PdfDocument.FromFile("myPdfForm.pdf")
Dim form = doc.FormMożemy teraz użyć słownika person do wypełnienia pól formularza w dokumencie 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")Każde pole formularza jest powiązane z kluczem z słownika danej osoby.
Na koniec zapisujemy wypełniony formularz PDF:
doc.SaveAs("myPdfForm_filled.pdf");doc.SaveAs("myPdfForm_filled.pdf")Ta metoda utworzy nowy dokument PDF z polami formularza wypełnionymi danymi z pliku JSON.
To pokazuje, jak skutecznie można używać Newtonsoft.Json do parsowania danych JSON i IronPDF do manipulacji dokumentami PDF.
Najpierw użyj IronPDF do wyodrębnienia metadanych z pliku PDF:
var pdf = IronPdf.PdfDocument.FromFile("document.pdf");
var metadata = pdf.MetaData;Dim pdf = IronPdf.PdfDocument.FromFile("document.pdf")
Dim metadata = pdf.MetaDataNastępnie, serializuj te dane do ciągu JSON używając 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)W tym kodzie obiekt metadata zawiera właściwości takie jak Author, Title, CreateDate, itp. Są one serializowane do ciągu JSON i zapisywane do pliku o nazwie "metadata.json."
Połączenie Newtonsoft.Json i IronPDF pozwala na konwersję danych między plikami PDF a JSON, spełniając szeroki zakres zastosowań.
Podsumowując, Newtonsoft.Json i IronPDF razem stanowią potężne i elastyczne rozwiązanie do obsługi danych JSON i generowania plików PDF w środowisku .NET. Parsując dane JSON do obiektów lub słowników .NET za pomocą Newtonsoft.Json, możemy manipulować tymi danymi i wykorzystywać je w różnych kontekstach, takich jak wypełnianie formularzy PDF lub generowanie dynamicznych raportów PDF na podstawie szablonów. IronPDF sprawia, że proces tworzenia plików PDF i zarządzania nimi jest prosty i wydajny.
W niniejszym artykułe przedstawiono biblioteki, podkreślając niektóre z ich podstawowych funkcji. Jednak obie biblioteki mają do zaoferowania znacznie więcej. Zdecydowanie zalecamy zapoznanie się z obszerną dokumentacją, aby dogłębnie poznać ich funkcje i możliwości.
Jeśli chcesz wypróbować IronPDF, firma oferuje bezpłatną wersję próbną, dzięki której możesz zapoznać się z jego funkcjami i ocenić, czy spełnia Twoje potrzeby przed zakupem. Gdy zdecydujesz się kontynuować korzystanie z IronPDF, licencjonowanie rozpoczyna się od opcji licencyjnych IronPDF, które obejmują stały dostęp do wszystkich omówionych funkcji, a także wsparcie techniczne i aktualizacje. Dzięki temu zyskasz narzędzia i wsparcie, które pozwolą Ci skutecznie tworzyć, zarządzać i edytować pliki PDF w projektach .NET.
Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.
IronPDF jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
Kiedy potrzebujesz, aby twój PDF wyglądał jak HTML, szybko.
