La Bibliothèque PDF C#

HTML en PDF

Online Demo Voir tous les exemples de code %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

VIDÉOS

Comment convertir un PDF en PDF A en C# utilisant Iron PDF

Curtis Chau

Updated: 19 juillet 2026

La migration de GrabzItvers IronPDF transforme votre flux de travail PDF .NET d'un service de capture d'écran basé sur le cloud avec une complexité de rappel à une bibliothèque en cours de processus qui génère de véritables PDF vectoriels avec du texte sélectionnable et consultable. Ce guide fournit un chemin de migration complet, étape par étape, qui élimine les dépendances de serveurs externes, les gestionnaires de rappel et la tarification par capture pour les développeurs .NET professionnels.

Pourquoi migrer de GrabzItà IronPDF

Le problème de l'architecture de GrabzIt

GrabzIt est un service de capture d'écran et de PDF basé sur le cloud. Bien qu'il soit pratique pour les intégrations rapides, il présente des limites architecturales fondamentales :

PDF basés sur des images : GrabzItcrée des PDF basés sur des captures d'écran où le texte n'est pas sélectionnable — essentiellement des images enveloppées au format PDF. Il s'agit d'une limite fondamentale pour tout cas d'utilisation nécessitant la manipulation de texte ou l'accessibilité.
Traitement externe : Tout le contenu est envoyé aux serveurs de GrabzItpour traitement, ce qui soulève des problèmes de confidentialité et de conformité pour les données sensibles. Votre contenu HTML quitte votre infrastructure.
Complexité des rappels : GrabzItutilise un modèle de rappel asynchrone qui nécessite une infrastructure de gestion des webhooks. Vous devez mettre en place des points de terminaison pour recevoir les résultats, ce qui ajoute à la complexité de l'architecture.
Tarification par capture : Le modèle de paiement à l'utilisation peut devenir coûteux à grande échelle. Chaque génération de PDF a un coût.
Pas de recherche de texte : les fichiers PDF étant basés sur des images, la recherche et l'extraction de texte ne fonctionnent pas sans OCR, ce qui représente une étape et un coût supplémentaires.
Taille des fichiers plus importante : les PDF basés sur des images sont nettement plus volumineux que les PDF basés sur des vecteurs, souvent 5 à 10 fois plus volumineux.
Dépendance au réseau : Impossible de générer des PDF sans connexion Internet, ce qui rend les scénarios hors ligne impossibles.
Latence : Chaque génération de PDF nécessite un aller-retour réseau vers des serveurs externes, ce qui ajoute une latence notable par rapport à la génération locale en cours.

Comparaison GrabzItvs IronPDF

Aspect	GrabzIt	IronPDF
Type de PDF	Basée sur l'image (capture d'écran)	True vector PDF
Sélection du texte	Pas possible	Sélection du texte intégral
Recherche de texte	Nécessite une OCR	Recherche native
Lieu de traitement	Serveurs externes	Local/processus
Confidentialité	Données envoyées à l'extérieur	Les données restent locales
Temps de latence	Trajet aller-retour sur le réseau (500ms-5s)	Traitement local (~100ms)
Modèle de tarification	Par capture	Licence par développeur
Capacité hors ligne	Non	Oui
Taille du fichier	Grand (données d'image)	Petit (données vectorielles)
Rappel obligatoire	Oui (asynchrone)	Non (sync/async)
Support CSS/JS	Limité	Moteur Chromium complet

IronPDF s'intègre nativement aux modèles .NET modernes et fonctionne entièrement en cours, supprimant l'aller-retour en nuage de votre pipeline PDF.

Évaluation de la complexité de la migration

Estimation de l'effort par fonctionnalité

Fonction	Complexité de la migration
HTML vers PDF	Très faible
URL vers PDF	Très faible
HTML vers image	Faible
Taille de la page/marges	Faible
Manipulateurs de rappel	Faible
Filigranes	Faible
En-têtes/Pieds de page	Moyen
Clés d'authentification	Très faible

Changement de paradigme

Le Shift fondamental de cette migration GrabzItréside dans le passage d'un traitement cloud asynchrone basé sur des rappels à une génération synchrone en interne :

GrabzIt :   Envoyer du HTML → Attendre le rappel → Récupérer le résultat du serveur
IronPDF :   Rendre HTML → Obtenir le PDF immédiatement

GrabzIt :   Envoyer du HTML → Attendre le rappel → Récupérer le résultat du serveur
IronPDF :   Rendre HTML → Obtenir le PDF immédiatement

Text

Avant de commencer

Prérequis

**Version .NET :**IronPDF prend en charge .NET Framework 4.6.2+ et .NET Core 3.1+ / .NET 5+
Clé de licence : Obtenez votre clé de licence IronPDF sur IronPDF
Planifier la mise hors service de l'infrastructure : documenter les gestionnaires de rappel et les points de terminaison webhook pour la mise hors service

Identifier toutes les utilisations de GrabzIt

# Find GrabzItclient usage
grep -r "GrabzItClient\|GrabzIt\." --include="*.cs" .

# Find callback handlers
grep -r "GrabzIt\|grabzit" --include="*.ashx" --include="*.aspx" --include="*.cs" .

# Find configuration
grep -r "APPLICATION_KEY\|APPLICATION_SECRET\|grabzit" --include="*.config" --include="*.json" .

# Find GrabzItclient usage
grep -r "GrabzItClient\|GrabzIt\." --include="*.cs" .

# Find callback handlers
grep -r "GrabzIt\|grabzit" --include="*.ashx" --include="*.aspx" --include="*.cs" .

# Find configuration
grep -r "APPLICATION_KEY\|APPLICATION_SECRET\|grabzit" --include="*.config" --include="*.json" .

SHELL

Modifications du paquet NuGet

# Remove GrabzIt
dotnet remove package GrabzIt

# Install IronPDF
dotnet add package IronPdf

# Remove GrabzIt
dotnet remove package GrabzIt

# Install IronPDF
dotnet add package IronPdf

SHELL

Migration rapide

Étape 1 : Mise à jour de la configuration de la licence

Avant (GrabzIt):

GrabzIt requiert une clé et un secret d'application pour chaque instanciation du client :

var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");

var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");

Dim grabzIt As New GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET")

Dim grabzIt As New GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET")

Après (IronPDF):

// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Then create renderer without credentials
var renderer = new ChromePdfRenderer();

// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Then create renderer without credentials
var renderer = new ChromePdfRenderer();

Imports IronPdf

' Set once at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

' Then create renderer without credentials
Dim renderer As New ChromePdfRenderer()

Imports IronPdf

' Set once at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

' Then create renderer without credentials
Dim renderer As New ChromePdfRenderer()

Étape 2 : mise à jour des importations de l'espace de noms

// Before (GrabzIt)
using GrabzIt;
using GrabzIt.Parameters;

// After (IronPDF)
using IronPdf;

// Before (GrabzIt)
using GrabzIt;
using GrabzIt.Parameters;

// After (IronPDF)
using IronPdf;

Imports IronPdf

Imports IronPdf

Référence API complète

Mappage de GrabzItClient vers IronPDF

Méthode GrabzIt	Équivalent d'IronPDF
`new GrabzItClient(key, secret)`	`new ChromePdfRenderer()`
`HTMLToPDF(html)`	`renderer.RenderHtmlAsPdf(html)`
`URLToPDF(url)`	`renderer.RenderUrlAsPdf(url)`
`HTMLToImage(html)`	`pdf.ToBitmap()`
`Save(callbackUrl)`	`pdf.SaveAs(path)`
`SaveTo(filePath)`	`pdf.SaveAs(filePath)`
`GetResult(id)`	N/A
`GetStatus(id)`	N/A

Mappage des options PDF aux options de rendu

GrabzItPDFOptions	Propriété d'IronPDF
`PageSize` (A4, Lettre)	`RenderingOptions.PaperSize`
`CustomId`	N/A
`MarginTop`	`RenderingOptions.MarginTop`
`MarginBottom`	`RenderingOptions.MarginBottom`

ImageOptions vers IronPDF Mapping

GrabzItImageOptions	Équivalent d'IronPDF
`Format` (png, jpg)	`bitmap.Save(path, ImageFormat.Png)`
`Width`	`RenderingOptions.ViewPortWidth`
`Height`	`RenderingOptions.ViewPortHeight`

Exemples de migration de code

Exemple 1 : Conversion HTML vers PDF

Avant (GrabzIt):

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new PDFOptions();
        options.CustomId = "my-pdf";
        
        grabzIt.HTMLToPDF("<html><body><h1>Hello World</h1></body></html>", options);
        grabzIt.SaveTo("output.pdf");
    }
}

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new PDFOptions();
        options.CustomId = "my-pdf";
        
        grabzIt.HTMLToPDF("<html><body><h1>Hello World</h1></body></html>", options);
        grabzIt.SaveTo("output.pdf");
    }
}

' NuGet: Install-Package GrabzIt
Imports GrabzIt
Imports GrabzIt.Parameters
Imports System

Module Program
    Sub Main()
        Dim grabzIt As New GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET")
        Dim options As New PDFOptions()
        options.CustomId = "my-pdf"

        grabzIt.HTMLToPDF("<html><body><h1>Hello World</h1></body></html>", options)
        grabzIt.SaveTo("output.pdf")
    End Sub
End Module

' NuGet: Install-Package GrabzIt
Imports GrabzIt
Imports GrabzIt.Parameters
Imports System

Module Program
    Sub Main()
        Dim grabzIt As New GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET")
        Dim options As New PDFOptions()
        options.CustomId = "my-pdf"

        grabzIt.HTMLToPDF("<html><body><h1>Hello World</h1></body></html>", options)
        grabzIt.SaveTo("output.pdf")
    End Sub
End Module

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

La différence est substantielle : GrabzItnécessite des identifiants d'API (YOUR_APPLICATION_KEY, YOUR_APPLICATION_SECRET), crée un objet PDFOptions avec un ID personnalisé, et le résultat est un PDF basé sur une image envoyé via des serveurs externes. Le ChromePdfRenderer d'IronPDF génère un vrai PDF vectoriel localement avec du texte sélectionnable—pas de crédits, pas d'appels réseau, pas de rappels. Voir la documentation HTML vers PDF pour des options de rendu supplémentaires.

Exemple 2 : Conversion d'une URL en PDF

Avant (GrabzIt):

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new PDFOptions();
        options.PageSize = PageSize.A4;
        
        grabzIt.URLToPDF("https://www.example.com", options);
        grabzIt.SaveTo("webpage.pdf");
    }
}

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new PDFOptions();
        options.PageSize = PageSize.A4;
        
        grabzIt.URLToPDF("https://www.example.com", options);
        grabzIt.SaveTo("webpage.pdf");
    }
}

' NuGet: Install-Package GrabzIt
Imports GrabzIt
Imports GrabzIt.Parameters
Imports System

Module Program
    Sub Main()
        Dim grabzIt As New GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET")
        Dim options As New PDFOptions()
        options.PageSize = PageSize.A4

        grabzIt.URLToPDF("https://www.example.com", options)
        grabzIt.SaveTo("webpage.pdf")
    End Sub
End Module

' NuGet: Install-Package GrabzIt
Imports GrabzIt
Imports GrabzIt.Parameters
Imports System

Module Program
    Sub Main()
        Dim grabzIt As New GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET")
        Dim options As New PDFOptions()
        options.PageSize = PageSize.A4

        grabzIt.URLToPDF("https://www.example.com", options)
        grabzIt.SaveTo("webpage.pdf")
    End Sub
End Module

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

GrabzIt nécessite de configurer PageSize.A4 via l'objet options et de s'authentifier auprès de serveurs externes. La méthode RenderUrlAsPdf() d'IronPDF accepte directement l'URL et la rend localement en utilisant un moteur Chromium complet avec un support CSS et JavaScript complet. En savoir plus sur la conversion d'URL en PDF.

Exemple 3 : Conversion de HTML en image

Avant (GrabzIt):

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new ImageOptions();
        options.Format = ImageFormat.png;
        options.Width = 800;
        options.Height = 600;
        
        grabzIt.HTMLToImage("<html><body><h1>Hello World</h1></body></html>", options);
        grabzIt.SaveTo("output.png");
    }
}

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new ImageOptions();
        options.Format = ImageFormat.png;
        options.Width = 800;
        options.Height = 600;
        
        grabzIt.HTMLToImage("<html><body><h1>Hello World</h1></body></html>", options);
        grabzIt.SaveTo("output.png");
    }
}

' NuGet: Install-Package GrabzIt
Imports GrabzIt
Imports GrabzIt.Parameters
Imports System

Module Program
    Sub Main()
        Dim grabzIt As New GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET")
        Dim options As New ImageOptions()
        options.Format = ImageFormat.png
        options.Width = 800
        options.Height = 600
        
        grabzIt.HTMLToImage("<html><body><h1>Hello World</h1></body></html>", options)
        grabzIt.SaveTo("output.png")
    End Sub
End Module

' NuGet: Install-Package GrabzIt
Imports GrabzIt
Imports GrabzIt.Parameters
Imports System

Module Program
    Sub Main()
        Dim grabzIt As New GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET")
        Dim options As New ImageOptions()
        options.Format = ImageFormat.png
        options.Width = 800
        options.Height = 600
        
        grabzIt.HTMLToImage("<html><body><h1>Hello World</h1></body></html>", options)
        grabzIt.SaveTo("output.png")
    End Sub
End Module

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Drawing;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        var images = pdf.ToBitmap();
        images[0].Save("output.png", System.Drawing.Imaging.ImageFormat.Png);
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Drawing;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        var images = pdf.ToBitmap();
        images[0].Save("output.png", System.Drawing.Imaging.ImageFormat.Png);
    }
}

Imports IronPdf
Imports System
Imports System.Drawing

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")
        Dim images = pdf.ToBitmap()
        images(0).Save("output.png", System.Drawing.Imaging.ImageFormat.Png)
    End Sub
End Class

Imports IronPdf
Imports System
Imports System.Drawing

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")
        Dim images = pdf.ToBitmap()
        images(0).Save("output.png", System.Drawing.Imaging.ImageFormat.Png)
    End Sub
End Class

GrabzIt fournit une méthode dédiée HTMLToImage() avec ImageOptions pour la configuration du format, de la largeur et de la hauteur.IronPDF obtient le même résultat en rendant d'abord le HTML en PDF en utilisant RenderHtmlAsPdf(), puis en convertissant en bitmap avec ToBitmap(). Cette approche permet d'obtenir le PDF et l'image à partir d'une seule opération de rendu.

Notes de migration essentielles

Aucun rappel n'est nécessaire

Le changement architectural le plus important est l'élimination totale des gestionnaires de rappel :

// GrabzIt: Async callback pattern
grabzIt.HTMLToPDF(html, options);
grabzIt.Save("https://myserver.com/grabzit-callback");  // Wait for callback...

// Callback handler (separate endpoint)
public class GrabzItHandler : IHttpHandler
{
    public void ProcessRequest(HttpContext context)
    {
        string id = context.Request.QueryString["id"];
        GrabzItClient grabzIt = new GrabzItClient("APP_KEY", "APP_SECRET");
        GrabzItFile file = grabzIt.GetResult(id);
        file.Save("output.pdf");
    }
}

// IronPDF: Synchronous - result immediately available
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");  // Done! Non callback needed.

// GrabzIt: Async callback pattern
grabzIt.HTMLToPDF(html, options);
grabzIt.Save("https://myserver.com/grabzit-callback");  // Wait for callback...

// Callback handler (separate endpoint)
public class GrabzItHandler : IHttpHandler
{
    public void ProcessRequest(HttpContext context)
    {
        string id = context.Request.QueryString["id"];
        GrabzItClient grabzIt = new GrabzItClient("APP_KEY", "APP_SECRET");
        GrabzItFile file = grabzIt.GetResult(id);
        file.Save("output.pdf");
    }
}

// IronPDF: Synchronous - result immediately available
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");  // Done! Non callback needed.

Imports System.Web

' GrabzIt: Async callback pattern
grabzIt.HTMLToPDF(html, options)
grabzIt.Save("https://myserver.com/grabzit-callback")  ' Wait for callback...

' Callback handler (separate endpoint)
Public Class GrabzItHandler
    Implements IHttpHandler

    Public Sub ProcessRequest(context As HttpContext) Implements IHttpHandler.ProcessRequest
        Dim id As String = context.Request.QueryString("id")
        Dim grabzIt As New GrabzItClient("APP_KEY", "APP_SECRET")
        Dim file As GrabzItFile = grabzIt.GetResult(id)
        file.Save("output.pdf")
    End Sub

    Public ReadOnly Property IsReusable As Boolean Implements IHttpHandler.IsReusable
        Get
            Return False
        End Get
    End Property
End Class

' IronPDF: Synchronous - result immediately available
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")  ' Done! Non callback needed.

Imports System.Web

' GrabzIt: Async callback pattern
grabzIt.HTMLToPDF(html, options)
grabzIt.Save("https://myserver.com/grabzit-callback")  ' Wait for callback...

' Callback handler (separate endpoint)
Public Class GrabzItHandler
    Implements IHttpHandler

    Public Sub ProcessRequest(context As HttpContext) Implements IHttpHandler.ProcessRequest
        Dim id As String = context.Request.QueryString("id")
        Dim grabzIt As New GrabzItClient("APP_KEY", "APP_SECRET")
        Dim file As GrabzItFile = grabzIt.GetResult(id)
        file.Save("output.pdf")
    End Sub

    Public ReadOnly Property IsReusable As Boolean Implements IHttpHandler.IsReusable
        Get
            Return False
        End Get
    End Property
End Class

' IronPDF: Synchronous - result immediately available
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")  ' Done! Non callback needed.

Supprimez tous les gestionnaires de rappels GrabzIt (fichiers .ashx, points de terminaison des gestionnaires, configuration de webhook) après la migration.

Vrais PDF vectoriels

GrabzIt crée des PDF à base d'images où le texte n'est pas sélectionnable.IronPDF génère de véritables PDF vectoriels :

// With IronPDF, text extraction works natively
var pdf = PdfDocument.FromFile("document.pdf");
string text = pdf.ExtractAllText();  // Works without OCR!

// With IronPDF, text extraction works natively
var pdf = PdfDocument.FromFile("document.pdf");
string text = pdf.ExtractAllText();  // Works without OCR!

Imports IronPdf

' With IronPDF, text extraction works natively
Dim pdf = PdfDocument.FromFile("document.pdf")
Dim text As String = pdf.ExtractAllText()  ' Works without OCR!

Imports IronPdf

' With IronPDF, text extraction works natively
Dim pdf = PdfDocument.FromFile("document.pdf")
Dim text As String = pdf.ExtractAllText()  ' Works without OCR!

Voir la documentation sur l'extraction de texte pour plus de détails.

Taille des fichiers réduite

Les PDF vectoriels sont généralement 5 à 10 fois plus petits que les PDF à base d'images de GrabzIt. Cela permet d'améliorer les coûts de stockage, les temps de téléchargement et la possibilité d'envoyer des pièces jointes par courrier électronique.

Supprimer les informations d'identification de l'API

GrabzIt nécessite des identifiants API pour chaque opération :

// Remove these from configuration
// YOUR_APPLICATION_KEY
// YOUR_APPLICATION_SECRET

// Remove these from configuration
// YOUR_APPLICATION_KEY
// YOUR_APPLICATION_SECRET

net

net

IronPDF utilise une clé de licence unique définie une seule fois au démarrage de l'application - pas d'authentification par demande.

Dépannage

Édition 1 : GrabzItClient introuvable

Problème : Après avoir supprimé GrabzIt, les références GrabzItClient causent des erreurs de compilation.

Solution: Replace with ChromePdfRenderer:

// Remove:
// var grabzIt = new GrabzItClient("KEY", "SECRET");

// Replace with:
var renderer = new ChromePdfRenderer();

// Remove:
// var grabzIt = new GrabzItClient("KEY", "SECRET");

// Replace with:
var renderer = new ChromePdfRenderer();

' Remove:
' Dim grabzIt = New GrabzItClient("KEY", "SECRET")

' Replace with:
Dim renderer = New ChromePdfRenderer()

' Remove:
' Dim grabzIt = New GrabzItClient("KEY", "SECRET")

' Replace with:
Dim renderer = New ChromePdfRenderer()

Édition 2 : PDFOptions introuvables

Problème : La classe PDFOptions n'existe pas dans IronPDF.

Solution : Utiliser la propriété RenderingOptions :

// GrabzIt
var options = new PDFOptions();
options.PageSize = PageSize.A4;

// IronPDF
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

// GrabzIt
var options = new PDFOptions();
options.PageSize = PageSize.A4;

// IronPDF
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

' GrabzIt
Dim options As New PDFOptions()
options.PageSize = PageSize.A4

' IronPDF
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

' GrabzIt
Dim options As New PDFOptions()
options.PageSize = PageSize.A4

' IronPDF
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

Sujet 3 : Les gestionnaires de rappel sont toujours référencés

Problème : L'application attend des points de terminaison de rappel.

Solution : Supprimer entièrement l'infrastructure de rappel.IronPDF renvoie les résultats de manière synchrone - aucun webhook n'est nécessaire.

Edition 4 : ImageOptions Not Found

Problème : La classe ImageOptions n'existe pas dans IronPDF.

Solution : Générer d'abord un PDF, puis convertir :

// GrabzIt
var options = new ImageOptions();
options.Format = ImageFormat.png;
grabzIt.HTMLToImage(html, options);

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);
var images = pdf.ToBitmap();
images[0].Save("output.png", System.Drawing.Imaging.ImageFormat.Png);

// GrabzIt
var options = new ImageOptions();
options.Format = ImageFormat.png;
grabzIt.HTMLToImage(html, options);

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);
var images = pdf.ToBitmap();
images[0].Save("output.png", System.Drawing.Imaging.ImageFormat.Png);

' GrabzIt
Dim options As New ImageOptions()
options.Format = ImageFormat.png
grabzIt.HTMLToImage(html, options)

' IronPDF
Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim images = pdf.ToBitmap()
images(0).Save("output.png", System.Drawing.Imaging.ImageFormat.Png)

' GrabzIt
Dim options As New ImageOptions()
options.Format = ImageFormat.png
grabzIt.HTMLToImage(html, options)

' IronPDF
Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim images = pdf.ToBitmap()
images(0).Save("output.png", System.Drawing.Imaging.ImageFormat.Png)

Liste de contrôle de la migration

Pré-migration

Inventorier tous les appels à l'API GrabzItdans le code source
Identifier les gestionnaires de rappel et les points de terminaison webhook
Documenter les options et modèles actuels de GrabzIt
Obtenir une clé de licence IronPDF
Mise hors service du gestionnaire de rappel du plan

Migration de code

Installez le package NuGet IronPDF: dotnet add package IronPdf
Supprimez le package NuGet GrabzIt: dotnet remove package GrabzIt
Remplacez GrabzItClient par ChromePdfRenderer
Convertir HTMLToPDF() en RenderHtmlAsPdf()
Convertir URLToPDF() en RenderUrlAsPdf()
Remplacez Save(callback) par SaveAs(path)
Mettez à jour les options de PDFOptions à RenderingOptions

Migration des infrastructures

Supprimez les fichiers de gestion des rappels (.ashx, etc.)
Supprimez les clés API GrabzItde la configuration
Supprimer la configuration de l'URL du webhook
Ajouter la clé de licence IronPDF à la configuration
Supprimer le code d'interrogation/de vérification d'état

Essai

Tester la conversion de HTML en PDF
Test de conversion d'URL en PDF
Vérifier que le texte est sélectionnable dans les fichiers PDF de sortie
L'extraction de texte de test fonctionne (sans OCR)
Vérifiez que la taille des fichiers est plus petite
Test de performance sans latence réseau

Après la migration

Annuler l'abonnement GrabzIt
Code du gestionnaire de rappel d'archive
Mise à jour de la documentation
Surveiller les erreurs liées à GrabzIt

Veuillez noter: GrabzIt est une marque déposée de son propriétaire respectif. Ce site n'est pas affilié, approuvé ou sponsorisé par GrabzIt. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.

Curtis Chau

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

Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.

...