Die besten Funktionen von zwei leistungsstarken Bibliotheken werden kombiniert, um unglaublich effektive Anwendungen zu entwickeln, indem Refit mit IronPDF in C# integriert werden. Refit erleichtert die Nutzung von RESTful-APIs, indem es Entwicklern ermöglicht, API-Schnittstellen mit C#-Eigenschaften zu entwerfen, automatisch HTTP-Anfragen zu generieren und typensicheren API-Zugriff zu gewährleisten. Im Gegenzug bietet IronPDF eine große Auswahl an leistungsstarken Funktionen für die Arbeit mit PDF-Dateien, einschließlich des Zusammenführens und Kommentierens von PDFs sowie der Umwandlung von HTML-Inhalten. Diese Bibliotheken bieten reibungslose Workflows für die Datenpräsentation und -abfrage, wenn sie kombiniert werden. Datengetriebene Anwendungsentwicklung kann durch die Verwendung von Tools wie Refit zur Datenabfrage von einer API und IronPDF zur Erstellung umfassender, hochwertiger PDF-Berichte basierend auf diesen Daten effizienter und produktiver gemacht werden.

What is Refit C#?

Refit ist ein Open-Source-Framework for .NET, das einen deklarativen, typensicheren Ansatz verwendet, um den Prozess des Sendens von HTTP-Anfragen an RESTful-APIs zu vereinfachen. Refit erzeugt automatisch den erforderlichen HTTP-Client-Code, indem API-Endpunkte als C#-Schnittstellen mit Eigenschaften spezifiziert werden. Dies reduziert Boilerplate-Code erheblich und verbessert die Lesbarkeit des Codes. Indem Fehler während der Kompilierung und nicht während der Ausführung erkannt werden, stellt diese Technik sicher, dass Methodensignaturen korrekt mit API-Endpunkten übereinstimmen.

Darüber hinaus verarbeitet Refit mühelos die JSON-Serialisierung und -Deserialisierung und ermöglicht es Entwicklern, mit C#-Objekten zu interagieren, anstatt API-Antworten manuell zu konvertieren. Indem HTTP-Methoden, Header und Parameter direkt in die Schnittstellenspezifikationen definiert werden, machen Attribute die Konfiguration einfacher. Da der Client-Code weniger geändert werden muss, wenn API-Endpunkte aktualisiert werden, wird der Code einfacher und leichter zu warten.

Zum Beispiel kann Refit die benötigte HTTP GET-Anfrage für den Namen eines Benutzers generieren, indem eine Methode in einem Interface mit einem [Get("/users/{id}")] Attribut erstellt wird. Diese Anfrage kann dann über einen typensicheren Methodenanruf gestellt werden. Refit ist eine rundum produktivere Lösung für Entwickler, um APIs in .NET-Anwendungen zu integrieren, indem die mit der Verwaltung von HTTP-Clients verbundenen Kopfschmerzen abstrahiert werden.

Features of Refit C#

Typsichere API-Verfügbarkeit

Refit erkennt Fehler zur Kompilierungszeit und stellt sicher, dass Methodensignaturen den API-Endpunkten entsprechen. Die Möglichkeit von Laufzeitfehlern, die durch unpassende Endpunkte oder fehlerhafte Anfrageneinstellungen verursacht werden, wird durch diese Typensicherheit verringert.

HTTP-Client deklarativ

C#-Schnittstellen und -Attribute können von Entwicklern zur Erstellung von API-Endpunkten verwendet werden, was zu saubererem und wartbarerem HTTP-Anforderungscode führt. Dieser deklarative Ansatz abstrahiert die Komplexität der Implementierung einer HTTP-Anforderung je Client.

Automatische Serialisierung und Deserialisierung

Refit kümmert sich automatisch um die Umwandlung von C#-Objekten in JSON-Daten. Da Entwickler Anfrageträger nicht mehr manuell serialisieren oder Antworten deserialisieren müssen, wird die Datenverarbeitung deutlich vereinfacht.

Konfiguration auf der Grundlage von Attributen

Attribute werden verwendet, um HTTP-Methoden (wie GET, POST, PUT und DELETE) und Parameter zu definieren. Dies macht die Konfiguration einfach und leicht verständlich, da sie Header, Anfragekörper, Inhalt, Pfadparameter und Abfrageparameter umfasst.

Unterstützung für asynchrone Programmierung

Refit verwendet Task-basierte Methoden zur Handhabung asynchroner HTTP-Anfragen und ist so konzipiert, dass es nahtlos mit asynchronen Programmiermodellen in .NET zusammenarbeitet.

Anpassungsfähige Webbrowser

Der Kern des HTTP-Clients kann von Entwicklern angepasst werden, indem Timeout-Nummern, Standard-Header-Einstellungen und Nachrichtenkonfigurationen für Protokollierung, Authentifizierung und Wiederholungsrichtlinien geändert werden.

Integriertes Fehlermanagement

Refit verfügt über integrierte Funktionen zur Fehlerbehandlung von HTTP-Problemen, wodurch es Entwicklern leicht gemacht wird, ihre eigene benutzerdefinierte Fehlerbehandlungslogik einzubauen.

Anpassungsfähigkeit

Entwickler können mehrere Formate verwenden oder ungewöhnliche Datentypen mit Refits Unterstützung für benutzerdefinierte Serialisierungs- und Deserialisierungskonverter behandeln.

Kombinierte Integration von Dependency Injection

Refit ist eine hervorragende Ergänzung für moderne .NET-Anwendungen, die bewährte Praktiken für Abhängigkeitsinjektion (DI) befolgen, da sie einfach in DI-Anwendungen integriert werden kann.

Unterstützung bei der Verifizierung

Zur Sicherung von API-Anrufen macht Refit es einfach, Authentifizierungsheader, Schnittstellenmethoden wie Trägertoken und Basis-Authentifizierung zu konfigurieren.

Create and Config Refit C#

Folgende Schritte dienen zum Erstellen und Einrichten eines Refit-Clients in C#:

Ein neues Visual Studio-Projekt erstellen

Es ist einfach, ein Konsolenprojekt mit Visual Studio zu erstellen. Um eine Konsolenanwendung in Visual Studio zu erstellen, befolgen Sie diese Schritte:

Stellen Sie vor der Nutzung von Visual Studio sicher, dass es auf Ihrem Computer installiert ist.

Ein neues Projekt starten

Öffnen Sie Visual Studio und klicken Sie auf die Option "Ein neues Projekt erstellen".

Wählen Sie aus der Auswahl auf der linken Seite des Fensters "Ein neues Projekt erstellen" Ihre bevorzugte Programmiersprache (z.B. C#).

Aus der folgenden Projektreferenzvorlage können Sie die "Konsolen-App"- oder "Konsolen-App (.NET Core)"-Vorlage auswählen.

Geben Sie Ihrem Projekt einen Namen und wählen Sie den Speicherort des Projekts aus.

Wählen Sie das entsprechende .NET Framework aus. Klicken Sie dann auf "Erstellen", um das Konsolenanwendungsprojekt zu erstellen.

Installieren Sie Refit

Die Refit-Bibliothek muss zunächst in Ihr Projekt aufgenommen werden. Sie können das Refit NuGet Package mit dem NuGet Package Manager installieren oder die .NET-CLI in Visual Studio verwenden, um dieses Ziel zu erreichen.

Verwenden Sie die .NET-CLI zur Installation:

dotnet add package Refit

dotnet add package Refit

Definieren Sie die API-Schnittstelle

Erstellen Sie eine Schnittstelle für Ihre API. Um die HTTP-Methoden und Endpunkte zu definieren, verwenden Sie die Refit-Attribute.

using Refit;
using System.Threading.Tasks;

// Define the API interface
public interface IMyApi
{
    // Get user details by ID
    [Get("/users/{id}")]
    Task<User> GetUserAsync(int id);
    
    // Create a new user
    [Post("/users")]
    Task<User> CreateUserAsync([Body] User user);
}

// Define the User class
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Other properties...
}

using Refit;
using System.Threading.Tasks;

// Define the API interface
public interface IMyApi
{
    // Get user details by ID
    [Get("/users/{id}")]
    Task<User> GetUserAsync(int id);
    
    // Create a new user
    [Post("/users")]
    Task<User> CreateUserAsync([Body] User user);
}

// Define the User class
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Other properties...
}

Imports Refit
Imports System.Threading.Tasks

' Define the API interface
Public Interface IMyApi
    ' Get user details by ID
    <Get("/users/{id}")>
    Function GetUserAsync(ByVal id As Integer) As Task(Of User)

    ' Create a new user
    <Post("/users")>
    Function CreateUserAsync(<Body> ByVal user As User) As Task(Of User)
End Interface

' Define the User class
Public Class User
    Public Property Id As Integer
    Public Property Name As String
    ' Other properties...
End Class

Imports Refit
Imports System.Threading.Tasks

' Define the API interface
Public Interface IMyApi
    ' Get user details by ID
    <Get("/users/{id}")>
    Function GetUserAsync(ByVal id As Integer) As Task(Of User)

    ' Create a new user
    <Post("/users")>
    Function CreateUserAsync(<Body> ByVal user As User) As Task(Of User)
End Interface

' Define the User class
Public Class User
    Public Property Id As Integer
    Public Property Name As String
    ' Other properties...
End Class

Erstellen und Konfigurieren des Refit-Client

Starten Sie den Refit-Client und passen Sie seine Einstellungen nach Bedarf an. Dies kann direkt in Ihrem Hauptcode oder in einem Dienst, unter anderem, an verschiedenen Stellen in Ihrer Anwendung implementiert werden.

using Refit;
using System;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Define the base URL of your API
        var apiClient = RestService.For<IMyApi>("https://api.example.com");

        // Use the API client to make requests
        var user = await apiClient.GetUserAsync(1);
        Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}");

        // Create a new user
        var newUser = new User { Name = "John Doe" };
        var createdUser = await apiClient.CreateUserAsync(newUser);
        Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}");
    }
}

using Refit;
using System;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Define the base URL of your API
        var apiClient = RestService.For<IMyApi>("https://api.example.com");

        // Use the API client to make requests
        var user = await apiClient.GetUserAsync(1);
        Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}");

        // Create a new user
        var newUser = new User { Name = "John Doe" };
        var createdUser = await apiClient.CreateUserAsync(newUser);
        Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}");
    }
}

Imports Refit
Imports System
Imports System.Threading.Tasks

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		' Define the base URL of your API
		Dim apiClient = RestService.For(Of IMyApi)("https://api.example.com")

		' Use the API client to make requests
		Dim user = Await apiClient.GetUserAsync(1)
		Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}")

		' Create a new user
		Dim newUser = New User With {.Name = "John Doe"}
		Dim createdUser = Await apiClient.CreateUserAsync(newUser)
		Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}")
	End Function
End Class

Imports Refit
Imports System
Imports System.Threading.Tasks

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		' Define the base URL of your API
		Dim apiClient = RestService.For(Of IMyApi)("https://api.example.com")

		' Use the API client to make requests
		Dim user = Await apiClient.GetUserAsync(1)
		Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}")

		' Create a new user
		Dim newUser = New User With {.Name = "John Doe"}
		Dim createdUser = Await apiClient.CreateUserAsync(newUser)
		Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}")
	End Function
End Class

Erweiterte Konfiguration

Indem Sie den zugrunde liegenden HttpClient konfigurieren, können Sie den Refit-Client weiter personalisieren. Zum Beispiel können Sie Zeitlimits festlegen, ein Header-Attribut anwenden, Standardheader hinzufügen oder Nachrichtenkonfigurationen für Wiederholungsrichtlinien, Authentifizierung und Protokollierung verwenden.

using System.Net.Http;
using Refit;
using System;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Configure HttpClient with custom handler and timeout
        var httpClient = new HttpClient(new HttpClientHandler
        {
            // Customize the HttpClientHandler as needed
        })
        {
            BaseAddress = new Uri("https://api.example.com"),
            Timeout = TimeSpan.FromSeconds(30)
        };

        // Add default headers if needed
        httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_TOKEN_HERE");

        // Create the Refit API client
        var apiClient = RestService.For<IMyApi>(httpClient);

        // Use the API client to make requests
        var user = await apiClient.GetUserAsync(1);
        Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}");

        // Create a new user
        var newUser = new User { Name = "John Doe" };
        var createdUser = await apiClient.CreateUserAsync(newUser);
        Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}");
    }
}

using System.Net.Http;
using Refit;
using System;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Configure HttpClient with custom handler and timeout
        var httpClient = new HttpClient(new HttpClientHandler
        {
            // Customize the HttpClientHandler as needed
        })
        {
            BaseAddress = new Uri("https://api.example.com"),
            Timeout = TimeSpan.FromSeconds(30)
        };

        // Add default headers if needed
        httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_TOKEN_HERE");

        // Create the Refit API client
        var apiClient = RestService.For<IMyApi>(httpClient);

        // Use the API client to make requests
        var user = await apiClient.GetUserAsync(1);
        Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}");

        // Create a new user
        var newUser = new User { Name = "John Doe" };
        var createdUser = await apiClient.CreateUserAsync(newUser);
        Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}");
    }
}

Imports System.Net.Http
Imports Refit
Imports System
Imports System.Threading.Tasks

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		' Configure HttpClient with custom handler and timeout
		Dim httpClient As New HttpClient(New HttpClientHandler ) With {
			.BaseAddress = New Uri("https://api.example.com"),
			.Timeout = TimeSpan.FromSeconds(30)
		}

		' Add default headers if needed
		httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_TOKEN_HERE")

		' Create the Refit API client
		Dim apiClient = RestService.For(Of IMyApi)(httpClient)

		' Use the API client to make requests
		Dim user = Await apiClient.GetUserAsync(1)
		Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}")

		' Create a new user
		Dim newUser = New User With {.Name = "John Doe"}
		Dim createdUser = Await apiClient.CreateUserAsync(newUser)
		Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}")
	End Function
End Class

Imports System.Net.Http
Imports Refit
Imports System
Imports System.Threading.Tasks

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		' Configure HttpClient with custom handler and timeout
		Dim httpClient As New HttpClient(New HttpClientHandler ) With {
			.BaseAddress = New Uri("https://api.example.com"),
			.Timeout = TimeSpan.FromSeconds(30)
		}

		' Add default headers if needed
		httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_TOKEN_HERE")

		' Create the Refit API client
		Dim apiClient = RestService.For(Of IMyApi)(httpClient)

		' Use the API client to make requests
		Dim user = Await apiClient.GetUserAsync(1)
		Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}")

		' Create a new user
		Dim newUser = New User With {.Name = "John Doe"}
		Dim createdUser = Await apiClient.CreateUserAsync(newUser)
		Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}")
	End Function
End Class

Sie können typensichere und wartbare RESTful-API-Nutzung erreichen, indem Sie einen Refit-Client in C# erstellen und konfigurieren, indem Sie diese Anweisungen befolgen.

Einstieg

Die Installation beider Bibliotheken, die Konfiguration eines einfachen API-Clients mit Refit zur Datenabfrage, sowie die Verwendung von IronPDF zur Erstellung eines PDF basierend auf diesen Daten sind die ersten Schritte zur Integration von Refit und IronPDF in einem C#-Projekt. Hier sind die Schritte, um dies zu erreichen:

Was ist IronPDF?

Eine funktionsreiche Bibliothek zur Handhabung von PDF-Dokumenten in .NET-Anwendungen wird IronPDF genannt. Mit seinem umfangreichen Funktionsumfang können Benutzer PDFs von Grund auf oder aus HTML-Material erstellen, sowie bestehende PDF-Dokumente ändern, indem sie Teile hinzufügen, entfernen oder ändern. IronPDF bietet Entwicklern ein leistungsstarkes API zum Erstellen, Bearbeiten und Konvertieren von PDF-Dateien, was die Arbeit mit PDFs in .NET-Anwendungen erleichtert.

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

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

Hauptfunktionen von IronPDF

Konvertierung von HTML in PDF

IronPDF ermöglicht es Ihnen, hochwertige PDF-Dokumente unter Verwendung von HTML-Inhalt zu erstellen, einschließlich CSS und JavaScript. Diese Funktionalität ist sehr hilfreich, um PDFs aus dynamischen Inhalten oder Webseiten zu erstellen.

Bearbeiten und Manipulieren von PDFs

IronPDF bietet Modifikationstools für bereits vorhandene PDF-Dokumente. Es ist möglich, Seiten aus einem PDF zu extrahieren, Text, Bilder, Wasserzeichen oder Anmerkungen hinzuzufügen und mehrere PDFs in ein Dokument zu kombinieren.

Eine PDF-Datei von Grund auf neu erstellen

Mit dem IronPDF-API können Sie Text, Bilder, Formen und andere Objekte zu neuen PDF-Dokumenten programmatisch hinzufügen. Dies ermöglicht es, PDF-Rechnungen, Berichte und andere dokumentenbasierte Ausgaben dynamisch zu generieren.

Sicherheit von PDFs

Es ist möglich, PDF-Dokumente mit IronPDF zu verschlüsseln und Passwort-Sicherheit hinzuzufügen, um den Zugriff zu verwalten und sensible Daten zu schützen.

Formulare im PDF-Format

Durch das Ausfüllen von Formularfeldern können Benutzer mit PDF-Dokumenten interagieren, indem sie PDF-Formulare mit IronPDF erstellen und ausfüllen.

Textextraktionen

IronPDF erleichtert die einfache Suche, Analyse und Manipulation von Textdaten, indem es den Textinhalt aus PDF-Dokumenten extrahiert.

Transformation in Bildformate

IronPDF ist für Situationen geeignet, in denen Bilder anstelle von PDFs erforderlich sind, da es PDF-Dokumente in gängige Bildformate wie PNG, JPEG und BMP konvertieren kann.

IronPDF installieren

Verwenden Sie die .NET-CLI oder den NuGet Package Manager, um IronPDF zu Ihren .NET-Projekten hinzuzufügen.

dotnet add package IronPdf

Integrate IronPDF With Refit C#

Lasst uns ein C#-Codebeispiel zerlegen, das Refit mit IronPDF kombiniert. In diesem Beispiel verwenden wir Refit, um Daten von einer fiktiven RESTful-API abzurufen und IronPDF, um ein PDF-Dokument basierend auf diesen Daten zu erstellen. So funktioniert der folgende Code:

using System;
using System.Threading.Tasks;
using IronPdf;
using Refit;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Define the base URL of your API
        var apiClient = RestService.For<IMyApi>("https://api.example.com");

        try
        {
            // Use the API client to make requests
            var user = await apiClient.GetUserAsync(1);
            
            // Generate PDF with the retrieved user data
            GeneratePdf(user);
            Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}");

            // Create a new user
            var rand = new Random();
            var newUser = new User { Id = rand.Next(), Name = "John Doe" };
            var createdUser = await apiClient.CreateUserAsync(newUser);
            Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

    // Generate a PDF from user data
    public static void GeneratePdf(User user)
    {
        // Construct HTML content for the PDF
        var htmlContent = $@"
        <html>
            <head>
                <style>
                    body {{font-family: Arial, sans-serif;}}
                    h1 {{color: navy;}}
                    p {{font-size: 14px;}}
                </style>
            </head>
            <body>
                <h1>User Details</h1>
                <p><strong>ID:</strong> {user.Id}</p>
                <p><strong>Name:</strong> {user.Name}</p>
            </body>
        </html>";

        // Create an IronPDF ChromePdfRenderer instance
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF to a file
        var filePath = "UserDetails.pdf";
        pdfDocument.SaveAs(filePath);
        Console.WriteLine($"PDF generated and saved to {filePath}");
    }
}

using System;
using System.Threading.Tasks;
using IronPdf;
using Refit;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Define the base URL of your API
        var apiClient = RestService.For<IMyApi>("https://api.example.com");

        try
        {
            // Use the API client to make requests
            var user = await apiClient.GetUserAsync(1);
            
            // Generate PDF with the retrieved user data
            GeneratePdf(user);
            Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}");

            // Create a new user
            var rand = new Random();
            var newUser = new User { Id = rand.Next(), Name = "John Doe" };
            var createdUser = await apiClient.CreateUserAsync(newUser);
            Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

    // Generate a PDF from user data
    public static void GeneratePdf(User user)
    {
        // Construct HTML content for the PDF
        var htmlContent = $@"
        <html>
            <head>
                <style>
                    body {{font-family: Arial, sans-serif;}}
                    h1 {{color: navy;}}
                    p {{font-size: 14px;}}
                </style>
            </head>
            <body>
                <h1>User Details</h1>
                <p><strong>ID:</strong> {user.Id}</p>
                <p><strong>Name:</strong> {user.Name}</p>
            </body>
        </html>";

        // Create an IronPDF ChromePdfRenderer instance
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF to a file
        var filePath = "UserDetails.pdf";
        pdfDocument.SaveAs(filePath);
        Console.WriteLine($"PDF generated and saved to {filePath}");
    }
}

Mithilfe von Refit-Attributen konstruieren wir eine API-Schnittstelle namens IMyApi und geben den Endpunkt für das Abrufen von Benutzerdaten an. Wir bauen einen Refit-Client für die API und rufen Benutzerdaten asynchron in der Main-Funktion ab. Falls die Daten erfolgreich abgerufen werden, wird das Benutzerobjekt an die GeneratePdf-Methode übergeben. Mit der Klasse ChromePdfRenderer von IronPDF erstellen wir in der GeneratePdf-Methode HTML-Content-Konvertierung zu PDF-Text, das die Benutzerdetails darstellt, und geben es dann als PDF-Dokument aus. Nachher wird das erstellte PDF in einer Datenträgerdatei gespeichert.

Unten ist der Screenshot der erstellten PDF-Datei.

Abschluss

Zusammenfassend haben Entwickler, die mit RESTful APIs und der PDF-Erstellung arbeiten, eine starke und effektive Lösung in Form der Integration von Refit mit IronPDF in C#. Die Refit-Schnittstelle reduziert Boilerplate-Code, verbessert die Wartbarkeit und bietet einen typensicheren, deklarativen Ansatz, der die API-Nutzung erleichtert. IronPDF hingegen bietet eine umfangreiche Sammlung von Werkzeugen zum Erstellen, Ändern und Arbeiten mit PDF-Dokumenten und macht es einfach, hochwertige PDFs aus HTML-Text zu erstellen.

Entwickler können problemlos Daten von APIs mit Refit abrufen und mit IronPDF dynamische PDF-Dokumente basierend auf diesen Daten erstellen, indem sie die beiden Tools integrieren. Diese Integration rationalisiert die Workflows und eröffnet eine Vielzahl von Möglichkeiten zur Erstellung dynamischer, datengesteuerter PDF-Berichte, Rechnungen und anderer dokumentenbasierter Ausgaben.

Sie können IronPDF und andere Iron Software-Technologien in Ihren Entwicklungsstack für Unternehmensanwendungen integrieren, um funktionsreiche, hochwertige Softwarelösungen für Kunden und Endbenutzer bereitzustellen. Diese solide Basis wird auch die Projekte, Backendsysteme und Prozessoptimierungen erleichtern.

Entwickler können das kostenlose Testangebot von IronPDF optimal nutzen, die Kosten betragen $999. Diese Technologien sind wegen ihrer umfangreichen Dokumentation, aktiven Online-Entwicklergemeinschaft und regelmäßigen Updates eine ausgezeichnete Wahl für moderne Softwareentwicklungsprojekte.

Um mehr darüber zu erfahren, wie Sie mit IronPDF loslegen können, besuchen Sie bitte die Codebeispiele für HTML zu PDF und die umfassende Dokumentation.