Comment ajouter des signatures numériques PDF dans ASP.NET Core

Qu'est-ce qu'une signature numérique PDF et pourquoi est-elle importante ?

Une signature numérique est un mécanisme cryptographique qui lie l'identité du signataire à une version spécifique d'un document. Elle diffère d'une simple signature électronique — telle qu'un nom dactylographié ou une image scannée — car elle utilise la cryptographie à clé publique pour créer un sceau vérifiable et inviolable.

Lorsqu'une personne signe numériquement un PDF, le logiciel de signature génère un hachage du contenu du document et chiffre ce hachage avec la clé privée du signataire. La signature ainsi obtenue est intégrée au PDF, à côté du certificat public du signataire. Tout lecteur PDF prenant en charge les signatures numériques — y compris Adobe Acrobat Reader et les visionneuses PDF intégrées aux navigateurs modernes — peut déchiffrer le hachage avec la clé publique et le comparer à un hachage fraîchement calculé du document. Si les hachages correspondent, le document est authentique et non modifié.

Comment installer IronPDF dans un projet ASP.NET Core ?

Le moyen le plus rapide d'obtenir un environnement de signature fonctionnel est le package NuGet . Ouvrez la console du Package Manager dans Visual Studio et exécutez :

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

Vous pouvez également cliquer avec le bouton droit sur le projet dans l'Explorateur de solutions, choisir " Gérer les packages NuGet ", rechercher IronPdf et cliquer sur Installer. Après l'installation, ajoutez les directives using suivantes en haut de votre contrôleur ou de votre classe de service :

using IronPdf;
using IronPdf.Signing;

using IronPdf;
using IronPdf.Signing;

Imports IronPdf
Imports IronPdf.Signing

IronPDF cible .NET 8 et .NET 9/10, il s'intègre donc naturellement aux projets ASP.NET Core modernes. Pour une présentation détaillée de la première configuration, consultez le guide de démarrage rapide IronPDF .

Comment signer un PDF avec un fichier de certificat dans ASP.NET Core?

La méthode de signature la plus courante utilise un fichier de certificat .pfx ou .p12. Ces fichiers regroupent la clé privée et la chaîne de certificats publics dans une seule archive protégée par mot de passe. Vous pouvez en obtenir un auprès d'une autorité de certification (AC) de confiance telle que DigiCert ou GlobalSign , ou générer un certificat auto-signé pour le développement et les tests.

L'exemple ci-dessous génère un PDF à partir de HTML et applique une signature numérique basée sur un certificat :

using IronPdf;
using IronPdf.Signing;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/sign-with-certificate", (IWebHostEnvironment env) =>
{
    // Generate a PDF from HTML content
    var renderer = new ChromePdfRenderer();
    var document = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1><p>Terms and conditions...</p>");

    // Locate the PFX certificate on the server
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");

    // Build the signature object
    var signature = new PdfSignature(certPath, "yourPassword")
    {
        SigningContact = "legal@yourcompany.com",
        SigningLocation = "Chicago, IL, USA",
        SigningReason = "Document Approval"
    };

    // Apply the signature and save
    document.Sign(signature);
    string outputPath = Path.Combine(Path.GetTempPath(), "signed-contract.pdf");
    document.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "signed-contract.pdf");
});

app.Run();

using IronPdf;
using IronPdf.Signing;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/sign-with-certificate", (IWebHostEnvironment env) =>
{
    // Generate a PDF from HTML content
    var renderer = new ChromePdfRenderer();
    var document = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1><p>Terms and conditions...</p>");

    // Locate the PFX certificate on the server
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");

    // Build the signature object
    var signature = new PdfSignature(certPath, "yourPassword")
    {
        SigningContact = "legal@yourcompany.com",
        SigningLocation = "Chicago, IL, USA",
        SigningReason = "Document Approval"
    };

    // Apply the signature and save
    document.Sign(signature);
    string outputPath = Path.Combine(Path.GetTempPath(), "signed-contract.pdf");
    document.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "signed-contract.pdf");
});

app.Run();

Imports IronPdf
Imports IronPdf.Signing
Imports Microsoft.AspNetCore.Mvc

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapPost("/sign-with-certificate", Function(env As IWebHostEnvironment)
    ' Generate a PDF from HTML content
    Dim renderer = New ChromePdfRenderer()
    Dim document = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1><p>Terms and conditions...</p>")

    ' Locate the PFX certificate on the server
    Dim certPath As String = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx")

    ' Build the signature object
    Dim signature = New PdfSignature(certPath, "yourPassword") With {
        .SigningContact = "legal@yourcompany.com",
        .SigningLocation = "Chicago, IL, USA",
        .SigningReason = "Document Approval"
    }

    ' Apply the signature and save
    document.Sign(signature)
    Dim outputPath As String = Path.Combine(Path.GetTempPath(), "signed-contract.pdf")
    document.SaveAs(outputPath)

    Return Results.File(outputPath, "application/pdf", "signed-contract.pdf")
End Function)

app.Run()

ChromePdfRenderer convertit toute chaîne HTML ou URL valide en PDF. Le constructeur PdfSignature accepte le chemin du certificat et le mot de passe, et les propriétés facultatives (SigningContact, SigningLocation, SigningReason) ajoutent des métadonnées que les visionneuses PDF affichent dans le panneau de signature. La méthode Sign intègre la signature cryptographique, et SaveAs écrit le fichier signé sur le disque.

var stream = new MemoryStream();
document.SaveAs(stream);
stream.Position = 0;
return Results.File(stream, "application/pdf", "signed-contract.pdf");

var stream = new MemoryStream();
document.SaveAs(stream);
stream.Position = 0;
return Results.File(stream, "application/pdf", "signed-contract.pdf");

Dim stream As New MemoryStream()
document.SaveAs(stream)
stream.Position = 0
Return Results.File(stream, "application/pdf", "signed-contract.pdf")

Comment ajouter une image de signature visible à un PDF ?

Les signatures cryptographiques protègent l'intégrité des documents mais sont invisibles dans le PDF rendu. De nombreux processus de travail, notamment ceux impliquant des contrats ou des lettres, nécessitent également une représentation visible, telle qu'une signature manuscrite scannée ou un tampon d'entreprise, imprimé sur la page.

IronPDF prend en charge cela via la méthode LoadSignatureImageFromFile. La méthode accepte un chemin d'image, un index de page et un IronSoftware.Drawing.Rectangle qui définit la position et les dimensions de la signature visible :

using IronPdf;
using IronPdf.Signing;
using IronSoftware.Drawing;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/sign-with-visible-image", (IWebHostEnvironment env) =>
{
    // Load an existing PDF (for example, an invoice template)
    string pdfPath = Path.Combine(env.ContentRootPath, "Documents", "invoice.pdf");
    var document = PdfDocument.FromFile(pdfPath);

    // Paths to the certificate and the signature image
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");
    string imagePath = Path.Combine(env.ContentRootPath, "Images", "signature.png");

    // Define where the visible signature appears (x, y, width, height in points)
    var signatureArea = new Rectangle(50, 680, 200, 80);

    var signature = new PdfSignature(certPath, "yourPassword");
    signature.LoadSignatureImageFromFile(imagePath, pageIndex: 0, signatureArea);

    document.Sign(signature);
    string outputPath = Path.Combine(Path.GetTempPath(), "signed-invoice.pdf");
    document.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "signed-invoice.pdf");
});

app.Run();

using IronPdf;
using IronPdf.Signing;
using IronSoftware.Drawing;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/sign-with-visible-image", (IWebHostEnvironment env) =>
{
    // Load an existing PDF (for example, an invoice template)
    string pdfPath = Path.Combine(env.ContentRootPath, "Documents", "invoice.pdf");
    var document = PdfDocument.FromFile(pdfPath);

    // Paths to the certificate and the signature image
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");
    string imagePath = Path.Combine(env.ContentRootPath, "Images", "signature.png");

    // Define where the visible signature appears (x, y, width, height in points)
    var signatureArea = new Rectangle(50, 680, 200, 80);

    var signature = new PdfSignature(certPath, "yourPassword");
    signature.LoadSignatureImageFromFile(imagePath, pageIndex: 0, signatureArea);

    document.Sign(signature);
    string outputPath = Path.Combine(Path.GetTempPath(), "signed-invoice.pdf");
    document.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "signed-invoice.pdf");
});

app.Run();

Imports IronPdf
Imports IronPdf.Signing
Imports IronSoftware.Drawing
Imports Microsoft.AspNetCore.Mvc

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapPost("/sign-with-visible-image", Function(env As IWebHostEnvironment)
    ' Load an existing PDF (for example, an invoice template)
    Dim pdfPath As String = Path.Combine(env.ContentRootPath, "Documents", "invoice.pdf")
    Dim document = PdfDocument.FromFile(pdfPath)

    ' Paths to the certificate and the signature image
    Dim certPath As String = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx")
    Dim imagePath As String = Path.Combine(env.ContentRootPath, "Images", "signature.png")

    ' Define where the visible signature appears (x, y, width, height in points)
    Dim signatureArea As New Rectangle(50, 680, 200, 80)

    Dim signature As New PdfSignature(certPath, "yourPassword")
    signature.LoadSignatureImageFromFile(imagePath, pageIndex:=0, signatureArea)

    document.Sign(signature)
    Dim outputPath As String = Path.Combine(Path.GetTempPath(), "signed-invoice.pdf")
    document.SaveAs(outputPath)

    Return Results.File(outputPath, "application/pdf", "signed-invoice.pdf")
End Function)

app.Run()

L'image de la signature visible est intégrée à la page spécifiée aux coordonnées que vous indiquez. La signature cryptographique est appliquée simultanément à l'ensemble du document, vous offrant ainsi sécurité et confirmation visuelle en une seule opération.

Si l'image réside en mémoire (récupérée d'une base de données ou d'un stockage cloud, par exemple), utilisez plutôt LoadSignatureImageFromStream. Pour un aperçu plus détaillé des options de signature visuelle, consultez le guide pratique de signature PDF .

Comment créer des champs de formulaire de signature pour les signataires externes ?

Dans certains processus, le document est créé par votre système mais doit être signé par une partie externe : un client, un partenaire ou un organisme de réglementation. Plutôt que de recueillir un certificat auprès de cette partie au préalable, vous intégrez un champ de formulaire de signature dédié dans le PDF et vous leur envoyez le document. Les destinataires ouvrent le PDF dans Adobe Acrobat Reader ou un autre lecteur compatible, cliquent sur le champ de signature et apposent leur propre certificat ou signature électronique.

using IronPdf;
using IronPdf.Forms;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/generate-signable-form", (IWebHostEnvironment env) =>
{
    // Render the document that requires a client signature
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(@"
        <h1>Client Service Agreement</h1>
        <p>Please review the terms below and sign in the field provided.</p>
        <p>By signing, you confirm acceptance of all listed terms and conditions.</p>
    ");

    // Define the signature field: name, page, x, y, width, height (in points)
    var signatureField = new SignatureFormField(
        "ClientSignature",
        pageIndex: 0,
        x: 50,
        y: 600,
        width: 300,
        height: 100
    );

    pdf.Form.Add(signatureField);

    string outputPath = Path.Combine(Path.GetTempPath(), "client-agreement.pdf");
    pdf.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "client-agreement.pdf");
});

app.Run();

using IronPdf;
using IronPdf.Forms;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/generate-signable-form", (IWebHostEnvironment env) =>
{
    // Render the document that requires a client signature
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(@"
        <h1>Client Service Agreement</h1>
        <p>Please review the terms below and sign in the field provided.</p>
        <p>By signing, you confirm acceptance of all listed terms and conditions.</p>
    ");

    // Define the signature field: name, page, x, y, width, height (in points)
    var signatureField = new SignatureFormField(
        "ClientSignature",
        pageIndex: 0,
        x: 50,
        y: 600,
        width: 300,
        height: 100
    );

    pdf.Form.Add(signatureField);

    string outputPath = Path.Combine(Path.GetTempPath(), "client-agreement.pdf");
    pdf.SaveAs(outputPath);

    return Results.File(outputPath, "application/pdf", "client-agreement.pdf");
});

app.Run();

Imports IronPdf
Imports IronPdf.Forms
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.Extensions.Hosting

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapGet("/generate-signable-form", Function(env As IWebHostEnvironment)
    ' Render the document that requires a client signature
    Dim renderer = New ChromePdfRenderer()
    Dim pdf = renderer.RenderHtmlAsPdf("
        <h1>Client Service Agreement</h1>
        <p>Please review the terms below and sign in the field provided.</p>
        <p>By signing, you confirm acceptance of all listed terms and conditions.</p>
    ")

    ' Define the signature field: name, page, x, y, width, height (in points)
    Dim signatureField = New SignatureFormField(
        "ClientSignature",
        pageIndex:=0,
        x:=50,
        y:=600,
        width:=300,
        height:=100
    )

    pdf.Form.Add(signatureField)

    Dim outputPath As String = Path.Combine(Path.GetTempPath(), "client-agreement.pdf")
    pdf.SaveAs(outputPath)

    Return Results.File(outputPath, "application/pdf", "client-agreement.pdf")
End Function)

app.Run()

Les paramètres du constructeur SignatureFormField correspondent directement à la position du champ sur la page. Lorsque le destinataire ouvre le PDF, il voit un cadre clairement délimité où sa signature doit être apposée. Le formulaire rempli peut alors être renvoyé à votre système, où vous pouvez le charger, valider la signature intégrée et l'archiver.

Pour en savoir plus sur la gestion des formulaires PDF, notamment la lecture des données des formulaires soumis, consultez le guide d'édition des formulaires PDF .

Comment vérifier une signature numérique par programmation ?

Une fois un document signé et retourné, il peut être nécessaire de vérifier que la signature est toujours valide et que le document n'a pas été altéré. IronPDF expose la vérification de signature via l'objet PdfDocument :

using IronPdf;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/verify-signature", (IWebHostEnvironment env) =>
{
    string signedPath = Path.Combine(env.ContentRootPath, "Documents", "signed-contract.pdf");
    var document = PdfDocument.FromFile(signedPath);

    // Retrieve all embedded signatures
    var signatures = document.GetSignatures();

    foreach (var sig in signatures)
    {
        bool isValid = sig.VerifySignature();
        string status = isValid
            ? $"Valid -- signed by {sig.SignerName} on {sig.SigningTime:D}"
            : "INVALID -- document may have been tampered with";

        Console.WriteLine(status);
    }

    return Results.Ok(new { SignatureCount = signatures.Count });
});

app.Run();

using IronPdf;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/verify-signature", (IWebHostEnvironment env) =>
{
    string signedPath = Path.Combine(env.ContentRootPath, "Documents", "signed-contract.pdf");
    var document = PdfDocument.FromFile(signedPath);

    // Retrieve all embedded signatures
    var signatures = document.GetSignatures();

    foreach (var sig in signatures)
    {
        bool isValid = sig.VerifySignature();
        string status = isValid
            ? $"Valid -- signed by {sig.SignerName} on {sig.SigningTime:D}"
            : "INVALID -- document may have been tampered with";

        Console.WriteLine(status);
    }

    return Results.Ok(new { SignatureCount = signatures.Count });
});

app.Run();

Imports IronPdf
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.Extensions.Hosting

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapGet("/verify-signature", Function(env As IWebHostEnvironment)
                                    Dim signedPath As String = Path.Combine(env.ContentRootPath, "Documents", "signed-contract.pdf")
                                    Dim document = PdfDocument.FromFile(signedPath)

                                    ' Retrieve all embedded signatures
                                    Dim signatures = document.GetSignatures()

                                    For Each sig In signatures
                                        Dim isValid As Boolean = sig.VerifySignature()
                                        Dim status As String = If(isValid,
                                            $"Valid -- signed by {sig.SignerName} on {sig.SigningTime:D}",
                                            "INVALID -- document may have been tampered with")

                                        Console.WriteLine(status)
                                    Next

                                    Return Results.Ok(New With {.SignatureCount = signatures.Count})
                                End Function)

app.Run()

GetSignatures() renvoie une liste de toutes les signatures numériques intégrées dans le PDF. Chaque objet PdfDigitalSignature expose VerifySignature(), le nom du signataire, l'horodatage de la signature et la chaîne de certificats. Ces informations suffisent pour constituer une piste d'audit ou un tableau de bord de gestion documentaire qui signale les PDF dont les signatures sont brisées ou expirées.

Comment gérez-vous la gestion des certificats en production ?

Stocker un fichier .pfx sur le système de fichiers fonctionne pendant le développement mais n'est pas adapté à la production. Les fichiers de certificats contiennent des clés privées, et si le fichier est compromis, tous les documents signés avec cette clé sont menacés.

string certBase64 = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT")
    ?? throw new InvalidOperationException("PDF_SIGNING_CERT environment variable is not set.");

byte[] certBytes = Convert.FromBase64String(certBase64);
string certPassword = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT_PASSWORD")
    ?? throw new InvalidOperationException("PDF_SIGNING_CERT_PASSWORD environment variable is not set.");

var signature = new PdfSignature(certBytes, certPassword);

string certBase64 = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT")
    ?? throw new InvalidOperationException("PDF_SIGNING_CERT environment variable is not set.");

byte[] certBytes = Convert.FromBase64String(certBase64);
string certPassword = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT_PASSWORD")
    ?? throw new InvalidOperationException("PDF_SIGNING_CERT_PASSWORD environment variable is not set.");

var signature = new PdfSignature(certBytes, certPassword);

Imports System

Dim certBase64 As String = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT")
If certBase64 Is Nothing Then
    Throw New InvalidOperationException("PDF_SIGNING_CERT environment variable is not set.")
End If

Dim certBytes As Byte() = Convert.FromBase64String(certBase64)
Dim certPassword As String = Environment.GetEnvironmentVariable("PDF_SIGNING_CERT_PASSWORD")
If certPassword Is Nothing Then
    Throw New InvalidOperationException("PDF_SIGNING_CERT_PASSWORD environment variable is not set.")
End If

Dim signature = New PdfSignature(certBytes, certPassword)

Comment signer plusieurs fichiers PDF par lots de manière efficace ?

Lorsque vous devez signer des dizaines ou des centaines de documents en une seule opération (par exemple, signer un lot entier de factures en fin de mois), le chargement du certificat une seule fois et la réutilisation de l'objet PdfSignature sur tous les documents réduisent la charge de travail :

using IronPdf;
using IronPdf.Signing;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/batch-sign", (IWebHostEnvironment env) =>
{
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");
    var signature = new PdfSignature(certPath, "yourPassword")
    {
        SigningReason = "Batch Invoice Approval"
    };

    string[] invoicePaths = Directory.GetFiles(
        Path.Combine(env.ContentRootPath, "Invoices"),
        "*.pdf"
    );

    string outputDir = Path.Combine(env.ContentRootPath, "Signed");
    Directory.CreateDirectory(outputDir);

    foreach (string invoicePath in invoicePaths)
    {
        var doc = PdfDocument.FromFile(invoicePath);
        doc.Sign(signature);
        string outputFile = Path.Combine(outputDir, Path.GetFileName(invoicePath));
        doc.SaveAs(outputFile);
    }

    return Results.Ok(new { SignedCount = invoicePaths.Length });
});

app.Run();

using IronPdf;
using IronPdf.Signing;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapPost("/batch-sign", (IWebHostEnvironment env) =>
{
    string certPath = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx");
    var signature = new PdfSignature(certPath, "yourPassword")
    {
        SigningReason = "Batch Invoice Approval"
    };

    string[] invoicePaths = Directory.GetFiles(
        Path.Combine(env.ContentRootPath, "Invoices"),
        "*.pdf"
    );

    string outputDir = Path.Combine(env.ContentRootPath, "Signed");
    Directory.CreateDirectory(outputDir);

    foreach (string invoicePath in invoicePaths)
    {
        var doc = PdfDocument.FromFile(invoicePath);
        doc.Sign(signature);
        string outputFile = Path.Combine(outputDir, Path.GetFileName(invoicePath));
        doc.SaveAs(outputFile);
    }

    return Results.Ok(new { SignedCount = invoicePaths.Length });
});

app.Run();

Imports IronPdf
Imports IronPdf.Signing

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapPost("/batch-sign", Function(env As IWebHostEnvironment)
    Dim certPath As String = Path.Combine(env.ContentRootPath, "Certificates", "certificate.pfx")
    Dim signature As New PdfSignature(certPath, "yourPassword") With {
        .SigningReason = "Batch Invoice Approval"
    }

    Dim invoicePaths As String() = Directory.GetFiles(
        Path.Combine(env.ContentRootPath, "Invoices"),
        "*.pdf"
    )

    Dim outputDir As String = Path.Combine(env.ContentRootPath, "Signed")
    Directory.CreateDirectory(outputDir)

    For Each invoicePath As String In invoicePaths
        Dim doc = PdfDocument.FromFile(invoicePath)
        doc.Sign(signature)
        Dim outputFile As String = Path.Combine(outputDir, Path.GetFileName(invoicePath))
        doc.SaveAs(outputFile)
    Next

    Return Results.Ok(New With {.SignedCount = invoicePaths.Length})
End Function)

app.Run()

Créer l'objet PdfSignature une seule fois en dehors de la boucle signifie que le fichier de certificat est lu et analysé une seule fois. Chaque itération charge, signe et enregistre un PDF individuel. Pour les très grands lots, envisagez de traiter les documents en parallèle en utilisant Parallel.ForEach -- Les opérations de signature d'IronPDF sont sûres pour les threads lorsque chaque instance PdfDocument est isolée dans un seul thread.

Comment résoudre les erreurs de signature courantes ?

Quelles sont vos prochaines étapes ?

La signature numérique de PDF dans ASP.NET Core devient simple une fois que vous comprenez les trois opérations principales : le chargement d'un certificat, l'appel de Sign et l'enregistrement du résultat. IronPDF prend en charge les aspects cryptographiques complexes afin que vous puissiez vous concentrer sur la logique métier de votre application.

Pour continuer à développer votre flux de travail documentaire, explorez ces sujets connexes :

• Comment générer des PDF à partir de HTML dans ASP.NET Core — la base de la plupart des flux de travail de signature
• Comment ajouter des mots de passe et des autorisations aux fichiers PDF ? – Combinez la signature et le chiffrement pour une sécurité maximale.
• Comment fusionner et diviser des fichiers PDF — assembler des ensembles de documents avant de signer
• Options de licence IronPDF : choisissez le plan qui convient à votre déploiement
• Package NuGet IronPDF -- consultez la dernière version et le journal des modifications

Commencez par un essai gratuit IronPDF et obtenez votre premier PDF signé en moins d'une heure. Si vous avez des questions ou rencontrez des cas particuliers, l' équipe d'assistance Iron Software est disponible pour vous aider à mettre en place un flux de travail de signature de documents fiable et conforme à la législation.