La migration de Microsoft Auteurfor .NET à IronPDF déplace votre flux de travail de génération de PDF d'un cadre de test d'automatisation de navigateur à une bibliothèque PDF dédiée. Ce guide fournit un chemin de migration étape par étape qui supprime la gestion du cycle de vie asynchrone du navigateur et l'étape distincte de téléchargement playwright install du fichier binaire du navigateur.
Playwright for .NET (NuGet Microsoft.Playwright, sous licence MIT) est le framework d'automatisation de navigateur de Microsoft, conçu principalement pour les tests de bout en bout sur Chromium, Firefox et WebKit. Ses charges de travail typiques sont interactives : cliquer sur des boutons, remplir des formulaires, intercepter des requêtes réseau, prendre des captures d'écran, et valider la compatibilité inter-navigateurs.
La génération de PDF dans Auteurest une fonctionnalité secondaire exposée via Page.PdfAsync(), et elle est prise en charge uniquement sur Chromium — Firefox et WebKit n'implémentent pas de sortie PDF. La sortie utilise le chemin d'impression en PDF du navigateur (équivalent à Ctrl+P), ce qui a des implications pour les mises en page, les arrière-plans, et la pagination :
playwright installPlaywright a été conçu pour les tests de bout en bout, et non pour la génération de documents. Quelques implications pratiques lors de sa réutilisation pour les PDF :
Fichiers binaires de navigateur via playwright install. La configuration par défaut de Auteurtélécharge les fichiers binaires du navigateur (Chromium, Firefox, WebKit), ce qui peut être une considération pour les environnements avec des contraintes strictes de ressources ou de déploiement.
Modèle de navigateur/contexte/page asynchrone. Les développeurs doivent être à l'aise avec la gestion des contextes du navigateur et du cycle de vie des pages, y compris la suppression.
Architecture axée sur les tests, non optimisée pour la génération de documents à grande échelle.
Sémantique d'impression en PDF équivalente à l'impression Ctrl+P du navigateur. Les mises en page peuvent être refondues, les arrière-plans peuvent être omis par défaut et la sortie est paginée pour l'impression.
Pas de sortie PDF/A ou PDF/UA. Auteurne produit pas de documents conformes PDF/A (archivage) ou PDF/UA (accessibilité). Pour la Section 508, les directives d'accessibilité de l'UE, ou les exigences d'archivage à long terme, une bibliothèque PDF dédiée est généralement requise.
Utilisation des ressources du navigateur par rendu lorsque chaque PDF déclenche des contextes et des pages de navigateur.
Playwright expose une surface de configuration orientée vers l'automatisation des tests. Les éléments les plus pertinents lors de son utilisation juste pour la génération de PDF :
Étape d'installation du navigateur :
# 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)Configuration de lancement du navigateur :
// 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 UsingOptions de configuration spécifiques aux tests :
Headless : Doit configurer le mode sans tête pour la production (par défaut en mode avec affichage pour les tests)SlowMo : Retards de synchronisation des tests (sans pertinence pour la génération de PDF)Devtools : Configuration des outils de test (non nécessaire pour les documents)ExecutablePath : Chemins de navigateur personnalisés pour les environnements de testProxy : Interception du réseau pour les tests (surcharge inutile)DownloadsPath : Gestion des artefacts de testTracesDir : Traces d'exécution des testsGestion du contexte du navigateur :
// 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 requiredSurface multi-navigateurs :
// Auteursupports 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 : un seul moteur de rendu intégré
// 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")IronPDF inclut son moteur de rendu dans le package NuGet, il n'y a donc pas d'étape playwright install distincte et aucun cycle de vie du navigateur/contexte/page à gérer.
| Métrique | Auteur | IronPDF |
|---|---|---|
| Objectif principal | Cadre de test d'automatisation de navigateur bout-en-bout | Génération de document PDF |
| Philosophie de conception | Axé sur les tests; PDF est une fonctionnalité secondaire | Bibliothèque PDF spécialement conçue à cet effet |
| Paquet NuGet | Microsoft.Playwright (MIT) | IronPdf (commercial) |
| Étape de binaire de navigateur | Téléchargement playwright install séparé | Inclus dans le package NuGet |
| Moteurs prenant en charge le PDF | Uniquement pour Chromium (Firefox / WebKit n'implémentent pas Page.PdfAsync()) | Un seul moteur intégré basé sur Chromium |
| Premier rendu (Cold Start) | 4.5 secondes | 2.8 secondes |
| Rendu ultérieur | 3.8-4.1 secondes | 0.8-1,2 secondes |
| Mémoire par conversion | 280-420MB | 80-120MB |
| Style API | Cycle de vie asynchrone navigateur/contexte/page | Synchrone ou asynchrone ; renderer-based |
| Initialisation | CreateAsync() + LaunchAsync() + NewPageAsync() | new ChromePdfRenderer() |
| Support PDF/A | Non disponible | Prise en charge |
| Accessibilité PDF/UA | Non disponible | Prise en charge |
| Signatures numériques | Non disponible | Prise en charge |
| Édition de PDF | Non disponible | Fusionner, diviser, tamponner, éditer |
| Modèle de support | Communauté | Commercial avec SLA |
IronPDF est construit spécifiquement pour la génération de PDF, avec une surface d'API centrée sur le document. Il utilise un moteur de rendu intégré basé sur Chromium et prend en charge à la fois les opérations synchrones et asynchrones, ce qui permet aux développeurs d'avoir un modèle mental plus simple lorsque la sortie PDF — et non l'interaction avec le navigateur — est l'objectif.
Playwright est un bon choix lorsque la charge de travail principale est l'automatisation de navigateur ou les tests inter-navigateurs, avec une sortie PDF comme tâche secondaire occasionnelle.IronPDF est la meilleure solution lorsque la génération de PDF est la charge de travail principale : il n'y a pas de téléchargement binaire de navigateur séparé, pas de cycle de vie navigateur/contexte/page à gérer, et des fonctionnalités de documents comme PDF/A, signatures numériques, sécurité et fusion sont disponibles dès le départ.
# 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 IronPdfAucun playwright install n'est requis avec IronPDF - le moteur de rendu est intégré automatiquement.
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"// 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| API Playwright | API IronPDF |
|---|---|
Playwright.CreateAsync() | new ChromePdfRenderer() |
playwright.Chromium.LaunchAsync() | Pas nécessaire |
browser.NewPageAsync() | Pas nécessaire |
page.GotoAsync(url) | renderer.RenderUrlAsPdf(url) |
page.SetContentAsync(html) + page.PdfAsync() | renderer.RenderHtmlAsPdf(html) |
page.CloseAsync() | Pas nécessaire |
browser.CloseAsync() | Pas nécessaire |
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} |
Avant (Dramaturge):
// 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 ModuleAprès (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
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 ModuleCet exemple illustre la différence architecturale fondamentale. Auteurnécessite cinq opérations asynchrones : Playwright.CreateAsync(), Chromium.LaunchAsync(), NewPageAsync(), SetContentAsync(), et PdfAsync(), plus le nettoyage explicite du navigateur avec CloseAsync().
IronPDF élimine toute cette complexité : créez un ChromePdfRenderer, appelez RenderHtmlAsPdf(), et SaveAs(). Pas de modèles asynchrones, pas de cycle de vie du navigateur, pas de code de nettoyage. L'approche d'IronPDF offre une syntaxe plus propre et une meilleure intégration avec les applications .NET modernes. Consultez la documentation HTML vers PDF pour des exemples complets.
Avant (Dramaturge):
// 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 ModuleAprès (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
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 ModulePlaywright utilise GotoAsync() pour naviguer vers une URL suivi par PdfAsync().IronPDF fournit une méthode RenderUrlAsPdf() unique qui gère la navigation et la génération de PDF en un seul appel. Notez que Auteurnécessite de spécifier Format dans PagePdfOptions, tandis qu'IronPDF utilise RenderingOptions.PaperSize pour la configuration de la taille du papier. Pour en savoir plus, consultez nos tutoriels.
Avant (Dramaturge):
// 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 ModuleAprès (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");
}
}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 ClassPlaywright utilise des valeurs de marge basées sur des chaînes ("1in", "0.5in") tandis qu'IronPDF utilise des valeurs numériques en millimètres. La conversion est : 1 pouce = 25,4 mm, donc "1in" devient 25 et "0.5in" devient environ 12. Le Format = "Letter" de Auteurcorrespond à PaperSize = PdfPaperSize.Letter d'IronPDF.
Avant (Dramaturge):
// 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 ModuleAprès (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
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 ModuleCet exemple illustre la différence de syntaxe entre les espaces réservés de l'en-tête et du pied de page. Auteurutilise des espaces réservés basés sur des classes HTML (<span class='pageNumber'></span>), tandis qu'IronPDF utilise des espaces réservés entre accolades ({page}). Notez que Auteurnécessite DisplayHeaderFooter = true pour activer les en-têtes/pieds de page, tandis qu'IronPDF les active automatiquement lorsque vous définissez le contenu des en-têtes/pieds de page.
Playwright nécessite l'utilisation d'async/await tout au long du processus ;IronPDF prend en charge les opérations synchrones :
// 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 ClassPlaywright utilise des unités de chaîne de caractères ;IronPDF utilise des millimètres numériques :
| Auteur | IronPDF(mm) |
|---|---|
"1in" | 25 |
"0.5in" | 12 |
"1cm" | 10 |
| Cours de dramaturgie | IronPDF Placeholder |
|---|---|
<span class='pageNumber'> | {page} |
<span class='totalPages'> | {total-pages} |
<span class='date'> | {date} |
<span class='title'> | {html-title} |
Supprimez tout le code de gestion du navigateur :
// 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")Après avoir migré vers IronPDF, vous bénéficiez de fonctionnalités que Auteurne peut pas vous offrir :
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")pdf.ApplyWatermark("<h1 style='color:red; opacity:0.3;'>DRAFT</h1>");IRON VB CONVERTER ERROR developers@ironsoftware.compdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "readonly";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;pdf.SecuritySettings.OwnerPassword = "admin"
pdf.SecuritySettings.UserPassword = "readonly"
pdf.SecuritySettings.AllowUserCopyPasteContent = Falsevar signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);Dim signature = New PdfSignature("certificate.pfx", "password")
pdf.Sign(signature)pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b)Microsoft.Playwright.playwright (et tous les fichiers binaires Auteurmis en cache sous votre profil utilisateur)IronPdf : dotnet add package IronPdfChromePdfRendererpage.SetContentAsync() + page.PdfAsync() en RenderHtmlAsPdf()page.GotoAsync() + page.PdfAsync() en RenderUrlAsPdf()
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
