"}">
Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. GraphQL C#
.NET AIDE

GraphQL C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

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.

Qu'est-ce que 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.

Configurer GraphQL en C#

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 pour .NET.

Tout d'abord, installez le package NuGet Hot Chocolate :

Install-Package HotChocolate.AspNetCore

Créer un schéma GraphQL

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!");
    }
}
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 Class
$vbLabelText   $csharpLabel

Dans cet exemple, nous définissons un champ helloWorld qui retourne une chaîne "Hello, GraphQL!" lorsqu'il est interrogé.

Créer un serveur GraphQL

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

Interroger GraphQL à partir de C#

Voyons maintenant comment interroger cette API GraphQL à partir d'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);
    }
}
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 Class
$vbLabelText   $csharpLabel

GraphQL 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#.

Sortie

GraphQL C# (Comment ça marche pour les développeurs) : Figure 1 - Sortie de la console après exécution du code précédent

Introduction à IronPDF en 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");
    }
}
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 Class
$vbLabelText   $csharpLabel

Installer IronPDF

Pour commencer avec IronPDF, installez le package NuGet :

Install-Package IronPdf

Générer un PDF avec des données GraphQL en utilisant IronPDF

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.

Exemple

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

Dans 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 de IronPDF pour convertir cet HTML en fichier PDF.

Sortie

GraphQL C# (Comment ça marche pour les développeurs) : Figure 2 - PDF généré à partir du code précédent

Conclusion

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 dont ils ont besoin pour construire des applications robustes et alimentées par les données qui répondent aux exigences du paysage numérique d'aujourd'hui.

Le tutoriel HTML vers PDF est disponible dans le Guide de Licence IronPDF pour permettre aux utilisateurs de le consulter.

Questions Fréquemment Posées

En quoi GraphQL diffère-t-il des API RESTful ?

GraphQL permet aux clients de demander exactement les données dont ils ont besoin, réduisant ainsi la sur-récupération et la sous-récupération typiques des API RESTful. Cette flexibilité le rend plus efficace pour la requête et la manipulation de données.

Quelle bibliothèque est recommandée pour configurer un serveur GraphQL en C# ?

La bibliothèque HotChocolate est recommandée pour configurer un serveur GraphQL en C#. Elle fournit des outils pour définir des schémas et gérer les requêtes au sein d'un environnement .NET.

Comment puis-je créer un rapport PDF à partir de données GraphQL en C# ?

Vous pouvez extraire des données d'une API GraphQL et utiliser IronPDF pour convertir les données en un rapport PDF dynamique. IronPDF vous permet de manipuler les documents PDF en convertissant le contenu HTML en format PDF.

Quelles étapes sont impliquées dans l'intégration de GraphQL dans un projet C# ?

Pour intégrer GraphQL dans un projet C#, installez le package NuGet HotChocolate, définissez un schéma pour décrire les types de données et opérations, et configurez le serveur en utilisant ASP.NET Core.

Comment interroger une API GraphQL en utilisant un client C# ?

Utilisez le package NuGet GraphQL.Client pour configurer un GraphQLHttpClient avec l'URI du point de terminaison de l'API. Définissez votre requête et envoyez-la en utilisant la méthode SendQueryAsync.

Puis-je convertir une URL en PDF en C# ?

Oui, vous pouvez convertir une URL en PDF en C# en utilisant le ChromePdfRenderer de IronPDF. Cela vous permet de rendre le contenu HTML à partir d'URLs directement dans un document PDF.

Pourquoi utiliser IronPDF en conjonction avec GraphQL pour la création de PDFs ?

IronPDF peut convertir le contenu HTML dynamique extrait via GraphQL en PDFs, ce qui est idéal pour créer des rapports basés sur les données nécessitant des données mises à jour et spécifiques.

Comment créer un schéma GraphQL de base en C# ?

Pour créer un schéma GraphQL de base en C#, définissez les types de données et opérations disponibles en utilisant les outils de définition de schéma de la bibliothèque HotChocolate. Cela implique de spécifier les champs et leurs types de données.

Quels sont les avantages d'utiliser GraphQL avec C# pour les applications web ?

Utiliser GraphQL avec C# offre flexibilité et avantages de performance, permettant une interrogation et une manipulation des données efficaces, ce qui est essentiel pour construire des applications web modernes.

Comment installer IronPDF pour une utilisation dans un projet C# ?

Installez IronPDF pour un projet C# en utilisant le gestionnaire de packages NuGet avec la commande : Install-Package IronPdf. Cela vous permet d'accéder à ses capacités de génération et de manipulation de PDFs.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit