Nie znalazłeś tego, czego szukałeś?
Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Przewodniki migracji
  4. Przejście z biblioteki Adobe PDF Library SDK na IronPDF
PRZEWODNIKI MIGRACJI

Jak przejść z biblioteki Adobe PDF Library SDK na IronPDF

Curtis Chau
Curtis Chau
Zaktualizowano:

Adobe PDF Library SDK (APDFL) jest dystrybuowane przez Datalogics na zasadzie licencji od Adobe i dzieli podstawowy kod źródłowy z silnikiem Acrobat. Jest potężny, ale jego model sprzedaży, natywny ślad uruchomieniowy, brak wbudowanego renderera HTML do PDF i niskopoziomowy projekt API prowadzą wiele zespołów .NET do poszukiwania alternatyw. Ten przewodnik oferuje krok po kroku ścieżkę migracji zAdobe PDF Library SDKdo IronPDF— nowoczesnej biblioteki PDF dla .NET wsparciającej .NET Framework 4.6.2 do .NET 9.

Dlaczego warto rozważyć odejście od biblioteki Adobe PDF Library SDK?

Podczas gdy APDFL oferuje silnik PDF pochodny od Acrobat, kilka czynników skłania zespoły deweloperskie do poszukiwania alternatyw dla HTML do PDF, manipulacji dokumentów i generowania raportów.

Społecznościowo zarządzane, indywidualne ceny

Datalogics nie publikuje cen listowych dla APDFL. Według stron wycenowych Datalogics, plany użytkowania wewnętrznego zaczynają się od około 5 999 USD/rok, a wdrożenia OEM, ISV i SaaS negocjują opłaty za platformę plus tantiemy lub udział w przychodach na wierzchu wszystkiego. Całkowity koszt jest zazwyczaj poza zasięgiem dla małych i średnich zespołów i prawie zawsze wymaga rozmowy z działem sprzedaży.

Złożona integracja SDK

APDFL obudowuje natywny silnik C/C++ mający wspólne korzenie z Acrobat. Powiazanie .NET (Datalogics.PDFL) wymaga specyficznych dla platformy binariow runtime — pakiet NuGet Adobe.PDF.Library.LM.NET dostarcza x64 Windows, Linux, i macOS ARM — ostroznego zarzadzania pamiecia oraz wyraznego cyklu zycia Library na kazdym punkcie wejscia. Dodaje to obciążenie rozwoju i komplikuje potoki CI/CD.

Brak wbudowanego renderera HTML

Udokumentowana lista konwersji APDFL obejmuje formaty PDF/A, PDF/X, ZUGFeRD, EPS, PS, XPS i Office, ale nie HTML. Produkcja PDF z ciągu HTML za pomocą APDFL oznacza samodzielne tworzenie stron, czcionek i wątków treści, lub parowanie APDFL z osobnym silnikiem renderującym HTML.

Projektowanie API niskiego poziomu

Tworzenie PDF za pomocą APDFL polega na programowym konstruowaniu stron, strumieni treści, wątków tekstowych i czcionek. Proste zadania, takie jak renderowanie ciągu HTML, stają się wieloetapowymi operacjami wymagającymi obliczeń współrzędnych, osadzania czcionek i ręcznego zarządzania elementami treści.

Nakłady związane z zarządzaniem cyklem życia bibliotek

Kazdy punkt wejscia wymaga owiniecia w kod using (var lib = new Library()) (lub polaczenia wywolan Library.Initialize() / Library.Terminate()) z ostroznym usunieciem utworzonych wewnatrz obiektow PDF. Pominiecie czyszczenia moze spowodowac wycieki zasobow.

Zbytnio zaawansowany dla wielu projektów

Dla aplikacji głównie potrzebujących konwersji HTML do PDF, podstawowej manipulacji dokumentów lub generowania raportów, pełen silnik pochodny od Acrobat jest często bardziej rozwinięty niż wymagana praca.

Adobe PDF Library SDKa IronPDF: kluczowe różnice

Zrozumienie podstawowych różnic architektonicznych między tymi bibliotekami pomaga w zaplanowaniu skutecznej strategii migracji.

Aspekt Adobe PDF Library SDK IronPDF
Ceny Prowadzony przez sprzedaż; użytek wewnętrzny od ~5 999 USD/rok, Tantiemy OEM/SaaS na wierzchu Przezroczyste na dewelopera / na wdrożenie
Instalacja Adobe.PDF.Library.LM.NET dostarcza natywne runtime na platforme Prosty pakiet NuGet
Tworzenie dokumentów Niskopoziomowa konstrukcja strony/treści Renderowanie HTML/CSS
HTML do PDF Nie wbudowane ChromePdfRenderer.RenderHtmlAsPdf
Inicjalizacja wymagany using (Library lib = new Library()) Automatyczne
Układ współrzędnych Punkty PostScript, punkt początkowy w lewym dolnym rogu Układ oparty na CSS
Obsługa czcionek Wymagane ręczne osadzenie Automatyczne
Zarządzanie pamięcią Ręczna utylizacja każdego obiektu PDF Standardowy wzorzec IDisposable
Obsługa asynchroniczna Niedostępne Pełna obsługa async/await

Przygotowania przed migracją

Wymagania wstępne

Przed rozpoczęciem migracji upewnij się, że Twoje środowisko spełnia te wymagania:

  • .NET Framework 4.6.2+ lub .NET Core 3.1 / .NET 5-9
  • Visual Studio 2019+ lub JetBrains Rider
  • Dostęp do menedżera pakietów NuGet
  • Klucz licencyjny IronPDF(bezpłatna wersja próbna dostępna na stronie ironpdf.com)

Audyt wykorzystania biblioteki Adobe PDF Library SDK

Uruchom te polecenia w katalogu rozwiązania, aby zidentyfikować wszystkie odwołania do biblioteki Adobe PDF Library SDK:

grep -r "using Datalogics" --include="*.cs" .
grep -r "Adobe.PDF.Library" --include="*.csproj" .
grep -r "Library.Initialize\|Library.Terminate" --include="*.cs" .
grep -r "using Datalogics" --include="*.cs" .
grep -r "Adobe.PDF.Library" --include="*.csproj" .
grep -r "Library.Initialize\|Library.Terminate" --include="*.cs" .
SHELL

Zmiany wymagające dostosowania

Kategoria Adobe PDF Library SDK IronPDF Działanie migracyjne
Inicjalizacja Library.Initialize() / Terminate() Automatyczne Usuń kod cyklu życia
Tworzenie dokumentów new Document() z konstrukcja strony ChromePdfRenderer Użyj renderowania HTML
Układ współrzędnych Punkty PostScript, punkt początkowy w lewym dolnym rogu Układ oparty na CSS Użyj HTML/CSS
Obsługa czcionek Reczne tworzenie i osadzanie Font Automatyczne Usuń kod czcionki
Zarządzanie pamięcią Ręczne usuwanie obiektów COM Standardowy interfejs IDisposable Uzyj instrukcji using
Struktura strony CreatePage(), AddContent() Automatycznie z HTML Znacznie uprościć

Proces migracji krok po kroku

Krok 1: Zaktualizuj pakiety NuGet

Usuń pakietAdobe PDF Library SDKi zainstaluj IronPDF:

# Remove Adobe PDF Library (.NET 6/7/8 projects)
dotnet remove package Adobe.PDF.Library.LM.NET
# .NET Framework projects use the LM.NETFramework variant
dotnet remove package Adobe.PDF.Library.LM.NETFramework

# Install IronPDF
dotnet add package IronPdf
# Remove Adobe PDF Library (.NET 6/7/8 projects)
dotnet remove package Adobe.PDF.Library.LM.NET
# .NET Framework projects use the LM.NETFramework variant
dotnet remove package Adobe.PDF.Library.LM.NETFramework

# Install IronPDF
dotnet add package IronPdf
SHELL

Krok 2: Skonfiguruj klucz licencyjny

Zastąp licencję Adobe kluczem licencyjnym opartym na kodzie IronPDF:

// Replace Adobe's Library.LicenseKey with IronPDF license
// Add at application startup, before any IronPDF operations
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;
// Replace Adobe's Library.LicenseKey with IronPDF license
// Add at application startup, before any IronPDF operations
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;
' Replace Adobe's Library.LicenseKey with IronPDF license
' Add at application startup, before any IronPDF operations
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

' Verify license status
Dim isLicensed As Boolean = IronPdf.License.IsLicensed
$vbLabelText   $csharpLabel

Krok 3: Zaktualizuj odniesienia do przestrzeni nazw

Przeprowadź globalne wyszukiwanie i zamianę w całym rozwiązaniu:

Znajdź Zastąp przez
using Datalogics.PDFL; using IronPdf;

APDFL eksponuje pojedynczy glowny przestrzen nazw, Datalogics.PDFL. Document, Page, Content, Font oraz Color sa klasami w tej przestrzeni nazw, wiec istnieje tylko jedna dyrektywa using do zamiany.

Krok 4: Usuń kod cyklu życia biblioteki

Jednym z najważniejszych uproszczeń jest usunięcie wzorców inicjalizacji i zakończenia:

//Adobe PDF Library SDK- REMOVE THIS PATTERN
Library.Initialize();
try
{
    // PDF operations
}
finally
{
    Library.Terminate(); // Must always terminate
}

//IronPDF- Just use directly
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
//Adobe PDF Library SDK- REMOVE THIS PATTERN
Library.Initialize();
try
{
    // PDF operations
}
finally
{
    Library.Terminate(); // Must always terminate
}

//IronPDF- Just use directly
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
'Adobe PDF Library SDK- REMOVE THIS PATTERN
Library.Initialize()
Try
    ' PDF operations
Finally
    Library.Terminate() ' Must always terminate
End Try

'IronPDF- Just use directly
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Kompletna dokumentacja API

Metody cyklu życia biblioteki

Metoda Adobe Odpowiednik IronPDF
Library.Initialize() Nie jest potrzebne
Library.Terminate() Nie jest potrzebne
Library.LicenseKey = "KEY" IronPdf.License.LicenseKey = "KEY"
using (Library lib = new Library()) Nie jest potrzebne

Metody tworzenia dokumentów

Metoda Adobe Metoda IronPDF
new Document() new ChromePdfRenderer()
new Document(path) PdfDocument.FromFile(path)
doc.CreatePage(index, rect) Automatycznie z HTML
doc.Save(SaveFlags.Full, path) pdf.SaveAs(path)
doc.NumPages pdf.PageCount
doc.GetPage(index) pdf.Pages[index]
doc.InsertPages(insertAfter, src, start, count, flags) PdfDocument.Merge(pdfs)

Tworzenie treści (główna zmiana paradygmatu)

Adobe PDF Library SDK wymaga tworzenia treści na niskim poziomie.IronPDF wykorzystuje HTML/CSS:

Metoda Adobe Metoda IronPDF
new Text() Uzyj HTML <p>, <h1>, itd.
text.AddRun(textRun) Użyj HTML
new TextRun(text, font, size, point) Stylizacja CSS
new Font(name, flags) CSS font-family
new Image(path) tag HTML <img>
content.AddElement(...) Treść HTML
page.UpdateContent() Nie jest potrzebne

Znaki wodne i metody zabezpieczeń

Metoda Adobe Metoda IronPDF
doc.Watermark(textParams, wmParams) pdf.ApplyWatermark(html)
WatermarkParams.Opacity (0,0-1,0) parametr opacity (0-100) lub CSS opacity
new EncryptionHandler(user, owner, perms) pdf.SecuritySettings
PermissionFlags.PrintDoc AllowUserPrinting

Wyodrębnianie tekstu

Metoda Adobe Metoda IronPDF
new WordFinder(doc, config) pdf.ExtractAllText()
wordFinder.GetWordList() pdf.Pages[i].Text
Złożone iteracje słów/znaków Pojedyncze wywołanie metody

Przykłady migracji kodu

Konwersja HTML do PDF

APDFL nie zawiera wbudowanego renderera HTML. Najbliższe jak do jak zapewnia konstrukcję stron i wątków treści ręcznie, aby naśladować układ, jaki wytworzyłby dokument HTML — lub sparowanie APDFL z osobnym silnikiem HTML do PDF.

Wdrożenie biblioteki Adobe PDF Library SDK:

//Adobe PDF Library SDK(Datalogics APDFL)
// NuGet: Adobe.PDF.Library.LM.NET — namespace Datalogics.PDFL
using Datalogics.PDFL;
using System;

class AdobeHtmlToPdf
{
    static void Main()
    {
        using (Library lib = new Library())
        using (Document doc = new Document())
        {
            // US Letter in points (8.5 x 11 inches @ 72 DPI)
            Rect pageRect = new Rect(0, 0, 612, 792);
            using (Page page = doc.CreatePage(Document.BeforeFirstPage, pageRect))
            {
                Content content = page.Content;
                Font font = new Font("Helvetica", FontCreateFlags.Embedded);

                Text text = new Text();
                text.AddRun(new TextRun("Hello World", font, 24, new Point(72, 720)));
                content.AddElement(text);

                page.UpdateContent();
            }

            doc.Save(SaveFlags.Full, "output.pdf");
        }
    }
}
//Adobe PDF Library SDK(Datalogics APDFL)
// NuGet: Adobe.PDF.Library.LM.NET — namespace Datalogics.PDFL
using Datalogics.PDFL;
using System;

class AdobeHtmlToPdf
{
    static void Main()
    {
        using (Library lib = new Library())
        using (Document doc = new Document())
        {
            // US Letter in points (8.5 x 11 inches @ 72 DPI)
            Rect pageRect = new Rect(0, 0, 612, 792);
            using (Page page = doc.CreatePage(Document.BeforeFirstPage, pageRect))
            {
                Content content = page.Content;
                Font font = new Font("Helvetica", FontCreateFlags.Embedded);

                Text text = new Text();
                text.AddRun(new TextRun("Hello World", font, 24, new Point(72, 720)));
                content.AddElement(text);

                page.UpdateContent();
            }

            doc.Save(SaveFlags.Full, "output.pdf");
        }
    }
}
Imports Datalogics.PDFL
Imports System

Class AdobeHtmlToPdf
    Shared Sub Main()
        Using lib As New Library()
            Using doc As New Document()
                ' US Letter in points (8.5 x 11 inches @ 72 DPI)
                Dim pageRect As New Rect(0, 0, 612, 792)
                Using page As Page = doc.CreatePage(Document.BeforeFirstPage, pageRect)
                    Dim content As Content = page.Content
                    Dim font As New Font("Helvetica", FontCreateFlags.Embedded)

                    Dim text As New Text()
                    text.AddRun(New TextRun("Hello World", font, 24, New Point(72, 720)))
                    content.AddElement(text)

                    page.UpdateContent()
                End Using

                doc.Save(SaveFlags.Full, "output.pdf")
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

Wdrożenie IronPDF:

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

class IronPdfHtmlToPdf
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        // Convert HTML to PDF with simple API
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class IronPdfHtmlToPdf
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        // Convert HTML to PDF with simple API
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System

Class IronPdfHtmlToPdf
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"

        ' Convert HTML to PDF with simple API
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF eliminuje opakowanie cyklu życia biblioteki, obiekty parametrów konwersji oraz jawną likwidację. ChromePdfRenderer wykorzystuje silnik oparty na Chromium dla dokladnego wsparcia CSS i JavaScript. W przypadku zaawansowanych scenariuszy zapoznaj się z dokumentacją dotyczącą konwersji HTML do PDF.

Łączenie wielu plików PDF

Łączenie plików PDF wyraźnie pokazuje różnicę w złożoności API.

Wdrożenie biblioteki Adobe PDF Library SDK:

//Adobe PDF Library SDK(Datalogics APDFL)
using Datalogics.PDFL;
using System;

class AdobeMergePdfs
{
    static void Main()
    {
        using (Library lib = new Library())
        using (Document doc1 = new Document("document1.pdf"))
        using (Document doc2 = new Document("document2.pdf"))
        {
            // InsertPages(insertAfter, sourceDoc, sourceStartPage, pageCount, flags)
            doc1.InsertPages(
                Document.LastPage,
                doc2,
                0,
                Document.AllPages,
                PageInsertFlags.Bookmarks | PageInsertFlags.Threads);

            doc1.Save(SaveFlags.Full, "merged.pdf");
        }
    }
}
//Adobe PDF Library SDK(Datalogics APDFL)
using Datalogics.PDFL;
using System;

class AdobeMergePdfs
{
    static void Main()
    {
        using (Library lib = new Library())
        using (Document doc1 = new Document("document1.pdf"))
        using (Document doc2 = new Document("document2.pdf"))
        {
            // InsertPages(insertAfter, sourceDoc, sourceStartPage, pageCount, flags)
            doc1.InsertPages(
                Document.LastPage,
                doc2,
                0,
                Document.AllPages,
                PageInsertFlags.Bookmarks | PageInsertFlags.Threads);

            doc1.Save(SaveFlags.Full, "merged.pdf");
        }
    }
}
Imports Datalogics.PDFL
Imports System

Class AdobeMergePdfs
    Shared Sub Main()
        Using lib As New Library()
            Using doc1 As New Document("document1.pdf")
                Using doc2 As New Document("document2.pdf")
                    ' InsertPages(insertAfter, sourceDoc, sourceStartPage, pageCount, flags)
                    doc1.InsertPages(Document.LastPage, doc2, 0, Document.AllPages, PageInsertFlags.Bookmarks Or PageInsertFlags.Threads)

                    doc1.Save(SaveFlags.Full, "merged.pdf")
                End Using
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

Wdrożenie IronPDF:

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

class IronPdfMergePdfs
{
    static void Main()
    {
        // Load PDF documents
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        // Merge PDFs with simple method
        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class IronPdfMergePdfs
{
    static void Main()
    {
        // Load PDF documents
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        // Merge PDFs with simple method
        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");
    }
}
Imports IronPdf
Imports System

Class IronPdfMergePdfs
    Shared Sub Main()
        ' Load PDF documents
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")

        ' Merge PDFs with simple method
        Dim merged = PdfDocument.Merge(pdf1, pdf2)
        merged.SaveAs("merged.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Podejście firmy Adobe wymaga iteracji strona po stronie z parametrami wstawiania.IronPDF oferuje metode Merge, ktora akceptuje wiele dokumentow.

Dodawanie znaków wodnych

Znak wodny ilustruje, w jaki sposób IronPDF wykorzystuje HTML/CSS do zapewnienia elastyczności stylizacji.

Wdrożenie biblioteki Adobe PDF Library SDK:

//Adobe PDF Library SDK(Datalogics APDFL)
using Datalogics.PDFL;
using System;

class AdobeAddWatermark
{
    static void Main()
    {
        using (Library lib = new Library())
        using (Document doc = new Document("input.pdf"))
        {
            WatermarkParams watermarkParams = new WatermarkParams();
            watermarkParams.Opacity = 0.5; // 0.0 - 1.0
            watermarkParams.Rotation = 45.0;
            watermarkParams.Scale = -1; // auto-fit

            WatermarkTextParams textParams = new WatermarkTextParams();
            textParams.Text = "CONFIDENTIAL";
            textParams.Color = new Color(0.8, 0.8, 0.8);
            textParams.TextAlign = HorizontalAlignment.Center;

            // Apply via Document.Watermark(textParams, wmParams)
            doc.Watermark(textParams, watermarkParams);

            doc.Save(SaveFlags.Full, "watermarked.pdf");
        }
    }
}
//Adobe PDF Library SDK(Datalogics APDFL)
using Datalogics.PDFL;
using System;

class AdobeAddWatermark
{
    static void Main()
    {
        using (Library lib = new Library())
        using (Document doc = new Document("input.pdf"))
        {
            WatermarkParams watermarkParams = new WatermarkParams();
            watermarkParams.Opacity = 0.5; // 0.0 - 1.0
            watermarkParams.Rotation = 45.0;
            watermarkParams.Scale = -1; // auto-fit

            WatermarkTextParams textParams = new WatermarkTextParams();
            textParams.Text = "CONFIDENTIAL";
            textParams.Color = new Color(0.8, 0.8, 0.8);
            textParams.TextAlign = HorizontalAlignment.Center;

            // Apply via Document.Watermark(textParams, wmParams)
            doc.Watermark(textParams, watermarkParams);

            doc.Save(SaveFlags.Full, "watermarked.pdf");
        }
    }
}
Imports Datalogics.PDFL
Imports System

Class AdobeAddWatermark
    Shared Sub Main()
        Using lib As New Library()
            Using doc As New Document("input.pdf")
                Dim watermarkParams As New WatermarkParams()
                watermarkParams.Opacity = 0.5 ' 0.0 - 1.0
                watermarkParams.Rotation = 45.0
                watermarkParams.Scale = -1 ' auto-fit

                Dim textParams As New WatermarkTextParams()
                textParams.Text = "CONFIDENTIAL"
                textParams.Color = New Color(0.8, 0.8, 0.8)
                textParams.TextAlign = HorizontalAlignment.Center

                ' Apply via Document.Watermark(textParams, wmParams)
                doc.Watermark(textParams, watermarkParams)

                doc.Save(SaveFlags.Full, "watermarked.pdf")
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

Wdrożenie IronPDF:

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

class IronPdfAddWatermark
{
    static void Main()
    {
        var pdf = PdfDocument.FromFile("input.pdf");

        // Apply text watermark with simple API
        pdf.ApplyWatermark("<h1 style='color:red; opacity:0.5;'>CONFIDENTIAL</h1>",
            rotation: 45,
            verticalAlignment: VerticalAlignment.Middle,
            horizontalAlignment: HorizontalAlignment.Center);

        pdf.SaveAs("watermarked.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;
using System;

class IronPdfAddWatermark
{
    static void Main()
    {
        var pdf = PdfDocument.FromFile("input.pdf");

        // Apply text watermark with simple API
        pdf.ApplyWatermark("<h1 style='color:red; opacity:0.5;'>CONFIDENTIAL</h1>",
            rotation: 45,
            verticalAlignment: VerticalAlignment.Middle,
            horizontalAlignment: HorizontalAlignment.Center);

        pdf.SaveAs("watermarked.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Editing
Imports System

Class IronPdfAddWatermark
    Shared Sub Main()
        Dim pdf = PdfDocument.FromFile("input.pdf")

        ' Apply text watermark with simple API
        pdf.ApplyWatermark("<h1 style='color:red; opacity:0.5;'>CONFIDENTIAL</h1>",
                           rotation:=45,
                           verticalAlignment:=VerticalAlignment.Middle,
                           horizontalAlignment:=HorizontalAlignment.Center)

        pdf.SaveAs("watermarked.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Funkcja znakowania wodnego oparta na HTML w IronPDF zapewnia pełną kontrolę nad projektem dzięki stylom CSS, eliminując potrzebę stosowania oddzielnych obiektów parametrów.

Ochrona hasłem i szyfrowanie

Wdrożenie biblioteki Adobe PDF Library SDK:

using Datalogics.PDFL;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    Library.Initialize();
    try
    {
        using (Document doc = new Document(inputPath))
        {
            PermissionFlags permissions =
                PermissionFlags.PrintDoc |
                PermissionFlags.PrintFidelity;

            EncryptionHandler encHandler = new EncryptionHandler(
                password,      // User password
                password,      // Owner password
                permissions,
                EncryptionMethod.AES256);

            doc.SetEncryptionHandler(encHandler);
            doc.Save(SaveFlags.Full | SaveFlags.Encrypted, outputPath);
        }
    }
    finally
    {
        Library.Terminate();
    }
}
using Datalogics.PDFL;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    Library.Initialize();
    try
    {
        using (Document doc = new Document(inputPath))
        {
            PermissionFlags permissions =
                PermissionFlags.PrintDoc |
                PermissionFlags.PrintFidelity;

            EncryptionHandler encHandler = new EncryptionHandler(
                password,      // User password
                password,      // Owner password
                permissions,
                EncryptionMethod.AES256);

            doc.SetEncryptionHandler(encHandler);
            doc.Save(SaveFlags.Full | SaveFlags.Encrypted, outputPath);
        }
    }
    finally
    {
        Library.Terminate();
    }
}
Imports Datalogics.PDFL

Public Sub ProtectPdf(inputPath As String, outputPath As String, password As String)
    Library.Initialize()
    Try
        Using doc As New Document(inputPath)
            Dim permissions As PermissionFlags = PermissionFlags.PrintDoc Or PermissionFlags.PrintFidelity

            Dim encHandler As New EncryptionHandler(
                password,      ' User password
                password,      ' Owner password
                permissions,
                EncryptionMethod.AES256)

            doc.SetEncryptionHandler(encHandler)
            doc.Save(SaveFlags.Full Or SaveFlags.Encrypted, outputPath)
        End Using
    Finally
        Library.Terminate()
    End Try
End Sub
$vbLabelText   $csharpLabel

Wdrożenie IronPDF:

using IronPdf;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    using var pdf = PdfDocument.FromFile(inputPath);

    pdf.SecuritySettings.UserPassword = password;
    pdf.SecuritySettings.OwnerPassword = password;
    pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
    pdf.SecuritySettings.AllowUserCopyPasteContent = false;
    pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

    pdf.SaveAs(outputPath);
}
using IronPdf;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    using var pdf = PdfDocument.FromFile(inputPath);

    pdf.SecuritySettings.UserPassword = password;
    pdf.SecuritySettings.OwnerPassword = password;
    pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
    pdf.SecuritySettings.AllowUserCopyPasteContent = false;
    pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

    pdf.SaveAs(outputPath);
}
Imports IronPdf

Public Sub ProtectPdf(inputPath As String, outputPath As String, password As String)
    Using pdf = PdfDocument.FromFile(inputPath)
        pdf.SecuritySettings.UserPassword = password
        pdf.SecuritySettings.OwnerPassword = password
        pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights
        pdf.SecuritySettings.AllowUserCopyPasteContent = False
        pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit

        pdf.SaveAs(outputPath)
    End Using
End Sub
$vbLabelText   $csharpLabel

IronPDF wykorzystuje właściwości silnie typowane zamiast bitowych flag uprawnień i obiektów obsługujących szyfrowanie.

Wyodrębnianie tekstu

Wdrożenie biblioteki Adobe PDF Library SDK:

using Datalogics.PDFL;

public string ExtractText(string pdfPath)
{
    string extractedText = "";

    Library.Initialize();
    try
    {
        using (Document doc = new Document(pdfPath))
        {
            WordFinderConfig config = new WordFinderConfig();
            config.IgnoreCharGaps = true;

            for (int i = 0; i < doc.NumPages; i++)
            {
                using (WordFinder wordFinder = new WordFinder(doc, i, config))
                {
                    IList<Word> words = wordFinder.GetWordList();
                    foreach (Word word in words)
                    {
                        extractedText += word.Text + " ";
                    }
                    extractedText += "\n";
                }
            }
        }
    }
    finally
    {
        Library.Terminate();
    }

    return extractedText;
}
using Datalogics.PDFL;

public string ExtractText(string pdfPath)
{
    string extractedText = "";

    Library.Initialize();
    try
    {
        using (Document doc = new Document(pdfPath))
        {
            WordFinderConfig config = new WordFinderConfig();
            config.IgnoreCharGaps = true;

            for (int i = 0; i < doc.NumPages; i++)
            {
                using (WordFinder wordFinder = new WordFinder(doc, i, config))
                {
                    IList<Word> words = wordFinder.GetWordList();
                    foreach (Word word in words)
                    {
                        extractedText += word.Text + " ";
                    }
                    extractedText += "\n";
                }
            }
        }
    }
    finally
    {
        Library.Terminate();
    }

    return extractedText;
}
Imports Datalogics.PDFL

Public Function ExtractText(ByVal pdfPath As String) As String
    Dim extractedText As String = ""

    Library.Initialize()
    Try
        Using doc As New Document(pdfPath)
            Dim config As New WordFinderConfig()
            config.IgnoreCharGaps = True

            For i As Integer = 0 To doc.NumPages - 1
                Using wordFinder As New WordFinder(doc, i, config)
                    Dim words As IList(Of Word) = wordFinder.GetWordList()
                    For Each word As Word In words
                        extractedText &= word.Text & " "
                    Next
                    extractedText &= vbLf
                End Using
            Next
        End Using
    Finally
        Library.Terminate()
    End Try

    Return extractedText
End Function
$vbLabelText   $csharpLabel

Wdrożenie IronPDF:

using IronPdf;

public string ExtractText(string pdfPath)
{
    using var pdf = PdfDocument.FromFile(pdfPath);
    return pdf.ExtractAllText();
}
using IronPdf;

public string ExtractText(string pdfPath)
{
    using var pdf = PdfDocument.FromFile(pdfPath);
    return pdf.ExtractAllText();
}
Imports IronPdf

Public Function ExtractText(pdfPath As String) As String
    Using pdf = PdfDocument.FromFile(pdfPath)
        Return pdf.ExtractAllText()
    End Using
End Function
$vbLabelText   $csharpLabel

Iteracja słowo po słowie w Adobe staje się pojedynczym wywołaniem metody dzięki IronPDF.

Nagłówki i stopki

Wdrożenie biblioteki Adobe PDF Library SDK:

using Datalogics.PDFL;

public void AddHeaderFooter(string inputPath, string outputPath)
{
    Library.Initialize();
    try
    {
        using (Document doc = new Document(inputPath))
        {
            Font font = new Font("Helvetica", FontCreateFlags.None);

            for (int i = 0; i < doc.NumPages; i++)
            {
                using (Page page = doc.GetPage(i))
                {
                    Content content = page.Content;

                    // Add header
                    Text header = new Text();
                    header.AddRun(new TextRun("Document Header",
                        font, 10, new Point(72, page.MediaBox.Top - 36)));
                    content.AddElement(header);

                    // Add footer with page number
                    Text footer = new Text();
                    footer.AddRun(new TextRun($"Page {i + 1} of {doc.NumPages}",
                        font, 10, new Point(72, 36)));
                    content.AddElement(footer);

                    page.UpdateContent();
                }
            }
            doc.Save(SaveFlags.Full, outputPath);
        }
    }
    finally
    {
        Library.Terminate();
    }
}
using Datalogics.PDFL;

public void AddHeaderFooter(string inputPath, string outputPath)
{
    Library.Initialize();
    try
    {
        using (Document doc = new Document(inputPath))
        {
            Font font = new Font("Helvetica", FontCreateFlags.None);

            for (int i = 0; i < doc.NumPages; i++)
            {
                using (Page page = doc.GetPage(i))
                {
                    Content content = page.Content;

                    // Add header
                    Text header = new Text();
                    header.AddRun(new TextRun("Document Header",
                        font, 10, new Point(72, page.MediaBox.Top - 36)));
                    content.AddElement(header);

                    // Add footer with page number
                    Text footer = new Text();
                    footer.AddRun(new TextRun($"Page {i + 1} of {doc.NumPages}",
                        font, 10, new Point(72, 36)));
                    content.AddElement(footer);

                    page.UpdateContent();
                }
            }
            doc.Save(SaveFlags.Full, outputPath);
        }
    }
    finally
    {
        Library.Terminate();
    }
}
Imports Datalogics.PDFL

Public Sub AddHeaderFooter(inputPath As String, outputPath As String)
    Library.Initialize()
    Try
        Using doc As New Document(inputPath)
            Dim font As New Font("Helvetica", FontCreateFlags.None)

            For i As Integer = 0 To doc.NumPages - 1
                Using page As Page = doc.GetPage(i)
                    Dim content As Content = page.Content

                    ' Add header
                    Dim header As New Text()
                    header.AddRun(New TextRun("Document Header", font, 10, New Point(72, page.MediaBox.Top - 36)))
                    content.AddElement(header)

                    ' Add footer with page number
                    Dim footer As New Text()
                    footer.AddRun(New TextRun($"Page {i + 1} of {doc.NumPages}", font, 10, New Point(72, 36)))
                    content.AddElement(footer)

                    page.UpdateContent()
                End Using
            Next
            doc.Save(SaveFlags.Full, outputPath)
        End Using
    Finally
        Library.Terminate()
    End Try
End Sub
$vbLabelText   $csharpLabel

Wdrożenie IronPDF:

using IronPdf;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Document Header",
        FontSize = 10,
        FontFamily = "Helvetica"
    };

    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10,
        FontFamily = "Helvetica"
    };

    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(outputPath);
}
using IronPdf;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Document Header",
        FontSize = 10,
        FontFamily = "Helvetica"
    };

    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10,
        FontFamily = "Helvetica"
    };

    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(outputPath);
}
Imports IronPdf

Public Sub CreatePdfWithHeaderFooter(html As String, outputPath As String)
    Dim renderer = New ChromePdfRenderer()

    renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
        .CenterText = "Document Header",
        .FontSize = 10,
        .FontFamily = "Helvetica"
    }

    renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
        .CenterText = "Page {page} of {total-pages}",
        .FontSize = 10,
        .FontFamily = "Helvetica"
    }

    Using pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs(outputPath)
    End Using
End Sub
$vbLabelText   $csharpLabel

IronPDF automatycznie obsługuje iteracje stron i wspiera tokeny zastępcze jak {page} i {total-pages}. Więcej informacji na temat bardziej zaawansowanych układów znajdziesz w dokumentacji dotyczącej nagłówków i stopek.

Konwersja adresów URL do formatu PDF

Adobe PDF Library SDK nie posiada wbudowanej funkcji renderowania adresów URL.IronPDF zapewnia natywną obsługę:

using IronPdf;

public void ConvertUrlToPdf(string url, string outputPath)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderUrlAsPdf(url);
    pdf.SaveAs(outputPath);
}
using IronPdf;

public void ConvertUrlToPdf(string url, string outputPath)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderUrlAsPdf(url);
    pdf.SaveAs(outputPath);
}
Imports IronPdf

Public Sub ConvertUrlToPdf(url As String, outputPath As String)
    Dim renderer As New ChromePdfRenderer()
    Using pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs(outputPath)
    End Using
End Sub
$vbLabelText   $csharpLabel

Pełne opcje konwersji adresów URL można znaleźć w dokumentacji funkcji URL to PDF.

Integracja z ASP.NET Core.NET Core

Wzorzec statycznej inicjalizacji bibliotekiAdobe PDF Library SDKpowoduje konflikt z wstrzykiwaniem zależności.IronPDF w naturalny sposób integruje się z nowoczesnymi architekturami .NET.

Wzorzec Adobe (problematyczny dla DI):

public class AdobePdfService
{
    public byte[] Generate(string content)
    {
        Library.Initialize();
        try
        {
            // Złożony dokument construction...
            return bytes;
        }
        finally
        {
            Library.Terminate();
        }
    }
}
public class AdobePdfService
{
    public byte[] Generate(string content)
    {
        Library.Initialize();
        try
        {
            // Złożony dokument construction...
            return bytes;
        }
        finally
        {
            Library.Terminate();
        }
    }
}
Public Class AdobePdfService
    Public Function Generate(content As String) As Byte()
        Library.Initialize()
        Try
            ' Złożony dokument construction...
            Return bytes
        Finally
            Library.Terminate()
        End Try
    End Function
End Class
$vbLabelText   $csharpLabel

Wzorzec IronPDF(przyjazny dla DI):

public interface IPdfService
{
    Task<byte[]> GeneratePdfAsync(string html);
}

public class IronPdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;

    public IronPdfService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        using var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
        return pdf.BinaryData;
    }
}

// Register in Program.cs (.NET 6+):
builder.Services.AddSingleton<IPdfService, IronPdfService>();
public interface IPdfService
{
    Task<byte[]> GeneratePdfAsync(string html);
}

public class IronPdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;

    public IronPdfService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        using var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
        return pdf.BinaryData;
    }
}

// Register in Program.cs (.NET 6+):
builder.Services.AddSingleton<IPdfService, IronPdfService>();
Imports System.Threading.Tasks

Public Interface IPdfService
    Function GeneratePdfAsync(html As String) As Task(Of Byte())
End Interface

Public Class IronPdfService
    Implements IPdfService

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer()
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
    End Sub

    Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte()) Implements IPdfService.GeneratePdfAsync
        Using pdf = Await _renderer.RenderHtmlAsPdfAsync(html)
            Return pdf.BinaryData
        End Using
    End Function
End Class

' Register in Program.vb (.NET 6+):
builder.Services.AddSingleton(Of IPdfService, IronPdfService)()
$vbLabelText   $csharpLabel

Obsługa asynchroniczna

Adobe PDF Library SDK nie obsługuje operacji asynchronicznych.IronPDF zapewnia pełne możliwości async/await niezbędne dla skalowalnych aplikacji internetowych:

public async Task<IActionResult> GenerateReport()
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}
public async Task<IActionResult> GenerateReport()
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

Public Class ReportController
    Inherits Controller

    Public Async Function GenerateReport() As Task(Of IActionResult)
        Dim renderer As New ChromePdfRenderer()
        Using pdf = Await renderer.RenderHtmlAsPdfAsync(html)
            Return File(pdf.BinaryData, "application/pdf")
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

Optymalizacja wydajności

Porównanie zużycia pamięci

Scenariusz Adobe PDF Library SDK IronPDF
Prosty plik PDF ~100 MB ~50 MB
Złożony dokument ~200 MB ~80 MB
Partia (100 plików PDF) Wysoka (pamięć natywna) ~100 MB

Wskazówki dotyczące optymalizacji

Ponowne wykorzystanie instancji renderera:

// Good: Reuse renderer for batch operations
var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}
// Good: Reuse renderer for batch operations
var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}
' Good: Reuse renderer for batch operations
Dim renderer = New ChromePdfRenderer()
For Each html In htmlList
    Using pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs($"output_{i}.pdf")
    End Using
Next
$vbLabelText   $csharpLabel

Wykorzystanie Async w aplikacjach internetowych:

public async Task<IActionResult> GenerateReport()
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}
public async Task<IActionResult> GenerateReport()
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

Public Class ReportController
    Inherits Controller

    Public Async Function GenerateReport() As Task(Of IActionResult)
        Dim renderer As New ChromePdfRenderer()
        Using pdf = Await renderer.RenderHtmlAsPdfAsync(html)
            Return File(pdf.BinaryData, "application/pdf")
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

Rozwiązywanie typowych problemów związanych z migracją

Problem: Pozycjonowanie oparte na współrzędnych nie działa

Adobe używa współrzędnych punktowych PostScript.IronPDF wykorzystuje pozycjonowanie CSS:

// Adobe: Point-based
new TextRun("Hello", font, 12, new Point(100, 700));

// IronPDF: CSS-based
string html = "<p style='position:absolute; left:100px; top:92px;'>Hello</p>";
// Adobe: Point-based
new TextRun("Hello", font, 12, new Point(100, 700));

// IronPDF: CSS-based
string html = "<p style='position:absolute; left:100px; top:92px;'>Hello</p>";
' Adobe: Point-based
New TextRun("Hello", font, 12, New Point(100, 700))

' IronPDF: CSS-based
Dim html As String = "<p style='position:absolute; left:100px; top:92px;'>Hello</p>"
$vbLabelText   $csharpLabel

Problem: Różnice w rozmiarze stron

Adobe stosuje punkty PostScript.IronPDF wykorzystuje wyliczenia lub wymiary niestandardowe:

// Adobe: Points
Rect(0, 0, 612, 792) // Letter

// IronPDF: Enum or custom
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom:
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);
// Adobe: Points
Rect(0, 0, 612, 792) // Letter

// IronPDF: Enum or custom
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom:
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);
' Adobe: Points
Rect(0, 0, 612, 792) ' Letter

' IronPDF: Enum or custom
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
' Or custom:
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11)
$vbLabelText   $csharpLabel

Problem: Nie znaleziono czcionki

Adobe wymaga ręcznego osadzania czcionek.IronPDF automatycznie obsługuje czcionki:

// IronPDF: Use web fonts if needed
string html = @"
<style>
    @import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
    body { font-family: 'Roboto', sans-serif; }
</style>";
// IronPDF: Use web fonts if needed
string html = @"
<style>
    @import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
    body { font-family: 'Roboto', sans-serif; }
</style>";
' IronPDF: Use web fonts if needed
Dim html As String = "
<style>
    @import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
    body { font-family: 'Roboto', sans-serif; }
</style>"
$vbLabelText   $csharpLabel

Problem: SaveFlags niedostępne

Adobe stosuje kombinacje flag zapisywania.IronPDF wykorzystuje bezpośrednie zapisywanie:

// Adobe
doc.Save(SaveFlags.Full | SaveFlags.Incremental, path);

//IronPDF- full save is default
pdf.SaveAs(path);
// Adobe
doc.Save(SaveFlags.Full | SaveFlags.Incremental, path);

//IronPDF- full save is default
pdf.SaveAs(path);
$vbLabelText   $csharpLabel

Lista kontrolna po migracji

Po zakończeniu migracji kodu sprawdź, czy:

  • Uruchom wszystkie istniejące testy jednostkowe i integracyjne
  • Porównaj wizualnie pliki PDF z poprzednimi wersjami
  • Przetestuj wszystkie procesy związane z plikami PDF w środowisku testowym
  • Zweryfikuj, czy licencjonowanie dziala poprawnie (IronPdf.License.IsLicensed)
  • Testy wydajności w porównaniu z poprzednią implementacją
  • Usuń konfigurację licencji Adobe
  • Aktualizacja zależności potoku CI/CD
  • Usuń wszystkie biblioteki DLL Adobe PDF Library z projektu
  • Opisz nowe wzorce dla swojego zespołu programistów

Dodatkowe zasoby

Migracja z APDFL do IronPDF może uprościć typową bazę kodu generacji PDF dla .NET, szczególnie dla zespołów, których podstawową potrzebą jest HTML do PDF lub manipulacja dokumentu, a nie pełen zestaw funkcji pochodny od Acrobat. Przejscie z niskopoziomowej konstrukcji strony na renderowanie HTML/CSS usuwa wiekszosc obliczen wspolrzednych, zarzadzanie czcionkami oraz kod obslugi cyklu zycia Library, a przejrzyste, na programiste, licencjonowanie IronPDF jest zazwyczaj latwiejsze do zaplanowania w budzecie niz model prowadzony przez sprzedaz APDFL, OEM/SaaS-royalty.

Zwróć uwagęAdobe, Acrobat i Adobe PDF Library są zarejestrowanymi znakami towarowymi Adobe Inc. APDFL jest dystrybuowany przez Datalogics, Inc. na podstawie licencji od Adobe. Ta strona nie jest powiązana, popierana ani sponsorowana przez Adobe Inc. ani Datalogics, Inc. Wszystkie nazwy produktów, logo i marki są własnością ich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

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

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie