Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. GraphQL C#
POMOC .NET

GraphQL C# (jak to działa dla programistów)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

GraphQL zdobył znaczną popularność jako alternatywa dla RESTful API do tworzenia elastycznych i wydajnych usług sieciowych. GraphQL jest dostępny w wielu różnych językach, takich jak Java, Python, ASP .NET core. Ale w tym artykule zagłębimy się w użycie GraphQL w kontekście C#, eksplorując jego koncepcje, implementację i użycie z praktycznymi przykładami. Również będziemy używać IronPDF dla C# do tworzenia plików PDF za pomocą klasy zapytań definicji schematu GraphQL.

Czym jest GraphQL?

GraphQL to język zapytań dla API, który umożliwia klientom żądanie dokładnie tych danych, których potrzebują. W przeciwieństwie do RESTful API, gdzie wiele punktów końcowych może zwracać stałe struktury danych, usługi GraphQL pozwalają klientom na określenie kształtu danych, które potrzebują, co czyni je bardziej efektywnymi i elastycznymi.

Setting up GraphQL in C

Aby używać GraphQL w projekcie C#, potrzebna będzie biblioteka HotChocolate, popularna implementacja serwera końcowego GraphQL dla .NET.

Najpierw zainstaluj paczkę NuGet Hot Chocolate:

Install-Package HotChocolate.AspNetCore

Tworzenie schematu GraphQL

Schemat GraphQL definiuje typy danych i operacje dostępne w Twoim API. Oto prosty przykład implementacji schema-first dla aplikacji blogowej:

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

W tym przykładzie definiujemy pole helloWorld, które zwraca ciąg znaków "Hello, GraphQL!" podczas zapytania.

Tworzenie serwera GraphQL

Następnie, skonfiguruj serwer GraphQL używając 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

Querying GraphQL from C

Teraz zobaczmy, jak zapytać to API GraphQL z poziomu klienta C# używając paczki 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# oferuje potężny i elastyczny sposób projektowania API, a dzięki bibliotekom takim jak HotChocolate, integracja zaplecza GraphQL w aplikacjach C# staje się prosta. Definiując schemat i konfigurowując serwer, możesz udostępnić swoje dane za pośrednictwem API GraphQL i efektywnie zapytać je z klientów C#.

Wynik

GraphQL C# (Jak to działa dla deweloperów): Rysunek 1 - Wynik konsoli z uruchomienia poprzedniego kodu

Intro to IronPDF in C

IronPDF to wszechstronna biblioteka C#, która pozwala łatwo tworzyć, edytować i manipulować dokumentami PDF. W tej sekcji przedstawimy IronPDF i pokażemy, jak połączyć go z GraphQL do generowania dynamicznych raportów PDF.

IronPDF wyróżnia się swoją funkcjonalnością HTML do PDF, zachowując wszystkie układy i style. Umożliwia tworzenie plików PDF z treści internetowych, idealnych do raportów, faktur i dokumentacji. Pliki HTML, URL i ciągi HTML mogą zostać bezproblemowo zamienione na pliki 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");
    }
}
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

Instalacja IronPDF

Aby rozpocząć z IronPDF, zainstaluj paczkę NuGet:

Install-Package IronPdf

Generowanie PDF z danymi GraphQL za pomocą IronPDF

Stwórzmy raport PDF, który pobiera dane użytkownika z naszego API GraphQL i wyświetla je w sformatowany sposób.

Przykład

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

W tym przykładzie używamy klienta GraphQL do pobrania wiadomości helloWorld z naszego API GraphQL. Następnie konstruujemy szablon HTML, który zawiera tę wiadomość i używamy ChromePdfRenderer IronPDF do zamiany tego HTML na plik PDF.

Wynik

GraphQL C# (Jak to działa dla deweloperów): Rysunek 2 - Wygenerowany plik PDF z poprzedniego kodu

Wnioski

GraphQL pojawił się jako przełom w rozwoju API, oferując bardziej elastyczny i wydajny sposób na zapytania i manipulowanie danymi w porównaniu do tradycyjnych RESTful API. Jego zdolność do umożliwienia klientom żądania tylko rodzaju danych, których potrzebują, czyni go szczególnie atrakcyjnym dla nowoczesnych aplikacji internetowych, gdzie wydajność i elastyczność są priorytetem.

Ponadto, łącznie GraphQL z narzędziami i paczkami takimi jak IronPDF otwiera świat ekscytujących możliwości dla generowania dynamicznych i danych raportów PDF. Niezależnie od tego, czy tworzysz faktury, generujesz raporty, czy produkujesz inne rodzaje dokumentów, integracja IronPDF z GraphQL w C# zapewnia potężny i wydajny sposób automatyzacji generowania PDF.

Podsumowując, GraphQL i C# tworzą potężne połączenie do budowy nowoczesnych, elastycznych i wydajnych aplikacji internetowych. Dzięki bibliotekom takim jak HotChocolate, GraphQL.Client oraz IronPDF, deweloperzy mają wszystkie narzędzia potrzebne do budowy solidnych, opartych na danych aplikacji, które spełniają potrzeby współczesnego cyfrowego krajobrazu.

Samouczek HTML do PDF jest dostępny w następującym Przewodniku licencyjnym IronPDF dla użytkowników do skorzystania.

Często Zadawane Pytania

Czym GraphQL różni się od interfejsów API RESTful?

GraphQL pozwala klientom żądać dokładnie tych danych, których potrzebują, ograniczając nadmierne i niedostateczne pobieranie danych, typowe dla interfejsów API RESTful. Ta elastyczność sprawia, że jest on bardziej wydajny w zakresie wyszukiwania i manipulowania danymi.

Jaka biblioteka jest zalecana do skonfigurowania serwera GraphQL w języku C#?

Biblioteka HotChocolate jest zalecana do konfiguracji serwera GraphQL w języku C#. Zapewnia narzędzia do definiowania schematów i zarządzania zapytaniami w środowisku .NET.

Jak mogę utworzyć raport PDF na podstawie danych GraphQL w języku C#?

Możesz pobrać dane z interfejsu API GraphQL i użyć IronPDF do przekształcenia danych w dynamiczny raport PDF. IronPDF pozwala na manipulowanie dokumentami PDF poprzez konwersję treści HTML do formatu PDF.

Jakie kroki należy wykonać, aby zintegrować GraphQL z projektem w języku C#?

Aby zintegrować GraphQL z projektem C#, zainstaluj pakiet HotChocolate NuGet, zdefiniuj schemat określający typy danych i operacje oraz skonfiguruj serwer przy użyciu ASP.NET Core.

Jak wysłać zapytanie do interfejsu API GraphQL za pomocą klienta C#?

Użyj pakietu NuGet GraphQL.Client, aby skonfigurować GraphQLHttpClient z adresem URI punktu końcowego API. Zdefiniuj zapytanie i wyślij je za pomocą metody SendQueryAsync.

Czy mogę przekonwertować adres URL na plik PDF w języku C#?

Tak, można przekonwertować adres URL na plik PDF w języku C# przy użyciu biblioteki ChromePdfRenderer firmy IronPDF. Umożliwia ona renderowanie treści HTML z adresów URL bezpośrednio do dokumentu PDF.

Dlaczego warto używać IronPDF w połączeniu z GraphQL do tworzenia plików PDF?

IronPDF może konwertować dynamiczną zawartość HTML pobraną za pośrednictwem GraphQL do formatu PDF, co idealnie nadaje się do tworzenia raportów opartych na danych, które wymagają aktualnych i konkretnych wyników.

Jak utworzyć podstawowy schemat GraphQL w języku C#?

Aby utworzyć podstawowy schemat GraphQL w języku C#, należy zdefiniować dostępne typy danych i operacje za pomocą narzędzi do definiowania schematów biblioteki HotChocolate. Wymaga to określenia pól i ich typów danych.

Jakie są zalety używania GraphQL z C# w aplikacjach internetowych?

Wykorzystanie GraphQL w języku C# zapewnia elastyczność i korzyści w zakresie wydajności, umożliwiając efektywne wyszukiwanie i przetwarzanie danych, co jest niezbędne do tworzenia nowoczesnych aplikacji internetowych.

Jak zainstalować IronPDF do użytku w projekcie C#?

Zainstaluj IronPDF dla projektu C# za pomocą menedżera pakietów NuGet, używając polecenia: Install-Package IronPdf. Umożliwi to dostęp do funkcji generowania i edycji plików PDF.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie