Migrieren von GrabzIt zu IronPDF in C#

Das GrabzIt-Architektur-Problem

GrabzIt ist ein cloudbasierter Screenshot- und PDF-Erfassungsdienst. Obwohl er für schnelle Integrationen geeignet ist, hat er grundlegende architektonische Einschränkungen:

1. Bildbasierte PDFs: GrabzIt erstellt Screenshot-basierte PDFs, bei denen der Text nicht auswählbar ist – im Wesentlichen Bilder im PDF-Format. Dies ist eine grundlegende Einschränkung für jeden Anwendungsfall, der Textmanipulation oder Barrierefreiheit erfordert.

2. Externe Verarbeitung: Alle Inhalte werden zur Verarbeitung an die Server von GrabzIt gesendet – dies wirft Bedenken hinsichtlich Datenschutz und Compliance bei sensiblen Daten auf. Ihr HTML-Inhalt verlässt Ihre Infrastruktur.

3. Callback-Komplexität: GrabzIt verwendet ein asynchrones Callback-Modell, das eine Webhook-Handling-Infrastruktur erfordert. Sie müssen Endpunkte einrichten, um die Ergebnisse zu erhalten, was die Komplexität der Architektur erhöht.

4. Preisgestaltung pro Erfassung: Das Pay-per-Use-Modell kann bei großem Umfang teuer werden. Jede PDF-Erstellung ist mit Kosten verbunden.

5. Keine Textsuche: Da PDFs bildbasiert sind, funktionieren Textsuche und -extraktion ohne OCR nicht – ein zusätzlicher Arbeitsschritt und Kostenfaktor.

6. Größere Dateigrößen: Bildbasierte PDFs sind wesentlich größer als vektorbasierte PDFs, oft 5- bis 10-mal so groß.

7. Netzwerkabhängigkeit: Ohne Internetverbindung können keine PDFs generiert werden, wodurch Offline-Szenarien unmöglich sind.

8. Latenz: Jede PDF-Generierung erfordert einen Netzwerk-Roundtrip zu externen Servern, was eine Latenz von 500 ms bis 5 s zur Folge hat.

GrabzIt vs IronPDFVergleich

Für Teams, die die Einführung von .NET 10 und C# 14 bis 2025 und 2026 planen, bietet IronPDF eine zukunftssichere Grundlage mit lokaler Verarbeitung, die sich nativ in moderne .NET-Muster integriert.

Geschätzter Aufwand nach Merkmalen

Paradigmen-Verschiebung

Der grundlegende Shift bei dieser GrabzIt-Migration besteht in der Umstellung von asynchroner, auf Rückruffunktionen basierender Cloud-Verarbeitung auf synchrone In-Process-Generierung:

GrabzIt:   Senden von HTML → Warten auf Rückruf → Abrufen des Ergebnisses vom Server
IronPDF:   HTML rendern → PDF sofort erhalten

Voraussetzungen

1. .NET Version:IronPDF unterstützt .NET Framework 4.6.2+ und .NET Core 3.1+ / .NET 5/6/7/8/9+
2. Lizenzschlüssel: Ihren IronPDF-Lizenzschlüssel erhalten Sie unter IronPDF.
3. Infrastrukturentfernung planen: Callback-Handler und Webhook-Endpunkte für die Stilllegung dokumentieren

Die gesamte GrabzIt-Nutzung identifizieren

# Find GrabzIt client 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 GrabzIt client 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" .

NuGet-Paketänderungen

# Remove GrabzIt
dotnet remove package GrabzIt

# Install IronPDF
dotnet add package IronPdf

# Remove GrabzIt
dotnet remove package GrabzIt

# Install IronPDF
dotnet add package IronPdf

Schritt 1: Lizenzkonfiguration aktualisieren

Vor (GrabzIt):

GrabzIt erfordert für jede Client-Instanziierung einen Anwendungsschlüssel und ein Geheimnis:

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")

Nach (IronPDF):

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

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

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

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

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

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

Schritt 2: Aktualisieren der Namensraum-Importe

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

// After (IronPDF)
using IronPdf;

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

// After (IronPDF)
using IronPdf;

Imports IronPdf

GrabzItClient-zu-IronPDF-Zuordnung

Zuordnung von PDFOptions zu RenderingOptions

Zuordnung von ImageOptions zu IronPDF

Beispiel 1: Konvertierung von HTML in PDF

Vor (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");
    }
}

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

Nach (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

Der Unterschied ist erheblich: GrabzIt benötigt API-Zugangsdaten (YOUR_APPLICATION_KEY, YOUR_APPLICATION_SECRET), erstellt ein PDFOptions Objekt mit einer benutzerdefinierten ID, und das Ergebnis ist ein bildbasiertes PDF, das über externe Server gesendet wird. IronPDF s ChromePdfRenderer generiert lokal ein echtes Vektor-PDF mit auswählbarem Text – ohne Anmeldeinformationen, ohne Netzwerkaufrufe, ohne Rückruffunktionen. Weitere Rendering-Optionen finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: Konvertierung von URL in PDF

Vor (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");
    }
}

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

Nach (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

GrabzIt erfordert die Konfiguration von PageSize.A4 über das Optionsobjekt und die Authentifizierung mit externen Servern. Die Methode RenderUrlAsPdf() von IronPDF akzeptiert die URL direkt und rendert sie lokal mit einer vollständigen Chromium-Engine mit vollständiger CSS- und JavaScript Unterstützung. Erfahren Sie mehr über die URL in PDF Konvertierung.

Beispiel 3: Konvertierung von HTML in Bilder

Vor (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");
    }
}

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

Nach (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

GrabzIt bietet eine spezielle Methode HTMLToImage() mit ImageOptions zur Konfiguration von Format, Breite und Höhe.IronPDF erzielt das gleiche Ergebnis, indem es zuerst HTML mit RenderHtmlAsPdf() in PDF rendert und anschließend mit ToBitmap() in Bitmap konvertiert. Bei diesem Ansatz erhalten Sie sowohl die PDF- als auch die Bildausgabe in einem einzigen Rendervorgang.

Keine Rückrufe erforderlich

Die wichtigste architektonische Änderung ist die vollständige Abschaffung der Callback-Handler:

// 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! No 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! No 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! No callback needed.

Löschen Sie nach der Migration alle GrabzIt-Callback-Handler (.ashx-Dateien, Handler-Endpunkte, Webhook-Konfiguration).

Echte Vektor-PDFs

GrabzIt erstellt bildbasierte PDFs, bei denen der Text nicht auswählbar ist.IronPDF erzeugt echte Vektor-PDFs:

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

Weitere Informationen finden Sie in der Textextraktionsdokumentation.

Kleine Dateigrößen

Vektorbasierte PDFs sind in der Regel 5-10x kleiner als die bildbasierten PDFs von GrabzIt. Dies verbessert die Speicherkosten, die Downloadzeiten und die Durchführbarkeit von E-Mail-Anhängen.

API-Zugangsdaten entfernen

GrabzIt benötigt für jeden Vorgang API-Anmeldedaten:

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

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

IronPDF verwendet einen einzigen Lizenzschlüssel, der einmalig beim Start der Anwendung festgelegt wird - keine Authentifizierung pro Anfrage.

Ausgabe 1: GrabzItClient nicht gefunden

Problem: Nach der Entfernung von GrabzIt verursachen GrabzItClient-Referenzen Kompilierungsfehler.

Lösung: Ersetzen Sie durch 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()

Ausgabe 2: PDFOptions Not Found

Problem: Die Klasse PDFOptions existiert nicht in IronPDF.

Lösung: Verwenden Sie die Eigenschaft 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

Ausgabe 3: Callback-Handler werden immer noch referenziert

Problem: Die Anwendung erwartet Callback-Endpunkte.

Lösung: Die Callback-Infrastruktur vollständig entfernen.IronPDF liefert die Ergebnisse synchron - es werden keine Webhooks benötigt.

Ausgabe 4: ImageOptions Not Found

Problem: Die Klasse ImageOptions existiert nicht in IronPDF.

Lösung: Zuerst als PDF rendern, dann konvertieren:

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

Vor der Migration

• Inventarisierung aller GrabzIt-API-Aufrufe im Quellcode
• Callback-Handler und Webhook-Endpunkte identifizieren
• Dokumentation der aktuellen GrabzIt-Optionen und -Vorlagen -IronPDF-Lizenzschlüssel erhalten
• Plan-Rückrufbearbeiter außer Betrieb nehmen

Code-Migration

• Installieren Sie das IronPDFNuGet Paket: dotnet add package IronPdf
• GrabzIt NuGet Paket entfernen: dotnet remove package GrabzIt
• Ersetzen Sie GrabzItClient durch ChromePdfRenderer
• Konvertiere HTMLToPDF() in RenderHtmlAsPdf()
• Konvertiere URLToPDF() in RenderUrlAsPdf()
• Ersetzen Sie Save(callback) durch SaveAs(path)
• Optionen von PDFOptions auf RenderingOptions aktualisieren

Infrastruktur-Migration

• Löschen der Callback-Handler-Dateien (.ashx, etc.)
• GrabzIt-API-Schlüssel aus der Konfiguration entfernen
• Webhook-URL-Konfiguration entfernen
• Fügen Sie den IronPDFLizenzschlüssel zur Konfiguration hinzu
• Code für Abfrage/Statusprüfung entfernen

Testen

• Test der Konvertierung von HTML in PDF
• Test der URL-zu-PDF-Konvertierung
• Überprüfen, ob der Text in den ausgegebenen PDFs auswählbar ist
• Test der Textextraktion funktioniert (ohne OCR)
• Überprüfen Sie, ob die Dateigrößen kleiner sind.
• Leistungstest ohne Netzwerklatenz

Nach der Migration

• GrabzIt-Abonnement kündigen
• Archiv-Callback-Handler-Code
• Dokumentation aktualisieren
• Auf etwaige GrabzIt-bezogene Fehler achten