Xamarin PDF-Generator: Erstellen Sie mobile PDF-Apps mit IronPDF

Warum funktioniert ein serverseitiger Ansatz für die mobile PDF-Generierung?

IronPDF zeichnet sich durch die Umwandlung von HTML-Inhalten in ansprechende PDF-Dokumente mit voller Unterstützung für CSS, JavaScript und komplexe Layouts aus. Die Ausführung von IronPDF auf einem dedizierten Server – anstatt innerhalb einer mobilen Anwendung – umgeht die Plattformbeschränkungen, die das direkte Rendern von PDFs auf iOS und Android verhindern.

Das serverseitige Modell bietet mehrere konkrete Vorteile:

• Einheitliche Ausgabe: Schriftarten, Bilder und CSS werden serverseitig aufgelöst, wodurch Darstellungsunterschiede zwischen Android- und iOS-Hardware vermieden werden.
• Funktionszugriff: IronPDF Funktionen wie die Erstellung von PDF-Formularen, digitale Signaturen, Wasserzeichen und mehrseitige Layouts sind auf dem Server uneingeschränkt verfügbar.
• Leichtere mobile App: Das Gerät sendet lediglich eine HTTP-Anfrage und speichert die zurückgegebenen PDF-Bytes – es läuft keine ressourcenintensive PDF-Engine auf dem Telefon.
• Zentralisierte Lizenzierung: Eine einzige IronPDF Lizenz deckt Ihre Serverbereitstellung ab, anstatt jedes Gerät separat zu lizenzieren.

Der Xamarin.Forms-Client ruft die API auf, empfängt ein Byte-Array, schreibt es in den lokalen Speicher und öffnet optional einen PDF-Viewer. Der Server kümmert sich um alles Weitere.

Wie richtet man eine IronPDF PDF-Generierungs-API ein?

Beginnen Sie mit der Erstellung eines ASP.NET Core Web API-Projekts. Dies ist eine standardmäßige minimale .NET 10 API, die Sie überall hosten können – im Azure App Service, in AWS, auf einem lokalen Server oder in einem Docker-Container.

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

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;
    }
}

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 Namespace

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>"
};

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>"
}

Wie implementiert man den Xamarin-Client?

Erstellen Sie in der Xamarin.Forms-Anwendung eine Serviceklasse, die die API aufruft. Der Dienst sollte schlank gehalten werden – seine einzige Aufgabe besteht darin, die HTML-Nutzdaten zu serialisieren, sie zu senden und die rohen PDF-Bytes an den Aufrufer zurückzugeben.

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}");
        }
    }
}

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 Namespace

Ein Timeout von 60 Sekunden berücksichtigt komplexe HTML-Dokumente mit vielen Bildern oder CSS-Ressourcen. Bei sehr großen Dateien empfiehlt es sich, von der API eine vorab signierte Download-URL zurückzugeben, anstatt die Binärdatei direkt zu streamen – dadurch bleibt die Speichernutzung auf Mobilgeräten vorhersehbar.

Wie speichert und öffnet man PDF-Dateien auf dem Gerät?

Sobald der Dienst das Byte-Array zurückgibt, schreiben Sie es in den Gerätespeicher und öffnen Sie es im PDF-Viewer der Plattform. Xamarin.Forms verwendet das DependencyService-Muster, um plattformspezifische Implementierungen aufzurufen.

Die Schnittstelle im gemeinsamen Code definieren:

using System.Threading.Tasks;

namespace XamarinPdfApp.Interfaces
{
    public interface ISaveFile
    {
        Task<string> SavePdfAsync(string filename, byte[] pdfData);
    }
}

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 Namespace

Registrieren Sie die iOS-Implementierung mit 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;
        }
    }
}

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 Namespace

Für Android schreiben Sie in das Verzeichnis für externe Dateien der App und tragen ein FileProvider in das Manifest ein, damit Sie die URI an einen PDF-Viewer weitergeben können. Der Aufruf DependencyService.Get<ISaveFile>() in gemeinsam genutztem Code ruft die Implementierung ab, die für die aktuelle Plattform zur Laufzeit registriert ist.

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")
});

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")
})

Wie erstellt man Professional Rechnungs- und Berichts-PDFs?

Die Qualität einer PDF-Datei hängt fast ausschließlich von der Qualität der an den Renderer übergebenen HTML-Vorlage ab. Verwenden Sie C#-Stringinterpolation oder eine Template-Bibliothek wie Scriban, um datengesteuertes HTML zu erstellen:

public string BuildInvoiceHtml(Invoice invoice)
{
    var rows = string.Join(
        "\n",
        invoice.Elements.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} &nbsp;|&nbsp; Due: {invoice.DueDate:yyyy-MM-dd}</p>
  <p>Bill to: <strong>{invoice.ClientName}</strong></p>
  <table>
    <thead><tr><th>Element</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>";
}

public string BuildInvoiceHtml(Invoice invoice)
{
    var rows = string.Join(
        "\n",
        invoice.Elements.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} &nbsp;|&nbsp; Due: {invoice.DueDate:yyyy-MM-dd}</p>
  <p>Bill to: <strong>{invoice.ClientName}</strong></p>
  <table>
    <thead><tr><th>Element</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>";
}

Imports System
Imports System.Linq

Public Function BuildInvoiceHtml(invoice As Invoice) As String
    Dim rows = String.Join(
        vbLf,
        invoice.Elements.Select(Function(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} &nbsp;|&nbsp; Due: {invoice.DueDate:yyyy-MM-dd}</p>
  <p>Bill to: <strong>{invoice.ClientName}</strong></p>
  <table>
    <thead><tr><th>Element</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>"
End Function

Der ChromePdfRenderer rendert diese Vorlage genau so, wie es ein Browser tun würde. Sie können Wasserzeichen mithilfe der IronPDF-Wasserzeichen-API hinzufügen oder benutzerdefinierte Wasserzeichendesigns für vertrauliche Entwürfe anwenden. Bei Dokumenten, die ein Unterschriftenfeld erfordern, ermöglicht die Signaturunterstützung von IronPDF das serverseitige Einbetten von Platzhaltern für digitale Signaturen.

Wie verarbeitet man PDF-Formulare in einer Xamarin-App?

PDF-Formulare sind eine gängige Voraussetzung für mobile Geschäftsanwendungen – Verträge, Onboarding-Fragebögen und Inspektionschecklisten profitieren alle von vorausgefüllten, bearbeitbaren Feldern. Die Server-API kann Felddaten zusammen mit der HTML-Vorlage entgegennehmen und Formularwerte einbetten, bevor sie das PDF zurückgibt:

[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");
}

[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 Function

Der mobile Client sendet ein Wörterbuch mit Feldnamen und Werten. Der Server füllt die Felder aus und sendet ein Formular zurück, das der Benutzer überprüfen, die restlichen Felder in einem PDF-Viewer ausfüllen und anschließend absenden kann.

Wie extrahiert man Text und führt PDFs aus einer Xamarin-App zusammen?

Über die Dokumentenerstellung hinaus unterstützt IronPDF eine breite Palette von Dokumentoperationen, die Sie als API-Endpunkte bereitstellen können:

• Text aus PDF extrahieren : PDF-Inhalte analysieren, um Dokumente zu indexieren oder Dateneingabeformulare vorauszufüllen.
• PDFs zusammenführen oder aufteilen : Mehrere Berichte zu einer einzigen PDF-Datei kombinieren oder ein großes Dokument in separate Dateien für einzelne Abschnitte aufteilen.
• PDF in Bild konvertieren : PDF-Seiten als PNG- oder JPEG-Miniaturansichten zur Vorschau in der mobilen Benutzeroberfläche rendern.

Jeder dieser Punkte wird zu einem separaten API-Endpunkt. Der Xamarin-Client ruft sie wie jede andere REST-Ressource auf, wodurch der mobile Code frei von PDF-Logik bleibt und der Server als maßgeblicher Dokumentenverarbeiter fungiert.

Welche Probleme treten häufig auf und wie lassen sie sich beheben?

Die Server-Client-Architektur ist unkompliziert, aber einige Aspekte im Produktionsbetrieb verdienen Beachtung:

Zur Ratenbegrenzung fügen Sie Middleware auf der ASP.NET Core Seite mithilfe einer Bibliothek wie AspNetCoreRateLimit hinzu. Protokollieren Sie jede Generierungsanforderung mit Zeitangaben, damit Sie langsame Vorlagen erkennen können, bevor sie sich auf die Benutzer auswirken.

Sollten Sie von Xamarin zu .NET MAUI migrieren?

Wenn Sie 2026 ein neues mobiles Projekt starten, ist .NET MAUI die richtige Wahl. Microsoft hat den Support für Xamarin im Mai 2024 eingestellt, sodass keine weiteren Sicherheitsupdates oder Fehlerbehebungen mehr bereitgestellt werden. .NET MAUI ist der direkte Nachfolger und läuft unter .NET 10, was der aktuellen IronPDF Laufzeitumgebung entspricht.

Die in diesem Leitfaden beschriebene serverseitige Architektur funktioniert identisch für .NET MAUI Anwendungen – der Client-HTTP-Code ist im Wesentlichen derselbe; nur der DependencyService wird durch die in MAUI eingebaute Dependency Injection ersetzt. Teams, die bestehende Xamarin-Anwendungen betreuen, sollten eine Migration zu MAUI planen; Der offizielle .NET MAUI Migrationsleitfaden von Microsoft dokumentiert die einzelnen Schritte detailliert.

Wie implementiert und lizenziert man IronPDF für den Produktiveinsatz?

Die Bereitstellung ist unkompliziert: Die ASP.NET Core API wird mit Docker containerisiert und anschließend in Azure App Service, AWS ECS oder einem beliebigen Kubernetes-Cluster bereitgestellt. Der IronPDF Lizenzschlüssel ist als Umgebungsvariable auf dem Server festgelegt:

IronPdf.License.LicenseKey = Environment.GetEnvironmentVariable("IRONPDF_LICENSE_KEY")
    ?? throw new InvalidOperationException("IronPDF license key not set.");

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

Auf der IronPDF -Lizenzseite finden Sie die passende Lizenzstufe für Ihre Anwendung. Mit einer kostenlosen Testlizenz können Sie den vollen Funktionsumfang testen, bevor Sie sich endgültig entscheiden. Bei containerisierten oder serverlosen Bereitstellungen prüfen Sie, ob die Lizenzstufe die Anzahl der gleichzeitig laufenden Serverinstanzen abdeckt.

Nach der Lizenzierung sollten Sie die IronPDF -Dokumentation für erweiterte Konfigurationsoptionen erkunden, darunter Thread-sichere Rendering-Einstellungen, PDF/A-Konformität und Accessibility-Tagging.