PRZEWODNIKI MIGRACJI

Migracja z ActivePDF do IronPDF: (Przewodnik .NET)

Zaktualizowano:1 lutego, 2026

ActivePDF to niezawodny zestaw narzędzi do obsługi plików PDF dla programistów .NET. Jednak od czasu przejęcia przez Foxit wiele zespołów programistycznych ma wątpliwości co do przyszłości platformy, warunków licencji i dalszego rozwoju. Niniejszy przewodnik przedstawia szczegółową, krok po kroku ścieżkę migracji zActivePDFdoIronPDF— nowoczesnej, aktywnie rozwijanej biblioteki .NET do obsługi plików PDF, obsługującej platformy od .NET Framework 4.6.2 do .NET 9 i nowszych.

Dlaczego warto rozważyć odejście od ActivePDF?

Przejęcie firmyActivePDFprzez Foxit postawiło przed programistami pracującymi nad rozwiązaniami do generowania i edycji plików PDF w aplikacjach .NET kilka wyzwań.

Niepewna przyszłość produktu

PrzejęcieActivePDFprzez firmę Foxit rodzi pytania dotyczące długoterminowej ścieżki rozwoju tego zestawu narzędzi. Programiści korzystający zActivePDFnarażeni są na potencjalne ryzyko, że biblioteka stanie się przestarzała, a wsparcie techniczne zostanie ograniczone, a rozwój zatrzyma się. Dla zespołów planujących projekty sięgające lat 2025 i 2026 ta niepewność stwarza znaczne ryzyko techniczne.

Komplikacje związane z licencjonowaniem

Przejęcie spowodowało niepewność w zakresie licencji, co może skomplikówać wdrożenia. Tradycyjny model licencjonowaniaActivePDFoparty na przypisaniu do konkretnego komputera powoduje utrudnienia w nowoczesnych środowiskach chmurowych i kontenerowych, gdzie aplikacje dynamicznie skalują się w całej infrastrukturze.

Wzorce architektury starszego typu

ArchitekturaActivePDFodzwierciedla starszą filozofię projektowania skoncentrowaną na wzorcach zestawów narzędzi z zachowaniem stanu. Przepływ pracy CloseOutputFile wymaga jawnego zarządzania uchwytami plików, co nie jest zgodne z nowoczesnymi konwencjami języka C# i może powodować problemy z zarządzaniem zasobami, jeśli nie zostanie przeprowadzone ostrożnie.

Koszty związane z instalacją i konfiguracją

W przeciwieństwie do współczesnego zarządzania pakietami opartego na NuGet,ActivePDFczęsto wymaga ręcznego dodawania odwołań do bibliotek DLL i jawnej konfiguracji ścieżek podczas instancjonowania zestawu narzędzi — jest to schemat, który utrudnia wdrażanie i komplikuje procesy CI/CD.

ActivePDFa IronPDF: kluczowe różnice

Przed rozpoczęciem procesu migracji zrozumienie podstawowych różnic międzyActivePDFaIronPDFpomaga określić oczekiwania dotyczące wymaganych zmian w kodzie.

Aspekt	ActivePDF	IronPDF
Status firmy	Przejęta przez Foxit (niepewna przyszłość)	Niezależny, przejrzysty plan rozwoju
Instalacja	Ręczne odwołania do bibliotek DLL	Prosty pakiet NuGet
Wzorzec API	Stateful (`CloseOutputFile`)	Płynne, funkcjonalne API
Model licencji	Zablokowane przez maszynę	Klucz oparty na kodzie
Wsparcie .NET	Skupienie się na starszej wersji .NET Framework	Framework 4.6.2 do .NET Framework 9+
Obsługa błędów	Całkowite kody zwrotne	Nowoczesne oparte na wyjątkach
Obsługa asynchroniczna	Niedostępne	Pełna obsługa async/await

Przygotowania przed migracją

Przeprowadź audyt swojego kodu źródłowego

Przed rozpoczęciem migracji należy zidentyfikować wszystkie miejsca użyciaActivePDFw całym rozwiązaniu. Uruchom te polecenia w katalogu rozwiązania:

grep -r "using ActivePDF" --include="*.cs" .
grep -r "using APToolkitNET" --include="*.cs" .
grep -r "APToolkitNET" --include="*.csproj" .

grep -r "using ActivePDF" --include="*.cs" .
grep -r "using APToolkitNET" --include="*.cs" .
grep -r "APToolkitNET" --include="*.csproj" .

SHELL

Zmiany powodujące niekompatybilność dokumentów

Zrozumienie podstawowych różnic między interfejsami API pomaga w planowaniu strategii migracji:

Kategoria	DziałanieActivePDF	DziałanieIronPDF	Działanie migracyjne
Model obiektowy	Pojedynczy obiekt `Toolkit`	`ChromePdfRenderer` + `PdfDocument`	Rozdzielenie zagadnień
Operacje na plikach	`CloseOutputFile()`	Direct `SaveAs()`	Usuń niejednoznaczne sformułowania
Tworzenie strony	`NewPage()` metoda	Automatycznie z HTML	Usuń wywołania tworzenia stron
Wartości zwracane	Kody błędów liczb całkowitych	Wyjątki	Wprowadź try/catch
Jednostki rozmiaru strony	Punkty (612x792 = Letter)	Wypisywanie lub milimetry	Aktualizacja pomiarów

Wymagania wstępne

Upewnij się, że Twoje środowisko spełnia następujące 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 licencyjnyIronPDF(bezpłatna wersja próbna dostępna na stronie ironpdf.com)

Proces migracji krok po kroku

Krok 1: Zaktualizuj pakiety NuGet

Usuń pakietActivePDFi zainstaluj IronPDF:

# RemoveActivePDFpackage
dotnet remove package APToolkitNET

# Install IronPDF
dotnet add package IronPdf

# RemoveActivePDFpackage
dotnet remove package APToolkitNET

# Install IronPDF
dotnet add package IronPdf

SHELL

Alternatywnie, za pomocą konsoli menedżera pakietów Visual Studio:

Uninstall-Package APToolkitNET
Install-Package IronPdf

W przypadku projektów z ręcznymi odwołaniami do bibliotek DLL usuń odwołanie z pliku .csproj:


<Reference Include="APToolkitNET">
    <HintPath>path\to\APToolkitNET.dll</HintPath>
</Reference>


<Reference Include="APToolkitNET">
    <HintPath>path\to\APToolkitNET.dll</HintPath>
</Reference>

XML

Krok 2: Skonfiguruj klucz licencyjny

Dodaj klucz licencyjnyIronPDFpodczas uruchamiania aplikacji, przed wykonaniem jakichkolwiek operacji na plikach PDF:

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;

' Add at application startup (Program.vb or Startup.vb)
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 ActivePDF.Toolkit;`	`using IronPdf;`
`using APToolkitNET;`	`using IronPdf;`
`using APToolkitNET.PDFObjects;`	`using IronPdf;`
`using APToolkitNET.Common;`	`using IronPdf;`

Kompletna dokumentacja API

Metody tworzenia dokumentów

MetodaActivePDF	OdpowiednikIronPDF
`new Toolkit()`	`new ChromePdfRenderer()`
`toolkit.OpenOutputFile(path)`	Nie jest potrzebny odpowiednik
`toolkit.CloseOutputFile()`	Nie jest potrzebny odpowiednik
`toolkit.AddHTML(html)`	`renderer.RenderHtmlAsPdf(html)`
`toolkit.AddURL(url)`	`renderer.RenderUrlAsPdf(url)`
`toolkit.SaveAs(path)`	`pdf.SaveAs(path)`

Operacje na plikach

MetodaActivePDF	OdpowiednikIronPDF
`toolkit.OpenInputFile(path)`	`PdfDocument.FromFile(path)`
`toolkit.AddPDF(path)`	`PdfDocument.Merge()`
`toolkit.GetPageCount()`	`pdf.PageCount`
`toolkit.GetText()`	`pdf.ExtractAllText()`

Konfiguracja strony

MetodaActivePDF	OdpowiednikIronPDF
`toolkit.SetPageSize(612, 792)`	`RenderingOptions.PaperSize = PdfPaperSize.Letter`
`toolkit.SetOrientation("Landscape")`	`RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape`
`toolkit.SetMargins(t, b, l, r)`	`RenderingOptions.MarginTop/Bottom/Left/Right`

Metody bezpieczeństwa

MetodaActivePDF	OdpowiednikIronPDF
`toolkit.Encrypt(password)`	`pdf.SecuritySettings.OwnerPassword`
`toolkit.SetUserPassword(pwd)`	`pdf.SecuritySettings.UserPassword`
`toolkit.SetPermissions(flags)`	`pdf.SecuritySettings.AllowUserXxx`
`toolkit.AddWatermark(text)`	`pdf.ApplyWatermark(html)`

Przykłady migracji kodu

Konwersja HTML do PDF

Konwersja ciągów znaków HTML na dokumenty PDF stanowi jeden z najczęstszych scenariuszy generowania plików PDF. Oto jak kod zmienia się podczas migracji.

Wdrożenie ActivePDF:

// NuGet: Install-Package APToolkitNET
using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        if (toolkit.OpenOutputFile("output.pdf") == 0)
        {
            toolkit.AddHTML(htmlContent);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF created successfully");
        }
    }
}

// NuGet: Install-Package APToolkitNET
using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        if (toolkit.OpenOutputFile("output.pdf") == 0)
        {
            toolkit.AddHTML(htmlContent);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF created successfully");
        }
    }
}

Imports ActivePDF.Toolkit
Imports System

Class Program
    Shared Sub Main()
        Dim toolkit As New Toolkit()

        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"

        If toolkit.OpenOutputFile("output.pdf") = 0 Then
            toolkit.AddHTML(htmlContent)
            toolkit.CloseOutputFile()
            Console.WriteLine("PDF created successfully")
        End If
    End Sub
End Class

$vbLabelText $csharpLabel

Wdrożenie IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");

        Console.WriteLine("PDF created successfully");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");

        Console.WriteLine("PDF created successfully");
    }
}

Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")

        Console.WriteLine("PDF created successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

PodejścieIronPDFeliminuje konieczność jawnego zarządzania uchwytami plików, zapewniając jednocześnie czystszy i bardziej czytelny kod. W zaawansowanych scenariuszach konwersji HTML do PDF, ChromePdfRenderer firmyIronPDFwykorzystuje silnik renderujący oparty na Chromium, zapewniający idealną zgodność z CSS i JavaScript.

Konwersja adresów URL do formatu PDF

Przechwytywanie stron internetowych jako dokumentów PDF przebiega według podobnego schematu modernizacji.

Wdrożenie ActivePDF:

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        string url = "https://www.example.com";

        if (toolkit.OpenOutputFile("webpage.pdf") == 0)
        {
            toolkit.AddURL(url);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF from URL created successfully");
        }
    }
}

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        string url = "https://www.example.com";

        if (toolkit.OpenOutputFile("webpage.pdf") == 0)
        {
            toolkit.AddURL(url);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF from URL created successfully");
        }
    }
}

Imports ActivePDF.Toolkit
Imports System

Class Program
    Shared Sub Main()
        Dim toolkit As New Toolkit()

        Dim url As String = "https://www.example.com"

        If toolkit.OpenOutputFile("webpage.pdf") = 0 Then
            toolkit.AddURL(url)
            toolkit.CloseOutputFile()
            Console.WriteLine("PDF from URL created successfully")
        End If
    End Sub
End Class

$vbLabelText $csharpLabel

Wdrożenie IronPDF:

using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string url = "https://www.example.com";

        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");

        Console.WriteLine("PDF from URL created successfully");
    }
}

using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string url = "https://www.example.com";

        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");

        Console.WriteLine("PDF from URL created successfully");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        Dim url As String = "https://www.example.com"

        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")

        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class

$vbLabelText $csharpLabel

Łączenie wielu plików PDF

Łączenie wielu dokumentów PDF w jeden plik pokazuje funkcjonalne podejścieIronPDFdo manipulacji dokumentami.

Wdrożenie ActivePDF:

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        if (toolkit.OpenOutputFile("merged.pdf") == 0)
        {
            toolkit.AddPDF("document1.pdf");
            toolkit.AddPDF("document2.pdf");
            toolkit.CloseOutputFile();
            Console.WriteLine("PDFs merged successfully");
        }
    }
}

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        if (toolkit.OpenOutputFile("merged.pdf") == 0)
        {
            toolkit.AddPDF("document1.pdf");
            toolkit.AddPDF("document2.pdf");
            toolkit.CloseOutputFile();
            Console.WriteLine("PDFs merged successfully");
        }
    }
}

Imports ActivePDF.Toolkit
Imports System

Class Program
    Shared Sub Main()
        Dim toolkit As New Toolkit()

        If toolkit.OpenOutputFile("merged.pdf") = 0 Then
            toolkit.AddPDF("document1.pdf")
            toolkit.AddPDF("document2.pdf")
            toolkit.CloseOutputFile()
            Console.WriteLine("PDFs merged successfully")
        End If
    End Sub
End Class

$vbLabelText $csharpLabel

Wdrożenie IronPDF:

using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");

        Console.WriteLine("PDFs merged successfully");
    }
}

using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");

        Console.WriteLine("PDFs merged successfully");
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")

        Dim merged = PdfDocument.Merge(pdf1, pdf2)
        merged.SaveAs("merged.pdf")

        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

Aby uzyskać informacje na temat bardziej zaawansowanych scenariuszy łączenia, w tym selektywnego wyodrębniania stron, zapoznaj się z dokumentacją dotyczącą łączenia plików PDF.

Dodawanie nagłówków i stopek

Wdrożenie ActivePDF:

using ActivePDF.Toolkit;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile(outputPath) == 0)
    {
        toolkit.SetHeader("My Document", 12, "Arial");
        toolkit.SetFooter("Page %p of %P", 10, "Arial");
        toolkit.AddHTML(html);
        toolkit.CloseOutputFile();
    }
}

using ActivePDF.Toolkit;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile(outputPath) == 0)
    {
        toolkit.SetHeader("My Document", 12, "Arial");
        toolkit.SetFooter("Page %p of %P", 10, "Arial");
        toolkit.AddHTML(html);
        toolkit.CloseOutputFile();
    }
}

Imports ActivePDF.Toolkit

Public Sub CreatePdfWithHeaderFooter(html As String, outputPath As String)
    Dim toolkit As New Toolkit()

    If toolkit.OpenOutputFile(outputPath) = 0 Then
        toolkit.SetHeader("My Document", 12, "Arial")
        toolkit.SetFooter("Page %p of %P", 10, "Arial")
        toolkit.AddHTML(html)
        toolkit.CloseOutputFile()
    End If
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 = "My Document",
        FontSize = 12,
        FontFamily = "Arial"
    };

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

    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 = "My Document",
        FontSize = 12,
        FontFamily = "Arial"
    };

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

    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 = "My Document",
        .FontSize = 12,
        .FontFamily = "Arial"
    }

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

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

$vbLabelText $csharpLabel

IronPDF obsługuje zarówno nagłówki i stopki tekstowe, jak i HTML, zapewniając pełną elastyczność projektowania.

Ochrona hasłem i bezpieczeństwo

Wdrożenie ActivePDF:

using ActivePDF.Toolkit;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        toolkit.Encrypt(password);
        toolkit.SetUserPassword(password);
        toolkit.SetPermissions(4); // Print only
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

using ActivePDF.Toolkit;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        toolkit.Encrypt(password);
        toolkit.SetUserPassword(password);
        toolkit.SetPermissions(4); // Print only
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

Imports ActivePDF.Toolkit

Public Sub ProtectPdf(inputPath As String, outputPath As String, password As String)
    Dim toolkit As New Toolkit()

    If toolkit.OpenInputFile(inputPath) = 0 Then
        toolkit.Encrypt(password)
        toolkit.SetUserPassword(password)
        toolkit.SetPermissions(4) ' Print only
        toolkit.SaveAs(outputPath)
        toolkit.CloseInputFile()
    End If
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.OwnerPassword = password;
    pdf.SecuritySettings.UserPassword = 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.OwnerPassword = password;
    pdf.SecuritySettings.UserPassword = 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.OwnerPassword = password
        pdf.SecuritySettings.UserPassword = password
        pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights
        pdf.SecuritySettings.AllowUserCopyPasteContent = False
        pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit

        pdf.SaveAs(outputPath)
    End Using
End Sub

$vbLabelText $csharpLabel

API ustawień zabezpieczeńIronPDFzapewnia szczegółową kontrolę nad uprawnieniami do dokumentów dzięki silnie typowanym wyliczeniom zamiast flag całkowitoliczbowych.

Wyodrębnianie tekstu

Wdrożenie ActivePDF:

using ActivePDF.Toolkit;

public string ExtractText(string pdfPath)
{
    Toolkit toolkit = new Toolkit();
    string text = "";

    if (toolkit.OpenInputFile(pdfPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            text += toolkit.GetTextFromPage(i) + "\n";
        }
        toolkit.CloseInputFile();
    }

    return text;
}

using ActivePDF.Toolkit;

public string ExtractText(string pdfPath)
{
    Toolkit toolkit = new Toolkit();
    string text = "";

    if (toolkit.OpenInputFile(pdfPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            text += toolkit.GetTextFromPage(i) + "\n";
        }
        toolkit.CloseInputFile();
    }

    return text;
}

Imports ActivePDF.Toolkit

Public Function ExtractText(pdfPath As String) As String
    Dim toolkit As New Toolkit()
    Dim text As String = ""

    If toolkit.OpenInputFile(pdfPath) = 0 Then
        Dim pageCount As Integer = toolkit.GetPageCount()
        For i As Integer = 1 To pageCount
            text &= toolkit.GetTextFromPage(i) & vbCrLf
        Next
        toolkit.CloseInputFile()
    End If

    Return text
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

WdrożenieIronPDFsprowadza wyodrębnianie tekstu z wielu wierszy do jednego wywołania metody.

Dodawanie znaków wodnych

Wdrożenie ActivePDF:

using ActivePDF.Toolkit;

public void AddWatermark(string inputPath, string outputPath, string watermarkText)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            toolkit.SetPage(i);
            toolkit.AddWatermark(watermarkText, 45, 0.5f);
        }
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

using ActivePDF.Toolkit;

public void AddWatermark(string inputPath, string outputPath, string watermarkText)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            toolkit.SetPage(i);
            toolkit.AddWatermark(watermarkText, 45, 0.5f);
        }
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

Imports ActivePDF.Toolkit

Public Sub AddWatermark(inputPath As String, outputPath As String, watermarkText As String)
    Dim toolkit As New Toolkit()

    If toolkit.OpenInputFile(inputPath) = 0 Then
        Dim pageCount As Integer = toolkit.GetPageCount()
        For i As Integer = 1 To pageCount
            toolkit.SetPage(i)
            toolkit.AddWatermark(watermarkText, 45, 0.5F)
        Next
        toolkit.SaveAs(outputPath)
        toolkit.CloseInputFile()
    End If
End Sub

$vbLabelText $csharpLabel

Wdrożenie IronPDF:

using IronPdf;

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

    pdf.ApplyWatermark(
        $"<h1 style='color:lightgray;font-size:72px;'>{watermarkText}</h1>",
        rotation: 45,
        opacity: 50);

    pdf.SaveAs(outputPath);
}

using IronPdf;

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

    pdf.ApplyWatermark(
        $"<h1 style='color:lightgray;font-size:72px;'>{watermarkText}</h1>",
        rotation: 45,
        opacity: 50);

    pdf.SaveAs(outputPath);
}

Imports IronPdf

Public Sub AddWatermark(inputPath As String, outputPath As String, watermarkText As String)
    Using pdf = PdfDocument.FromFile(inputPath)
        pdf.ApplyWatermark(
            $"<h1 style='color:lightgray;font-size:72px;'>{watermarkText}</h1>",
            rotation:=45,
            opacity:=50)

        pdf.SaveAs(outputPath)
    End Using
End Sub

$vbLabelText $csharpLabel

Funkcja znakowania wodnego oparta na HTML wIronPDFumożliwia stosowanie stylów CSS, co zapewnia pełną kontrolę nad projektem bez konieczności powtarzania czynności na każdej stronie.

Integracja z ASP.NET Core.NET Core

Nowoczesne aplikacje internetowe czerpią znaczne korzyści z bardziej przejrzystych wzorców integracji IronPDF.

Wzór ActivePDF:

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile("temp.pdf") == 0)
    {
        toolkit.AddHTML(request.Html);
        toolkit.CloseOutputFile();

        byte[] bytes = System.IO.File.ReadAllBytes("temp.pdf");
        return File(bytes, "application/pdf", "report.pdf");
    }

    return BadRequest("PDF generation failed");
}

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile("temp.pdf") == 0)
    {
        toolkit.AddHTML(request.Html);
        toolkit.CloseOutputFile();

        byte[] bytes = System.IO.File.ReadAllBytes("temp.pdf");
        return File(bytes, "application/pdf", "report.pdf");
    }

    return BadRequest("PDF generation failed");
}

<HttpPost>
Public Function GeneratePdf(<FromBody> request As ReportRequest) As IActionResult
    Dim toolkit As New Toolkit()

    If toolkit.OpenOutputFile("temp.pdf") = 0 Then
        toolkit.AddHTML(request.Html)
        toolkit.CloseOutputFile()

        Dim bytes As Byte() = System.IO.File.ReadAllBytes("temp.pdf")
        Return File(bytes, "application/pdf", "report.pdf")
    End If

    Return BadRequest("PDF generation failed")
End Function

$vbLabelText $csharpLabel

Wzór IronPDF:

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(request.Html);

    return File(pdf.BinaryData, "application/pdf", "report.pdf");
}

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(request.Html);

    return File(pdf.BinaryData, "application/pdf", "report.pdf");
}

<HttpPost>
Public Function GeneratePdf(<FromBody> request As ReportRequest) As IActionResult
    Dim renderer As New ChromePdfRenderer()
    Using pdf = renderer.RenderHtmlAsPdf(request.Html)
        Return File(pdf.BinaryData, "application/pdf", "report.pdf")
    End Using
End Function

$vbLabelText $csharpLabel

IronPDF eliminuje potrzebę tworzenia plików tymczasowych, zwracając dane binarne PDF bezpośrednio z pamięci.

Obsługa asynchroniczna w aplikacjach internetowych

ActivePDF nie obsługuje natywnie operacji asynchronicznych.IronPDFzapewnia pełne możliwości async/await niezbędne dla skalowalnych aplikacji internetowych:

using IronPdf;

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

using IronPdf;

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

Imports IronPdf

Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
    Dim renderer As New ChromePdfRenderer()
    Using pdf = Await renderer.RenderHtmlAsPdfAsync(html)
        Return pdf.BinaryData
    End Using
End Function

$vbLabelText $csharpLabel

Konfiguracja wstrzykiwania zależności

W przypadku aplikacji .NET 6+ zarejestruj usługiIronPDFw swoim kontenerze DI:

// Program.cs (.NET 6+)
builder.Services.AddSingleton<ChromePdfRenderer>();

// Service wrapper
public interface IPdfService
{
    Task<byte[]> GeneratePdfAsync(string html);
    Task<byte[]> GeneratePdfFromUrlAsync(string url);
}

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;
    }

    public async Task<byte[]> GeneratePdfFromUrlAsync(string url)
    {
        using var pdf = await _renderer.RenderUrlAsPdfAsync(url);
        return pdf.BinaryData;
    }
}

// Program.cs (.NET 6+)
builder.Services.AddSingleton<ChromePdfRenderer>();

// Service wrapper
public interface IPdfService
{
    Task<byte[]> GeneratePdfAsync(string html);
    Task<byte[]> GeneratePdfFromUrlAsync(string url);
}

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;
    }

    public async Task<byte[]> GeneratePdfFromUrlAsync(string url)
    {
        using var pdf = await _renderer.RenderUrlAsPdfAsync(url);
        return pdf.BinaryData;
    }
}

Imports Microsoft.Extensions.DependencyInjection
Imports System.Threading.Tasks

' Program.vb (.NET 6+)
builder.Services.AddSingleton(Of ChromePdfRenderer)()

' Service wrapper
Public Interface IPdfService
    Function GeneratePdfAsync(html As String) As Task(Of Byte())
    Function GeneratePdfFromUrlAsync(url 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

    Public Async Function GeneratePdfFromUrlAsync(url As String) As Task(Of Byte()) Implements IPdfService.GeneratePdfFromUrlAsync
        Using pdf = Await _renderer.RenderUrlAsPdfAsync(url)
            Return pdf.BinaryData
        End Using
    End Function
End Class

$vbLabelText $csharpLabel

Obsługa błędów Migracja

ActivePDF używa całkowitoliczbowych kodów zwrotnych, które wymagają tabel odnośników.IronPDFwykorzystuje nowoczesną obsługę wyjątków:

Obsługa błędów ActivePDF:

Toolkit toolkit = new Toolkit();
int result = toolkit.OpenOutputFile(path);

if (result != 0)
{
    // Error - need to look up error code
    Console.WriteLine($"Error code: {result}");
}

Toolkit toolkit = new Toolkit();
int result = toolkit.OpenOutputFile(path);

if (result != 0)
{
    // Error - need to look up error code
    Console.WriteLine($"Error code: {result}");
}

Dim toolkit As New Toolkit()
Dim result As Integer = toolkit.OpenOutputFile(path)

If result <> 0 Then
    ' Error - need to look up error code
    Console.WriteLine($"Error code: {result}")
End If

$vbLabelText $csharpLabel

Obsługa błędów w IronPDF:

try
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(path);
}
catch (IronPdf.Exceptions.IronPdfProductException ex)
{
    Console.WriteLine($"IronPDF Error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"General Error: {ex.Message}");
}

try
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(path);
}
catch (IronPdf.Exceptions.IronPdfProductException ex)
{
    Console.WriteLine($"IronPDF Error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"General Error: {ex.Message}");
}

Imports IronPdf.Exceptions

Try
    Dim renderer = New ChromePdfRenderer()
    Using pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs(path)
    End Using
Catch ex As IronPdfProductException
    Console.WriteLine($"IronPDF Error: {ex.Message}")
Catch ex As Exception
    Console.WriteLine($"General Error: {ex.Message}")
End Try

$vbLabelText $csharpLabel

Wskazówki dotyczące optymalizacji wydajności

Ponowne wykorzystanie instancji renderera

Utworzenie nowego ChromePdfRenderer wiąże się z obciążeniem związanym z inicjalizacją. W przypadku operacji wsadowych należy ponownie wykorzystać pojedynczą instancję:

var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

Imports IronPdf

Dim renderer As 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

W przypadku aplikacji .NET Core asynchroniczne generowanie plików PDF poprawia przepustowość:

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

Właściwa utylizacja zasobów

Zawsze używaj instrukcji using, aby zapewnić prawidłowe czyszczenie:

using var pdf = renderer.RenderHtmlAsPdf(html);
return pdf.BinaryData;

using var pdf = renderer.RenderHtmlAsPdf(html);
return pdf.BinaryData;

$vbLabelText $csharpLabel

Kompresja obrazów

Zmniejsz rozmiar plików wyjściowych dzięki kompresji obrazów:

using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.CompressImages(85); // 85% quality
pdf.SaveAs("compressed.pdf");

using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.CompressImages(85); // 85% quality
pdf.SaveAs("compressed.pdf");

$vbLabelText $csharpLabel

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

Problem: Różnice w rozmiarze stron

ActivePDF używa punktów (612x792 = Letter), podczas gdyIronPDFużywa enumów lub milimetrów:

// ActivePDF: Points
toolkit.SetPageSize(612, 792);

// IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom in mm:
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(215.9, 279.4);

// ActivePDF: Points
toolkit.SetPageSize(612, 792);

// IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom in mm:
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(215.9, 279.4);

' ActivePDF: Points
toolkit.SetPageSize(612, 792)

' IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
' Or custom in mm:
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(215.9, 279.4)

$vbLabelText $csharpLabel

Problem: Brak odpowiednika CloseOutputFile

IronPDF wykorzystuje nowoczesny paradygmat bez jawnego zarządzania uchwytami plików:

// ActivePDF
toolkit.OpenOutputFile(path);
toolkit.AddHTML(html);
toolkit.CloseOutputFile(); // Required!

//IronPDF- no open/close needed
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path); // 'using' handles cleanup

// ActivePDF
toolkit.OpenOutputFile(path);
toolkit.AddHTML(html);
toolkit.CloseOutputFile(); // Required!

//IronPDF- no open/close needed
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path); // 'using' handles cleanup

' ActivePDF
toolkit.OpenOutputFile(path)
toolkit.AddHTML(html)
toolkit.CloseOutputFile() ' Required!

' IronPDF - no open/close needed
Using pdf = renderer.RenderHtmlAsPdf(html)
    pdf.SaveAs(path) ' 'Using' handles cleanup
End Using

$vbLabelText $csharpLabel

Problem: Plik PDF wyświetla się jako pusty

Jeśli treści zależne od JavaScriptu wyświetlają się jako puste, skonfiguruj opóźnienia renderowania:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.RenderDelay(2000);
// Or wait for element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.RenderDelay(2000);
// Or wait for element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.RenderDelay(2000)
' Or wait for element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded")

$vbLabelText $csharpLabel

Problem: CSS/obrazy się nie ładują

Skonfiguruj adres URL bazowy dla rozpoznawania ścieżek względnych:

renderer.RenderingOptions.BaseUrl = new Uri("https://yourdomain.com/assets/");

renderer.RenderingOptions.BaseUrl = new Uri("https://yourdomain.com/assets/");

renderer.RenderingOptions.BaseUrl = New Uri("https://yourdomain.com/assets/")

$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
Sprawdź, czy licencjonowanie działa poprawnie (IronPdf.License.IsLicensed)
Porównanie wydajności z poprzednią implementacją
Usuń stare pliki instalacyjneActivePDFi odwołania do bibliotek DLL
Aktualizacja zależności potoku CI/CD
Udokumentuj wzorceIronPDFdla swojego zespołu programistów

Rozwiązanie PDF na przyszłość

W obliczu zbliżającej się premiery .NET 10 i wprowadzenia nowych funkcji językowych w C# 14, wybór biblioteki .NET do obsługi plików PDF, która jest aktywnie rozwijana, gwarantuje, że aplikacje pozostaną kompatybilne z ewoluującymi możliwościami środowiska uruchomieniowego. ZaangażowanieIronPDFw obsługę najnowszych wersji .NET oznacza, że inwestycja w migrację przyniesie korzyści w miarę rozszerzania się projektów w latach 2025 i 2026.

Dodatkowe zasoby

Przejście zActivePDFnaIronPDFunowocześnia infrastrukturę generowania plików PDF dzięki bardziej przejrzystym interfejsom API, lepszej integracji z platformą .NET oraz aktywnemu, długoterminowemu wsparciu technicznemu. Inwestycja w migrację przynosi korzyści w postaci lepszej łatwości utrzymania kodu, możliwości asynchronicznych oraz pewności co do dalszego rozwoju biblioteki PDF.

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

Zaktualizowano 1 lutego, 2026

Jak przeprowadzić migrację z ZetPDF do IronPDF w języku C#

Opanuj migrację z ZetPDF do IronPDF dzięki temu kompletnemu przewodnikowi w języku C#. Przejdź z biblioteki opartej na współrzędnych na nowoczesne rozwiązanie do konwersji HTML na PDF. Zawiera przykłady kodu dotyczące konwersji HTML, łączenia plików PDF oraz usuwania zależności od PDFSharp.

Czytaj więcej

Zaktualizowano 1 lutego, 2026

Jak przeprowadzić migrację z Scryber.Core do IronPDF w języku C#

Opanuj migrację z Scryber.Core do IronPDF dzięki temu kompletnemu przewodnikowi w języku C#. Przejdź z niestandardowego parsowania XML/HTML na nowoczesny renderer Chromium. Zawiera przykłady kodu dotyczące konwersji HTML, renderowania adresów URL oraz zastępowania zastrzeżonych powiązań.

Czytaj więcej

Zaktualizowano 1 lutego, 2026

Jak przeprowadzić migrację z XFINIUM.PDF do IronPDF w języku C#

Opanuj migrację z XFINIUM.PDF do IronPDF dzięki temu kompletnemu przewodnikowi w języku C#. Przejdź od ręcznego pozycjonowania opartego na współrzędnych do deklaratywnego renderowania HTML/CSS. Zawiera przykłady kodu dotyczące zastępowania prymitywów graficznych i automatycznego układu.

Czytaj więcej

Migracja z Haukcode.DinkToPdf do IronPDF

Migracja z Foxit PDF SDK do IronPDF...

Rozpocznij Bezpłatny 30-dniowy Okres Próbny

Migracja z ActivePDF do IronPDF: (Przewodnik .NET)

Dlaczego warto rozważyć odejście od ActivePDF?

Niepewna przyszłość produktu

Komplikacje związane z licencjonowaniem

Wzorce architektury starszego typu

Koszty związane z instalacją i konfiguracją

ActivePDFa IronPDF: kluczowe różnice

Przygotowania przed migracją

Przeprowadź audyt swojego kodu źródłowego

Zmiany powodujące niekompatybilność dokumentów

Wymagania wstępne

Proces migracji krok po kroku

Krok 1: Zaktualizuj pakiety NuGet

Krok 2: Skonfiguruj klucz licencyjny

Krok 3: Zaktualizuj odniesienia do przestrzeni nazw

Kompletna dokumentacja API

Metody tworzenia dokumentów

Operacje na plikach

Konfiguracja strony

Metody bezpieczeństwa

Przykłady migracji kodu

Konwersja HTML do PDF

Konwersja adresów URL do formatu PDF

Łączenie wielu plików PDF

Dodawanie nagłówków i stopek

Ochrona hasłem i bezpieczeństwo

Wyodrębnianie tekstu

Dodawanie znaków wodnych

Integracja z ASP.NET Core.NET Core

Obsługa asynchroniczna w aplikacjach internetowych

Konfiguracja wstrzykiwania zależności

Obsługa błędów Migracja

Wskazówki dotyczące optymalizacji wydajności

Ponowne wykorzystanie instancji renderera

Wykorzystanie Async w aplikacjach internetowych

Właściwa utylizacja zasobów

Kompresja obrazów

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

Problem: Różnice w rozmiarze stron

Problem: Brak odpowiednika CloseOutputFile

Problem: Plik PDF wyświetla się jako pusty

Problem: CSS/obrazy się nie ładują

Lista kontrolna po migracji

Rozwiązanie PDF na przyszłość

Dodatkowe zasoby

Powiązane artykuły

Jak przeprowadzić migrację z ZetPDF do IronPDF w języku C#

Jak przeprowadzić migrację z Scryber.Core do IronPDF w języku C#

Jak przeprowadzić migrację z XFINIUM.PDF do IronPDF w języku C#

Następny krok: Rozpocznij darmową 30-dniową wersję próbną

Następny krok: Rozpocznij darmową 30-dniową wersję próbną

Want to deploy IronSuite to a live project for FREE?

What’s included?

Zaufane przez miliony inżynierów na całym świecie

Zespol wsparcia Iron