AIDE .NET

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

Kannapat Udonpant

juin 6, 2024

Introduction

GraphQL a gagné en popularité en tant qu'alternative aux API RESTful pour la création de services web flexibles et efficaces. GraphQL est disponible dans de nombreux langages différents, tels que Java, Python, ASP .NET core. Mais dans cet article, nous allons nous plonger dans l'utilisation de GraphQL dans le contexte de C#, en explorant ses concepts, sa mise en œuvre et son utilisation à l'aide d'exemples pratiques. Nous utiliserons égalementIronPDF 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 ?

Langage de requête GraphQL pour les API qui permet aux clients de demander exactement les données dont ils ont besoin. Contrairement aux API RESTful, où plusieurs points d'accès 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, ce qui les rend plus efficaces et plus flexibles.

Mise en place de GraphQL dans C# ;

Pour utiliser GraphQL dans un projet C#, vous aurez besoin de la bibliothèque HotChocolate, une implémentation populaire du serveur de points d'extrémité GraphQL pour .NET.

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

Install-Package HotChocolate.AspNetCore

Création d'un schéma GraphQL

Un schéma de mise en œuvre GraphQL définit les types de données et les opérations disponibles dans votre API. Voici un exemple simple de schéma premier, d'un schéma de service GraphQL pour une application de blog :

using HotChocolate.Types;
public class QueryType : ObjectType
{
    protected override void Configure(IObjectTypeDescriptor descriptor)
    {
        descriptor.Field("hello world")
            .Type<StringType>()
            .Resolve(context => "Hello, GraphQL!");
    }
}

using HotChocolate.Types;
public class QueryType : ObjectType
{
    protected override void Configure(IObjectTypeDescriptor descriptor)
    {
        descriptor.Field("hello world")
            .Type<StringType>()
            .Resolve(context => "Hello, GraphQL!");
    }
}

Imports HotChocolate.Types
Public Class QueryType
	Inherits ObjectType

	Protected Overrides Sub Configure(ByVal descriptor As IObjectTypeDescriptor)
		descriptor.Field("hello world").Type(Of StringType)().Resolve(Function(context) "Hello, GraphQL!")
	End Sub
End Class

Dans cet exemple, nous définissons un champ hello world qui renvoie une chaîne de caractères "Hello, GraphQL"!" lorsqu'il est interrogé.

Création d'un serveur GraphQL

Ensuite, mettez en place un serveur GraphQL à l'aide d'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

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;
using GraphQL.Client.Http;
using System;
using System.Threading.Tasks;
// query class
public class query
{
    public static async Task Main()
    {
        using var graphQLClient = new GraphQLHttpClient(new GraphQLHttpClientOptions
        {
            EndPoint = new Uri("http://localhost:5000/graphql")
        });
        var schema = new GraphQLRequest
        {
            Query = @"
                {
                    hello world
                }"
        };
        var response = await graphQLClient.SendQueryAsync<dynamic>(schema);
        Console.WriteLine(response.Data.hello);
    }
}

using GraphQL.Client;
using GraphQL.Client.Http;
using System;
using System.Threading.Tasks;
// query class
public class query
{
    public static async Task Main()
    {
        using var graphQLClient = new GraphQLHttpClient(new GraphQLHttpClientOptions
        {
            EndPoint = new Uri("http://localhost:5000/graphql")
        });
        var schema = new GraphQLRequest
        {
            Query = @"
                {
                    hello world
                }"
        };
        var response = await graphQLClient.SendQueryAsync<dynamic>(schema);
        Console.WriteLine(response.Data.hello);
    }
}

'INSTANT VB NOTE: 'Option Strict Off' is used here since dynamic typing is used:
Option Strict Off

Imports GraphQL.Client
Imports GraphQL.Client.Http
Imports System
Imports System.Threading.Tasks
' query class
Public Class query
	Public Shared Async Function Main() As Task
		Dim graphQLClient = New GraphQLHttpClient(New GraphQLHttpClientOptions With {.EndPoint = New Uri("http://localhost:5000/graphql")})
		Dim schema = New GraphQLRequest With {.Query = "
                {
                    hello world
                }"}
'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)(schema)
		Console.WriteLine(response.Data.hello)
	End Function
End Class

GraphQL C# offre un moyen puissant et flexible de concevoir des API, et avec des bibliothèques comme HotChocolate, l'intégration d'un backend GraphQL dans vos applications C# devient simple. En définissant un schéma et en mettant en place 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 lors de l'exécution du code précédent

Introduction à IronPDF en C&num ;

IronPDF est une bibliothèque C# polyvalente qui vous permet de créer, d'éditer et de manipuler des documents PDF sans effort. Dans cette section, nous allons présenter IronPDF et montrer comment l'utiliser en conjonction avec GraphQL pour générer des rapports PDF dynamiques.

IronPDF excelle par sonFonctionnalité HTML vers PDF, en préservant toutes les mises en page et styles. Il permet de créer des PDF à partir de contenu web, ce qui est parfait pour les rapports, les factures et la documentation. Les fichiers HTML, les URL 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();

        // 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

Installation d'IronPDF

Pour commencer à utiliser IronPDF, installez le paquetage NuGet :

Install-Package IronPdf

Génération de PDF avec des données GraphQL à l'aide d'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;
using GraphQL.Client.Http;
using System.Threading.Tasks;
using System;
public class PdfGenerator
{
    public async Task GeneratePdfAsync()
    {
        var graphQLClient = new GraphQLHttpClient(new GraphQLHttpClientOptions
        {
            EndPoint = new Uri("http://localhost:5000/graphql")
        });
        // graphql queries & graphql requests
        var query = new GraphQLRequest 
        {
            Query = @"
                {
                    hello world
                }"
        };
        var response = await graphQLClient.SendQueryAsync<dynamic>(query);
        var helloMessage = response.Data.hello.ToString();
        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;
using GraphQL.Client.Http;
using System.Threading.Tasks;
using System;
public class PdfGenerator
{
    public async Task GeneratePdfAsync()
    {
        var graphQLClient = new GraphQLHttpClient(new GraphQLHttpClientOptions
        {
            EndPoint = new Uri("http://localhost:5000/graphql")
        });
        // graphql queries & graphql requests
        var query = new GraphQLRequest 
        {
            Query = @"
                {
                    hello world
                }"
        };
        var response = await graphQLClient.SendQueryAsync<dynamic>(query);
        var helloMessage = response.Data.hello.ToString();
        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
Imports GraphQL.Client.Http
Imports System.Threading.Tasks
Imports System
Public Class PdfGenerator
	Public Async Function GeneratePdfAsync() As Task
		Dim graphQLClient = New GraphQLHttpClient(New GraphQLHttpClientOptions With {.EndPoint = New Uri("http://localhost:5000/graphql")})
		' graphql queries & graphql requests
		Dim query As New GraphQLRequest With {.Query = "
                {
                    hello world
                }"}
'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.hello.ToString()
		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

Dans cet exemple, nous utilisons le client GraphQL pour récupérer le message "hello world'" à partir de notre API GraphQL. Ensuite, nous construisons un modèle HTML qui inclut ce message et nous utilisons le ChromePdfRenderer d'IronPDF pour convertir ce HTML en un fichier PDF.

Sortie

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

Conclusion

GraphQL a changé la donne en matière de développement d'API, car il offre un moyen plus souple et plus efficace d'interroger et de manipuler des données que les API RESTful traditionnelles. Sa capacité à permettre aux clients de demander uniquement le type de données dont ils ont besoin le rend particulièrement intéressant pour les applications web modernes où la performance et la flexibilité sont primordiales.

En outre, la combinaison de GraphQL avec des outils et des progiciels tels queIronPDF ouvre un monde de possibilités passionnantes pour la création de rapports PDF dynamiques et axés sur les données. Qu'il s'agisse de créer des factures, de générer des rapports ou de produire tout autre type de document, l'intégration d'IronPDF avec GraphQL en C# constitue un moyen puissant et efficace d'automatiser la génération de PDF.

En résumé, GraphQL et C# constituent une combinaison puissante pour créer des applications web modernes, flexibles et efficaces. Avec des bibliothèques telles que HotChocolate, GraphQL.Client et IronPDF, les développeurs disposent de 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 à l'adresse suivanteGuide de licence IronPDF pour les utilisateurs.

Kannapat Udonpant

Discutez avec l'équipe d'ingénierie maintenant

Ingénieur logiciel

Avant de devenir ingénieur logiciel, Kannapat a obtenu un doctorat en ressources environnementales à l'université d'Hokkaido au Japon. Tout en poursuivant ses études, Kannapat est également devenu membre du Vehicle Robotics Laboratory, qui fait partie du Department of Bioproduction Engineering (département d'ingénierie de la bioproduction). En 2022, il a mis à profit ses compétences en C# pour rejoindre l'équipe d'ingénieurs d'Iron Software, où il se concentre sur IronPDF. Kannapat apprécie son travail car il apprend directement auprès du développeur qui écrit la majeure partie du code utilisé dans IronPDF. Outre l'apprentissage par les pairs, Kannapat apprécie l'aspect social du travail chez Iron Software. Lorsqu'il n'écrit pas de code ou de documentation, Kannapat peut généralement être trouvé en train de jouer sur sa PS5 ou de revoir The Last of Us.

< PRÉCÉDENT
Constructeur de base d'appel C# (Comment ça marche pour les développeurs)

SUIVANT >
C# Long to String (Comment ça marche pour les développeurs)