Wie man ein PDF in ein Bild in .NET konvertiert

Wie installiert man die benötigten Pakete?

Dieser Workflow wird von zwei Paketen unterstützt: einer Bibliothek zur PDF-Generierung und einer Bibliothek zum Versenden von E-Mails. Installieren Sie beides entweder über die Paket-Manager-Konsole in Visual Studio oder über die .NET -Befehlszeilenschnittstelle.

Install-Package IronPdf, MailKit

IronPDF verfügt über eine auf Chromium basierende Rendering-Engine , die HTML, CSS und JavaScript in pixelgenaue PDF-Dokumente umwandelt. Es läuft unter Windows, Linux und macOS, was bedeutet, dass derselbe Code in einer ASP.NET Core Web-API, einem Hintergrunddienst oder einer Azure-Funktion funktioniert. MailKit ist die Bibliothek, die Microsoft für die gesamte neue .NET -E-Mail-Entwicklung empfiehlt – sie unterstützt SMTP, IMAP, POP3, OAuth 2.0 und die vollständige MIME-Konstruktion. Der Quellcode und die Dokumentation von MailKit sind auf GitHub verfügbar.

Wie erzeugt man ein PDF-Dokument im Speicher?

The ChromePdfRenderer class is the entry point for HTML to PDF conversion. Übergeben Sie einen HTML-String an RenderHtmlAsPdf und Sie erhalten ein PdfDocument-Objekt zurück, das sich vollständig im Speicher befindet. Greifen Sie auf die Rohbytes über die BinaryData-Eigenschaft zu – dieses Byte-Array ist genau das, was E-Mail-Anhangs-APIs erwarten.

using IronPdf;

var renderer = new ChromePdfRenderer();

string htmlContent = """
    <h1>Order Confirmation</h1>
    <p>Thank you for your purchase.</p>
    <table>
        <tr><th>Item</th><th>Qty</th><th>Price</th></tr>
        <tr><td>Widget A</td><td>2</td><td>$19.99</td></tr>
        <tr><td>Widget B</td><td>1</td><td>$59.99</td></tr>
    </table>
    <p><strong>Order Total: $99.97</strong></p>
    """;

PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);

// pdf.BinaryData holds the complete PDF as a byte array
byte[] pdfBytes = pdf.BinaryData;
Console.WriteLine($"PDF generated: {pdfBytes.Length} bytes");

using IronPdf;

var renderer = new ChromePdfRenderer();

string htmlContent = """
    <h1>Order Confirmation</h1>
    <p>Thank you for your purchase.</p>
    <table>
        <tr><th>Item</th><th>Qty</th><th>Price</th></tr>
        <tr><td>Widget A</td><td>2</td><td>$19.99</td></tr>
        <tr><td>Widget B</td><td>1</td><td>$59.99</td></tr>
    </table>
    <p><strong>Order Total: $99.97</strong></p>
    """;

PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);

// pdf.BinaryData holds the complete PDF as a byte array
byte[] pdfBytes = pdf.BinaryData;
Console.WriteLine($"PDF generated: {pdfBytes.Length} bytes");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

Dim htmlContent As String = "
    <h1>Order Confirmation</h1>
    <p>Thank you for your purchase.</p>
    <table>
        <tr><th>Item</th><th>Qty</th><th>Price</th></tr>
        <tr><td>Widget A</td><td>2</td><td>$19.99</td></tr>
        <tr><td>Widget B</td><td>1</td><td>$59.99</td></tr>
    </table>
    <p><strong>Order Total: $99.97</strong></p>
    "

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

' pdf.BinaryData holds the complete PDF as a byte array
Dim pdfBytes As Byte() = pdf.BinaryData
Console.WriteLine($"PDF generated: {pdfBytes.Length} bytes")

Die RenderHtmlAsPdf-Methode analysiert das HTML mit derselben Chromium-Engine, die Google Chrome antreibt, sodass Tabellen, CSS Raster, Flexbox und eingebettete Schriften genau wie in einem Browser gerendert werden. Das Ergebnis ist ein PdfDocument, dessen BinaryData-Eigenschaft das vollständige PDF-Binär ohne jeglichen Festplattenzugriff zurückgibt. Für Dokumente, die externe Bilder oder Stylesheets einbinden, verwenden Sie den optionalen BasePath-Parameter, um IronPDF mitzuteilen, wo relative Ressourcen-URLs aufgelöst werden sollen – dies wird detailliert auf der HTML-Datei zu PDF Anleitung behandelt.

using IronPdf;

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop    = 15;
renderer.RenderingOptions.MarginBottom = 15;
renderer.RenderingOptions.MarginLeft   = 12;
renderer.RenderingOptions.MarginRight  = 12;

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='font-size:9pt;color:#666;text-align:right;'>Monthly Report</div>",
    DrawDividerLine = true
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='font-size:8pt;text-align:center;'>{page} of {total-pages}</div>"
};

PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Monthly Summary</h1><p>See attached data.</p>");
byte[] pdfBytes = pdf.BinaryData;

using IronPdf;

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop    = 15;
renderer.RenderingOptions.MarginBottom = 15;
renderer.RenderingOptions.MarginLeft   = 12;
renderer.RenderingOptions.MarginRight  = 12;

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='font-size:9pt;color:#666;text-align:right;'>Monthly Report</div>",
    DrawDividerLine = true
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='font-size:8pt;text-align:center;'>{page} of {total-pages}</div>"
};

PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Monthly Summary</h1><p>See attached data.</p>");
byte[] pdfBytes = pdf.BinaryData;

Imports IronPdf

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.MarginTop = 15
renderer.RenderingOptions.MarginBottom = 15
renderer.RenderingOptions.MarginLeft = 12
renderer.RenderingOptions.MarginRight = 12

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='font-size:9pt;color:#666;text-align:right;'>Monthly Report</div>",
    .DrawDividerLine = True
}

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='font-size:8pt;text-align:center;'>{page} of {total-pages}</div>"
}

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Monthly Summary</h1><p>See attached data.</p>")
Dim pdfBytes As Byte() = pdf.BinaryData

Wie kann man mit MailKit eine PDF-Datei an eine E-Mail anhängen?

MailKit erstellt direkt einen MIME-Nachrichtenbaum, wodurch Sie die volle Kontrolle über Inhaltstyp, Kodierung und Metadaten der Anhänge erhalten. Die BodyBuilder-Hilfsklasse vereinfacht den häufigen Fall eines Text- oder HTML-Körpers mit einem oder mehreren Dateianhängen.

using IronPdf;
using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;

// Step 1 -- generate the PDF in memory
var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Monthly Report</h1><p>Generated automatically.</p>");

// Step 2 -- build the email message
var message = new MimeMessage();
message.From.Add(new MailboxAddress("Reports Service", "reports@example.com"));
message.To.Add(new MailboxAddress("Alice Smith", "alice@example.com"));
message.Subject = "Your Monthly Report is Ready";

var builder = new BodyBuilder();
builder.TextBody = "Hello Alice,\n\nPlease find your monthly report attached.\n\nRegards,\nReports Service";
builder.HtmlBody = "<p>Hello Alice,</p><p>Please find your monthly report attached.</p>";

// Add the in-memory PDF as an attachment
builder.Attachments.Add("MonthlyReport.pdf", pdf.BinaryData, new ContentType("application", "pdf"));
message.Body = builder.ToMessageBody();

// Step 3 -- send via SMTP with TLS
using var client = new SmtpClient();
await client.ConnectAsync("smtp.example.com", 587, SecureSocketOptions.StartTls);
await client.AuthenticateAsync("username", "app-password");
await client.SendAsync(message);
await client.DisconnectAsync(true);

using IronPdf;
using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;

// Step 1 -- generate the PDF in memory
var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Monthly Report</h1><p>Generated automatically.</p>");

// Step 2 -- build the email message
var message = new MimeMessage();
message.From.Add(new MailboxAddress("Reports Service", "reports@example.com"));
message.To.Add(new MailboxAddress("Alice Smith", "alice@example.com"));
message.Subject = "Your Monthly Report is Ready";

var builder = new BodyBuilder();
builder.TextBody = "Hello Alice,\n\nPlease find your monthly report attached.\n\nRegards,\nReports Service";
builder.HtmlBody = "<p>Hello Alice,</p><p>Please find your monthly report attached.</p>";

// Add the in-memory PDF as an attachment
builder.Attachments.Add("MonthlyReport.pdf", pdf.BinaryData, new ContentType("application", "pdf"));
message.Body = builder.ToMessageBody();

// Step 3 -- send via SMTP with TLS
using var client = new SmtpClient();
await client.ConnectAsync("smtp.example.com", 587, SecureSocketOptions.StartTls);
await client.AuthenticateAsync("username", "app-password");
await client.SendAsync(message);
await client.DisconnectAsync(true);

Imports IronPdf
Imports MailKit.Net.Smtp
Imports MailKit.Security
Imports MimeKit

' Step 1 -- generate the PDF in memory
Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Monthly Report</h1><p>Generated automatically.</p>")

' Step 2 -- build the email message
Dim message As New MimeMessage()
message.From.Add(New MailboxAddress("Reports Service", "reports@example.com"))
message.To.Add(New MailboxAddress("Alice Smith", "alice@example.com"))
message.Subject = "Your Monthly Report is Ready"

Dim builder As New BodyBuilder()
builder.TextBody = "Hello Alice," & vbCrLf & vbCrLf & "Please find your monthly report attached." & vbCrLf & vbCrLf & "Regards," & vbCrLf & "Reports Service"
builder.HtmlBody = "<p>Hello Alice,</p><p>Please find your monthly report attached.</p>"

' Add the in-memory PDF as an attachment
builder.Attachments.Add("MonthlyReport.pdf", pdf.BinaryData, New ContentType("application", "pdf"))
message.Body = builder.ToMessageBody()

' Step 3 -- send via SMTP with TLS
Using client As New SmtpClient()
    Await client.ConnectAsync("smtp.example.com", 587, SecureSocketOptions.StartTls)
    Await client.AuthenticateAsync("username", "app-password")
    Await client.SendAsync(message)
    Await client.DisconnectAsync(True)
End Using

builder.Attachments.Add akzeptiert drei Argumente: den Dateinamen, den der Empfänger in seinem E-Mail-Client sieht, das rohe Byte-Array von pdf.BinaryData und eine ContentType-Instanz, die den MIME-Typ als application/pdf spezifiziert. Die asynchronen SMTP-Methoden halten den aufrufenden Thread frei, während die Netzwerkoperation abgeschlossen wird – ein entscheidender Vorteil bei ASP.NET Core -Controllern, die Dutzende von gleichzeitigen Anfragen verarbeiten.

SecureSocketOptions.StartTls verhandelt einen verschlüsselten Kanal mit dem SMTP-Server auf Port 587. Für Gmail verwenden Sie ein App-Passwort anstelle Ihres Kontopassworts: Erstellen Sie eines unter Google Account Security > App Passwords und übergeben Sie es dann an AuthenticateAsync. Für Microsoft 365 konfigurieren Sie die OAuth 2.0-Authentifizierung über die SaslMechanismOAuth2-Klasse von MailKit, wenn Ihr Mandant die Basisauthentifizierung deaktiviert hat.

message.To.Add(new MailboxAddress("Alice Smith",   "alice@example.com"));
message.To.Add(new MailboxAddress("Bob Jones",     "bob@example.com"));
message.Cc.Add(new MailboxAddress("Carol Manager", "carol@example.com"));

message.To.Add(new MailboxAddress("Alice Smith",   "alice@example.com"));
message.To.Add(new MailboxAddress("Bob Jones",     "bob@example.com"));
message.Cc.Add(new MailboxAddress("Carol Manager", "carol@example.com"));

message.To.Add(New MailboxAddress("Alice Smith", "alice@example.com"))
message.To.Add(New MailboxAddress("Bob Jones", "bob@example.com"))
message.Cc.Add(New MailboxAddress("Carol Manager", "carol@example.com"))

Wie kann man System .NET.Mail als Alternative verwenden?

Für Projekte, die ältere .NET-Versionen anvisieren oder wenn das Hinzufügen eines Drittanbieter-NuGet-Pakets nicht erlaubt ist, übernimmt der eingebaute System.Net.Mail-Namespace die grundlegende SMTP-Zustellung. Microsoft empfiehlt es nicht mehr für Neuentwicklungen, aber es deckt die gängigen Anwendungsfälle ohne zusätzliche Abhängigkeiten ab.

using IronPdf;
using System.Net;
using System.Net.Mail;

// Generate the PDF
var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Invoice #1001</h1><p>Amount due: $350.00</p>");

// Build the mail message
using var message = new MailMessage("invoices@example.com", "customer@example.com");
message.Subject = "Invoice #1001 Attached";
message.Body    = "Your invoice is attached to this email. Please remit payment within 30 days.";
message.IsBodyHtml = false;

// Wrap the byte array in a MemoryStream for the Attachment constructor
var stream = new MemoryStream(pdf.BinaryData);
message.Attachments.Add(new Attachment(stream, "Invoice-1001.pdf", "application/pdf"));

// Send via SMTP
using var client = new SmtpClient("smtp.example.com", 587)
{
    Credentials = new NetworkCredential("username", "password"),
    EnableSsl   = true
};
await client.SendMailAsync(message);

using IronPdf;
using System.Net;
using System.Net.Mail;

// Generate the PDF
var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Invoice #1001</h1><p>Amount due: $350.00</p>");

// Build the mail message
using var message = new MailMessage("invoices@example.com", "customer@example.com");
message.Subject = "Invoice #1001 Attached";
message.Body    = "Your invoice is attached to this email. Please remit payment within 30 days.";
message.IsBodyHtml = false;

// Wrap the byte array in a MemoryStream for the Attachment constructor
var stream = new MemoryStream(pdf.BinaryData);
message.Attachments.Add(new Attachment(stream, "Invoice-1001.pdf", "application/pdf"));

// Send via SMTP
using var client = new SmtpClient("smtp.example.com", 587)
{
    Credentials = new NetworkCredential("username", "password"),
    EnableSsl   = true
};
await client.SendMailAsync(message);

Imports IronPdf
Imports System.Net
Imports System.Net.Mail
Imports System.IO

' Generate the PDF
Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Invoice #1001</h1><p>Amount due: $350.00</p>")

' Build the mail message
Using message As New MailMessage("invoices@example.com", "customer@example.com")
    message.Subject = "Invoice #1001 Attached"
    message.Body = "Your invoice is attached to this email. Please remit payment within 30 days."
    message.IsBodyHtml = False

    ' Wrap the byte array in a MemoryStream for the Attachment constructor
    Dim stream As New MemoryStream(pdf.BinaryData)
    message.Attachments.Add(New Attachment(stream, "Invoice-1001.pdf", "application/pdf"))

    ' Send via SMTP
    Using client As New SmtpClient("smtp.example.com", 587)
        client.Credentials = New NetworkCredential("username", "password")
        client.EnableSsl = True
        Await client.SendMailAsync(message)
    End Using
End Using

Der Hauptunterschied im Vergleich zu MailKit besteht darin, dass System.Net.Mail.Attachment kein Byte-Array direkt akzeptiert – Sie müssen pdf.BinaryData zuerst in einem MemoryStream einhüllen. Sowohl MailMessage als auch SmtpClient werden in using-Anweisungen eingefasst, die die SMTP-Verbindung auflösen und den zugrunde liegenden Stream nach dem Senden spülen. Wenn Sie das using bei MailMessage weglassen, könnte der Anhangsstream in einigen Laufzeiten vor Abschluss des Sendens aufgelöst werden.

Wie lässt sich dieses Muster auf reale Geschäftsprozesse anwenden?

Das In-Memory-PDF-zu-E-Mail-Muster ist direkt anwendbar auf die Dokumentenautomatisierungsszenarien, die den meisten Geschäftsanwendungen zugrunde liegen.

app.MapPost("/checkout", async (CheckoutRequest req, IEmailService emailService) =>
{
    var renderer = new ChromePdfRenderer();
    PdfDocument receipt = renderer.RenderHtmlAsPdf(BuildReceiptHtml(req));

    // Fire and forget -- do not await so the HTTP response is immediate
    _ = emailService.SendReceiptAsync(req.CustomerEmail, receipt.BinaryData);

    return Results.Ok(new { message = "Order confirmed." });
});

app.MapPost("/checkout", async (CheckoutRequest req, IEmailService emailService) =>
{
    var renderer = new ChromePdfRenderer();
    PdfDocument receipt = renderer.RenderHtmlAsPdf(BuildReceiptHtml(req));

    // Fire and forget -- do not await so the HTTP response is immediate
    _ = emailService.SendReceiptAsync(req.CustomerEmail, receipt.BinaryData);

    return Results.Ok(new { message = "Order confirmed." });
});

Imports System.Threading.Tasks

app.MapPost("/checkout", Async Function(req As CheckoutRequest, emailService As IEmailService) As Task(Of IResult)
    Dim renderer As New ChromePdfRenderer()
    Dim receipt As PdfDocument = renderer.RenderHtmlAsPdf(BuildReceiptHtml(req))

    ' Fire and forget -- do not await so the HTTP response is immediate
    _ = emailService.SendReceiptAsync(req.CustomerEmail, receipt.BinaryData)

    Return Results.Ok(New With {.message = "Order confirmed."})
End Function)

Wie gehen Sie mit Fehlern und Wiederholungsversuchen um?

Netzwerkoperationen schlagen fehl. SMTP-Server sind vorübergehend nicht verfügbar, Authentifizierungstoken laufen ab und die Beschränkungen der Anhangsgröße variieren je nach Anbieter. Integrieren Sie von Anfang an Resilienz in den E-Mail-Versandprozess.

Die Sendelogik von MailKit wird in einen try/catch-Block eingeschlossen und Fehler werden in einer persistenten Warteschlange protokolliert, damit sie wiederholt werden können:

using IronPdf;
using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;
using Microsoft.Extensions.Logging;

async Task SendPdfEmailWithRetryAsync(
    byte[] pdfBytes,
    string recipientEmail,
    string subject,
    ILogger logger,
    int maxAttempts = 3)
{
    for (int attempt = 1; attempt <= maxAttempts; attempt++)
    {
        try
        {
            var message = new MimeMessage();
            message.From.Add(new MailboxAddress("Mailer", "mailer@example.com"));
            message.To.Add(MailboxAddress.Parse(recipientEmail));
            message.Subject = subject;

            var builder = new BodyBuilder { TextBody = "Your document is attached." };
            builder.Attachments.Add("document.pdf", pdfBytes, new ContentType("application", "pdf"));
            message.Body = builder.ToMessageBody();

            using var smtpClient = new SmtpClient();
            await smtpClient.ConnectAsync("smtp.example.com", 587, SecureSocketOptions.StartTls);
            await smtpClient.AuthenticateAsync("user", "pass");
            await smtpClient.SendAsync(message);
            await smtpClient.DisconnectAsync(true);

            logger.LogInformation("Email sent to {Email} on attempt {Attempt}", recipientEmail, attempt);
            return;
        }
        catch (Exception ex) when (attempt < maxAttempts)
        {
            logger.LogWarning(ex, "Send attempt {Attempt} failed. Retrying...", attempt);
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
    }
}

using IronPdf;
using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;
using Microsoft.Extensions.Logging;

async Task SendPdfEmailWithRetryAsync(
    byte[] pdfBytes,
    string recipientEmail,
    string subject,
    ILogger logger,
    int maxAttempts = 3)
{
    for (int attempt = 1; attempt <= maxAttempts; attempt++)
    {
        try
        {
            var message = new MimeMessage();
            message.From.Add(new MailboxAddress("Mailer", "mailer@example.com"));
            message.To.Add(MailboxAddress.Parse(recipientEmail));
            message.Subject = subject;

            var builder = new BodyBuilder { TextBody = "Your document is attached." };
            builder.Attachments.Add("document.pdf", pdfBytes, new ContentType("application", "pdf"));
            message.Body = builder.ToMessageBody();

            using var smtpClient = new SmtpClient();
            await smtpClient.ConnectAsync("smtp.example.com", 587, SecureSocketOptions.StartTls);
            await smtpClient.AuthenticateAsync("user", "pass");
            await smtpClient.SendAsync(message);
            await smtpClient.DisconnectAsync(true);

            logger.LogInformation("Email sent to {Email} on attempt {Attempt}", recipientEmail, attempt);
            return;
        }
        catch (Exception ex) when (attempt < maxAttempts)
        {
            logger.LogWarning(ex, "Send attempt {Attempt} failed. Retrying...", attempt);
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
    }
}

Imports IronPdf
Imports MailKit.Net.Smtp
Imports MailKit.Security
Imports MimeKit
Imports Microsoft.Extensions.Logging

Public Async Function SendPdfEmailWithRetryAsync(
    pdfBytes As Byte(),
    recipientEmail As String,
    subject As String,
    logger As ILogger,
    Optional maxAttempts As Integer = 3) As Task

    For attempt As Integer = 1 To maxAttempts
        Try
            Dim message = New MimeMessage()
            message.From.Add(New MailboxAddress("Mailer", "mailer@example.com"))
            message.To.Add(MailboxAddress.Parse(recipientEmail))
            message.Subject = subject

            Dim builder = New BodyBuilder With {
                .TextBody = "Your document is attached."
            }
            builder.Attachments.Add("document.pdf", pdfBytes, New ContentType("application", "pdf"))
            message.Body = builder.ToMessageBody()

            Using smtpClient = New SmtpClient()
                Await smtpClient.ConnectAsync("smtp.example.com", 587, SecureSocketOptions.StartTls)
                Await smtpClient.AuthenticateAsync("user", "pass")
                Await smtpClient.SendAsync(message)
                Await smtpClient.DisconnectAsync(True)
            End Using

            logger.LogInformation("Email sent to {Email} on attempt {Attempt}", recipientEmail, attempt)
            Return
        Catch ex As Exception When attempt < maxAttempts
            logger.LogWarning(ex, "Send attempt {Attempt} failed. Retrying...", attempt)
            Await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)))
        End Try
    Next
End Function

Exponentielles Backoff – 2 Sekunden nach dem ersten Fehler, 4 Sekunden nach dem zweiten – verhindert die Überlastung eines SMTP-Servers. In Produktionsanwendungen sollte die Wiederholungsschleife durch eine Message Queue (Azure Service Bus, RabbitMQ oder AWS SQS) ersetzt werden, damit Fehler auch nach einem Neustart der Anwendung erhalten bleiben.

IronPDF wirft auch eine PdfException, wenn der HTML-Inhalt nicht gerendert werden kann. Fangen Sie es separat von den SMTP-Ausnahmen ab, damit die Fehlermeldung spezifisch ist:

PdfDocument pdf;
try
{
    pdf = renderer.RenderHtmlAsPdf(htmlContent);
}
catch (IronPdf.Exceptions.PdfException ex)
{
    logger.LogError(ex, "PDF rendering failed");
    throw;
}

PdfDocument pdf;
try
{
    pdf = renderer.RenderHtmlAsPdf(htmlContent);
}
catch (IronPdf.Exceptions.PdfException ex)
{
    logger.LogError(ex, "PDF rendering failed");
    throw;
}

Imports IronPdf.Exceptions

Dim pdf As PdfDocument
Try
    pdf = renderer.RenderHtmlAsPdf(htmlContent)
Catch ex As PdfException
    logger.LogError(ex, "PDF rendering failed")
    Throw
End Try

Die Trennung von Darstellungsfehlern und Auslieferungsfehlern beschleunigt die Fehlersuche. Für einen umfassenderen Einblick in die Fehlerbehandlung in automatisierten Dokumentenpipelines bietet der 5-stufige Leitfaden zur PDF-Generierung detaillierte Informationen zu Validierungsmustern.

Wie kann die Anhangsgröße innerhalb der Anbietergrenzen gehalten werden?

Die meisten kommerziellen E-Mail-Anbieter legen eine maximale Anhangsgröße fest. Gmail beschränkt einzelne Anhänge auf 25 MB; Bei Microsoft 365 ist die Standardgröße für Standardpostfächer auf 20 MB festgelegt. Ein aufwändig gestalteter HTML-Bericht mit eingebetteten Bildern kann diese Grenzwerte unerwartet überschreiten.

Drei Techniken helfen dabei, innerhalb der Grenzen zu bleiben:

Komprimieren Sie Bilder vor dem Rendern. Eingebundene Bilder sollten komprimiertes JPEG oder WebP anstelle von unkomprimiertem PNG verwenden. Ein PNG-Logo mit 600 dpi kann die PDF-Datei um mehrere Megabyte vergrößern; Ein JPEG mit 85 % Qualität ist typischerweise unter 200 KB groß, bei gleichem visuellen Ergebnis.

Verwenden Sie die Kompressionseinstellungen von IronPDF. Die PdfDocument.CompressImages-Methode verringert die Auflösung eingebetteter Bitmaps nach dem Rendern. Rufen Sie es auf, bevor Sie BinaryData lesen:

pdf.CompressImages(60); // quality 0-100
byte[] compressedPdfBytes = pdf.BinaryData;

pdf.CompressImages(60); // quality 0-100
byte[] compressedPdfBytes = pdf.BinaryData;

pdf.CompressImages(60) ' quality 0-100
Dim compressedPdfBytes As Byte() = pdf.BinaryData

Teilen Sie umfangreiche Berichte in mehrere E-Mails auf. Falls ein Bericht auch nach der Komprimierung das Limit Ihres Anbieters überschreitet, erstellen Sie für jeden Abschnitt eine separate PDF-Datei und versenden Sie diese in einer separaten E-Mail. Die PDF-Aufteilungs- und Zusammenführungs-Anleitung zeigt, wie man ein PdfDocument mithilfe von CopyPages nach Seitenbereich unterteilt.

Externe Referenzen für SMTP-Größenbeschränkungen: Gmail-Anhangsbeschränkungen , Microsoft 365-Nachrichtengrößenbeschränkungen .

Was sind Ihre nächsten Schritte?

Sie haben jetzt eine funktionierende Vorlage, um ein PDF im Speicher mit IronPDF zu generieren und es als E-Mail-Anhang entweder mit MailKit oder System.Net.Mail zu senden. Der In-Memory-Ansatz eliminiert Festplattenlese- und Schreibzugriffe, vereinfacht containerisierte Bereitstellungen und skaliert auf Hochdurchsatzszenarien, ohne dass temporäre Datei Bereinigung erforderlich ist.

Um die Integration zu vertiefen:

• Lesen Sie das Tutorial "HTML zu PDF" , um komplexe Dokumentlayouts mit Kopf- und Fußzeilen sowie Seitennummerierung zu beherrschen.
• Erkunden Sie die benutzerdefinierten PDF-Rendering-Optionen , um Ränder, Seitengröße und JavaScript Ausführungstimeout zu steuern.
• Fügen Sie der generierten PDF-Datei vor dem Anhängen eine digitale Signatur hinzu, um den Empfängern fälschungssichere Dokumente zu bieten.
• Bereitstellung in Azure Functions oder App Service für die serverlose Dokumentenerstellung in großem Umfang.
• Testen Sie IronPDF kostenlos, um den vollen Funktionsumfang zu prüfen, bevor Sie sich für eine Produktionslizenz entscheiden, oder informieren Sie sich über die Lizenzoptionen und die Preisgestaltung für den Einsatz.