Didn’t find what you were looking for?
Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Guides de migration
  4. migration de craftmypdf vers IronPDF
VIDéOS

Comment convertir des images en PDF en utilisant C#

Curtis Chau
Curtis Chau
Mis à jour:

Pourquoi migrer de CraftMyPDFà IronPDF?

Les API PDF basées sur le cloud, telles que CraftMyPDF, présentent des problèmes fondamentaux qui les rendent inadaptées à de nombreux environnements de production.

Le problème des API PDF basées sur le cloud

  1. Vos données quittent votre système : chaque modèle HTML et chaque charge utile de données JSON est transmis aux serveurs de CraftMyPDF. Pour les factures, les contrats, les dossiers médicaux ou toute autre donnée commerciale sensible, cela crée des risques de conformité HIPAA, GDPR et SOC2.

  2. Latence Réseau : Chaque génération de PDF implique un aller-retour réseau plus un temps de mise en file et de rendu (en général des secondes).IronPDF génère localement en quelques millisecondes.

  3. Les coûts par PDF s'accumulent : La tarification basée sur le crédit s'accumule avec le volume — les charges de travail à haut débit créent des coûts récurrents importants par rapport à une licence perpétuelle unique.

  4. Sortie optimisée pour l'impression : les API cloud sont souvent optimisées pour l'impression, réduisant les arrière-plans et simplifiant les couleurs afin d'économiser de l'encre. Le résultat ne ressemble jamais à votre code HTML affiché à l'écran.

  5. Verrouillage du modèle : CraftMyPDFnécessite son éditeur propriétaire par glisser-déposer. Vous ne pouvez pas utiliser librement les langages HTML/CSS standard.

Comparaison des architectures

Aspect CraftMyPDF IronPDF
Lieu des données Cloud (vos données quittent votre système) Sur site (les données ne quittent jamais le site)
Latence Aller-retour réseau + rendu (en général des secondes) Millisecondes
Tarification Abonnement basé sur le crédit Licence perpétuelle à usage unique
Système de modèles Drag-and-drop propriétaire uniquement Tout HTML/CSS/JavaScript
Qualité de la production Optimisé pour l'impression Rendu d'écran parfait
Travaille hors ligne Non (nécessite internet) Oui
Conformité Organisation des feuilles de données Conformité SOC2/HIPAA

Comparaison des fonctionnalités

Fonction CraftMyPDF IronPDF
HTML vers PDF Via des modèles d'API ✅Natif
URL vers PDF Via API ✅Natif
Modèles personnalisés Éditeur propriétaire uniquement ✅Tout HTML
Prise en charge de CSS3 Limité ✅Complet
Rendu JavaScript Limité ✅Complet
Fusionner/séparer des PDF Via API ✅Natif
Filigranes Via API ✅Natif
Travail hors ligne ❌ ✅
Auto-hébergé ❌ ✅

Préparation de la migration

Prérequis

Assurez-vous que votre environnement répond à ces exigences :

  • .NET Framework 4.6.2+ ou .NET Core 3.1 / .NET 5-9
  • Visual Studio 2019+ ou VS Code avec l'extension C#
  • Accès au Package Manager NuGet
  • Clé de licence IronPDF(essai gratuit disponible sur ironpdf.com)

Audit de l'utilisation de CraftMyPDF

Exécutez ces commandes dans votre répertoire de solutions pour identifier toutes les références à CraftMyPDF:

# Find all CraftMyPDFusages in your codebase
grep -r "CraftMyPdf\|craftmypdf\|api.craftmypdf.com" --include="*.cs" .
grep -r "X-API-KEY" --include="*.cs" .

# Find API key references
grep -r "your-api-key\|template-id\|template_id" --include="*.cs" .

# Find NuGet package references
grep -r "CraftMyPdf\|RestSharp" --include="*.csproj" .
# Find all CraftMyPDFusages in your codebase
grep -r "CraftMyPdf\|craftmypdf\|api.craftmypdf.com" --include="*.cs" .
grep -r "X-API-KEY" --include="*.cs" .

# Find API key references
grep -r "your-api-key\|template-id\|template_id" --include="*.cs" .

# Find NuGet package references
grep -r "CraftMyPdf\|RestSharp" --include="*.csproj" .
SHELL

Modifications importantes à prévoir

Changement CraftMyPDF IronPDF Impact
Architecture Cloud REST API Bibliothèque .NET locale Supprimer les appels HTTP
Modèles Éditeur propriétaire HTML standard Convertir les modèles en HTML
Clé API Nécessaire pour chaque appel Licence au démarrage Suppression de la gestion des clés API
Modèle asynchrone Obligatoire (HTTP) En option Supprimer l'attente si vous le souhaitez
Gestion des erreurs Codes d'état HTTP Exceptions Modifier les modèles try/catch
Liaison de données Modèles JSON Interpolation de chaînes de caractères Simplifier la liaison des données

Processus de migration étape par étape

Étape 1 : Mise à jour des paquets NuGet

Supprimez la bibliothèque client HTTP et installez IronPDF:

# Remove RestSharp HTTP client
dotnet remove package RestSharp

# Install IronPDF
dotnet add package IronPdf
# Remove RestSharp HTTP client
dotnet remove package RestSharp

# Install IronPDF
dotnet add package IronPdf
SHELL

Étape 2 : Mise à jour des références aux espaces de noms

Remplacer les espaces de noms des clients HTTP par IronPDF:

// Remove these
using RestSharp;
using System.IO;

// Add this
using IronPdf;
// Remove these
using RestSharp;
using System.IO;

// Add this
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Étape 3 : configuration de la licence (une fois au démarrage)

Remplacer les en-têtes de clés API par requête par une configuration de licence unique :

// Add at application startup (Program.cs or Global.asax)
// This replaces all X-API-KEY headers
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup (Program.cs or Global.asax)
// This replaces all X-API-KEY headers
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
' Add at application startup (Program.vb or Global.asax)
' This replaces all X-API-KEY headers
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Référence complète de migration des API

Mappage des points d'extrémité de l'interface utilisateur

CraftMyPDF IronPDF
POST /v1/create renderer.RenderHtmlAsPdf(html)
X-API-KEY en-tête License.LicenseKey = "..."
template_id Chaîne HTML standard
{%name%} espaces réservés $"{name}" interpolation C#
POST /v1/merge PdfDocument.Merge(pdfs)
POST /v1/add-watermark pdf.ApplyWatermark(html)
Rappels de webhook Pas nécessaire
Limitation des tarifs Sans objet

Cartographie de configuration

Option CraftMyPDF Équivalent d'IronPDF
template_id Chaîne HTML
data JSON Interpolation C#
page_size: "A4" PaperSize = PdfPaperSize.A4
orientation: "landscape" PaperOrientation = Landscape
margin_top: 20 MarginTop = 20
header HtmlHeader
footer HtmlFooter

Exemples de migration de code

Conversion HTML en PDF

L'opération la plus courante démontre le changement fondamental de l'architecture, qui passe de l'API en nuage au rendu local.

Mise en œuvre de CraftMyPDF:

// NuGet: Install-Package RestSharp
using System;
using RestSharp;
using System.IO;

class Program
{
    static void Main()
    {
        var client = new RestClient("https://api.craftmypdf.com/v1/create");
        var request = new RestRequest(Method.POST);
        request.AddHeader("X-API-KEY", "your-api-key");
        request.AddJsonBody(new
        {
            template_id = "your-template-id",
            data = new
            {
                html = "<h1>Hello World</h1><p>This is a PDF from HTML</p>"
            }
        });

        var response = client.Execute(request);
        File.WriteAllBytes("output.pdf", response.RawBytes);
    }
}
// NuGet: Install-Package RestSharp
using System;
using RestSharp;
using System.IO;

class Program
{
    static void Main()
    {
        var client = new RestClient("https://api.craftmypdf.com/v1/create");
        var request = new RestRequest(Method.POST);
        request.AddHeader("X-API-KEY", "your-api-key");
        request.AddJsonBody(new
        {
            template_id = "your-template-id",
            data = new
            {
                html = "<h1>Hello World</h1><p>This is a PDF from HTML</p>"
            }
        });

        var response = client.Execute(request);
        File.WriteAllBytes("output.pdf", response.RawBytes);
    }
}
Imports System
Imports RestSharp
Imports System.IO

Module Program
    Sub Main()
        Dim client As New RestClient("https://api.craftmypdf.com/v1/create")
        Dim request As New RestRequest(Method.POST)
        request.AddHeader("X-API-KEY", "your-api-key")
        request.AddJsonBody(New With {
            .template_id = "your-template-id",
            .data = New With {
                .html = "<h1>Hello World</h1><p>This is a PDF from HTML</p>"
            }
        })

        Dim response = client.Execute(request)
        File.WriteAllBytes("output.pdf", response.RawBytes)
    End Sub
End Module
$vbLabelText   $csharpLabel

Mise en œuvre d'IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML</p>");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML</p>");
        pdf.SaveAs("output.pdf");
    }
}
Imports System
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML</p>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF élimine la configuration de RestClient, les en-têtes de clé API, les ID de modèle et la gestion des réponses HTTP, réduisant ainsi une opération en nuage de 15 lignes à 4 lignes de code local. Pour plus d'options, consultez la documentation HTML vers PDF.

Conversion d'URL en PDF

Mise en œuvre de CraftMyPDF:

// NuGet: Install-Package RestSharp
using System;
using RestSharp;
using System.IO;

class Program
{
    static void Main()
    {
        var client = new RestClient("https://api.craftmypdf.com/v1/create");
        var request = new RestRequest(Method.POST);
        request.AddHeader("X-API-KEY", "your-api-key");
        request.AddJsonBody(new
        {
            template_id = "your-template-id",
            data = new
            {
                url = "https://example.com"
            },
            export_type = "file" // "file" returns binary PDF; "json" returns a CDN URL
        });

        var response = client.Execute(request);
        File.WriteAllBytes("webpage.pdf", response.RawBytes);
    }
}
// NuGet: Install-Package RestSharp
using System;
using RestSharp;
using System.IO;

class Program
{
    static void Main()
    {
        var client = new RestClient("https://api.craftmypdf.com/v1/create");
        var request = new RestRequest(Method.POST);
        request.AddHeader("X-API-KEY", "your-api-key");
        request.AddJsonBody(new
        {
            template_id = "your-template-id",
            data = new
            {
                url = "https://example.com"
            },
            export_type = "file" // "file" returns binary PDF; "json" returns a CDN URL
        });

        var response = client.Execute(request);
        File.WriteAllBytes("webpage.pdf", response.RawBytes);
    }
}
Imports System
Imports RestSharp
Imports System.IO

Module Program
    Sub Main()
        Dim client As New RestClient("https://api.craftmypdf.com/v1/create")
        Dim request As New RestRequest(Method.POST)
        request.AddHeader("X-API-KEY", "your-api-key")
        request.AddJsonBody(New With {
            .template_id = "your-template-id",
            .data = New With {
                .url = "https://example.com"
            },
            .export_type = "file" ' "file" returns binary PDF; "json" returns a CDN URL
        })

        Dim response = client.Execute(request)
        File.WriteAllBytes("webpage.pdf", response.RawBytes)
    End Sub
End Module
$vbLabelText   $csharpLabel

Mise en œuvre d'IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
Imports System
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 Class
$vbLabelText   $csharpLabel

La méthode RenderUrlAsPdf de IronPDF capture la page web complète, y compris le contenu rendu par JavaScript. Pour plus d'options, consultez l'URL vers la documentation PDF.

En-têtes et pieds de page

Mise en œuvre de CraftMyPDF:

// NuGet: Install-Package RestSharp
using System;
using RestSharp;
using System.IO;

class Program
{
    static void Main()
    {
        var client = new RestClient("https://api.craftmypdf.com/v1/create");
        var request = new RestRequest(Method.POST);
        request.AddHeader("X-API-KEY", "your-api-key");
        request.AddJsonBody(new
        {
            template_id = "your-template-id",
            data = new
            {
                html = "<h1>Document Content</h1>",
                header = "<div>Page Header</div>",
                footer = "<div>Page {page} of {total_pages}</div>"
            }
        });

        var response = client.Execute(request);
        File.WriteAllBytes("document.pdf", response.RawBytes);
    }
}
// NuGet: Install-Package RestSharp
using System;
using RestSharp;
using System.IO;

class Program
{
    static void Main()
    {
        var client = new RestClient("https://api.craftmypdf.com/v1/create");
        var request = new RestRequest(Method.POST);
        request.AddHeader("X-API-KEY", "your-api-key");
        request.AddJsonBody(new
        {
            template_id = "your-template-id",
            data = new
            {
                html = "<h1>Document Content</h1>",
                header = "<div>Page Header</div>",
                footer = "<div>Page {page} of {total_pages}</div>"
            }
        });

        var response = client.Execute(request);
        File.WriteAllBytes("document.pdf", response.RawBytes);
    }
}
Imports System
Imports RestSharp
Imports System.IO

Module Program
    Sub Main()
        Dim client As New RestClient("https://api.craftmypdf.com/v1/create")
        Dim request As New RestRequest(Method.POST)
        request.AddHeader("X-API-KEY", "your-api-key")
        request.AddJsonBody(New With {
            .template_id = "your-template-id",
            .data = New With {
                .html = "<h1>Document Content</h1>",
                .header = "<div>Page Header</div>",
                .footer = "<div>Page {page} of {total_pages}</div>"
            }
        })

        Dim response = client.Execute(request)
        File.WriteAllBytes("document.pdf", response.RawBytes)
    End Sub
End Module
$vbLabelText   $csharpLabel

Mise en œuvre d'IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
        {
            CenterText = "Page Header"
        };
        renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
        {
            CenterText = "Page {page} of {total-pages}"
        };

        var pdf = renderer.RenderHtmlAsPdf("<h1>Document Content</h1>");
        pdf.SaveAs("document.pdf");
    }
}
// NuGet: Install-Package IronPdf
using System;
using IronPdf;
using IronPdf.Rendering;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
        {
            CenterText = "Page Header"
        };
        renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
        {
            CenterText = "Page {page} of {total-pages}"
        };

        var pdf = renderer.RenderHtmlAsPdf("<h1>Document Content</h1>");
        pdf.SaveAs("document.pdf");
    }
}
Imports System
Imports IronPdf
Imports IronPdf.Rendering

Module Program
    Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.TextHeader = New TextHeaderFooter() With {
            .CenterText = "Page Header"
        }
        renderer.RenderingOptions.TextFooter = New TextHeaderFooter() With {
            .CenterText = "Page {page} of {total-pages}"
        }

        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Document Content</h1>")
        pdf.SaveAs("document.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

IronPDF prend en charge les jetons d'espace réservé comme {page} et {total-pages} pour la numérotation dynamique des pages. Pour plus d'options, consultez la documentation sur les en-têtes et les pieds de page.

Conversion de variables de modèles

CraftMyPDF utilise des espaces réservés de modèles propriétaires qui doivent être convertis en interpolation de chaînes C# :

Modèle CraftMyPDF :

// CraftMyPDFtemplate variables
request.AddJsonBody(new
{
    template_id = "invoice-template",
    data = new
    {
        customer = "John Doe",
        amount = "$1,000",
        items = invoiceItems
    }
});
// CraftMyPDFtemplate variables
request.AddJsonBody(new
{
    template_id = "invoice-template",
    data = new
    {
        customer = "John Doe",
        amount = "$1,000",
        items = invoiceItems
    }
});
' CraftMyPDFtemplate variables
request.AddJsonBody(New With {
    .template_id = "invoice-template",
    .data = New With {
        .customer = "John Doe",
        .amount = "$1,000",
        .items = invoiceItems
    }
})
$vbLabelText   $csharpLabel

Modèle IronPDF:

// C# string interpolation
var html = $@"
<html>
<body>
    <h1>Invoice</h1>
    <p>Customer: {customerName}</p>
    <p>Amount: {amount}</p>
    {GenerateItemsTable(invoiceItems)}
</body>
</html>";

var pdf = renderer.RenderHtmlAsPdf(html);
// C# string interpolation
var html = $@"
<html>
<body>
    <h1>Invoice</h1>
    <p>Customer: {customerName}</p>
    <p>Amount: {amount}</p>
    {GenerateItemsTable(invoiceItems)}
</body>
</html>";

var pdf = renderer.RenderHtmlAsPdf(html);
Dim html As String = $"
<html>
<body>
    <h1>Invoice</h1>
    <p>Customer: {customerName}</p>
    <p>Amount: {amount}</p>
    {GenerateItemsTable(invoiceItems)}
</body>
</html>"

Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Notes de migration essentielles

Supprimer tout le code HTTP

Le changement le plus important est l'élimination des dépendances de réseau.IronPDFs'exécute localement - pas de RestClient, pas d'appels API, pas de gestion des réponses :

// CraftMyPDF- HTTP required
var client = new RestClient("https://api.craftmypdf.com/v1/create");
var request = new RestRequest(Method.POST);
request.AddHeader("X-API-KEY", "your-api-key");
var response = await client.ExecuteAsync(request);

//IronPDF- no HTTP
var pdf = renderer.RenderHtmlAsPdf(html);
// CraftMyPDF- HTTP required
var client = new RestClient("https://api.craftmypdf.com/v1/create");
var request = new RestRequest(Method.POST);
request.AddHeader("X-API-KEY", "your-api-key");
var response = await client.ExecuteAsync(request);

//IronPDF- no HTTP
var pdf = renderer.RenderHtmlAsPdf(html);
Imports RestSharp

' CraftMyPDF- HTTP required
Dim client As New RestClient("https://api.craftmypdf.com/v1/create")
Dim request As New RestRequest(Method.POST)
request.AddHeader("X-API-KEY", "your-api-key")
Dim response = Await client.ExecuteAsync(request)

' IronPDF- no HTTP
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Supprimer le code de limitation de vitesse

CraftMyPDF impose des limites de débit API nécessitant une logique de relance.IronPDF n'a pas de limites :

// CraftMyPDF- needed to avoid 429 errors
await Task.Delay(100);
if (response.StatusCode == TooManyRequests) { /* retry */ }

//IronPDF- no limits, just generate
var pdf = renderer.RenderHtmlAsPdf(html);
// Remove all rate limit code!
// CraftMyPDF- needed to avoid 429 errors
await Task.Delay(100);
if (response.StatusCode == TooManyRequests) { /* retry */ }

//IronPDF- no limits, just generate
var pdf = renderer.RenderHtmlAsPdf(html);
// Remove all rate limit code!
$vbLabelText   $csharpLabel

Supprimer les gestionnaires de hooks Web

CraftMyPDF utilise des webhooks asynchrones pour compléter les PDF.IronPDF est synchrone - le PDF est prêt immédiatement :

// CraftMyPDF- webhook callback required
// POST with webhook_url, wait for callback

//IronPDF- PDF ready immediately
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// No callback needed!
// CraftMyPDF- webhook callback required
// POST with webhook_url, wait for callback

//IronPDF- PDF ready immediately
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// No callback needed!
' CraftMyPDF- webhook callback required
' POST with webhook_url, wait for callback

' IronPDF- PDF ready immediately
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
' No callback needed!
$vbLabelText   $csharpLabel

Sync par défaut

Supprimer les motifs async/await s'ils n'étaient nécessaires que pour les appels HTTP :

// CraftMyPDF- async required
var response = await client.ExecuteAsync(request);

//IronPDF- sync by default (async available if needed)
var pdf = renderer.RenderHtmlAsPdf(html);
// CraftMyPDF- async required
var response = await client.ExecuteAsync(request);

//IronPDF- sync by default (async available if needed)
var pdf = renderer.RenderHtmlAsPdf(html);
' CraftMyPDF- async required
Dim response = Await client.ExecuteAsync(request)

' IronPDF- sync by default (async available if needed)
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Liste de contrôle post-migration

Après avoir effectué la migration du code, vérifiez les points suivants :

  • Exécuter tous les tests de génération de PDF
  • Comparer la qualité de sortie (le moteur Chromium d'IronPDF offre un rendu pixel perfect)
  • Mesurer l'amélioration des performances (millisecondes contre secondes)
  • Vérifiez que tous les modèles ont été correctement convertis.
  • Tester le traitement par lots sans limite de débit
  • Tester dans tous les environnements cibles
  • Mise à jour des pipelines CI/CD
  • Annuler l'abonnement à CraftMyPDF
  • Supprimer la clé API du répertoire secrets/config

Ressources supplémentaires

La migration de CraftMyPDFvers IronPDF élimine les dépendances au cloud, la latence du réseau, les coûts par PDF et le verrouillage des modèles tout en offrant un rendu Chromium au pixel près qui fonctionne hors ligne. Le passage des appels à l'API REST aux invocations de méthodes locales simplifie votre base de code et conserve les données documentaires sensibles au sein de votre infrastructure.

[[i: (CraftMyPDF est une marque déposée de son propriétaire respectif. Ce site n'est pas affilié, approuvé, ou parrainé par CraftMyPDF. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.)]]

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

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 ...

Lire la suite

Articles connexes

Mis à jour

Comment définir des tailles de papier personnalisées pour les PDF en utilisant C# | IronPDF

Découvrez comment rendre des fichiers PDF avec des tailles de papier personnalisées en utilisant C# et IronPDF. Cette vidéo vous guide à travers la génération de PDF adaptés à des modèles non standards, idéale pour créer des documents personnalisés tels que des invitations, des affiches ou des rapports personnalisés. Améliorez votre processus de création de documents avec facilité.

Lire la suite
Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi