Les meilleures fonctionnalités de deux bibliothèques puissantes sont combinées pour produire des applications incroyablement efficaces en intégrant Refit avec IronPDF en C#. Refit facilite l'utilisation des API RESTful en permettant aux développeurs de concevoir des interfaces API avec des caractéristiques C#, générant automatiquement des requêtes HTTP, et garantissant un accès API de type-safe. Inversement, IronPDF offre une large gamme de capacités puissantes pour travailler avec des fichiers PDF, notamment la fusion et l'annotation de PDF ainsi que la conversion de contenu HTML. Ces bibliothèques fournissent des flux de travail fluides pour la présentation et la récupération de données lorsqu'elles sont combinées. Le développement d'applications axées sur les données peut être rendu plus efficace et productif en utilisant des outils comme Refit pour récupérer des données d'une API et IronPDF pour produire des rapports PDF détaillés et de haute qualité basés sur ces données.

Qu'est-ce que Refit C# ?

Refit est un framework open-source pour .NET qui utilise une méthodologie déclarative et sûre pour simplifier le processus d'envoi de requêtes HTTP aux API RESTful. Refit produit automatiquement le code client HTTP requis en spécifiant les points de terminaison API comme des interfaces C# embelies de caractéristiques. Cela réduit considérablement le code passe-partout et améliore la lisibilité du code. En détectant les erreurs lors de la compilation plutôt que lors de l'exécution, cette technique garantit que les signatures de méthode correspondent correctement aux points de terminaison API.

De plus, Refit gère la sérialisation et dé-sérialisation JSON avec facilité, permettant aux développeurs d'interagir avec des objets C# au lieu de convertir manuellement les réponses API. En définissant des méthodes HTTP, des en-têtes et des paramètres directement dans les spécifications de l'interface, les attributs simplifient la configuration. Parce que le code client doit être modifié moins souvent lorsque les points de terminaison API sont mis à jour, le code devient plus simple et plus facile à maintenir.

Par exemple, Refit peut générer la requête HTTP GET requise pour le nom d'un utilisateur en créant une méthode dans une interface avec un attribut [Get("/users/{id}")]. Cette requête peut ensuite être effectuée via un appel de méthode type-safe. Refit est une solution plus productive pour les développeurs pour intégrer des API dans des applications .NET en évitant les tracas liés à la gestion des clients HTTP.

Features of Refit C#

Disponibilité d'API Type-Safe

Refit détecte les erreurs au moment de la compilation et s'assure que les signatures de méthode correspondent aux points de terminaison API. La possibilité d'erreurs d'exécution causées par des points de terminaison mal assortis ou des configurations incorrectes de requêtes est réduite par cette sécurité de type.

Client HTTP Déclaratif

Les interfaces C# et les attributs peuvent être utilisés par les développeurs pour construire les points de terminaison API, ce qui se traduit par un code de requête HTTP plus propre et plus facile à maintenir. Cette méthode déclarative abstrait la complexité de l'implémentation d'une méthode de requête HTTP par client.

Sérialisation et Dé-sérialisation Automatique

Refit prend en charge la conversion des objets C# en données JSON automatiquement. Parce que les développeurs n'ont plus à sérialiser manuellement les corps de requêtes ou à dé-sérialiser les réponses, la gestion des données est beaucoup plus simple.

Configuration Basée sur des Attributs

Les attributs sont utilisés pour définir les méthodes HTTP (comme GET, POST, PUT et DELETE) et les paramètres. Cela rend la configuration simple et facile à comprendre car elle comprend des en-têtes, le corps de la requête, le contenu, les paramètres de chemin et les paramètres de requête.

Support de la Programmation Asynchrone

Refit utilise des méthodes basées sur des tâches pour gérer des requêtes HTTP asynchrones et est conçu pour interagir facilement avec des modèles de programmation asynchrone dans .NET.

Navigateurs Web Adaptables

Le client HTTP de base peut être personnalisé par les développeurs en modifiant les nombres de délais, les paramètres d'en-tête par défaut, et les configurations de gestionnaires de messages pour la journalisation, l'authentification et les stratégies de réessai.

Gestion des Erreurs Intégrée

Refit a des capacités intégrées pour gérer les problèmes HTTP, ce qui facilite l'intégration par les développeurs de leur propre logique de gestion des erreurs personnalisée.

Adaptabilité

Les développeurs peuvent utiliser plusieurs formats ou gérer des types de données inhabituels avec le support de Refit pour les convertisseurs de sérialisation et de dé-sérialisation personnalisés.

Intégration de l'Injection de Dépendance

Refit est un excellent choix pour les applications .NET contemporaines qui adhèrent aux pratiques recommandées pour l'injection de dépendance (DI) puisqu'il est simple à intégrer dans des applications DI.

Assistance à la Vérification

Pour sécuriser les appels API, Refit facilite la configuration des en-têtes d'authentification, des méthodes d'interface telles que les jetons porteurs et l'authentification de base.

Create and Config Refit C#

Les étapes suivantes peuvent être utilisées pour construire et configurer un client Refit en C# :

Créer un nouveau projet Visual Studio

Créer un projet de console est facile avec Visual Studio. Pour créer une application console dans Visual Studio, suivez ces étapes :

Avant d'utiliser Visual Studio, assurez-vous qu'il est installé sur votre ordinateur.

Démarrer un Nouveau Projet

Ouvrez Visual Studio, cliquez sur l'option " Créer un nouveau projet ".

Dans la sélection sur le côté gauche de la boîte " Créer un nouveau projet ", sélectionnez votre langage de programmation préféré (C#, par exemple).

Dans la liste de référence des modèles de projet suivante, vous pouvez choisir le modèle " Console App " ou " Console App (.NET Core) ".

Donnez un nom à votre projet, et choisissez l'emplacement de stockage du projet.

Sélectionnez le bon Framework .NET. Puis cliquez sur " Créer " pour créer le projet d'application console.

Installer Refit

La bibliothèque Refit doit d'abord être incluse dans votre projet. Vous pouvez installer le package NuGet Refit en utilisant le gestionnaire de packages NuGet ou utiliser le .NET CLI dans Visual Studio pour accomplir ceci.

Utiliser le .NET CLI pour l'installation :

dotnet add package Refit

dotnet add package Refit

Définir l'Interface API

Créez une interface pour symboliser votre API. Pour définir les méthodes et points de terminaison HTTP, utilisez les attributs Refit.

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

Créer et Configurer le Client Refit

Lancez le client Refit et ajustez ses paramètres au besoin. Cela peut être implémenté directement dans votre code principal ou dans un service, entre autres emplacements dans votre application.

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

Configuration Avancée

En configurant le HttpClient sous-jacent, vous pouvez personnaliser davantage le client Refit. Comme exemple, vous pouvez définir des délais, appliquer des attributs d'en-têtes, ajouter des en-têtes par défaut, ou utiliser des gestionnaires de messages pour des politiques de réessai, l'authentification et la journalisation.

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

Vous pouvez utiliser une consommation d'API RESTful sûre et maintenable en créant et en configurant un client Refit en C# en suivant ces instructions.

Commencer

Installer les deux bibliothèques, configurer un client API simple en utilisant Refit pour récupérer des données, et utiliser IronPDF pour créer un PDF basé sur ces données sont les premières étapes de l'intégration de Refit et IronPDF dans un projet C#. Voici les étapes pour faire cela :

Qu'est-ce que IronPDF?

Une bibliothèque riche en caractéristiques pour la gestion des documents PDF dans les applications .NET est appelée IronPDF. Avec son ensemble de fonctionnalités étendu, les utilisateurs peuvent créer des PDFs à partir de zéro ou de matériel HTML, ainsi que modifier des documents PDF existants en ajoutant, supprimant ou modifiant des parties. IronPDF offre aux développeurs une API robuste pour créer, modifier et convertir des fichiers PDF, facilitant ainsi le travail avec des PDFs dans des applications .NET.

IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.

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

Caractéristiques clés d'IronPDF

Conversion HTML en PDF

IronPDF vous permet de créer des documents PDF de haute qualité en utilisant du contenu HTML, y compris CSS et JavaScript. Cette fonctionnalité est très utile pour créer des PDFs à partir de contenu dynamique ou de pages web.

Édition et manipulation des PDFs

IronPDF offre des outils de modification pour les documents PDF déjà existants. Il est possible d'extraire des pages d'un PDF, d'ajouter du texte, des images, des filigranes ou des notes, et de combiner plusieurs PDFs en un seul document.

Créer un PDF de zéro

Avec l'API d'IronPDF, vous pouvez ajouter du texte, des images, des formes et d'autres objets à des documents PDF nouveaux de manière programmatique. Cela permet de générer des factures PDF, des rapports, et d'autres sorties basées sur des documents de manière dynamique.

Sécurité des PDFs

Vous pouvez gérer l'accès et protéger des données critiques en cryptant des documents PDF à l'aide d'IronPDF et en ajoutant une sécurité par mot de passe.

Formulaires dans les PDFs

En mettant des données dans des champs de formulaire, les utilisateurs peuvent interagir avec des documents PDF en créant et remplissant des formulaires PDF avec IronPDF.

Extractions de texte

IronPDF facilite la recherche, l'analyse et la manipulation de données textuelles en extrayant le contenu textuel des documents PDF.

Transformation en Formats d'Image

IronPDF est approprié pour les situations où des images sont nécessaires à la place de PDFs car il peut convertir des documents PDF en formats d'image courants, y compris PNG, JPEG, et BMP.

Installer IronPDF

Utilisez le .NET CLI ou le Gestionnaire de Packages NuGet pour ajouter IronPDF à vos projets .NET.

dotnet add package IronPdf

Integrate IronPDF With Refit C#

Décomposons un exemple de code C# qui combine Refit avec IronPDF. Dans cet exemple, nous utiliserons Refit pour récupérer des données d'une API RESTful fictive et utiliserons IronPDF pour créer un document PDF basé sur ces données. Voici le fonctionnement du code suivant :

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}");
    }
}

En utilisant les attributs Refit, nous construisons une interface API appelée IMyApi et fournissons le point de terminaison pour la récupération de données utilisateur. Nous construisons un client Refit pour l'API et récupérons des données utilisateur de manière asynchrone dans la fonction Main. Dans le cas où les données sont récupérées avec succès, l'objet utilisateur est transmis à la méthode GeneratePdf. En utilisant la classe ChromePdfRenderer d'IronPDF, nous créons une conversion de contenu HTML en texte PDF qui représente les détails de l'utilisateur dans la méthode GeneratePdf et ensuite la produisons sous forme de document PDF. Après cela, le PDF créé est stocké dans un fichier disque.

Ci-dessous la capture d'écran du fichier PDF généré.

Conclusion

Pour résumer, les développeurs travaillant avec les API RESTful et la production PDF ont une solution forte et efficace sous la forme de l'intégration de Refit avec IronPDF en C#. L'interface Refit réduit le code standard, améliore la maintenance, et offre une approche déclarative et type-safe, facilitant ainsi la consommation des API. Cependant, IronPDF offre une collection étendue d'outils pour produire, modifier et travailler avec des documents PDF, ce qui rend facile la création de PDFs de haute qualité à partir de texte HTML.

Les développeurs peuvent facilement récupérer des données à partir d'API avec Refit et créer des documents PDF dynamiques avec IronPDF en fonction de ces données en intégrant les deux outils. Les flux de travail sont simplifiés par cette intégration, qui crée également de nombreuses opportunités pour créer des rapports PDF dynamiques basés sur les données, des factures, et d'autres sorties basées sur des documents.

Vous pouvez intégrer IronPDF et d'autres Technologies Iron Software dans votre pile de développement d'applications d'entreprise pour fournir des solutions logicielles riches en fonctionnalités et haut de gamme aux clients et utilisateurs finaux. Cette base solide facilitera également les projets, les systèmes backend et l'amélioration des processus.

Les développeurs peuvent tirer le meilleur parti du coût de l'essai gratuit d'IronPDF qui est $999. Ces technologies sont un excellent choix pour les projets de développement de logiciels modernes grâce à leur documentation exhaustive, leur communauté active de développeurs en ligne et leurs mises à jour régulières.

Pour en savoir plus sur comment démarrer avec IronPDF, veuillez visiter les exemples de code pour HTML en PDF et la documentation complète.