Biblioteka PDF dla C#

HTML do PDF

Online Demo Zobacz wszystkie przykłady kodu %s

using IronPdf;

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

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

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

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

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

using IronPdf;

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

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

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

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

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

PM >Install-Package IronPdf

Install-Package IronPdf

FILMY

Renderowanie treści WebGL w plikach PDF za pomocą IronPDF

Curtis Chau

Updated: 19 lipca 2026

Migracja z MicrosoftPlaywrightfor .NET do IronPDF przenosi twój przepływ pracy generowania PDF z testowego frameworku automatyzacji przeglądarek do wykreowanej specjalnie biblioteki PDF. Ten przewodnik oferuje krok po kroku sciezke migracji, ktora usuwa asynchroniczne zarzadzanie cyklem zycia przegladarki oraz oddzielny krok pobierania przegladarki-binary playwright install.

Dlaczego warto przejść zPlaywrightna IronPDF

ZrozumieniePlaywrightdla .NET

Playwright for .NET (NuGet Microsoft.Playwright, licencjonowany na MIT) to framework automatyzacji przegladarki firmy Microsoft, zaprojektowany przede wszystkim do testowania koncowego na Chromium, Firefox i WebKit. Typowe obciążenia to interaktywne działania: klikanie przycisków, wypełnianie formularzy, przechwytywanie żądań sieciowych, robienie zrzutów ekranu i sprawdzanie kompatybilności między przeglądarkami.

Generowanie plikow PDF wPlaywrightjest funkcja dodatkowa udostepniana poprzez Page.PdfAsync() i jest obslugiwane tylko w Chromium — Firefox i WebKit nie implementuja wyjscia PDF. Wyjście używa ścieżki druk-do-PDF przeglądarki (równoważne Ctrl+P), co ma implikacje dla układów, tła i paginacji:

Architektura skupiona na testach, nie zoptymalizowana do bezgłowego tworzenia dokumentów
Binaria przegladarki (Chromium oraz opcjonalnie Firefox i WebKit) musza byc zainstalowane oddzielnie poprzez playwright install
Asynchroniczne API zaprojektowane dla przepływów pracy automatyzacji testów
Brak wbudowanych funkcji w zakresie PDF/A, PDF/UA, cyfrowych podpisów, znaków wodnych, łączenia i bezpieczeństwa

Uwagi dotyczące używaniaPlaywrightdla PDF-ów

Playwright został zaprojektowany do testowania end-to-end, a nie do generowania dokumentów. Kilka praktycznych implikacji przy przerabianiu go do celów PDF-ów:

Binaria przegladarki za pomoca playwright install. Domyslna konfiguracjaPlaywrightpobiera binaria przegladarki (Chromium, Firefox, WebKit), co moze byc rozwazaniem dla srodowisk z ograniczeniami zasobow lub wdrozeniami.
Asynchroniczny model przeglądarki/kontekstu/strony. Deweloperzy muszą być zaznajomieni z kontekstami przeglądarki i zarządzaniem cyklem życia strony, w tym z usuwaniem.
Architektura skupiona na testach, nie zoptymalizowana do generacji wysokiej objętości dokumentów.
Sens używania druk-do-PDF równoważny do wydruku przeglądarki Ctrl+P. Układ strony może ulec zmianie, tła mogą być domyślnie pominięte, a wynik jest paginowany do druku.
**Brak wyjścia PDF/A lub PDF/UA.**Playwrightnie produkuje dokumentów zgodnych z PDF/A (archiwalne) ani PDF/UA (dostępność). Dla Sekcji 508, dyrektyw dostępności UE lub długoterminowych wymagań archiwalnych zazwyczaj wymagana jest dedykowana biblioteka PDF.
Użycie zasobów przeglądarki per render przy każdym PDF, który uruchamia konteksty przeglądarki i strony.

Powierzchnia konfiguracji

Playwright ujawnia powierzchnię konfiguracji ukierunkowaną na automatyzację testów. Elementy najbardziej istotne podczas używania go tylko do generowania PDF-ów:

Krok instalacji przeglądarki:

# Separate installation step before first use
playwright install            # Downloads browser binaries (Chromium, Firefox, WebKit)
# Or for a single browser:
playwright install chromium   # Chromium-only (the only engine that supports PDF output)

# Separate installation step before first use
playwright install            # Downloads browser binaries (Chromium, Firefox, WebKit)
# Or for a single browser:
playwright install chromium   # Chromium-only (the only engine that supports PDF output)

SHELL

Konfiguracja uruchamiania przeglądarki:

// Testing-focused launch options for PDF generation
using var playwright = await Playwright.CreateAsync();
var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions
{
    Headless = true,  // Required for server environments
    Args = new[] { "--disable-gpu", "--no-sandbox" } // Linux/Docker configs
});

// Testing-focused launch options for PDF generation
using var playwright = await Playwright.CreateAsync();
var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions
{
    Headless = true,  // Required for server environments
    Args = new[] { "--disable-gpu", "--no-sandbox" } // Linux/Docker configs
});

' Testing-focused launch options for PDF generation
Using playwright = Await Playwright.CreateAsync()
    Dim browser = Await playwright.Chromium.LaunchAsync(New BrowserTypeLaunchOptions With {
        .Headless = True,  ' Required for server environments
        .Args = New String() { "--disable-gpu", "--no-sandbox" } ' Linux/Docker configs
    })
End Using

' Testing-focused launch options for PDF generation
Using playwright = Await Playwright.CreateAsync()
    Dim browser = Await playwright.Chromium.LaunchAsync(New BrowserTypeLaunchOptions With {
        .Headless = True,  ' Required for server environments
        .Args = New String() { "--disable-gpu", "--no-sandbox" } ' Linux/Docker configs
    })
End Using

Opcje konfiguracyjne dotyczące testowania:

Headless: Nalezy skonfigurowac tryb bezglowicowy dla produkcji (domyslnie uruchamia sie w trybie glowicowym do testowania)
SlowMo: Opoznienia czasowe testow (nieistotne dla generowania PDF)
Devtools: Konfiguracja narzedzi do testowania (niepotrzebne dla dokumentow)
ExecutablePath: Niestandardowe sciezki przegladarki dla srodowisk testowych
Proxy: Intercepcja sieciowa dla testowania (niepotrzebne obciazenie)
DownloadsPath: Zarzadzanie artefaktami testowymi
TracesDir: Sledzenia wykonania testow

Zarządzanie kontekstem przeglądarki:

// Complex context lifecycle from testing paradigm
var context = await browser.NewContextAsync(new BrowserNewContextOptions
{
    ViewportSize = new ViewportSize { Width = 1920, Height = 1080 },
    UserAgent = "custom-user-agent",
    Locale = "en-US",
    TimezoneId = "America/New_York"
});
var page = await context.NewPageAsync();
// ... generate PDF ...
await context.CloseAsync();  // Manual cleanup required
await browser.CloseAsync();  // Manual cleanup required

// Complex context lifecycle from testing paradigm
var context = await browser.NewContextAsync(new BrowserNewContextOptions
{
    ViewportSize = new ViewportSize { Width = 1920, Height = 1080 },
    UserAgent = "custom-user-agent",
    Locale = "en-US",
    TimezoneId = "America/New_York"
});
var page = await context.NewPageAsync();
// ... generate PDF ...
await context.CloseAsync();  // Manual cleanup required
await browser.CloseAsync();  // Manual cleanup required

' Complex context lifecycle from testing paradigm
Dim context = Await browser.NewContextAsync(New BrowserNewContextOptions With {
    .ViewportSize = New ViewportSize With {.Width = 1920, .Height = 1080},
    .UserAgent = "custom-user-agent",
    .Locale = "en-US",
    .TimezoneId = "America/New_York"
})
Dim page = Await context.NewPageAsync()
' ... generate PDF ...
Await context.CloseAsync()  ' Manual cleanup required
Await browser.CloseAsync()  ' Manual cleanup required

' Complex context lifecycle from testing paradigm
Dim context = Await browser.NewContextAsync(New BrowserNewContextOptions With {
    .ViewportSize = New ViewportSize With {.Width = 1920, .Height = 1080},
    .UserAgent = "custom-user-agent",
    .Locale = "en-US",
    .TimezoneId = "America/New_York"
})
Dim page = Await context.NewPageAsync()
' ... generate PDF ...
Await context.CloseAsync()  ' Manual cleanup required
Await browser.CloseAsync()  ' Manual cleanup required

Wieloprzeglądarkowa powierzchnia:

//Playwrightsupports launching multiple engines
await playwright.Chromium.LaunchAsync();  // For Chromium-based testing (and PDF output)
await playwright.Firefox.LaunchAsync();   // For Firefox testing
await playwright.Webkit.LaunchAsync();    // For WebKit/Safari testing
// Note: Page.PdfAsync() is implemented on Chromium only.

//Playwrightsupports launching multiple engines
await playwright.Chromium.LaunchAsync();  // For Chromium-based testing (and PDF output)
await playwright.Firefox.LaunchAsync();   // For Firefox testing
await playwright.Webkit.LaunchAsync();    // For WebKit/Safari testing
// Note: Page.PdfAsync() is implemented on Chromium only.

IronPDF: pojedynczy wbudowany renderer

// No separate browser-binary install or context management
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// No separate browser-binary install or context management
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

IronPDF dostarcza swoj silnik renderujacy wewnatrz pakietu NuGet, wiec nie ma oddzielnego kroku playwright install i nie ma cyklu zycia przegladarki/kontekstu/strony do zarzadzania.

Porównanie wydajnościPlaywrighti IronPDF

Metryka	Playwright	IronPDF
Główny cel	E2E framework automatyzacji przeglądarek	Generowanie dokumentów PDF
Filozofia projektowania	Skupienie na testach; PDF jest funkcją drugorzędną	Biblioteka PDF stworzona specjalnie do tego celu
Pakiet NuGet	`Microsoft.Playwright` (MIT)	`IronPdf` (komercyjne)
Krok binariów przeglądarki	Oddzielny krok pobierania `playwright install`	W pakiecie NuGet
Silniki obsługujące PDF	Tylko Chromium (Firefox / WebKit nie implementuja `Page.PdfAsync()`)	Pojedynczy wbudowany renderer oparty na Chrominum
Pierwsze renderowanie (zimny start)	4,5 sekundy	2,8 sekundy
Kolejne wersje	3,8–4,1 sekundy	0,8–1,2 sekundy
Pamięć na konwersję	280–420 MB	80–120 MB
Styl API	Asynchroniczny cykl życia przeglądarki/kontekstu/strony	Synchroniczne lub asynchroniczne; renderer-based
Inicjalizacja	`CreateAsync()` + `LaunchAsync()` + `NewPageAsync()`	`new ChromePdfRenderer()`
Obsługa formatu PDF/A	Niedostępne	Obsługiwane
Dostępność PDF/UA	Niedostępne	Obsługiwane
Podpisy cyfrowe	Niedostępne	Obsługiwane
Edycja plików PDF	Niedostępne	Łączenie, dzielenie, stemplowanie, edycja
Model wsparcia	Społeczność	Reklama z umową SLA

IronPDF jest zbudowany specjalnie do generowania PDF-ów, z dokumentocentrycznym interfejsem API. Używa pojedynczego wbudowanego silnika renderingowego opartego na Chromium i obsługuje zarówno operacje synchroniczne, jak i asynchroniczne, co daje deweloperom prostszy model mentalny, gdy głównym celem jest wyjście PDF, a nie interakcja z przeglądarką.

Podsumowanie

Playwright jest mocno dopasowany, gdy głównym obciążeniem jest automatyzacja przeglądarki lub testowanie między przeglądarkami, z wyjściem PDF jako okazjonalnym zadaniem pobocznym.IronPDF jest lepiej dopasowany, gdy głównym obciążeniem jest generowanie PDF-ów: nie ma osobnego kroku instalacji binariów przeglądarki, brak cyklu życia przeglądarki/kontekstu/strony do zarządzania, a takie cechy dokumentów jak PDF/A, cyfrowe podpisy, zabezpieczenia i scalanie są dostępne od razu.

Zanim zaczniesz

Wymagania wstępne

Środowisko .NET: .NET Framework 4.6.2+ lub .NET Core 3.1+ / .NET 5/6/7/8/9+
Dostęp do NuGet: Możliwość instalowania pakietów NuGet
Licencja IronPDF: Uzyskaj klucz licencyjny na stronie ironpdf.com

Zmiany w pakiecie NuGet

# Remove Playwright
dotnet remove package Microsoft.Playwright

# Remove the downloaded browser binaries
# Delete the .playwright folder in your project (and any cached binaries
# under your user profile, e.g. %USERPROFILE%\.cache\ms-playwright on Windows)

# Add IronPDF
dotnet add package IronPdf

# Remove Playwright
dotnet remove package Microsoft.Playwright

# Remove the downloaded browser binaries
# Delete the .playwright folder in your project (and any cached binaries
# under your user profile, e.g. %USERPROFILE%\.cache\ms-playwright on Windows)

# Add IronPDF
dotnet add package IronPdf

SHELL

Brak wymogu playwright install w przypadku IronPDF - silnik renderujacy jest automatycznie dolaczany.

Konfiguracja licencji

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

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

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

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

Kompletna dokumentacija API

Zmiany w przestrzeni nazw

// Before: Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

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

// Before: Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

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

' Before: Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

' After: IronPDF
Imports IronPdf
Imports IronPdf.Rendering

' Before: Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

' After: IronPDF
Imports IronPdf
Imports IronPdf.Rendering

Mapowania podstawowych interfejsów API

Interfejs APIPlaywright	IronPDF API
`Playwright.CreateAsync()`	`new ChromePdfRenderer()`
`playwright.Chromium.LaunchAsync()`	Nie jest potrzebne
`browser.NewPageAsync()`	Nie jest potrzebne
`page.GotoAsync(url)`	`renderer.RenderUrlAsPdf(url)`
`page.SetContentAsync(html)` + `page.PdfAsync()`	`renderer.RenderHtmlAsPdf(html)`
`page.CloseAsync()`	Nie jest potrzebne
`browser.CloseAsync()`	Nie jest potrzebne
`PagePdfOptions.Format`	`RenderingOptions.PaperSize`
`PagePdfOptions.Margin`	`RenderingOptions.MarginTop/Bottom/Left/Right`
`PagePdfOptions.DisplayHeaderFooter`	`TextFooter`
`PagePdfOptions.HeaderTemplate`	`RenderingOptions.HtmlHeader`
`PagePdfOptions.FooterTemplate`	`RenderingOptions.HtmlFooter`
`<span class='pageNumber'>`	`{page}`

Przykłady migracji kodu

Przykład 1: Konwersja ciągu znaków HTML do formatu PDF

Przed (Playwright):

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        string html = "<h1>Hello World</h1><p>This is a test PDF.</p>";
        await page.SetContentAsync(html);
        await page.PdfAsync(new PagePdfOptions { Path = "output.pdf" });
        
        await browser.CloseAsync();
    }
}

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        string html = "<h1>Hello World</h1><p>This is a test PDF.</p>";
        await page.SetContentAsync(html);
        await page.PdfAsync(new PagePdfOptions { Path = "output.pdf" });
        
        await browser.CloseAsync();
    }
}

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()

        Dim html As String = "<h1>Hello World</h1><p>This is a test PDF.</p>"
        Await page.SetContentAsync(html)
        Await page.PdfAsync(New PagePdfOptions With {.Path = "output.pdf"})

        Await browser.CloseAsync()
    End Function
End Module

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()

        Dim html As String = "<h1>Hello World</h1><p>This is a test PDF.</p>"
        Await page.SetContentAsync(html)
        Await page.PdfAsync(New PagePdfOptions With {.Path = "output.pdf"})

        Await browser.CloseAsync()
    End Function
End Module

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        string html = "<h1>Hello World</h1><p>This is a test PDF.</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        string html = "<h1>Hello World</h1><p>This is a test PDF.</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf

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

        Dim html As String = "<h1>Hello World</h1><p>This is a test PDF.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf

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

        Dim html As String = "<h1>Hello World</h1><p>This is a test PDF.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Module

Ten przykład ilustruje podstawową różnicę architektoniczną.Playwrightwymaga pieciu operacji asynchronicznych: Playwright.CreateAsync(), Chromium.LaunchAsync(), NewPageAsync(), SetContentAsync() i PdfAsync(), plus jawne czyszczenie przegladarki przy uzyciu CloseAsync().

IronPDF eliminuje cala te zlozonosc: utworz ChromePdfRenderer, wywolaj RenderHtmlAsPdf(), i SaveAs(). Żadnych wzorców asynchronicznych, żadnego cyklu życia przeglądarki, żadnego kodu czyszczącego. Podejście IronPDF oferuje bardziej przejrzystą składnię i lepszą integrację z nowoczesnymi aplikacjami .NET. Kompleksowe przykłady można znaleźć w dokumentacji dotyczącej konwersji HTML do PDF.

Przykład 2: Konwersja adresów URL do formatu PDF

Przed (Playwright):

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        await page.GotoAsync("https://www.example.com");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "webpage.pdf",
            Format = "A4"
        });
        
        await browser.CloseAsync();
    }
}

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        await page.GotoAsync("https://www.example.com");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "webpage.pdf",
            Format = "A4"
        });
        
        await browser.CloseAsync();
    }
}

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()

        Await page.GotoAsync("https://www.example.com")
        Await page.PdfAsync(New PagePdfOptions With {
            .Path = "webpage.pdf",
            .Format = "A4"
        })

        Await browser.CloseAsync()
    End Function
End Module

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()

        Await page.GotoAsync("https://www.example.com")
        Await page.PdfAsync(New PagePdfOptions With {
            .Path = "webpage.pdf",
            .Format = "A4"
        })

        Await browser.CloseAsync()
    End Function
End Module

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

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

// NuGet: Install-Package IronPdf
using IronPdf;

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

' NuGet: Install-Package IronPdf
Imports IronPdf

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

        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf

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

        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Module

Playwright uzywa GotoAsync() do nawigacji do URL, nastepnie PdfAsync().IronPDF dostarcza pojedyncza metode RenderUrlAsPdf(), ktora obsluguje nawigacje i generowanie PDF w jednym wywolaniu. Nalezy pamietac, zePlaywrightwymaga okreslenia Format w PagePdfOptions, podczas gdy IronPDF uzywa RenderingOptions.PaperSize do konfiguracji rozmiaru papieru. Dowiedz się więcej z naszych samouczków.

Przykład 3: Niestandardowy rozmiar strony z marginesami

Przed (Playwright):

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var playwright = await Playwright.CreateAsync();
        await using var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        await page.SetContentAsync("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "custom.pdf",
            Format = "Letter",
            Margin = new Margin { Top = "1in", Bottom = "1in", Left = "0.5in", Right = "0.5in" }
        });
    }
}

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var playwright = await Playwright.CreateAsync();
        await using var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        await page.SetContentAsync("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "custom.pdf",
            Format = "Letter",
            Margin = new Margin { Top = "1in", Bottom = "1in", Left = "0.5in", Right = "0.5in" }
        });
    }
}

Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Using playwright = Await Playwright.CreateAsync()
            Await Using browser = Await playwright.Chromium.LaunchAsync()
                Dim page = Await browser.NewPageAsync()
                Await page.SetContentAsync("<h1>Custom PDF</h1><p>Letter size with margins</p>")
                Await page.PdfAsync(New PagePdfOptions With {
                    .Path = "custom.pdf",
                    .Format = "Letter",
                    .Margin = New Margin With {
                        .Top = "1in",
                        .Bottom = "1in",
                        .Left = "0.5in",
                        .Right = "0.5in"
                    }
                })
            End Using
        End Using
    End Function
End Module

Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Using playwright = Await Playwright.CreateAsync()
            Await Using browser = Await playwright.Chromium.LaunchAsync()
                Dim page = Await browser.NewPageAsync()
                Await page.SetContentAsync("<h1>Custom PDF</h1><p>Letter size with margins</p>")
                Await page.PdfAsync(New PagePdfOptions With {
                    .Path = "custom.pdf",
                    .Format = "Letter",
                    .Margin = New Margin With {
                        .Top = "1in",
                        .Bottom = "1in",
                        .Left = "0.5in",
                        .Right = "0.5in"
                    }
                })
            End Using
        End Using
    End Function
End Module

Po (IronPDF):

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 25;
        renderer.RenderingOptions.MarginBottom = 25;
        renderer.RenderingOptions.MarginLeft = 12;
        renderer.RenderingOptions.MarginRight = 12;
        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        pdf.SaveAs("custom.pdf");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 25;
        renderer.RenderingOptions.MarginBottom = 25;
        renderer.RenderingOptions.MarginLeft = 12;
        renderer.RenderingOptions.MarginRight = 12;
        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        pdf.SaveAs("custom.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.MarginTop = 25
        renderer.RenderingOptions.MarginBottom = 25
        renderer.RenderingOptions.MarginLeft = 12
        renderer.RenderingOptions.MarginRight = 12
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Letter size with margins</p>")
        pdf.SaveAs("custom.pdf")
    End Sub
End Class

Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.MarginTop = 25
        renderer.RenderingOptions.MarginBottom = 25
        renderer.RenderingOptions.MarginLeft = 12
        renderer.RenderingOptions.MarginRight = 12
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Letter size with margins</p>")
        pdf.SaveAs("custom.pdf")
    End Sub
End Class

Playwright uzywa wartosci marginesu na podstawie lancucha znakow ("1in", "0.5in"), podczas gdy IronPDF uzywa wartosci numerycznych w milimetrach. Konwersja wynosi: 1 cal = 25,4 mm, wiec "1in" staje sie 25 a "0.5in" staje sie w przyblizeniu 12. Mapowanie Format = "Letter" zPlaywrightdo PaperSize = PdfPaperSize.Letter w IronPDF.

Przykład 4: Nagłówki, stopki i ustawienia niestandardowe

Przed (Playwright):

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        await page.SetContentAsync(html);
        
        await page.PdfAsync(new PagePdfOptions
        {
            Path = "custom.pdf",
            Format = "A4",
            Margin = new Margin { Top = "1cm", Bottom = "1cm", Left = "1cm", Right = "1cm" },
            DisplayHeaderFooter = true,
            HeaderTemplate = "<div style='font-size:10px; text-align:center;'>Header</div>",
            FooterTemplate = "<div style='font-size:10px; text-align:center;'>Page <span class='pageNumber'></span></div>"
        });
        
        await browser.CloseAsync();
    }
}

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        await page.SetContentAsync(html);
        
        await page.PdfAsync(new PagePdfOptions
        {
            Path = "custom.pdf",
            Format = "A4",
            Margin = new Margin { Top = "1cm", Bottom = "1cm", Left = "1cm", Right = "1cm" },
            DisplayHeaderFooter = true,
            HeaderTemplate = "<div style='font-size:10px; text-align:center;'>Header</div>",
            FooterTemplate = "<div style='font-size:10px; text-align:center;'>Page <span class='pageNumber'></span></div>"
        });
        
        await browser.CloseAsync();
    }
}

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()
        
        Dim html As String = "<h1>Custom PDF</h1><p>With margins and headers.</p>"
        Await page.SetContentAsync(html)
        
        Await page.PdfAsync(New PagePdfOptions With {
            .Path = "custom.pdf",
            .Format = "A4",
            .Margin = New Margin With {.Top = "1cm", .Bottom = "1cm", .Left = "1cm", .Right = "1cm"},
            .DisplayHeaderFooter = True,
            .HeaderTemplate = "<div style='font-size:10px; text-align:center;'>Header</div>",
            .FooterTemplate = "<div style='font-size:10px; text-align:center;'>Page <span class='pageNumber'></span></div>"
        })
        
        Await browser.CloseAsync()
    End Function
End Module

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()
        
        Dim html As String = "<h1>Custom PDF</h1><p>With margins and headers.</p>"
        Await page.SetContentAsync(html)
        
        Await page.PdfAsync(New PagePdfOptions With {
            .Path = "custom.pdf",
            .Format = "A4",
            .Margin = New Margin With {.Top = "1cm", .Bottom = "1cm", .Left = "1cm", .Right = "1cm"},
            .DisplayHeaderFooter = True,
            .HeaderTemplate = "<div style='font-size:10px; text-align:center;'>Header</div>",
            .FooterTemplate = "<div style='font-size:10px; text-align:center;'>Page <span class='pageNumber'></span></div>"
        })
        
        Await browser.CloseAsync()
    End Function
End Module

Po (IronPDF):

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

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.TextHeader.CenterText = "Header";
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page}";
        
        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("custom.pdf");
    }
}

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

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.TextHeader.CenterText = "Header";
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page}";
        
        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("custom.pdf");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()
        
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.TextHeader.CenterText = "Header"
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page}"
        
        Dim html As String = "<h1>Custom PDF</h1><p>With margins and headers.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("custom.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()
        
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.TextHeader.CenterText = "Header"
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page}"
        
        Dim html As String = "<h1>Custom PDF</h1><p>With margins and headers.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("custom.pdf")
    End Sub
End Module

Ten przykład pokazuje różnicę w składni symboli zastępczych nagłówka/stopki.Playwrightwykorzystuje zastepcze elementy HTML oparte na klasach (<span class='pageNumber'></span>), podczas gdy IronPDF uzywa zastepczych elementow w nawiasach klamrowych ({page}). Nalezy zauwazyc, zePlaywrightwymaga DisplayHeaderFooter = true do wlaczenia naglowkow/stopki, podczas gdy IronPDF wlacza je automatycznie po ustawieniu zawartosci naglowka/stopki.

Ważne uwagi dotyczące migracji

Konwersja z trybu asynchronicznego na synchroniczny

Playwright wymaga stosowania async/await w całym kodzie;IronPDF obsługuje operacje synchroniczne:

// Playwright: Async required
public async Task<byte[]> GeneratePdfAsync(string html)
{
    using var playwright = await Playwright.CreateAsync();
    await using var browser = await playwright.Chromium.LaunchAsync();
    var page = await browser.NewPageAsync();
    await page.SetContentAsync(html);
    return await page.PdfAsync();
}

// IronPDF: Sync is simpler
public byte[] GeneratePdf(string html)
{
    var renderer = new ChromePdfRenderer();
    return renderer.RenderHtmlAsPdf(html).BinaryData;
}

// Playwright: Async required
public async Task<byte[]> GeneratePdfAsync(string html)
{
    using var playwright = await Playwright.CreateAsync();
    await using var browser = await playwright.Chromium.LaunchAsync();
    var page = await browser.NewPageAsync();
    await page.SetContentAsync(html);
    return await page.PdfAsync();
}

// IronPDF: Sync is simpler
public byte[] GeneratePdf(string html)
{
    var renderer = new ChromePdfRenderer();
    return renderer.RenderHtmlAsPdf(html).BinaryData;
}

Imports System.Threading.Tasks
Imports Microsoft.Playwright

Public Class PdfGenerator
    ' Playwright: Async required
    Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
        Using playwright = Await Playwright.CreateAsync()
            Await Using browser = Await playwright.Chromium.LaunchAsync()
                Dim page = Await browser.NewPageAsync()
                Await page.SetContentAsync(html)
                Return Await page.PdfAsync()
            End Using
        End Using
    End Function

    ' IronPDF: Sync is simpler
    Public Function GeneratePdf(html As String) As Byte()
        Dim renderer = New ChromePdfRenderer()
        Return renderer.RenderHtmlAsPdf(html).BinaryData
    End Function
End Class

Imports System.Threading.Tasks
Imports Microsoft.Playwright

Public Class PdfGenerator
    ' Playwright: Async required
    Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
        Using playwright = Await Playwright.CreateAsync()
            Await Using browser = Await playwright.Chromium.LaunchAsync()
                Dim page = Await browser.NewPageAsync()
                Await page.SetContentAsync(html)
                Return Await page.PdfAsync()
            End Using
        End Using
    End Function

    ' IronPDF: Sync is simpler
    Public Function GeneratePdf(html As String) As Byte()
        Dim renderer = New ChromePdfRenderer()
        Return renderer.RenderHtmlAsPdf(html).BinaryData
    End Function
End Class

Konwersja jednostek marginesu

Playwright używa jednostek typu string;IronPDF używa milimetrów:

Playwright	IronPDF (mm)
`"1in"`	`25`
`"0.5in"`	`12`
`"1cm"`	`10`

Konwersja symboli zastępczych nagłówków/stopek

KlasaPlaywright	IronPDF Placeholder
`<span class='pageNumber'>`	`{page}`
`<span class='totalPages'>`	`{total-pages}`
`<span class='date'>`	`{date}`
`<span class='title'>`	`{html-title}`

Eliminacja cyklu życia przeglądarki

Usuń cały kod zarządzania przeglądarką:

// Playwright: Explicit cleanup required
await page.CloseAsync();
await browser.CloseAsync();
playwright.Dispose();

// IronPDF: No disposal needed - just use the renderer
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Playwright: Explicit cleanup required
await page.CloseAsync();
await browser.CloseAsync();
playwright.Dispose();

// IronPDF: No disposal needed - just use the renderer
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

' Playwright: Explicit cleanup required
Await page.CloseAsync()
Await browser.CloseAsync()
playwright.Dispose()

' IronPDF: No disposal needed - just use the renderer
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

' Playwright: Explicit cleanup required
Await page.CloseAsync()
Await browser.CloseAsync()
playwright.Dispose()

' IronPDF: No disposal needed - just use the renderer
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

Nowe możliwości po migracji

Po migracji do IronPDF zyskujesz możliwości, którychPlaywrightnie jest w stanie zapewnić:

Łączenie plików PDF

var pdf1 = renderer.RenderHtmlAsPdf(html1);
var pdf2 = renderer.RenderHtmlAsPdf(html2);
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

var pdf1 = renderer.RenderHtmlAsPdf(html1);
var pdf2 = renderer.RenderHtmlAsPdf(html2);
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

Dim pdf1 = renderer.RenderHtmlAsPdf(html1)
Dim pdf2 = renderer.RenderHtmlAsPdf(html2)
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")

Dim pdf1 = renderer.RenderHtmlAsPdf(html1)
Dim pdf2 = renderer.RenderHtmlAsPdf(html2)
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")

Znaki wodne

pdf.ApplyWatermark("<h1 style='color:red; opacity:0.3;'>DRAFT</h1>");

pdf.ApplyWatermark("<h1 style='color:red; opacity:0.3;'>DRAFT</h1>");

IRON VB CONVERTER ERROR developers@ironsoftware.com

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ochrona hasłem

pdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "readonly";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;

pdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "readonly";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;

pdf.SecuritySettings.OwnerPassword = "admin"
pdf.SecuritySettings.UserPassword = "readonly"
pdf.SecuritySettings.AllowUserCopyPasteContent = False

pdf.SecuritySettings.OwnerPassword = "admin"
pdf.SecuritySettings.UserPassword = "readonly"
pdf.SecuritySettings.AllowUserCopyPasteContent = False

Podpisy cyfrowe

var signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);

var signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);

Dim signature = New PdfSignature("certificate.pfx", "password")
pdf.Sign(signature)

Dim signature = New PdfSignature("certificate.pfx", "password")
pdf.Sign(signature)

Zgodność z PDF/A

pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);

pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);

pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b)

pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b)

Lista kontrolna migracji

Przed migracją

Zidentyfikuj cały kod generujący pliki PDF w Playwright
Wartości marginesów dokumentu (przelicz cal/cm na milimetry)
Zwróć uwagę na składnię symboli zastępczych nagłówka/stopki przy konwersji
Uzyskaj klucz licencyjny IronPDF ze strony ironpdf.com

Zmiany w pakiecie

Usun pakiet NuGet Microsoft.Playwright
Usun folder .playwright (i wszelkie zapamietane podrecznikowe binaria przegladarkiPlaywrightw profilu uzytkownika)
Zainstaluj pakiet NuGet IronPdf: dotnet add package IronPdf

Zmiany w kodzie

Zaktualizuj importy przestrzeni nazw
Zastap asynchroniczny cykl zycia przegladarki za pomoca ChromePdfRenderer
Przeksztalc page.SetContentAsync() + page.PdfAsync() do RenderHtmlAsPdf()
Przeksztalc page.GotoAsync() + page.PdfAsync() do RenderUrlAsPdf()
Zamień wartości marginesów na wartości w milimetrach
Przekształć składnię symboli zastępczych nagłówków/stopek
Usuń cały kod dotyczący zamykania przeglądarki/strony
Dodaj inicjalizację licencji podczas uruchamiania aplikacji

Po migracji

Wizualne porównanie pliku PDF
Sprawdź renderowanie nagłówków/stopek wraz z numerami stron
Sprawdź marginesy i dokładność rozmiaru strony
W razie potrzeby dodaj nowe funkcje (zabezpieczenia, znaki wodne, scałanie)

Zwróć uwagę: Playwright to zarejestrowany znak towarowy jego właściciela. Ta strona nie jest powiązana z firmą Microsoft, nie jest przez nią promowana ani sponsorowana. 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ęczników.

...

Czytaj więcej