Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Unterstützung
  4. GraphQL in C#
.NET HILFE

GraphQL C# (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

GraphQL hat sich als beliebte Alternative zu RESTful-APIs für den Aufbau flexibler und effizienter Webdienste etabliert. GraphQL ist in vielen verschiedenen Sprachen verfügbar, wie z.B. Java, Python, ASP .NET Core. Aber in diesem Artikel werden wir die Verwendung von GraphQL im Kontext von C# eingehend untersuchen, indem wir dessen Konzepte, Implementierung und Nutzung mit praktischen Beispielen erkunden. Außerdem werden wir IronPDF für C# verwenden, um PDF-Dateien mit Hilfe der GraphQL-Schema-Definition-Abfrageklasse zu erstellen.

Was ist GraphQL?

GraphQL ist eine Abfragesprache für APIs, die es den Clients ermöglicht, genau die Daten anzufordern, die sie benötigen. Im Gegensatz zu RESTful-APIs, bei denen mehrere Endpunkte feste Datenstrukturen zurückgeben könnten, erlauben es GraphQL-Dienste den Clients, die Form der benötigten Daten anzugeben, 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.

Zuerst installieren Sie das Hot Chocolate NuGet-Paket:

Install-Package HotChocolate.AspNetCore

Erstellen eines GraphQL-Schemas

Ein GraphQL-Schema definiert die Datentypen und Operationen, die in Ihrer API verfügbar sind. Hier ist ein einfaches Beispiel für eine schema-basierte Implementierung einer Blog-Anwendung:

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

In diesem Beispiel definieren wir ein helloWorld-Feld, das einen String "Hello, GraphQL!" zurückgibt, wenn es abgefragt wird.

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
$vbLabelText   $csharpLabel

Abfrage von GraphQL aus C#;

Nun möchten wir sehen, wie man diese GraphQL-API von einem C#-Client mit dem GraphQL.Client NuGet-Paket abfragt:

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# 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 unkompliziert. Durch die Definition eines Schemas und das Einrichten eines Servers können Sie Ihre Daten über eine GraphQL-API bereitstellen und effizient von C#-Clients abfragen.

Ausgabe

GraphQL C# (wie es für Entwickler funktioniert): Abbildung 1 - Konsolenausgabe nach Ausführen des vorherigen Codes

Einführung in IronPDF in C#;

IronPDF ist eine vielseitige C#-Bibliothek, die es ermöglicht, PDF-Dokumente mühelos zu erstellen, zu bearbeiten und zu manipulieren. In diesem Abschnitt stellen wir IronPDF vor und demonstrieren, wie man es in Verbindung mit GraphQL einsetzt, um dynamische PDF-Berichte zu erstellen.

IronPDF glänzt mit seiner HTML-zu-PDF-Funktionalität, die alle Layouts und Stile bewahrt. Es ermöglicht die Erstellung von PDFs aus Webinhalten, perfekt für Berichte, Rechnungen und Dokumentationen. 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();

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

Installation von IronPDF

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

Install-Package IronPdf

Erzeugen von PDF mit GraphQL-Daten mit IronPDF

Erstellen wir einen PDF-Bericht, der Benutzerdaten aus unserer GraphQL-API abruft und sie formatiert darstellt.

Beispiel

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

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

Ausgabe

GraphQL C# (wie es für Entwickler funktioniert): Abbildung 2 - Ausgegebenes PDF aus dem vorherigen Code

Abschluss

GraphQL hat sich als wegweisend in der API-Entwicklung erwiesen und bietet eine flexiblere und effizientere Methode, um Daten im Vergleich zu traditionellen RESTful-APIs abzufragen und zu manipulieren. Seine Fähigkeit, es den Clients zu ermöglichen, nur die benötigten Abfragedaten anzufordern, macht es besonders attraktiv für moderne Webanwendungen, bei denen Leistung und Flexibilität entscheidend sind.

Darüber hinaus eröffnet die Kombination von GraphQL mit Tools und Paketen wie IronPDF eine Welt aufregender Möglichkeiten zur Erstellung dynamischer und datengesteuerter PDF-Berichte. Ob Sie Rechnungen erstellen, Berichte generieren oder andere Arten von Dokumenten produzieren möchten, die Integration von IronPDF mit GraphQL in C# bietet eine leistungsstarke und effiziente Möglichkeit, die PDF-Generierung zu automatisieren.

Zusammenfassend lässt sich sagen, dass GraphQL und C# eine starke Kombination für den Aufbau moderner, flexibler und effizienter Webanwendungen darstellen. Mit Bibliotheken wie HotChocolate, GraphQL.Client und IronPDF haben Entwickler alle Werkzeuge, die sie benötigen, um robuste, datengesteuerte Anwendungen zu bauen, die den Anforderungen der heutigen digitalen Landschaft gerecht werden.

Das Tutorial HTML zu PDF ist unter dem folgenden IronPDF-Lizenzhandbuch für Benutzer erhältlich.

Häufig gestellte Fragen

Wie unterscheidet sich GraphQL von RESTful-APIs?

GraphQL ermöglicht es Clients, genau die Daten anzufordern, die sie benötigen, und reduziert somit das Über- und Unterabrufen, das typisch für RESTful-APIs ist. Diese Flexibilität macht es effizienter zum Abfragen und Manipulieren von Daten.

Welche Bibliothek wird zur Einrichtung eines GraphQL-Servers in C# empfohlen?

Die HotChocolate-Bibliothek wird zur Einrichtung eines GraphQL-Servers in C# empfohlen. Sie bietet Werkzeuge zur Definition von Schemata und zur Verwaltung von Abfragen innerhalb einer .NET-Umgebung.

Wie kann ich einen PDF-Bericht aus GraphQL-Daten in C# erstellen?

Sie können Daten von einer GraphQL-API abrufen und IronPDF verwenden, um die Daten in einen dynamischen PDF-Bericht zu konvertieren. IronPDF ermöglicht es Ihnen, PDF-Dokumente zu manipulieren, indem es HTML-Inhalte in das PDF-Format konvertiert.

Welche Schritte sind bei der Integration von GraphQL in ein C#-Projekt erforderlich?

Um GraphQL in ein C#-Projekt zu integrieren, installieren Sie das HotChocolate NuGet-Paket, definieren Sie ein Schema zur Darstellung von Datentypen und Operationen und richten Sie den Server mit ASP.NET Core ein.

Wie fragt man eine GraphQL-API mit einem C#-Client ab?

Verwenden Sie das GraphQL.Client NuGet-Paket, um einen GraphQLHttpClient mit dem API-Endpunkt-URI einzurichten. Definieren Sie Ihre Abfrage und senden Sie sie mit der Methode SendQueryAsync.

Kann ich eine URL in ein PDF in C# konvertieren?

Ja, Sie können eine URL in ein PDF in C# mit dem ChromePdfRenderer von IronPDF konvertieren. Es ermöglicht Ihnen, HTML-Inhalte direkt von URLs in ein PDF-Dokument zu rendern.

Warum IronPDF in Verbindung mit GraphQL zur PDF-Erstellung verwenden?

IronPDF kann dynamische HTML-Inhalte, die über GraphQL abgerufen werden, in PDFs konvertieren, was ideal ist für die Erstellung von datengetriebenen Berichten, die aktualisierte und spezifische Datenausgaben erfordern.

Wie erstellt man ein einfaches GraphQL-Schema in C#?

Um ein einfaches GraphQL-Schema in C# zu erstellen, definieren Sie die verfügbaren Datentypen und Operationen mit den Schema-Definitionstools der HotChocolate-Bibliothek. Dazu gehört die Angabe von Feldern und deren Datentypen.

Welche Vorteile bietet die Verwendung von GraphQL mit C# für Webanwendungen?

Die Verwendung von GraphQL mit C# bietet Flexibilität und Leistungsverbesserungen, erlaubt effiziente Datenabfragen und -manipulationen, was für den Aufbau moderner Webanwendungen unerlässlich ist.

Wie installiert man IronPDF zur Verwendung in einem C#-Projekt?

Installieren Sie IronPDF für ein C#-Projekt mit dem NuGet-Paketmanager mit dem Befehl: Install-Package IronPdf. Dies ermöglicht Ihnen den Zugriff auf seine PDF-Erstellungs- und Bearbeitungsmöglichkeiten.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen