Kann IronPDF nativ in Xamarin.Forms verwendet werden?

IronPDF läuft nicht nativ in Xamarin.Forms, kann jedoch mithilfe eines serverseitigen Ansatzes integriert werden, um die PDF-Erstellung und -Manipulation zu steuern.

Welche Vorteile bietet die Verwendung von IronPDF für die PDF-Erzeugung in mobilen Apps?

Die Verwendung von IronPDF ermöglicht es Ihnen, PDF-Dateien zu erstellen, Formulare auszufüllen, mehrere Seiten zu bearbeiten und Bilder, Schriftarten und benutzerdefinierte Layouts einzuschließen, wodurch die PDF-Erstellungsmöglichkeiten Ihrer mobilen Apps verbessert werden.

Wie geht IronPDF mit der PDF-Erstellung in Xamarin um?

IronPDF verwendet einen serverseitigen Ansatz zur PDF-Erstellung in Xamarin, der komplexe PDF-Funktionen ermöglicht, die normalerweise auf mobilen Geräten nicht unterstützt werden.

Ist es möglich, PDF-Formulare mit IronPDF in Xamarin auszufüllen?

Ja, IronPDF unterstützt das Ausfüllen von PDF-Formularen als Teil seiner umfassenden PDF-Handhabungsfunktionen für Xamarin-Anwendungen.

Welche Herausforderungen adressiert IronPDF bei der PDF-Erstellung in Xamarin?

IronPDF adressiert Herausforderungen wie Fehler und fehlende Funktionalitäten bei der direkten PDF-Erstellung auf mobilen Geräten durch die Nutzung einer serverseitigen Lösung.

Kann IronPDF benutzerdefinierte Layouts in PDFs für Xamarin-Apps handhaben?

Ja, IronPDF kann benutzerdefinierte Layouts in erstellte PDFs einfügen, sodass Sie die Kontrolle über das Design und die Präsentation Ihrer Dokumente haben.

Welche Art von PDF-Funktionen können in Xamarin mit IronPDF implementiert werden?

IronPDF ermöglicht die Implementierung von Funktionen wie mehrseitigen Dokumenten, Formularausfüllung, Bild- und Schrifteinbindung sowie benutzerdefinierte Layouts in Xamarin.

Warum wird ein serverseitiger Ansatz für die PDF-Erstellung mit IronPDF in Xamarin empfohlen?

Ein serverseitiger Ansatz wird empfohlen, weil er die Einschränkungen mobiler Geräte umgeht, um eine zuverlässige PDF-Erstellung und fortgeschrittene Funktionen sicherzustellen.

What common issues might arise when using IronPDF in a Xamarin app, and how can they be addressed?

Typical issues include request timeouts or large PDF sizes. Solutions involve adjusting HTTP timeouts, using blob storage for large PDFs, securing endpoints with JWT, and embedding fonts directly in HTML.

What considerations should be made when deploying IronPDF for production use?

Ensure secure storage of licensing keys, use HTTPS for API endpoints, implement authentication, consider caching rendered PDFs, and monitor application performance for optimal scaling and reliability.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

IRONPDF NUTZEN

Dynamische PDF-Erzeugung in C# mit IronPDF

Curtis Chau

Updated: 12. Juli 2026

PDF-Dateien in Xamarin.Forms zu erstellen kann knifflig sein. Die meisten .NET PDF-Bibliotheken unterstützen mobile Apps nicht direkt, und der Versuch, PDF-Dokumente auf einem Gerät zu generieren, führt oft zu Fehlern oder fehlender Funktionalität. Genau hier kommt IronPDF ins Spiel.

IronPDF läuft zwar nicht nativ in einer Xamarin.Forms-App, aber ein serverseitiger API-Ansatz überbrückt diese Lücke elegant. Ihre mobile App sendet HTML-Inhalte an die API und erhält im Gegenzug fertige PDF-Dateien – so erhalten Sie Zugriff auf die Professional PDF-Generierung inklusive Formularen, Kopf- und Fußzeilen, Bildern und benutzerdefinierten Layouts.

Wichtiger Hinweis: Microsoft hat den Support für Xamarin im Mai 2024 eingestellt. Für neue Projekte wird .NET MAUI als Nachfolger empfohlen, da es IronPDF direkter unterstützt. Dieser Leitfaden behandelt das serverseitige Muster für ältere Xamarin-Projekte, die noch gewartet werden, und erläutert den Migrationspfad zu MAUI für Teams, die von Grund auf neu beginnen.

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.

IronPDF installieren

Installieren Sie IronPDF über NuGet mit einem der folgenden Befehle:

PM > Install-Package IronPdf

Install-Package IronPdf

PDF-Controller erstellen

Nachdem IronPDF installiert ist, fügen Sie einen Controller hinzu, der HTML akzeptiert und ein PDF zurückgibt:

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

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

ChromePdfRenderer verwendet eine auf Chromium basierende Engine, um HTML genau so darzustellen, wie es ein moderner Browser tun würde. Die HTML-zu-PDF-Konvertierung berücksichtigt CSS-Animationen, eingebettete Schriftarten, SVG-Grafiken und JavaScript-generierte Inhalte. Papierformat und Randeinstellungen werden direkt in das endgültige Dokumentlayout übernommen.

Kopf- und Fußzeilen hinzufügen

Für Professional Dokumente sollten Kopf- und Fußzeilen vor dem Aufruf des Renderers hinzugefügt werden:

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

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

Seitennummern-Token wie {page} und {total-pages} werden zur Renderzeit automatisch aufgelöst.

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

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

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

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 externe Dateiverzeichnis der App und registrieren Sie ein FileProvider im Manifest, damit Sie den URI an einen PDF-Viewer-Intent übergeben können. Der DependencyService.Get<ISaveFile>()-Aufruf im gemeinsamen Code ruft zur Laufzeit diejenige Implementierung ab, die für die aktuelle Plattform registriert ist.

Alles miteinander verkabeln

Kombinieren Sie in Ihrer Xamarin.Forms-Seite oder Ihrem ViewModel den Dienst und den Plattform-Saver:

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

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

Dadurch wird die gespeicherte PDF-Datei in dem vom Benutzer installierten Viewer geöffnet, typischerweise einer nativen PDF-Anwendung sowohl unter iOS als auch unter Android.

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

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 häufige Anforderung für mobile Business-Apps – Verträge, Onboarding-Fragebögen und Inspektionschecklisten profitieren alle von vorab ausgefüllten editierbaren 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

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:

Häufige Probleme und empfohlene Lösungen für die Xamarin- IronPDF -API-Integration
Ausgabe	Ursache	Empfohlene Lösung
Zeitüberschreitung der Anfrage	Komplexes HTML mit vielen externen Ressourcen benötigt Zeit zum Rendern.	Erhöhen Sie `HttpClient.Timeout` und legen Sie das serverseitige Rendering-Timeout in den Rendering-Optionen fest.
Großer Anstieg des PDF-Speicherbedarfs	Streaming einer 20 MB großen PDF-Datei über den Antworttext	In den Blob-Speicher hochladen und stattdessen eine kurzlebige Download-URL zurückgeben
Offline-Generierung	Das Gerät hat keine Verbindung, wenn der Benutzer eine PDF-Datei anfordert.	Anfragen lokal in die Warteschlange stellen und erneut versuchen, sobald die Verbindung wiederhergestellt ist.
Unautorisierter API-Zugriff	Der Endpunkt ist mit dem Internet verbunden.	Sicherung mit JWT oder API-Schlüssel; HTTPS auf allen Routen erzwingen
Schriftart nicht eingebettet	Auf dem Server-Betriebssystem ist die Schriftart nicht installiert.	Binden Sie die Schriftart als Base64-Daten-URI oder als CSS-Regel `@font-face` in den HTML-Code ein.
iOS-Speicherberechtigung	Die App zielt auf iOS 14+ mit strengerer Sandbox-Umgebung ab.	Schreiben Sie in `Environment.SpecialFolder.MyDocuments` innerhalb der App-Sandbox

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 eingebaute Abhängigkeitsinjektion von MAUI 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."))

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.

Checkliste für die Produktionsbereitstellung

Checkliste für die Bereitstellung einer IronPDF-basierten PDF-Generierungs-API
Element	Empfehlung
Lizenzschlüssel	Speichern Sie die Daten in Umgebungsvariablen oder einem Geheimnismanager, niemals im Quellcode.
HTTPS	TLS sollte für alle API-Endpunkte erzwungen werden; HTML-Nutzdaten sollten niemals über unverschlüsseltes HTTP gesendet werden.
Authentifizierung	Verwenden Sie JWT-Bearer-Token oder API-Schlüssel; widerrufen Sie diese bei Verstößen.
Caching	Um redundante Renderings zu vermeiden, werden identische HTML-Nutzdaten für eine kurze TTL zwischengespeichert.
Skalierung	IronPDF ist threadsicher; mehrere API-Replikate können hinter einem Load Balancer betrieben werden.
Überwachung	Renderverzögerung und Fehlerraten überwachen; bei Spitzenwerten über dem Basiswert eine Warnung ausgeben

Das serverseitige Muster skaliert horizontal, ohne dass Änderungen am Xamarin- oder MAUI-Client erforderlich sind. Fügen Sie Replikate hinzu, wenn das Volumen der PDF-Generierung zunimmt, und verlassen Sie sich darauf, dass der Load Balancer die Anfragen gleichmäßig verteilt.

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.

...