GraphQL a gagné une popularité significative en tant qu'alternative aux API RESTful pour créer des services web flexibles et efficaces. GraphQL est disponible dans de nombreuses langues différentes, telles que Java, Python, ASP .NET core. Mais dans cet article, nous examinerons l'utilisation de GraphQL dans le contexte de C#, en explorant ses concepts, son implémentation et son utilisation à travers des exemples pratiques. Nous utiliserons également IronPDF pour C# pour créer des fichiers PDF à l'aide de la classe de requête de définition de schéma GraphQL.
GraphQL est un langage de requête pour les APIs qui permet aux clients de demander exactement les données dont ils ont besoin. Contrairement aux API RESTful, où plusieurs points de terminaison peuvent renvoyer des structures de données fixes, les services GraphQL permettent aux clients de spécifier la forme des données dont ils ont besoin, les rendant ainsi plus efficaces et flexibles.
Pour utiliser GraphQL dans un projet C#, vous aurez besoin de la bibliothèque HotChocolate, une implémentation populaire de serveur de point de terminaison GraphQL for .NET.
Tout d'abord, installez le package NuGet Hot Chocolate :
Un schéma GraphQL définit les types de données et les opérations disponibles dans votre API. Voici un exemple simple d'implémentation de schéma d'abord pour une application de blog :
using HotChocolate.Types;
public class QueryType : ObjectType
{
protected override void Configure(IObjectTypeDescriptor descriptor)
{
descriptor.Field("helloWorld")
.Type<StringType>()
.Resolve(context => "Hello, GraphQL!");
}
}Imports HotChocolate.Types
Public Class QueryType
Inherits ObjectType
Protected Overrides Sub Configure(ByVal descriptor As IObjectTypeDescriptor)
descriptor.Field("helloWorld").Type(Of StringType)().Resolve(Function(context) "Hello, GraphQL!")
End Sub
End ClassDans cet exemple, nous définissons un champ helloWorld qui renvoie une chaîne "Hello, GraphQL!" lorsqu'on le sollicite.
Ensuite, configurez un serveur GraphQL en utilisant ASP.NET Core :
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddGraphQLServer()
.AddQueryType<QueryType>();
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapGraphQL();
});
}
}Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.Extensions.DependencyInjection
Public Class Startup
Public Sub ConfigureServices(ByVal services As IServiceCollection)
services.AddGraphQLServer().AddQueryType(Of QueryType)()
End Sub
Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
app.UseRouting()
app.UseEndpoints(Sub(endpoints)
endpoints.MapGraphQL()
End Sub)
End Sub
End ClassVoyons maintenant comment interroger cette API GraphQL depuis un client C# en utilisant le package NuGet GraphQL.Client :
using GraphQL.Client.Http;
using GraphQL.Client.Serializer.Newtonsoft;
using System;
using System.Threading.Tasks;
// GraphQL query class to interact with the API
public class Query
{
public static async Task Main()
{
// Set up the GraphQL client
using var graphQLClient = new GraphQLHttpClient(new GraphQLHttpClientOptions
{
EndPoint = new Uri("http://localhost:5000/graphql") // GraphQL endpoint
}, new NewtonsoftJsonSerializer());
// Define the GraphQL query
var request = new GraphQLRequest
{
Query = @"
{
helloWorld
}"
};
var response = await graphQLClient.SendQueryAsync<dynamic>(request);
// Print the response from the GraphQL server
Console.WriteLine((string)response.Data.helloWorld);
}
}'INSTANT VB NOTE: 'Option Strict Off' is used here since dynamic typing is used:
Option Strict Off
Imports GraphQL.Client.Http
Imports GraphQL.Client.Serializer.Newtonsoft
Imports System
Imports System.Threading.Tasks
' GraphQL query class to interact with the API
Public Class Query
Public Shared Async Function Main() As Task
' Set up the GraphQL client
Dim graphQLClient = New GraphQLHttpClient(New GraphQLHttpClientOptions With {.EndPoint = New Uri("http://localhost:5000/graphql")}, New NewtonsoftJsonSerializer())
' Define the GraphQL query
Dim request = New GraphQLRequest With {.Query = "
{
helloWorld
}"}
'INSTANT VB NOTE: In the following line, Instant VB substituted 'Object' for 'dynamic' - this will work in VB with Option Strict Off:
Dim response = Await graphQLClient.SendQueryAsync(Of Object)(request)
' Print the response from the GraphQL server
Console.WriteLine(CStr(response.Data.helloWorld))
End Function
End ClassGraphQL C# offre un moyen puissant et flexible de concevoir des APIs, et avec des bibliothèques comme HotChocolate, intégrer un backend GraphQL dans vos applications C# devient simple. En définissant un schéma et en configurant un serveur, vous pouvez exposer vos données via une API GraphQL et les interroger efficacement à partir de clients C#.
IronPDF est une bibliothèque C# polyvalente qui vous permet de créer, éditer et manipuler des documents PDF sans effort. Dans cette section, nous présenterons IronPDF et démontrerons comment l'utiliser conjointement avec GraphQL pour générer des rapports PDF dynamiques.
IronPDF excelle avec sa fonctionnalité HTML vers PDF, en préservant tous les mises en page et styles. Il permet la création de fichiers PDF à partir de contenu web, parfait pour les rapports, les factures et la documentation. Les fichiers HTML, les URLs et les chaînes HTML peuvent être convertis en PDF de manière transparente.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 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");
// 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");
// 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()
' 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")
' 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")
' Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End ClassPour commencer avec IronPDF, installez le package NuGet :
Créons un rapport PDF qui récupère les données utilisateur de notre API GraphQL et les affiche de manière formatée.
using IronPdf;
using GraphQL.Client.Http;
using GraphQL.Client.Serializer.Newtonsoft;
using System;
using System.Threading.Tasks;
public class PdfGenerator
{
public async Task GeneratePdfAsync()
{
// Initialize GraphQL client
var graphQLClient = new GraphQLHttpClient(new GraphQLHttpClientOptions
{
EndPoint = new Uri("http://localhost:5000/graphql")
}, new NewtonsoftJsonSerializer());
// Define GraphQL query
var query = new GraphQLRequest
{
Query = @"
{
helloWorld
}"
};
var response = await graphQLClient.SendQueryAsync<dynamic>(query);
var helloMessage = response.Data.helloWorld.ToString();
// Create HTML content for the PDF
var htmlContent = $@"
<html>
<head><title>GraphQL Report</title></head>
<body>
<h1>GraphQL Report</h1>
<p>{helloMessage}</p>
</body>
</html>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("GraphQLReport.pdf");
}
}'INSTANT VB NOTE: 'Option Strict Off' is used here since dynamic typing is used:
Option Strict Off
Imports IronPdf
Imports GraphQL.Client.Http
Imports GraphQL.Client.Serializer.Newtonsoft
Imports System
Imports System.Threading.Tasks
Public Class PdfGenerator
Public Async Function GeneratePdfAsync() As Task
' Initialize GraphQL client
Dim graphQLClient = New GraphQLHttpClient(New GraphQLHttpClientOptions With {.EndPoint = New Uri("http://localhost:5000/graphql")}, New NewtonsoftJsonSerializer())
' Define GraphQL query
Dim query As New GraphQLRequest With {.Query = "
{
helloWorld
}"}
'INSTANT VB NOTE: In the following line, Instant VB substituted 'Object' for 'dynamic' - this will work in VB with Option Strict Off:
Dim response = Await graphQLClient.SendQueryAsync(Of Object)(query)
Dim helloMessage = response.Data.helloWorld.ToString()
' Create HTML content for the PDF
Dim htmlContent = $"
<html>
<head><title>GraphQL Report</title></head>
<body>
<h1>GraphQL Report</h1>
<p>{helloMessage}</p>
</body>
</html>"
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("GraphQLReport.pdf")
End Function
End ClassDans cet exemple, nous utilisons le client GraphQL pour récupérer le message helloWorld de notre API GraphQL. Ensuite, nous construisons un modèle HTML qui inclut ce message et utilisons le ChromePdfRenderer d'IronPDF pour convertir cet HTML en fichier PDF.
GraphQL a émergé comme un changeur de jeu dans le développement d'API, offrant un moyen plus flexible et efficace de requêter et de manipuler des données par rapport aux API RESTful traditionnelles. Sa capacité à permettre aux clients de ne demander que les données de type de requête dont ils ont besoin le rend particulièrement attrayant pour les applications web modernes où la performance et la flexibilité sont primordiales.
En outre, combiner GraphQL avec des outils et des packages tels que IronPDF ouvre un monde de possibilités passionnantes pour générer des rapports PDF dynamiques et pilotés par les données. Que vous créiez des factures, génériez des rapports ou produisiez tout autre type de documents, intégrer IronPDF avec GraphQL en C# offre un moyen puissant et efficace d'automatiser la génération de PDF.
En résumé, GraphQL et C# constituent une combinaison puissante pour construire des applications web modernes, flexibles et efficaces. Avec des bibliothèques comme HotChocolate, GraphQL.Client, et IronPDF, les développeurs ont tous les outils nécessaires pour créer des applications robustes et axées sur les données qui répondent aux exigences du paysage numérique actuel.
Le tutoriel HTML vers PDF est disponible dans le Guide de Licence IronPDF pour permettre aux utilisateurs de le consulter.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
