Créer des fichiers PDF dans Xamarin.Forms peut être compliqué. La plupart des bibliothèques PDF .NET ne prennent pas directement en charge les applications mobiles, et la tentative de génération de documents PDF sur un appareil conduit souvent à des erreurs ou à des fonctionnalités manquantes. C'est là qu'intervient IronPDF .
Bien IronPDF ne s'exécute pas nativement dans une application Xamarin.Forms, une approche API côté serveur comble parfaitement cette lacune. Votre application mobile envoie du contenu HTML à l'API et reçoit en retour des fichiers PDF finalisés, vous donnant ainsi accès à une génération de PDF Professional incluant des formulaires, des en-têtes, des pieds de page, des images et des mises en page personnalisées.
Note importante : Microsoft a mis fin au support de Xamarin en mai 2024. Pour les nouveaux projets, .NET MAUI est le successeur recommandé et prend en charge IronPDF de manière plus directe. Ce guide décrit le modèle côté serveur pour les projets Xamarin existants encore en maintenance et explique le processus de migration vers MAUI pour les équipes qui démarrent de nouveaux projets.
IronPDF excelle dans la conversion de contenu HTML en documents PDF soignés, avec une prise en charge complète du CSS, du JavaScript et des mises en page complexes. L'exécution IronPDF sur un serveur dédié, plutôt que dans une application mobile, permet de contourner les contraintes de la plateforme qui empêchent le rendu direct des PDF sur l'appareil sous iOS et Android.
Le modèle côté serveur offre plusieurs avantages concrets :
Le client Xamarin.Forms appelle l'API, reçoit un tableau d'octets, l'écrit dans le stockage local et ouvre éventuellement une visionneuse PDF. Le serveur gère tout le reste.
Commencez par créer un projet d'API Web ASP.NET Core . Il s'agit d'une API minimale standard .NET 10 que vous pouvez héberger n'importe où : Azure App Service, AWS, un serveur sur site ou un conteneur Docker.
Installez IronPDF depuis NuGet à l'aide de l'une de ces commandes :
Une fois IronPDF installé, ajoutez un contrôleur qui accepte du HTML et renvoie un PDF :
using IronPdf;
using Microsoft.AspNetCore.Mvc;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
var app = builder.Build();
app.MapControllers();
app.Run();
namespace PdfGenerationApi.Controllers
{
[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
[HttpPost("generate")]
public async Task<IActionResult> GeneratePdf([FromBody] PdfRequest request)
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;
var pdf = await renderer.RenderHtmlAsPdfAsync(request.HtmlContent);
return File(pdf.BinaryData, "application/pdf", "document.pdf");
}
}
public class PdfRequest
{
public string HtmlContent { get; set; } = string.Empty;
}
}Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllers()
Dim app = builder.Build()
app.MapControllers()
app.Run()
Namespace PdfGenerationApi.Controllers
<ApiController>
<Route("api/[controller]")>
Public Class PdfController
Inherits ControllerBase
<HttpPost("generate")>
Public Async Function GeneratePdf(<FromBody> request As PdfRequest) As Task(Of IActionResult)
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.MarginLeft = 20
renderer.RenderingOptions.MarginRight = 20
Dim pdf = Await renderer.RenderHtmlAsPdfAsync(request.HtmlContent)
Return File(pdf.BinaryData, "application/pdf", "document.pdf")
End Function
End Class
Public Class PdfRequest
Public Property HtmlContent As String = String.Empty
End Class
End NamespaceChromePdfRenderer utilise un moteur basé sur Chromium pour rendre le HTML exactement comme le ferait un navigateur moderne. La conversion HTML vers PDF respecte les animations CSS, les polices intégrées, les graphiques SVG et le contenu généré par JavaScript. Le format du papier et les marges sont directement répercutés dans la mise en page finale du document.
Pour les documents Professional , ajoutez des en-têtes et des pieds de page avant d'appeler le moteur de rendu :
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
HtmlFragment = "<div style='text-align:right; font-size:12px; color:#555;'>Confidential -- Page {page} of {total-pages}</div>",
DrawDividerLine = true
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
HtmlFragment = "<div style='text-align:center; font-size:11px;'>Generated by MyCompany App</div>"
};Imports System
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
.HtmlFragment = "<div style='text-align:right; font-size:12px; color:#555;'>Confidential -- Page {page} of {total-pages}</div>",
.DrawDividerLine = True
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
.HtmlFragment = "<div style='text-align:center; font-size:11px;'>Generated by MyCompany App</div>"
}Les jetons de numéro de page comme {page} et {total-pages} sont résolus automatiquement au moment du rendu.
Dans l'application Xamarin.Forms, créez une classe de service qui appelle l'API. Le service doit rester léger : sa seule fonction est de sérialiser la charge utile HTML, de l'envoyer et de renvoyer les octets PDF bruts à l'appelant.
using System.Net.Http;
using System.Text;
using System.Text.Json;
namespace XamarinPdfApp.Services
{
public class PdfService
{
private readonly HttpClient _httpClient;
private const string ApiUrl = "https://your-api.example.com/api/pdf/generate";
public PdfService()
{
_httpClient = new HttpClient
{
Timeout = TimeSpan.FromSeconds(60)
};
}
public async Task<byte[]> GeneratePdfAsync(string htmlContent)
{
var payload = new { HtmlContent = htmlContent };
var json = JsonSerializer.Serialize(payload);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await _httpClient.PostAsync(ApiUrl, content);
if (response.IsSuccessStatusCode)
return await response.Content.ReadAsByteArrayAsync();
var error = await response.Content.ReadAsStringAsync();
throw new InvalidOperationException($"PDF generation failed ({(int)response.StatusCode}): {error}");
}
}
}Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Namespace XamarinPdfApp.Services
Public Class PdfService
Private ReadOnly _httpClient As HttpClient
Private Const ApiUrl As String = "https://your-api.example.com/api/pdf/generate"
Public Sub New()
_httpClient = New HttpClient With {
.Timeout = TimeSpan.FromSeconds(60)
}
End Sub
Public Async Function GeneratePdfAsync(htmlContent As String) As Task(Of Byte())
Dim payload = New With {Key .HtmlContent = htmlContent}
Dim json = JsonSerializer.Serialize(payload)
Dim content = New StringContent(json, Encoding.UTF8, "application/json")
Dim response = Await _httpClient.PostAsync(ApiUrl, content)
If response.IsSuccessStatusCode Then
Return Await response.Content.ReadAsByteArrayAsync()
End If
Dim error = Await response.Content.ReadAsStringAsync()
Throw New InvalidOperationException($"PDF generation failed ({CInt(response.StatusCode)}): {error}")
End Function
End Class
End NamespaceUn délai d'attente de 60 secondes permet de gérer les documents HTML complexes comportant de nombreuses images ou ressources CSS. Pour les fichiers très volumineux, envisagez de renvoyer une URL de téléchargement pré-signée depuis l'API au lieu de diffuser directement le fichier binaire ; cela permet de maintenir une utilisation prévisible de la mémoire mobile.
Une fois que le service a renvoyé le tableau d'octets, écrivez-le dans le stockage de l'appareil et ouvrez-le dans la visionneuse PDF de la plateforme. Xamarin.Forms utilise le modèle DependencyService pour appeler des implémentations spécifiques à la plateforme.
Définir l'interface dans le code partagé :
using System.Threading.Tasks;
namespace XamarinPdfApp.Interfaces
{
public interface ISaveFile
{
Task<string> SavePdfAsync(string filename, byte[] pdfData);
}
}Imports System.Threading.Tasks
Namespace XamarinPdfApp.Interfaces
Public Interface ISaveFile
Function SavePdfAsync(filename As String, pdfData As Byte()) As Task(Of String)
End Interface
End NamespaceEnregistrez l'implémentation iOS en utilisant DependencyService :
using Foundation;
using QuickLook;
using UIKit;
using XamarinPdfApp.Interfaces;
using Xamarin.Forms;
[assembly: Dependency(typeof(XamarinPdfApp.iOS.SaveFileIOS))]
namespace XamarinPdfApp.iOS
{
public class SaveFileIOS : ISaveFile
{
public async Task<string> SavePdfAsync(string filename, byte[] pdfData)
{
var documents = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
var filePath = System.IO.Path.Combine(documents, filename);
await System.IO.File.WriteAllBytesAsync(filePath, pdfData);
return filePath;
}
}
}Imports Foundation
Imports QuickLook
Imports UIKit
Imports XamarinPdfApp.Interfaces
Imports Xamarin.Forms
<Assembly: Dependency(GetType(XamarinPdfApp.iOS.SaveFileIOS))>
Namespace XamarinPdfApp.iOS
Public Class SaveFileIOS
Implements ISaveFile
Public Async Function SavePdfAsync(filename As String, pdfData As Byte()) As Task(Of String) Implements ISaveFile.SavePdfAsync
Dim documents = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
Dim filePath = System.IO.Path.Combine(documents, filename)
Await System.IO.File.WriteAllBytesAsync(filePath, pdfData)
Return filePath
End Function
End Class
End NamespacePour Android, écrivez dans le répertoire des fichiers externes de l'application et enregistrez un FileProvider dans le manifeste pour pouvoir transmettre l'URI à une intention de visualisation PDF. L'appel DependencyService.Get<ISaveFile>() dans le code partagé récupère quelle que soit l'implémentation enregistrée pour la plateforme actuelle à l'exécution.
Dans votre page Xamarin.Forms ou votre ViewModel, combinez le service et le module de sauvegarde de la plateforme :
var htmlContent = BuildInvoiceHtml(invoice);
var pdfBytes = await _pdfService.GeneratePdfAsync(htmlContent);
var saver = DependencyService.Get<ISaveFile>();
var filePath = await saver.SavePdfAsync("invoice.pdf", pdfBytes);
await Launcher.OpenAsync(new OpenFileRequest
{
File = new ReadOnlyFile(filePath, "application/pdf")
});Dim htmlContent = BuildInvoiceHtml(invoice)
Dim pdfBytes = Await _pdfService.GeneratePdfAsync(htmlContent)
Dim saver = DependencyService.Get(Of ISaveFile)()
Dim filePath = Await saver.SavePdfAsync("invoice.pdf", pdfBytes)
Await Launcher.OpenAsync(New OpenFileRequest With {
.File = New ReadOnlyFile(filePath, "application/pdf")
})Cela ouvre le PDF enregistré dans la visionneuse installée par l'utilisateur, généralement une application PDF native sur iOS et Android.
La qualité d'un PDF dépend presque entièrement de la qualité du modèle HTML transmis au moteur de rendu. Utilisez l'interpolation de chaînes C# ou une bibliothèque de modèles comme Scriban pour créer du HTML piloté par les données :
public string BuildInvoiceHtml(Invoice invoice)
{
var rows = string.Join(
"\n",
invoice.Éléments.Select(i =>
$"<tr><td>{i.Name}</td><td>{i.Quantity}</td><td>${i.UnitPrice:F2}</td><td>${i.Total:F2}</td></tr>"
)
);
return $@"<!DOCTYPE html>
<html lang='en'>
<head>
<meta charset='UTF-8'>
<style>
body {{font-family: Arial, sans-serif; color: #333; margin: 0; padding: 30px;}}
h1 {{color: #1a73e8;}}
table {{width: 100%; border-collapse: collapse; margin-top: 20px;}}
th {{background: #1a73e8; color: #fff; padding: 10px; text-align: left;}}
td {{padding: 10px; border-bottom: 1px solid #e0e0e0;}}
.total {{font-weight: bold; font-size: 1.1em; text-align: right; margin-top: 15px;}}
</style>
</head>
<body>
<h1>Invoice #{invoice.Number}</h1>
<p>Date: {invoice.Date:yyyy-MM-dd} | Due: {invoice.DueDate:yyyy-MM-dd}</p>
<p>Bill to: <strong>{invoice.ClientName}</strong></p>
<table>
<thead><tr><th>Élément</th><th>Qty</th><th>Unit Price</th><th>Total</th></tr></thead>
<tbody>{rows}</tbody>
</table>
<p class='total'>Grand Total: ${invoice.GrandTotal:F2}</p>
</body>
</html>";
}Le ChromePdfRenderer rend ce modèle exactement comme le ferait un navigateur. Vous pouvez ajouter des filigranes à l'aide de l'API de filigranes d'IronPDF ou appliquer des modèles de filigranes personnalisés aux brouillons confidentiels. Pour les documents nécessitant un champ de signature, la fonction de signature d'IronPDF vous permet d'intégrer des espaces réservés pour les signatures numériques côté serveur.
Les formulaires PDF sont une exigence courante pour les applications mobiles d'entreprise -- les contrats, les questionnaires d'intégration et les listes de contrôle d'inspection bénéficient tous de champs éditables préremplis. L'API serveur peut accepter les données de champ en plus du modèle HTML et intégrer les valeurs du formulaire avant de renvoyer le PDF :
[HttpPost("form")]
public async Task<IActionResult> GenerateForm([FromBody] FormRequest request)
{
var renderer = new ChromePdfRenderer();
// Render an HTML form template to create an interactive PDF form
var pdf = await renderer.RenderHtmlAsPdfAsync(request.HtmlTemplate);
// Fill known values before returning
var form = pdf.Form;
foreach (var field in request.FieldValues)
{
var pdfField = form.Fields.FirstOrDefault(f => f.Name == field.Key);
if (pdfField is IronPdf.Forms.PdfFormTextFieldField textField)
textField.Value = field.Value;
}
return File(pdf.BinaryData, "application/pdf", "form.pdf");
}Imports Microsoft.AspNetCore.Mvc
Imports IronPdf
<HttpPost("form")>
Public Async Function GenerateForm(<FromBody> request As FormRequest) As Task(Of IActionResult)
Dim renderer As New ChromePdfRenderer()
' Render an HTML form template to create an interactive PDF form
Dim pdf = Await renderer.RenderHtmlAsPdfAsync(request.HtmlTemplate)
' Fill known values before returning
Dim form = pdf.Form
For Each field In request.FieldValues
Dim pdfField = form.Fields.FirstOrDefault(Function(f) f.Name = field.Key)
If TypeOf pdfField Is IronPdf.Forms.PdfFormTextFieldField Then
Dim textField = DirectCast(pdfField, IronPdf.Forms.PdfFormTextFieldField)
textField.Value = field.Value
End If
Next
Return File(pdf.BinaryData, "application/pdf", "form.pdf")
End FunctionLe client mobile envoie un dictionnaire de noms de champs et de valeurs. Le serveur les remplit et renvoie un formulaire que l'utilisateur peut consulter, compléter les champs restants dans une visionneuse PDF, puis soumettre.
Au-delà de la génération, IronPDF prend en charge un large éventail d'opérations sur les documents que vous pouvez exposer en tant que points de terminaison d'API :
Chacun d'eux devient un point de terminaison d'API distinct. Le client Xamarin les appelle comme n'importe quelle autre ressource REST, ce qui permet de garder le code mobile exempt de logique PDF et de faire du serveur le processeur de documents faisant autorité.
L'architecture serveur-client est simple, mais plusieurs points relatifs à la production méritent d'être pris en compte :
| Enjeu | Cause | Correction recommandée |
|---|---|---|
| Délai d'attente dépassé | Le rendu d'un HTML complexe contenant de nombreuses ressources distantes peut prendre du temps. | Augmentez le délai d'expiration du rendu côté serveur HttpClient.Timeout et définissez-le dans les options de rendu. |
| Pic de mémoire PDF important | Diffusion d'un PDF de 20 Mo via le corps de réponse | Téléversez les données vers le stockage Blob et renvoyez une URL de téléchargement éphémère à la place. |
| Génération hors ligne | L'appareil n'est pas connecté lorsque l'utilisateur demande un PDF. | Mettre les requêtes en file d'attente locale et réessayer lorsque la connexion est rétablie. |
| Accès API non autorisé | Le point d'accès est ouvert à Internet. | Sécurisez avec un jeton JWT ou une clé API ; imposez le protocole HTTPS sur tous les itinéraires. |
| Police non incorporée | Le système d'exploitation du serveur ne possède pas la police installée. | Incorporez la police dans le code HTML sous forme d'URI de données base64 ou sous forme de règle CSS @font-face |
| Autorisation de stockage iOS | L'application cible iOS 14 et versions ultérieures avec un sandboxing plus strict. | Écrivez dans Environment.SpecialFolder.MyDocuments à l'intérieur du bac à sable de l'application. |
Pour limiter le débit, ajoutez un middleware côté ASP.NET Core à l'aide d'une bibliothèque telle que AspNetCoreRateLimit . Enregistrez chaque requête de génération avec des données de temps afin de pouvoir repérer les modèles lents avant qu'ils n'affectent les utilisateurs.
Si vous lancez un nouveau projet mobile en 2026, .NET MAUI est le choix idéal. Microsoft a mis fin au support de Xamarin en mai 2024, ce qui signifie qu'il n'y aura plus de correctifs de sécurité ni de mises à jour de bogues. .NET MAUI est le successeur direct et fonctionne sous .NET 10, correspondant à l'environnement d'exécution IronPDF actuel.
L'architecture côté serveur décrite dans ce guide fonctionne de manière identique pour les applications .NET MAUI ; le code HTTP client est essentiellement le même ; seul DependencyService est remplacé par l'injection de dépendance intégrée de MAUI. Les équipes qui maintiennent des applications Xamarin existantes devraient planifier une migration vers MAUI ; Le guide officiel de migration .NET MAUI de Microsoft documente les étapes en détail.
Le déploiement est simple : conteneurisez l'API ASP.NET Core avec Docker et déployez-la sur Azure App Service, AWS ECS ou n'importe quel cluster Kubernetes. La clé de licence IronPDF est définie comme variable d'environnement sur le serveur :
IronPdf.License.LicenseKey = Environment.GetEnvironmentVariable("IRONPDF_LICENSE_KEY")
?? throw new InvalidOperationException("IronPDF license key not set.");Imports System
Imports IronPdf
IronPdf.License.LicenseKey = If(Environment.GetEnvironmentVariable("IRONPDF_LICENSE_KEY"), Throw New InvalidOperationException("IronPDF license key not set."))Consultez la page relative aux licences IronPDF pour sélectionner le niveau de licence adapté à votre déploiement. Une licence d'essai gratuite vous permet de tester l'ensemble des fonctionnalités avant de vous engager. Pour les déploiements conteneurisés ou sans serveur, vérifiez que le niveau de licence couvre le nombre d'instances de serveur exécutées simultanément.
Après l'obtention de la licence, consultez la documentation IronPDF pour découvrir les options de configuration avancées, notamment les paramètres de rendu thread-safe, la conformité PDF/A et le balisage d'accessibilité.
| Élément | Recommandation |
|---|---|
| Clé de licence | Stockez-les dans des variables d'environnement ou un gestionnaire de secrets, jamais dans le code source. |
| HTTPS | Imposer le protocole TLS sur tous les points de terminaison de l'API ; ne jamais envoyer de données HTML via HTTP non chiffré. |
| Authentification | Utilisez des jetons porteurs JWT ou des clés API ; révoquez-les en cas de violation de sécurité. |
| Mise en cache | Mettre en cache les charges utiles HTML identiques pendant une courte durée de vie afin de réduire les rendus redondants. |
| Mise à l'échelle | IronPDF est compatible avec le multithreading ; exécutez plusieurs répliques de l'API derrière un équilibreur de charge. |
| Surveillance | Surveiller la latence de rendu et les taux d'erreur ; alerter en cas de pics au-dessus de la valeur de référence |
Le modèle côté serveur évolue horizontalement sans aucune modification du client Xamarin ou MAUI. Ajoutez des répliques à mesure que le volume de génération de PDF augmente et comptez sur l'équilibreur de charge pour répartir les requêtes de manière uniforme.
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.
