Grapevine .NET (Comment ça fonctionne pour les développeurs)

Qu'est-ce que Grapevine C#?

Un service web RESTful léger, rapide et adaptable ainsi qu'une API peuvent être créés avec l'aide de Grapevine, un micro cadre web C#. Il est parfait pour les petits projets, prototypes et microservices qui doivent gérer efficacement les requêtes HTTP, grâce à ses modèles simples et son architecture de base qui garantissent une mise en place rapide et une excellente performance.

Grapevine simplifie le processus d'identification et de gestion des points d'accès en fournissant un mécanisme de routage flexible et convivial. Il simplifie la création d'opérations CRUD et d'APIs RESTful bien organisées en prenant en charge un certain nombre de méthodes HTTP, incluant GET, POST, PUT et DELETE. Il prend également en charge le middleware, permettant aux programmeurs d'ajouter plus de fonctionnalités en créant des composants personnalisés pour la journalisation, l'authentification et la gestion des erreurs.

Parce que le cadre suit les principes REST, les développeurs peuvent créer des APIs évolutives et fiables. Sa simplicité et sa facilité d'utilisation en font une excellente option pour les développeurs qui ont besoin de prototyper rapidement et de lancer des services web sans se heurter aux complexités des cadres plus importants. Son design léger rend Grapevine approprié pour les microservices et les applications qui n'ont pas besoin des charges d'un cadre web complexe.

dotnet new console -n GrapevineExample
cd GrapevineExample

dotnet new console -n GrapevineExample
cd GrapevineExample

dotnet add package Grapevine

dotnet add package Grapevine

using Grapevine;
using Grapevine.Interfaces.Server;
using Grapevine.Server;
using Grapevine.Server.Attributes;
using Grapevine.Shared;

public class Program
{
    public static void Main(string[] args)
    {
        // Create and start a new REST server
        var server = new RestServer();
        server.Start();
        Console.WriteLine("Server is running...");
        Console.WriteLine("Press enter to stop the server.");
        Console.ReadKey();
        server.Stop();
    }
}

[RestResource]
public class SampleResource
{
    // Defines a route method for the /hello endpoint
    [RestRoute(HttpMethod = HttpMethod.GET, PathInfo = "/hello")]
    public IHttpContext HelloWorld(IHttpContext context)
    {
        // Send a response for the GET request at /hello
        context.Response.SendResponse("Hello, World!");
        return context;
    }
}

using Grapevine;
using Grapevine.Interfaces.Server;
using Grapevine.Server;
using Grapevine.Server.Attributes;
using Grapevine.Shared;

public class Program
{
    public static void Main(string[] args)
    {
        // Create and start a new REST server
        var server = new RestServer();
        server.Start();
        Console.WriteLine("Server is running...");
        Console.WriteLine("Press enter to stop the server.");
        Console.ReadKey();
        server.Stop();
    }
}

[RestResource]
public class SampleResource
{
    // Defines a route method for the /hello endpoint
    [RestRoute(HttpMethod = HttpMethod.GET, PathInfo = "/hello")]
    public IHttpContext HelloWorld(IHttpContext context)
    {
        // Send a response for the GET request at /hello
        context.Response.SendResponse("Hello, World!");
        return context;
    }
}

Imports Grapevine
Imports Grapevine.Interfaces.Server
Imports Grapevine.Server
Imports Grapevine.Server.Attributes
Imports Grapevine.Shared

Public Class Program
	Public Shared Sub Main(ByVal args() As String)
		' Create and start a new REST server
		Dim server = New RestServer()
		server.Start()
		Console.WriteLine("Server is running...")
		Console.WriteLine("Press enter to stop the server.")
		Console.ReadKey()
		server.Stop()
	End Sub
End Class

<RestResource>
Public Class SampleResource
	' Defines a route method for the /hello endpoint
	<RestRoute(HttpMethod := HttpMethod.GET, PathInfo := "/hello")>
	Public Function HelloWorld(ByVal context As IHttpContext) As IHttpContext
		' Send a response for the GET request at /hello
		context.Response.SendResponse("Hello, World!")
		Return context
	End Function
End Class

Démarrage

Mettre en place un projet où vous pouvez utiliser Grapevine pour créer des services web RESTful et IronPDF pour créer ou modifier des documents PDF est la première étape pour commencer avec Grapevine et IronPDF en C#. Voici un tutoriel étape par étape pour vous lancer :

dotnet add package IronPdf

dotnet add package IronPdf

Grapevine avec IronPDF

Pour que votre premier serveur gère les requêtes et réponses HTTP au sein du programme, une instance de Grapevine RestServer doit être initialisée en exécutant le fichier Program.cs. À l'aide des méthodes Start() et Stop() du serveur de repos, le serveur est géré, avec des instructions de pause sur la console lors de l'appui sur une touche.

using Grapevine.Interfaces.Server;
using Grapevine.Server.Attributes;
using Grapevine.Server;
using Grapevine.Shared;
using IronPdf;
using System.Threading.Tasks;
using System;

class Program
{
    [RestResource]
    public class PdfResource
    {
        // Route method for PDF generation
        [RestRoute(HttpMethod = Grapevine.Shared.HttpMethod.GET, PathInfo = "/generate-pdf")]
        public IHttpContext GeneratePdf(IHttpContext context)
        {
            // HTML content to be converted to PDF
            var htmlContent = "<h1>Hello, PDF!</h1><p>This is a PDF generated using IronPDF.</p>";

            // Create a new PDF renderer
            var renderer = new ChromePdfRenderer();

            // Render the PDF from the HTML content
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);

            // Convert PDF to byte array
            var pdfBytes = pdf.BinaryData;

            // Set response content type and length
            context.Response.ContentType = ContentType.CUSTOM_BINARY;
            context.Response.ContentLength64 = pdfBytes.Length;

            // Send PDF byte array as response
            context.Response.SendResponse(pdfBytes);

            return context;
        }
    }

    static async Task Main(string[] args)
    {
        // Create and start a new REST server
        var server = new RestServer();
        server.LogToConsole().Start();
        Console.WriteLine("Server is running...");
        Console.WriteLine("Press any key to stop the server.");
        Console.ReadKey();
        server.Stop();
    }
}

using Grapevine.Interfaces.Server;
using Grapevine.Server.Attributes;
using Grapevine.Server;
using Grapevine.Shared;
using IronPdf;
using System.Threading.Tasks;
using System;

class Program
{
    [RestResource]
    public class PdfResource
    {
        // Route method for PDF generation
        [RestRoute(HttpMethod = Grapevine.Shared.HttpMethod.GET, PathInfo = "/generate-pdf")]
        public IHttpContext GeneratePdf(IHttpContext context)
        {
            // HTML content to be converted to PDF
            var htmlContent = "<h1>Hello, PDF!</h1><p>This is a PDF generated using IronPDF.</p>";

            // Create a new PDF renderer
            var renderer = new ChromePdfRenderer();

            // Render the PDF from the HTML content
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);

            // Convert PDF to byte array
            var pdfBytes = pdf.BinaryData;

            // Set response content type and length
            context.Response.ContentType = ContentType.CUSTOM_BINARY;
            context.Response.ContentLength64 = pdfBytes.Length;

            // Send PDF byte array as response
            context.Response.SendResponse(pdfBytes);

            return context;
        }
    }

    static async Task Main(string[] args)
    {
        // Create and start a new REST server
        var server = new RestServer();
        server.LogToConsole().Start();
        Console.WriteLine("Server is running...");
        Console.WriteLine("Press any key to stop the server.");
        Console.ReadKey();
        server.Stop();
    }
}

Imports Grapevine.Interfaces.Server
Imports Grapevine.Server.Attributes
Imports Grapevine.Server
Imports Grapevine.Shared
Imports IronPdf
Imports System.Threading.Tasks
Imports System

Friend Class Program
	<RestResource>
	Public Class PdfResource
		' Route method for PDF generation
		<RestRoute(HttpMethod := Grapevine.Shared.HttpMethod.GET, PathInfo := "/generate-pdf")>
		Public Function GeneratePdf(ByVal context As IHttpContext) As IHttpContext
			' HTML content to be converted to PDF
			Dim htmlContent = "<h1>Hello, PDF!</h1><p>This is a PDF generated using IronPDF.</p>"

			' Create a new PDF renderer
			Dim renderer = New ChromePdfRenderer()

			' Render the PDF from the HTML content
			Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

			' Convert PDF to byte array
			Dim pdfBytes = pdf.BinaryData

			' Set response content type and length
			context.Response.ContentType = ContentType.CUSTOM_BINARY
			context.Response.ContentLength64 = pdfBytes.Length

			' Send PDF byte array as response
			context.Response.SendResponse(pdfBytes)

			Return context
		End Function
	End Class

	Shared Async Function Main(ByVal args() As String) As Task
		' Create and start a new REST server
		Dim server = New RestServer()
		server.LogToConsole().Start()
		Console.WriteLine("Server is running...")
		Console.WriteLine("Press any key to stop the server.")
		Console.ReadKey()
		server.Stop()
	End Function
End Class

Une classe PdfResource est définie dans la configuration Grapevine pour gérer des requêtes HTTP spécifiques associées à la création de PDF. L'attribut [RestResource], lorsqu'il est présent, indique que cette classe possède des méthodes pouvant répondre à des routes RESTful.

L'annotation [RestRoute(HttpMethod = HttpMethod.GET, PathInfo = "/generate-pdf")] sur la méthode GeneratePdf au sein de PdfResource indique que cette méthode répond aux requêtes GET à l'endpoint /generate-pdf. Dans la procédure :

• Le contenu qui sera transformé en PDF est représenté par une chaîne de contenu HTML (htmlContent), qui est définie.
• Un document PDF (pdf) est créé à partir du texte HTML à l'aide de ChromePdfRenderer d'IronPDF.
• Un tableau d'octets (pdfBytes) est créé à partir du document PDF final.
• Le contexte HTTP (context) est configuré pour répondre avec un type de contenu PDF, et il utilise SendResponse pour transmettre le tableau d'octets PDF au client.

Conclusion

En conclusion, les développeurs souhaitant intégrer des capacités de service web avec une production dynamique de PDF au sein de leurs applications trouveront une solution solide dans l'intégration de Grapevine C# avec IronPDF. La configuration et l'implémentation de points d'accès RESTful sont simplifiées par le cadre web minimaliste léger et convivial de Grapevine, qui facilite également le traitement des requêtes HTTP et la création de routes personnalisées. IronPDF, d'autre part, améliore l'application en permettant la conversion facile de contenu HTML en documents PDF excellents, incluant l'intégration JavaScript et la prise en charge du style CSS.

Cette connexion permet aux développeurs de créer des PDFs dynamiques et professionnels et de les distribuer tout en simplifiant la création de services web interactifs et axés sur les données. Ensemble, Grapevine et IronPDF offrent une boîte à outils flexible qui répond aux besoins du développement d'applications en ligne contemporain, que ce soit pour produire des rapports, des factures ou d'autres types de documents. Grâce à la combinaison des capacités robustes de création de PDF d'IronPDF et de l'interface conviviale de Grapevine, les développeurs peuvent créer des solutions évolutives et efficaces qui répondent à un large éventail de besoins utilisateurs et objectifs commerciaux.

Avec IronPDF, et le soutien de Iron Software, les développeurs gagnent plus d'applications web et de fonctionnalités ainsi qu'un développement plus efficient. Il y parvient en fusionnant un support complet avec les systèmes Iron Software incroyablement flexibles et la suite, offrant des options de licence clairement définies spécifiques au projet qui permettent aux développeurs de sélectionner facilement des modèles optimisés. Ces avantages permettent aux développeurs de mettre en œuvre des solutions rapidement, de manière cohésive et efficace pour un large éventail de défis.