pdforge (rebaptisé en "pdf noodle" en 2026 — pdfnoodle.com; le nom d'hôte api.pdforge.com continue de fonctionner via des redirections 301 jusqu'à la fin de 2026) est une API de génération de PDF basée sur le cloud, axée sur les modèles, offrant un moyen simple de produire des fichiers PDF en intégrant avec votre application via des appels HTTP. Il n'y a pas de SDK .NET officiel sur NuGet — l'intégration se fait avec HttpClient contre les endpoints REST documentés. En confiant la création de PDF à une API externe, les développeurs peuvent simplifier le processus de développement. Cependant, pdforge présente des inconvénients tels que des dépendances externes, des options de personnalisation limitées et des coûts d'abonnement permanents dont les développeurs doivent être conscients.
pdforge traite tous les documents sur des serveurs cloud externes. Cette architecture pose des problèmes importants pour les applications de production :
Traitement sur serveur externe : Chaque PDF que vous générez nécessite l'envoi de vos données HTML aux serveurs de pdforge ; vos documents quittent votre infrastructure.
Risques liés à la confidentialité et à la conformité : des données sensibles transitent par Internet vers des serveurs tiers. Lorsqu'ils utilisent pdforge, les développeurs doivent tenir compte des problèmes de sécurité liés à l'envoi de données à une API externe. Si le contenu du PDF contient des informations sensibles, cela peut constituer un facteur critique.
Frais d'abonnement récurrents : Les frais mensuels s'accumulent indéfiniment sans transfert de propriété. Le modèle SaaS de pdforge engendre des dépenses opérationnelles continues susceptibles de s'accumuler au fil du temps.
Dépendance à Internet : aucune génération de PDF lorsque le réseau est indisponible.
Limites de débit : les plafonds d'utilisation des API peuvent limiter le volume des applications.
Latence du réseau : le temps d'aller-retour ajoute des secondes à chaque génération de PDF.
| Fonction | pdforge | IronPDF |
|---|---|---|
| Type de déploiement | API basée sur le cloud | Bibliothèque locale |
| Dépendances | Nécessite une authentification Internet et API | Aucune dépendance externe |
| Personnalisation | Contrôle limité sur la génération de PDF | Contrôle total de la personnalisation |
| Structure des coûts | Abonnement en cours | Option d'achat unique |
| Sécurité | Problèmes potentiels liés aux données envoyées sur le web | Le traitement des données se fait entièrement dans l'environnement local |
| Complexité de l'installation | Installation initiale plus facile grâce à la manipulation externe | Nécessite plus d'installation et de configuration initiales |
IronPDF se différencie en fournissant une bibliothèque entièrement locale, accordant aux développeurs un contrôle total sur le processus de création de PDF. Ceci est particulièrement avantageux pour les applications où le traitement interne des fichiers est préféré, ou lorsque les appels d'API externes posent des problèmes de sécurité.IronPDF traite tout localement, ce qui minimise ces risques.
Pour les équipes planifiant l'adoption de .NET 10 et C# 14 sur les versions actuelles de .NET,IronPDF fournit une base de traitement locale qui élimine la dépendance au cloud tout en ajoutant des capacités complètes de manipulation de PDF.
# pdforge has no official .NET SDK on NuGet — integration is HttpClient + JSON.
# If your project depends only on built-in System.Net.Http, there is no
# competitor package to remove. Just install IronPDF:
dotnet add package IronPdf// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"# Find pdforge / pdf noodle endpoint usage
grep -r "api\.pdforge\.com\|api\.pdfnoodle\.com" --include="*.cs" .
# Find API key / Bearer token references
grep -r "pdfnoodle_api_\|pdforge_api_" --include="*.cs" --include="*.json" --include="*.config" .
# Find Chromium header/footer templates that need migrating
grep -r "totalPages\|pageNumber\|footerTemplate\|headerTemplate" --include="*.cs" .// Before: pdforge — raw HttpClient against api.pdfnoodle.com
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
// After: IronPDF
using IronPdf;
using IronPdf.Rendering;Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Text
Imports System.Text.Json
Imports IronPdf
Imports IronPdf.Rendering| pdforge (REST) | IronPDF |
|---|---|
HttpClient + Authorization: Bearer pdfnoodle_api_... | new ChromePdfRenderer() |
POST https://api.pdfnoodle.com/v1/html-to-pdf/sync | renderer.RenderHtmlAsPdf(html) |
Corps JSON { html, pdfParams } | ChromePdfRenderer + RenderingOptions |
Réponse : un ensemble JSON avec signedUrl | PdfDocument |
Retour : byte[] (après avoir récupéré signedUrl) | pdf.BinaryData |
| pdforge | IronPDF |
|---|---|
POST /v1/html-to-pdf/sync avec { html } | renderer.RenderHtmlAsPdf(html) |
| Récupérer l'URL, puis POST son HTML (aucun point de terminaison d'URL dédié) | renderer.RenderUrlAsPdf(url) |
Télécharger signedUrl puis File.WriteAllBytes(path, bytes) | pdf.SaveAs(path) |
await http.GetByteArrayAsync(signedUrl) | pdf.BinaryData |
pdforge pdfParams | IronPDF(RenderingOptions) |
|---|---|
format: "A4" | renderer.RenderingOptions.PaperSize = PdfPaperSize.A4 |
landscape: true | renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape |
margin: { top: "20px" } | renderer.RenderingOptions.MarginTop = 20 |
footerTemplate avec <span class="pageNumber"> / <span class="totalPages"> | TextFooter = new TextHeaderFooter { CenterText = "Page {page} of {total-pages}" } |
| Fonctionnalité d'IronPDF | Description du projet |
|---|---|
PdfDocument.Merge() | Combiner plusieurs PDF |
pdf.ExtractAllText() | Extraction de texte à partir de PDF |
pdf.ApplyWatermark() | Ajouter des filigranes |
pdf.SecuritySettings | Protection par mot de passe |
pdf.Form | Remplissage de formulaires |
pdf.SignWithDigitalSignature() | Signatures numériques |
Avant (pdforge):
// REST API — no .NET SDK on NuGet. Integration is HttpClient + JSON POST.
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY");
var body = new { html = "<html><body><h1>Hello World</h1></body></html>" };
var json = new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json");
var resp = await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json);
resp.EnsureSuccessStatusCode();
using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
var pdfBytes = await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString());
File.WriteAllBytes("output.pdf", pdfBytes);
}
}Imports System.IO
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Using http As New HttpClient()
http.DefaultRequestHeaders.Authorization = New AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY")
Dim body = New With {.html = "<html><body><h1>Hello World</h1></body></html>"}
Dim json As New StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json")
Dim resp = Await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json)
resp.EnsureSuccessStatusCode()
Using doc = JsonDocument.Parse(Await resp.Content.ReadAsStringAsync())
Dim pdfBytes = Await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString())
File.WriteAllBytes("output.pdf", pdfBytes)
End Using
End Using
End Function
End ModuleAprès (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
var html = "<html><body><h1>Hello World</h1></body></html>";
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
}
}Imports IronPdf
Class Program
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
Dim html = "<html><body><h1>Hello World</h1></body></html>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
End Sub
End ClassLa différence fondamentale réside dans le modèle de traitement et le type de retour. pdforge nécessite un POST HttpClient authentifié à https://api.pdfnoodle.com/v1/html-to-pdf/sync, qui renvoie un ensemble JSON contenant une URL S3 signée — vous récupérez ensuite les octets du PDF à partir de cette URL et les enregistrez avec File.WriteAllBytes().
IronPDF utilise ChromePdfRenderer avec RenderHtmlAsPdf() qui renvoie un objet PdfDocument. Cet objet peut être enregistré directement avec SaveAs(), ou vous pouvez accéder à pdf.BinaryData si vous avez besoin des octets bruts. Le PdfDocument permet également la manipulation (ajouter des filigranes, fusionner avec d'autres PDFs, ajouter de la sécurité) avant l'enregistrement. Consultez la documentation HTML vers PDF pour des exemples complets.
Avant (pdforge):
// REST API — no .NET SDK on NuGet. pdforge has no dedicated URL endpoint;
// fetch the page yourself and POST its HTML to /v1/html-to-pdf/sync.
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY");
var sourceHtml = await http.GetStringAsync("https://example.com");
var body = new { html = sourceHtml };
var json = new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json");
var resp = await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json);
resp.EnsureSuccessStatusCode();
using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
var pdfBytes = await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString());
File.WriteAllBytes("webpage.pdf", pdfBytes);
}
}Imports System.IO
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Using http As New HttpClient()
http.DefaultRequestHeaders.Authorization = New AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY")
Dim sourceHtml As String = Await http.GetStringAsync("https://example.com")
Dim body = New With {Key .html = sourceHtml}
Dim json As New StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json")
Dim resp As HttpResponseMessage = Await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json)
resp.EnsureSuccessStatusCode()
Using doc As JsonDocument = JsonDocument.Parse(Await resp.Content.ReadAsStringAsync())
Dim pdfBytes As Byte() = Await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString())
File.WriteAllBytes("webpage.pdf", pdfBytes)
End Using
End Using
End Function
End ModuleAprès (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("https://example.com");
pdf.SaveAs("webpage.pdf");
}
}Imports IronPdf
Class Program
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
pdf.SaveAs("webpage.pdf")
End Sub
End Classpdforge n'a pas de point de terminaison URL-to-PDF dédié — vous récupérez la page vous-même, puis postez son HTML au point de terminaison synchrone et téléchargez le résultat depuis l'URL signée retournée.IronPDF utilise RenderUrlAsPdf() sur ChromePdfRenderer, renvoyant un PdfDocument avec la méthode intégrée SaveAs().
Le principal avantage d'IronPDF est que l'URL est récupérée et rendue localement à l'aide d'un moteur Chromium - aucune donnée n'est envoyée à des serveurs externes. IronPDF, étant une bibliothèque locale, peut offrir de meilleures performances car il n'y a pas de temps d'aller-retour impliqué dans les requêtes web. En savoir plus sur la conversion d'URL en PDF.
Avant (pdforge):
// REST API — no .NET SDK on NuGet. Page size / orientation flow through the
// optional `pdfParams` object using Chromium/Puppeteer-style names.
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY");
var htmlContent = File.ReadAllText("input.html");
var body = new { html = htmlContent, pdfParams = new { format = "A4", landscape = true } };
var json = new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json");
var resp = await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json);
resp.EnsureSuccessStatusCode();
using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
var pdfBytes = await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString());
File.WriteAllBytes("output.pdf", pdfBytes);
}
}Imports System.IO
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Using http As New HttpClient()
http.DefaultRequestHeaders.Authorization = New AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY")
Dim htmlContent As String = File.ReadAllText("input.html")
Dim body = New With {
.html = htmlContent,
.pdfParams = New With {
.format = "A4",
.landscape = True
}
}
Dim json As New StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json")
Dim resp As HttpResponseMessage = Await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json)
resp.EnsureSuccessStatusCode()
Using doc As JsonDocument = JsonDocument.Parse(Await resp.Content.ReadAsStringAsync())
Dim pdfBytes As Byte() = Await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString())
File.WriteAllBytes("output.pdf", pdfBytes)
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.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
var htmlContent = System.IO.File.ReadAllText("input.html");
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
}
}Imports IronPdf
Imports IronPdf.Rendering
Class Program
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
Dim htmlContent = System.IO.File.ReadAllText("input.html")
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("output.pdf")
End Sub
End ClassCet exemple illustre la différence entre les modèles de configuration. pdforge transmet des options comme des champs JSON à l'intérieur d'un objet pdfParams dans le corps du POST (format = "A4", landscape = true), suivant les conventions de nommage de Chromium/Puppeteer.
IronPDF utilise la propriété RenderingOptions avec des enums fortement typés : renderer.RenderingOptions.PaperSize = PdfPaperSize.A4 et renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape. Ces outils offrent une prise en charge IntelliSense et une sécurité de type au moment de la compilation. Notez que IronPDF nécessite l'importation du namespace IronPdf.Rendering pour les enums de taille et d'orientation du papier. Voir les tutoriels pour plus d'exemples de configuration.
pdforge retourne une enveloppe JSON avec une URL signée ;IronPDF renvoie PdfDocument :
// pdforge: Two-step — parse signedUrl from JSON, then fetch bytes from it
var resp = await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json);
using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
var pdfBytes = await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString());
File.WriteAllBytes("output.pdf", pdfBytes);
// IronPDF: Returns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf"); // Direct save
byte[] bytes = pdf.BinaryData; // Get bytes if neededImports System.IO
Imports System.Net.Http
Imports System.Text.Json
Imports IronPdf
' pdforge: Two-step — parse signedUrl from JSON, then fetch bytes from it
Dim resp = Await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json)
Using doc As JsonDocument = JsonDocument.Parse(Await resp.Content.ReadAsStringAsync())
Dim pdfBytes = Await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString())
File.WriteAllBytes("output.pdf", pdfBytes)
End Using
' IronPDF: Returns PdfDocument
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf") ' Direct save
Dim bytes As Byte() = pdf.BinaryData ' Get bytes if needed// pdforge: HttpClient against the REST endpoint
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY");
// IronPDF: ChromePdfRenderer
var renderer = new ChromePdfRenderer();' pdforge: HttpClient against the REST endpoint
Using http As New HttpClient()
http.DefaultRequestHeaders.Authorization = New AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY")
' IronPDF: ChromePdfRenderer
Dim renderer As New ChromePdfRenderer()
End Using// pdforge operations
await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json); // HTML to PDF
// URL to PDF: fetch the page first, then POST its HTML to the same endpoint
//IronPDF methods
renderer.RenderHtmlAsPdf(html)
renderer.RenderUrlAsPdf(url)// pdforge: Two-step — fetch bytes from signed URL, then write to disk
var pdfBytes = await http.GetByteArrayAsync(signedUrl);
File.WriteAllBytes("output.pdf", pdfBytes);
// IronPDF: Built-in save method
pdf.SaveAs("output.pdf");' pdforge: Two-step — fetch bytes from signed URL, then write to disk
Dim pdfBytes = Await http.GetByteArrayAsync(signedUrl)
File.WriteAllBytes("output.pdf", pdfBytes)
' IronPDF: Built-in save method
pdf.SaveAs("output.pdf")pdforge transmet les options comme des champs JSON sur pdfParams ;IronPDF utilise RenderingOptions :
// pdforge: JSON pdfParams object on the POST body
var body = new { html, pdfParams = new { format = "A4", landscape = true } };
// IronPDF: Properties on RenderingOptions
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;' pdforge: JSON pdfParams object on the POST body
Dim body = New With {Key .html = html, Key .pdfParams = New With {Key .format = "A4", Key .landscape = True}}
' IronPDF: Properties on RenderingOptions
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscapepdforge hérite du format de modèle d'en-tête/pied de page de Chromium — fragments HTML contenant des éléments <span class="..."></span> que le moteur substitue au moment du rendu.IronPDF utilise des espaces réservés entre crochets à l'intérieur d'un TextHeaderFooter / HtmlHeaderFooter :
// pdforge: Chromium template HTML inside pdfParams.footerTemplate
// "<div>Page <span class=\"pageNumber\"></span> of <span class=\"totalPages\"></span></div>"
//IronPDF placeholders
"Page {page} of {total-pages}" // Note: hyphen in total-pagesAprès avoir migré vers IronPDF, vous bénéficiez de fonctionnalités que pdforge ne peut pas vous offrir :
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")var pdf = PdfDocument.FromFile("document.pdf");
string allText = pdf.ExtractAllText();Dim pdf = PdfDocument.FromFile("document.pdf")
Dim allText As String = pdf.ExtractAllText()pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>");pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>")pdf.SecuritySettings.UserPassword = "userpassword";
pdf.SecuritySettings.OwnerPassword = "ownerpassword";pdf.SecuritySettings.UserPassword = "userpassword"
pdf.SecuritySettings.OwnerPassword = "ownerpassword"| Fonction | pdforge | IronPDF |
|---|---|---|
| HTML vers PDF | ✓ | ✓ |
| URL vers PDF | ✓ | ✓ |
| Paramètres de la page | ✓ | ✓ |
| Capacité hors ligne | ✗ | ✓ |
| Traitement local | ✗ | ✓ |
| Fusionner des PDF | ✗ | ✓ |
| Diviser les PDF | ✗ | ✓ |
| Extraire le texte | ✗ | ✓ |
| Filigranes | ✗ | ✓ |
| Remplissage de formulaires | ✗ | ✓ |
| Signatures numériques | ✗ | ✓ |
| Protection par mot de passe | ✗ | ✓ |
| Pas de limite de tarif | ✗ | ✓ |
| Licence unique | ✗ | ✓ |
api.pdforge.com, api.pdfnoodle.com)pdfParams utilisée (taille de page, orientation, marges)<span class="pageNumber">, <span class="totalPages">) à convertir en espaces réservés d'IronPDF ({page}, {total-pages})IronPdf : dotnet add package IronPdfSystem.Net.Http / System.Text.Json utilisés uniquement pour les appels pdforgeusing IronPdf; et using IronPdf.Rendering; pour les enums de taille et d'orientation du papierHttpClient authentifié par ChromePdfRendererPOST /v1/html-to-pdf/sync par RenderHtmlAsPdf()RenderUrlAsPdf()GetByteArrayAsync(signedUrl) + File.WriteAllBytes() par pdf.SaveAs()pdfParams.format vers RenderingOptions.PaperSizepdfParams.landscape vers RenderingOptions.PaperOrientationPdfPaperSize.A4 / PdfPaperOrientation.Landscape enumsTextHeaderFooter / HtmlHeaderFooterBearer par un jeton unique IronPdf.License.LicenseKey au démarrage
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.
