PRZEWODNIKI MIGRACJI

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

Zaktualizowano:maja 18, 2026

PDFmyURL to oparta na chmurze usługa API zaprojektowana do konwersji URL-i i treści HTML na dokumenty PDF. Usługa przetwarza wszystkie konwersje na zewnętrznych serwerach, dostarczając prostą ścieżkę integracji wymagającą minimalnej lokalnej infrastruktury. Jednak architektura zależna od chmury generuje znaczące obawy dla aplikacji produkcyjnych, które obsługują informacje poufne, wymagają możliwości offline lub muszą unikać bieżących kosztów subskrypcji.

Ten przewodnik dostarcza kompletną ścieżkę migracji zPDFmyURLdo IronPDF, z instrukcjami krok po kroku, porównaniami kodu i praktycznymi przykładami dla profesjonalnych deweloperów .NET oceniających tę tranzycję.

Dlaczego migrować z PDFmyURL

Model przetwarzania w chmurzePDFmyURLwprowadza kilka wyzwań, które zespoły deweloperskie muszą rozważyć:

Prywatność i bezpieczeństwo danych: Każdy dokument, który konwertujesz, podróżuje do i przez serweryPDFmyURL— poufne umowy, raporty finansowe i dane osobiste są przetwarzane zewnętrznie.

Ciągłe koszty subskrypcji: Plany zaczynają się od 20 USD/miesiąc (Starter, 500 PDF-ów), 40 USD/miesiąc (Professional, 2 000 PDF-ów), i 70 USD/miesiąc (Advanced, 5 000 PDF-ów), bez własności w żadnym ramach. Ten model subskrypcyjne oznacza ciągły wydatek niezależnie od wzorców użytkowania.

Zależność od internetu: Każda konwersja wymaga połączenia sieciowego. Aplikacje nie mogą przetwarzać PDF-ów offline lub podczas awarii sieci.

Limity szybkości i dławienie: Połączenia API mogą być dławione podczas szczytowego użytkowania, potencjalnie wpływając na wydajność aplikacji.

Dostępność usługi: Twoja aplikacja zależy od tego, czy usługa trzeciej strony jest online i funkcjonalna.

Uzależnienie od dostawcy: Zmiany w API mogą złamać twoją integrację bez powiadomienia, wymagające reaktywnych aktualizacji kodu.

Porównanie funkcji IronPDF vs PDFmyURL

Zrozumienie różnic architektonicznych pomaga decydentom technicznym w ocenie inwestycji w migrację:

Aspekt	PDFmyURL	IronPDF
Miejsce przetwarzania	Serwery zewnętrzne	Lokalnie (na Twoim serwerze)
Typ	API Wrapper	Biblioteka .NET
Uwierzytelnianie	Klucz API na żądanie	Jednorazowy klucz licencyjny
Wymagana sieć	Każda konwersja	Tylko wstępna konfiguracja
Model cenowy	Miesięczna subskrypcja (20–70 USD+)	Dostępna jest Licencja wieczysta
Limity częstotliwości	Tak (w zależności od planu)	None
Ochrona danych	Dane wysyłane na zewnątrz	Dane pozostają lokalne
Wsparcie HTML/CSS/JS	Renderowanie po stronie serwera (zgodne z W3C)	Pełny silnik Chromium
Wzorzec asynchroniczny	Żądanie HTTP (związane z siecią)	Opcje sychronne i asynchroniczne
Manipulacja plikami PDF	Ograniczone	Pełny pakiet (łączenie, dzielenie, edycja)
Przykład zastosowania	Aplikacje o niewielkim natężeniu ruchu	Duże ilości i Enterprise

Szybki start: migracja zPDFmyURLdo IronPDF

Migrację można rozpocząć natychmiast, wykonując te podstawowe kroki.

Krok 1: Zainstaluj IronPDF

PDFmyURL nie ma pakietu NuGet — usługa to REST API, a opcjonalny PDFmyURL.NET.dll komponent dostarczany jest jako bezpośrednie pobranie DLL (nie na nuget.org). Większość integracji wywołuje API z WebClient / HttpClient, więc migracja polega głównie na kodzie, a nie na referencjach do pakietów. Jeśli używałeś asemblacji PDFmyURL.NET.dll, usuń referencję z projektu po migracji.

# Install IronPDF
dotnet add package IronPdf

# Install IronPDF
dotnet add package IronPdf

SHELL

Krok 2: Aktualizacja przestrzeni nazw

Zastąp importyPDFmyURLimportami IronPDF:

// Before:PDFmyURL— either plain HttpClient/WebClient against pdfmyurl.com/api,
// or the optional .NET component:
using PDFmyURLdotNET;          // only if you used PDFmyURL.NET.dll
using System.Net;               // WebClient / HttpClient

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

// Before:PDFmyURL— either plain HttpClient/WebClient against pdfmyurl.com/api,
// or the optional .NET component:
using PDFmyURLdotNET;          // only if you used PDFmyURL.NET.dll
using System.Net;               // WebClient / HttpClient

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

Imports PDFmyURLdotNET ' only if you used PDFmyURL.NET.dll
Imports System.Net ' WebClient / HttpClient

' After: IronPDF
Imports IronPdf
Imports IronPdf.Rendering

$vbLabelText $csharpLabel

Krok 3: Inicjalizacja licencji

Dodaj inicjalizację licencji podczas uruchamiania aplikacji:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

$vbLabelText $csharpLabel

Przykłady migracji kodu

Konwersja adresów URL do formatu PDF

Operacja URL-to-PDF demonstruje podstawowe różnice między APIPDFmyURLa IronPDF.

Podejście PDFmyURL:

//PDFmyURLREST API — no NuGet SDK. Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string url = "https://example.com";

        try
        {
            using (var client = new WebClient())
            {
                client.QueryString.Add("license", license);
                client.QueryString.Add("url", url);
                // PDF binary is returned in the response body
                client.DownloadFile("https://pdfmyurl.com/api", "output.pdf");
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

//PDFmyURLREST API — no NuGet SDK. Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string url = "https://example.com";

        try
        {
            using (var client = new WebClient())
            {
                client.QueryString.Add("license", license);
                client.QueryString.Add("url", url);
                // PDF binary is returned in the response body
                client.DownloadFile("https://pdfmyurl.com/api", "output.pdf");
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Imports System
Imports System.Net

Module Example

    Sub Main()
        Dim license As String = "your-license-key"
        Dim url As String = "https://example.com"

        Try
            Using client As New WebClient()
                client.QueryString.Add("license", license)
                client.QueryString.Add("url", url)
                ' PDF binary is returned in the response body
                client.DownloadFile("https://pdfmyurl.com/api", "output.pdf")
            End Using
        Catch ex As WebException
            Console.WriteLine("Error: " & ex.Message)
        End Try
    End Sub

End Module

$vbLabelText $csharpLabel

Podejście IronPDF:

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

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

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

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

Imports IronPdf
Imports System

Class Example
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

$vbLabelText $csharpLabel

PDFmyURL wymaga otwarcia połączenia HTTP do https://pdfmyurl.com/api przy każdej konwersji, dołączenia tokena license oraz docelowego url jako parametry zapytania (lub formularza), oraz zapisania ciała odpowiedzi na dysk. Błędy pojawiają się jako WebException na podstawie kodu statusu HTTP.

IronPDF upraszcza to do trzech linii: utwórz ChromePdfRenderer, wywołaj RenderUrlAsPdf() i użyj wbudowanej metody SaveAs(). Nie potrzeba poświadczeń przy każdym żądaniu — licencję ustawia się raz po uruchomieniu aplikacji.

Dla zaawansowanych scenariuszy URL-to-PDF zobacz dokumentację URL to PDF.

Konwersja ciągów znaków HTML do formatu PDF

Konwersja ciągu HTML wyraźnie pokazuje różnice wzorcowe.

Podejście PDFmyURL:

//PDFmyURLREST API — no NuGet SDK. Send the raw HTML in the `html` parameter.
// Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = "<html><body><h1>Hello World</h1></body></html>";

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license", license },
                    { "html", html }
                };
                // POST form-encoded; response body is the PDF binary
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

//PDFmyURLREST API — no NuGet SDK. Send the raw HTML in the `html` parameter.
// Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = "<html><body><h1>Hello World</h1></body></html>";

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license", license },
                    { "html", html }
                };
                // POST form-encoded; response body is the PDF binary
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Imports System
Imports System.Collections.Specialized
Imports System.IO
Imports System.Net

Class Example
    Shared Sub Main()
        Dim license As String = "your-license-key"
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"

        Try
            Using client As New WebClient()
                Dim values As New NameValueCollection From {
                    {"license", license},
                    {"html", html}
                }
                ' POST form-encoded; response body is the PDF binary
                Dim pdfBytes As Byte() = client.UploadValues("https://pdfmyurl.com/api", "POST", values)
                File.WriteAllBytes("output.pdf", pdfBytes)
            End Using
        Catch ex As WebException
            Console.WriteLine("Error: " & ex.Message)
        End Try
    End Sub
End Class

$vbLabelText $csharpLabel

Podejście IronPDF:

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

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

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

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

Imports IronPdf
Imports System

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

$vbLabelText $csharpLabel

PDFmyURL wysyła surowy HTML w parametrze formularza html do punktu końcowego swojego API i zwraca renderowany PDF jako ciało odpowiedzi. IronPDF's RenderHtmlAsPdf() przetwarza wszystko lokalnie za pomocą silnika renderującego Chromium.

Poznaj przewodnik konwersji HTML do PDF w celu uzyskania dodatkowych opcji.

Konwersja plików HTML z ustawieniami strony

Konfigurowanie rozmiaru papieru, orientacji i marginesów wymaga różnych podejść w każdej bibliotece.

Podejście PDFmyURL:

//PDFmyURLREST API — no NuGet SDK. Page settings are sent as query/form parameters.
// Parameter reference: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = File.ReadAllText("input.html");

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license",     license },
                    { "html",        html },
                    { "page_size",   "A4" },
                    { "orientation", "landscape" },
                    { "top",         "10" },
                    { "unit",        "mm" }
                };
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

//PDFmyURLREST API — no NuGet SDK. Page settings are sent as query/form parameters.
// Parameter reference: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = File.ReadAllText("input.html");

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license",     license },
                    { "html",        html },
                    { "page_size",   "A4" },
                    { "orientation", "landscape" },
                    { "top",         "10" },
                    { "unit",        "mm" }
                };
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Imports System
Imports System.Collections.Specialized
Imports System.IO
Imports System.Net

Class Example
    Shared Sub Main()
        Dim license As String = "your-license-key"
        Dim html As String = File.ReadAllText("input.html")

        Try
            Using client As New WebClient()
                Dim values As New NameValueCollection From {
                    {"license", license},
                    {"html", html},
                    {"page_size", "A4"},
                    {"orientation", "landscape"},
                    {"top", "10"},
                    {"unit", "mm"}
                }
                Dim pdfBytes As Byte() = client.UploadValues("https://pdfmyurl.com/api", "POST", values)
                File.WriteAllBytes("output.pdf", pdfBytes)
            End Using
        Catch ex As WebException
            Console.WriteLine("Error: " & ex.Message)
        End Try
    End Sub
End Class

$vbLabelText $csharpLabel

Podejście IronPDF:

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
    }
}

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering
Imports System

Class Example
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

$vbLabelText $csharpLabel

PDFmyURL konfiguruje strony poprzez dodanie parametrów formularza takich jak page_size=A4, orientation=landscape, i pola marginesów (top, bottom, left, right) obok unit (np. mm, in).IronPDF dostarcza silnie typizowane właściwości poprzez RenderingOptions z enumeracjami jak PdfPaperSize.A4 i wartościami całkowitymi dla marginesów w milimetrach.

Dokumentacja odniesienia mapowaniaPDFmyURLAPI do IronPDF

To mapowanie przyspiesza migrację, pokazując bezpośrednie odpowiedniki API:

Główne Klasy / Punkty Wejścia

PDFmyURL	IronPDF
`WebClient` / `HttpClient` publikowanie do `https://pdfmyurl.com/api`	`ChromePdfRenderer`
`PDFmyURLdotNET.PDFmyURL` (opcjonalny komponent .NET z `PDFmyURL.NET.dll`)	`ChromePdfRenderer`
Parametry formularza / zapytania	`ChromePdfRenderOptions`
Bajty ciała odpowiedzi HTTP	`PdfDocument`

Metody

PDFmyURL	IronPDF
`WebClient.DownloadFile(".../api?license=...&url=...", file)`	`renderer.RenderUrlAsPdf(url).SaveAs(file)`
POST z parametrem `html=`	`renderer.RenderHtmlAsPdf(html)`
`File.ReadAllText("input.html")` następnie POST `html=`	`renderer.RenderHtmlFileAsPdf(path)`
`pdf.ConvertURL(url, file)` (PDFmyURL.NET.dll)	`renderer.RenderUrlAsPdf(url).SaveAs(file)`
`pdf.ConvertHTML(html, file)` (PDFmyURL.NET.dll)	`renderer.RenderHtmlAsPdf(html).SaveAs(file)`
HTTP response body (`byte[]`)	`pdf.BinaryData`
Strumień odpowiedzi HTTP	`new MemoryStream(pdf.BinaryData)`

Opcje konfiguracji

UstawieniaPDFmyURLsą przekazywane jako parametry formy/zapytania w żądaniu HTTP. Poniższa tabela mapuje rzeczywiste nazwy parametrówPDFmyURLna RenderingOptions IronPDF.

ParametrPDFmyURL	IronPDF (RenderingOptions)
`page_size=A4`	`.PaperSize = PdfPaperSize.A4`
`page_size=Letter`	`.PaperSize = PdfPaperSize.Letter`
`orientation=landscape`	`.PaperOrientation = PdfPaperOrientation.Landscape`
`orientation=portrait`	`.PaperOrientation = PdfPaperOrientation.Portrait`
`top=10&unit=mm`	`.MarginTop = 10`
`bottom=10&unit=mm`	`.MarginBottom = 10`
`left=10&unit=mm`	`.MarginLeft = 10`
`right=10&unit=mm`	`.MarginRight = 10`
`header=<html>`	`.HtmlHeader = new HtmlHeaderFooter { HtmlFragment = html }`
`footer=<html>`	`.HtmlFooter = new HtmlHeaderFooter { HtmlFragment = html }`
`javascript_time=500`	`.RenderDelay = 500`
`no_javascript=true`	`.EnableJavaScript = false`
`css_media_type=print`	`.CssMediaType = PdfCssMediaType.Print`

Porównanie Uwierzytelnienia

PDFmyURL	IronPDF
`license=<key>` query/form parameter on every API request	`IronPdf.License.LicenseKey = "LICENSE-KEY"`
Token licencyjny na żądanie	Jednorazowo przy starcie
Wymagane dla każdego wywołania	Ustaw jeden raz globalnie

Typowe problemy związane z migracją i ich rozwiązania

Problem 1: Token licencyjny vs Klucz licencyjny

PDFmyURL: Wymaga tokena license w każdym żądaniu API.

Rozwiązanie: Ustaw licencjęIronPDF jeden raz przy starcie aplikacji:

// PDFmyURL: license token per request
client.QueryString.Add("license", "your-license-key");

// IronPDF: One-time license at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Set once, typically in Program.cs or Startup.cs

// PDFmyURL: license token per request
client.QueryString.Add("license", "your-license-key");

// IronPDF: One-time license at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Set once, typically in Program.cs or Startup.cs

' PDFmyURL: license token per request
client.QueryString.Add("license", "your-license-key")

' IronPDF: One-time license at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
' Set once, typically in Program.vb or Startup.vb

$vbLabelText $csharpLabel

Problem 2: Składnia zastępcza w nagłówkach/stopek

PDFmyURL: Używa tokenów takich jak [page] i [topage] wewnątrz parametrów formy (header / footer) (sprawdź bieżącą dokumentację API dla kompletnej listy tokenów).

Solution: Zaktualizuj format zastępczy IronPDF wewnątrz HtmlHeaderFooter.HtmlFragment:

// PDFmyURL: "Page [page] of [topage]"
// IronPDF: "Page {page} of {total-pages}"

// PDFmyURL: "Page [page] of [topage]"
// IronPDF: "Page {page} of {total-pages}"

' PDFmyURL: "Page [page] of [topage]"
' IronPDF: "Page {page} of {total-pages}"

$vbLabelText $csharpLabel

Problem 3: Wzorce asynchroniczne

PDFmyURL: Jest to zdalne wywołanie HTTP; zwykle wywoływany z HttpClient.PostAsync wobec pdfmyurl.com/api.

Rozwiązanie:IronPDF jest domyślnie synchroniczny i w procesie; opakuje dla asynchroniczności, jeśli jest to potrzebne:

// PDFmyURL: HTTP request to the public endpoint
var response = await http.PostAsync("https://pdfmyurl.com/api", form);

// IronPDF: Sync by default, wrap for async
var pdf = await Task.Run(() => renderer.RenderUrlAsPdf(url));

// PDFmyURL: HTTP request to the public endpoint
var response = await http.PostAsync("https://pdfmyurl.com/api", form);

// IronPDF: Sync by default, wrap for async
var pdf = await Task.Run(() => renderer.RenderUrlAsPdf(url));

Imports System.Net.Http
Imports System.Threading.Tasks

' PDFmyURL: HTTP request to the public endpoint
Dim response = Await http.PostAsync("https://pdfmyurl.com/api", form)

' IronPDF: Sync by default, wrap for async
Dim pdf = Await Task.Run(Function() renderer.RenderUrlAsPdf(url))

$vbLabelText $csharpLabel

Problem 4: Obsługa błędów

PDFmyURL: Błędy na poziomie HTTP (nieprawidłowa licencja, limit szybkości, błąd sieci, usługa niedostępna) pojawiają się jako WebException / kody statusu niepowodzenia.

Rozwiązanie: Zaktualizuj bloki catch dla typowanych wyjątków IronPDF:

// PDFmyURL: WebException from the HTTP call
catch (WebException e) { ... }

// IronPDF: Typed exceptions
catch (IronPdf.Exceptions.IronPdfRenderingException e) { ... }

// PDFmyURL: WebException from the HTTP call
catch (WebException e) { ... }

// IronPDF: Typed exceptions
catch (IronPdf.Exceptions.IronPdfRenderingException e) { ... }

$vbLabelText $csharpLabel

Problem 5: Wzorzec konfiguracji

PDFmyURL: Konfiguracja jest przekazywana jako parametry formularza/zapytania w żądaniu HTTP.

Rozwiązanie: Używaj silnie typowanych właściwości RenderingOptions:

// PDFmyURL: form/query parameters
values.Add("page_size", "A4");
values.Add("orientation", "landscape");

// IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;

// PDFmyURL: form/query parameters
values.Add("page_size", "A4");
values.Add("orientation", "landscape");

// IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;

' PDFmyURL: form/query parameters
values.Add("page_size", "A4")
values.Add("orientation", "landscape")

' IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape

$vbLabelText $csharpLabel

Lista kontrolna migracji PDFmyURL

Zadania przed migracją

Przeanalizuj swój kod w celu zidentyfikowania całego użycia PDFmyURL:

# FindPDFmyURLendpoint and component usage
grep -r "pdfmyurl.com/api\|PDFmyURLdotNET\|new PDFmyURL(" --include="*.cs" .

# Find license-token references
grep -r "license=\|licensekey" --include="*.cs" --include="*.json" --include="*.config" .

# Find placeholder patterns to migrate
grep -r "\[page\]\|\[topage\]" --include="*.cs" .

# FindPDFmyURLendpoint and component usage
grep -r "pdfmyurl.com/api\|PDFmyURLdotNET\|new PDFmyURL(" --include="*.cs" .

# Find license-token references
grep -r "license=\|licensekey" --include="*.cs" --include="*.json" --include="*.config" .

# Find placeholder patterns to migrate
grep -r "\[page\]\|\[topage\]" --include="*.cs" .

SHELL

Dokumentuj bieżące użyte parametry konfiguracji (rozmiar strony, orientacja, marginesy, nagłówek/stopka, itp.). Zaplanuj przechowywanie klucza licencyjnego za pomocą zmiennych środowiskowych.

Zadania związane z aktualizacją kodu

Usuń opcjonalną referencję PDFmyURL.NET.dll, jeśli ją użyłeś (nie istnieje pakiet NuGet do odinstalowania)
Zainstaluj pakiet NuGet IronPDF
Zaktualizuj wszystkie importy przestrzeni nazw
Zastąp license token w żądaniu na IronPdf.License.LicenseKey
Przekonwertuj parametry formularza/zapytania na właściwości RenderingOptions
Zaktualizuj składnię symbolu zastępczego w nagłówkach/stopkach (np. [page] → {page}, [topage] → {total-pages})
Zaktualizuj kod obsługi błędów (WebException → typowane wyjątki IronPDF)
Dodaj inicjalizację licencji IronPDF podczas uruchamiania

Testy po migracji

Po migracji należy zweryfikować następujące aspekty:

Sprawdź, czy jakość pliku PDF odpowiada oczekiwaniom
Zweryfikuj, czy wzorce asynchroniczne działają poprawnie
Porównaj wierność renderowania z poprzednim wynikiem
Sprawdź, czy wszystkie warianty szablonów wyświetlają się poprawnie
Zweryfikuj ustawienia strony (rozmiar, orientacja, marginesy)
Zainstaluj zależności Linux, jeśli wdrażasz na serwery Linux

Kluczowe korzyści z migracji do IronPDF

Przejście zPDFmyURLna IronPDF zapewnia kilka kluczowych korzyści:

Kompletna prywatność: Dokumenty nigdy nie opuszczają twojego serwera. Całe przetwarzanie odbywa się lokalnie, eliminując problemy z bezpieczeństwem danych dla poufnych treści.

Jednorazowy koszt: Opcja licencji wieczystej eliminuje cykliczne opłaty abonamentowe. Koniec z miesięcznymi płatnościami bez względu na wykorzystane zasoby.

Możliwość pracy offline: Działa bez internetu po wstępnym ustawieniu. Awarie sieci nie wpływają na generowanie PDF.

Brak limitów przesyłania: Przetwarzaj nieograniczoną liczbę dokumentów bez problemów z ograniczeniem przesyłania.

Niższe opóźnienia: Brak dodatkowego obciążenia sieciowego oznacza szybsze konwersje, zwłaszcza dla aplikacji o dużej objętości.

Pełna kontrola: Ty kontrolujesz środowisko przetwarzania, a nie usługa trzecia.

Nowoczesny silnik Chromium: Pełne wsparcie dla CSS3 i JavaScript ze tym samym silnikiem renderującym, który napędza przeglądarkę Chrome.

Aktywna rozwój: Regularne aktualizacje IronPDF zapewniają zgodność z nowoczesnymi wersjami .NET.

Zwróć uwagęPDFmyURL jest zarejestrowanym znakiem towarowym odpowiedniego właściciela. Ta strona nie jest powiązana, popierana ani sponsorowana przez PDFmyURL. Wszystkie nazwy produktów, logo i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.

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 maja 18, 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 maja 18, 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 maja 18, 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

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

Jak przeprowadzić migrację z Sync...

Zwycięstwo klienta:

Podkreślaj programistę:

Webinary:

Rozpocznij Bezpłatny 30-dniowy Okres Próbny

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

Dlaczego migrować z PDFmyURL

Porównanie funkcji IronPDF vs PDFmyURL

Szybki start: migracja zPDFmyURLdo IronPDF

Krok 1: Zainstaluj IronPDF

Krok 2: Aktualizacja przestrzeni nazw

Krok 3: Inicjalizacja licencji

Przykłady migracji kodu

Konwersja adresów URL do formatu PDF

Konwersja ciągów znaków HTML do formatu PDF

Konwersja plików HTML z ustawieniami strony

Dokumentacja odniesienia mapowaniaPDFmyURLAPI do IronPDF

Główne Klasy / Punkty Wejścia

Metody

Opcje konfiguracji

Porównanie Uwierzytelnienia

Typowe problemy związane z migracją i ich rozwiązania

Problem 1: Token licencyjny vs Klucz licencyjny

Problem 2: Składnia zastępcza w nagłówkach/stopek

Problem 3: Wzorce asynchroniczne

Problem 4: Obsługa błędów

Problem 5: Wzorzec konfiguracji

Lista kontrolna migracji PDFmyURL

Zadania przed migracją

Zadania związane z aktualizacją kodu

Testy po migracji

Kluczowe korzyści z migracji do IronPDF

Twój klucz licencyjny został dostarczony do Twojej skrzynki odbiorczej

Twoje zgłoszenie demo jest przetwarzane.

Zespół wsparcia Iron

Rozpocznij Bezpłatny 30-dniowy Okres Próbny

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

Dlaczego migrować z PDFmyURL

Porównanie funkcji IronPDF vs PDFmyURL

Szybki start: migracja zPDFmyURLdo IronPDF

Krok 1: Zainstaluj IronPDF

Krok 2: Aktualizacja przestrzeni nazw

Krok 3: Inicjalizacja licencji

Przykłady migracji kodu

Konwersja adresów URL do formatu PDF

Konwersja ciągów znaków HTML do formatu PDF

Konwersja plików HTML z ustawieniami strony

Dokumentacja odniesienia mapowaniaPDFmyURLAPI do IronPDF

Główne Klasy / Punkty Wejścia

Metody

Opcje konfiguracji

Porównanie Uwierzytelnienia

Typowe problemy związane z migracją i ich rozwiązania

Problem 1: Token licencyjny vs Klucz licencyjny

Problem 2: Składnia zastępcza w nagłówkach/stopek

Problem 3: Wzorce asynchroniczne

Problem 4: Obsługa błędów

Problem 5: Wzorzec konfiguracji

Lista kontrolna migracji PDFmyURL

Zadania przed migracją

Zadania związane z aktualizacją kodu

Testy po migracji

Kluczowe korzyści z migracji do IronPDF

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ą

Thank You

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

Chcesz wdrożyć IronSuite w projekcie na żywo za DARMO?

Co jest wliczone?

Twój klucz licencyjny został dostarczony do Twojej skrzynki odbiorczej

Twoje zgłoszenie demo jest przetwarzane.

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

Zespół wsparcia Iron