GraphQL C# (Wie es für Entwickler funktioniert)

Einführung

GraphQL hat als Alternative zu RESTful APIs für den Aufbau flexibler und effizienter Webdienste erheblich an Popularität gewonnen. GraphQL ist in vielen verschiedenen Sprachen verfügbar, wie Java, Python, ASP .NET Core. In diesem Artikel werden wir uns jedoch mit der Verwendung von GraphQL im Kontext von C# befassen und die Konzepte, die Implementierung und die Verwendung anhand praktischer Beispiele untersuchen. Außerdem werden wir Folgendes verwenden IronPDF für C# zur Erstellung von PDF-Dateien mit Hilfe der GraphQL-Schemadefinitions-Abfrageklasse.

Was ist GraphQL?

GraphQL-Abfragesprache für APIs, mit der Kunden genau die Daten anfordern können, die sie benötigen. Im Gegensatz zu RESTful-APIs, bei denen mehrere Endpunkte feste Datenstrukturen zurückgeben können, können Kunden bei GraphQL-Diensten die Form der benötigten Daten angeben, was sie effizienter und flexibler macht.

Einrichten von GraphQL in C#;

Um GraphQL in einem C#-Projekt zu verwenden, benötigen Sie die HotChocolate-Bibliothek, eine beliebte GraphQL-Endpunkt-Server-Implementierung für .NET.

Installieren Sie zunächst das Hot Chocolate NuGet-Paket:

Install-Package HotChocolate.AspNetCore

Erstellen eines GraphQL-Schemas

Ein GraphQL-Implementierungsschema definiert die in Ihrer API verfügbaren Datentypen und Operationen. Hier ist ein einfaches Beispiel für ein Schema eines GraphQL-Dienstes für eine Blog-Anwendung:

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

In diesem Beispiel definieren wir ein Hallo-Welt-Feld, das eine Zeichenkette "Hallo, GraphQL" zurückgibt!", wenn sie abgefragt werden.

Erstellen eines GraphQL-Servers

Als nächstes richten Sie einen GraphQL-Server mit ASP.NET Core ein:

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

Abfrage von GraphQL von C#

Sehen wir uns nun an, wie man diese GraphQL-API von einem C#-Client aus mit dem NuGet-Paket GraphQL.Client abfragt:

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>(shema);
        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>(shema);
        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)(shema)
		Console.WriteLine(response.Data.hello)
	End Function
End Class

GraphQL C# bietet eine leistungsstarke und flexible Möglichkeit, APIs zu entwerfen, und mit Bibliotheken wie HotChocolate wird die Integration eines GraphQL-Backends in Ihre C#-Anwendungen ganz einfach. Durch die Definition eines Schemas und die Einrichtung eines Servers können Sie Ihre Daten über eine GraphQL-API offenlegen und sie effizient von C#-Clients abfragen.

Ausgabe

Einführung in IronPDF in C#

IronPDF ist eine vielseitige C#-Bibliothek, mit der Sie mühelos PDF-Dokumente erstellen, bearbeiten und manipulieren können. In diesem Abschnitt stellen wir IronPDF vor und zeigen, wie man es in Verbindung mit GraphQL verwendet, um dynamische PDF-Berichte zu erstellen.

IronPDF zeichnet sich durch seine HTML zu PDF funktion, wobei alle Layouts und Stile erhalten bleiben. Es ermöglicht die Erstellung von PDF-Dateien aus Web-Inhalten, ideal für Berichte, Rechnungen und Dokumentation. HTML-Dateien, URLs und HTML-Strings können nahtlos in PDFs umgewandelt werden.

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 von IronPDF

Um mit IronPDF zu arbeiten, installieren Sie das NuGet-Paket:

Install-Package IronPdf

PDF-Erzeugung mit GraphQL-Daten mit IronPDF

Lassen Sie uns einen PDF-Bericht erstellen, der Benutzerdaten von unserer GraphQL-API abruft und sie in formatierter Form anzeigt.

Beispiel

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

In diesem Beispiel verwenden wir den GraphQL-Client, um die Nachricht "Hallo Welt " von unserer GraphQL-API abzurufen. Dann erstellen wir eine HTML-Vorlage, die diese Nachricht enthält, und verwenden den ChromePdfRenderer von IronPDF, um diese HTML-Datei in eine PDF-Datei zu konvertieren.

Ausgabe

Schlussfolgerung

GraphQL hat sich bei der Entwicklung von APIs als bahnbrechend erwiesen, da es im Vergleich zu herkömmlichen RESTful-APIs eine flexiblere und effizientere Methode zur Abfrage und Bearbeitung von Daten bietet. Seine Fähigkeit, Kunden nur die Art von Abfragedaten anzufordern, die sie benötigen, macht es besonders attraktiv für moderne Webanwendungen, bei denen Leistung und Flexibilität an erster Stelle stehen.

Außerdem ist die Kombination von GraphQL mit Tools und Paketen wie IronPDF eröffnet eine Welt voller spannender Möglichkeiten für die Erstellung dynamischer und datengesteuerter PDF-Berichte. Ob Sie nun Rechnungen, Berichte oder andere Dokumente erstellen, die Integration von IronPDF mit GraphQL in C# bietet eine leistungsstarke und effiziente Möglichkeit, die PDF-Erzeugung zu automatisieren.

Zusammenfassend lässt sich sagen, dass GraphQL und C# eine leistungsstarke Kombination für die Erstellung moderner, flexibler und effizienter Webanwendungen sind. Mit Bibliotheken wie HotChocolate, GraphQL.Client und IronPDF stehen Entwicklern alle Werkzeuge zur Verfügung, die sie benötigen, um robuste, datengesteuerte Anwendungen zu erstellen, die den Anforderungen der heutigen digitalen Landschaft gerecht werden.

Das HTML-zu-PDF-Tutorial ist unter folgender Adresse verfügbar link für die Nutzer zur Verfügung stehen.