Wie man eine PDF-Datei als E-Mail-Anhang in C# sendet

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
dotnet add package IronPdf
Install-Package MailKit
dotnet add package MailKit

Install-Package IronPdf
dotnet add package IronPdf
Install-Package MailKit
dotnet add package 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?

Die Klasse ChromePdfRenderer ist der Einstiegspunkt für die HTML-zu-PDF-Konvertierung . Übergibt man eine HTML-Zeichenkette an RenderHtmlAsPdf, erhält man ein PdfDocument-Objekt zurück, das vollständig im Speicher gehalten wird. Greifen Sie über die Eigenschaft BinaryData auf die Rohbytes zu – dieses Byte-Array entspricht genau dem, was E-Mail-Anhang-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 Methode RenderHtmlAsPdf analysiert das HTML mit derselben Chromium-Engine, die auch Google Chrome antreibt, sodass Tabellen, CSS Grid, Flexbox und eingebettete Schriftarten genau so gerendert werden wie im Browser. Das Ergebnis ist ein PdfDocument, dessen BinaryData Eigenschaft die vollständige PDF-Binärdatei ohne jegliche Lese- und Schreibvorgänge auf der Festplatte zurückgibt. Bei Dokumenten, die externe Bilder oder Stylesheets einbinden, verwenden Sie den optionalen Parameter BasePath, um IronPDF mitzuteilen, wo relative Ressourcen-URLs aufgelöst werden sollen – dies wird ausführlich auf der Anleitungsseite "HTML-Datei zu PDF" 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 Hilfsklasse BodyBuilder vereinfacht den häufigen Fall eines Text- oder HTML-Bodys 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 angibt. 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 handelt einen verschlüsselten Kanal mit dem SMTP-Server auf Port 587 aus. Verwenden Sie für Gmail ein App-Passwort anstelle Ihres Kontopassworts: Generieren Sie eines unter Google-Kontosicherheit > App-Passwörter und übermitteln Sie es dann an AuthenticateAsync. Für Microsoft 365 konfigurieren Sie die OAuth 2.0-Authentifizierung über die MailKit-Klasse SaslMechanismOAuth2, falls 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 auf ältere .NET Versionen abzielen, oder Projekte, bei denen das Hinzufügen eines NuGet Pakets von Drittanbietern nicht zulässig ist, übernimmt der integrierte Namespace System.Net.Mail 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 zu MailKit besteht darin, dass System.Net.Mail.Attachment kein Byte-Array direkt akzeptiert – Sie müssen pdf.BinaryData zuerst in MemoryStream einbetten. Sowohl MailMessage als auch SmtpClient sind in using-Anweisungen eingebettet, welche die SMTP-Verbindung trennen und den zugrunde liegenden Datenstrom nach dem Senden leeren. Wenn Sie using bei MailMessage weglassen, kann es bei einigen Laufzeitumgebungen vorkommen, dass der Anhangsstream verworfen wird, bevor der Sendevorgang abgeschlossen ist.

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 außerdem einen 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 Komprimierungseinstellungen von IronPDF. Die Methode PdfDocument.CompressImages reduziert die Auflösung eingebetteter Bitmaps nach dem Rendern. Rufen Sie es an, bevor Sie lesen BinaryData:

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 Anleitungsseite zum Aufteilen und Zusammenführen von PDFs zeigt, wie man eine PdfDocument-Datei mithilfe von CopyPages-Seitenbereichen aufteilt.

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

Was sind Ihre nächsten Schritte?

Sie verfügen nun über eine funktionierende Vorlage, um mit IronPDF eine PDF-Datei im Speicher zu generieren und diese anschließend als E-Mail-Anhang entweder mit MailKit oder mit System.Net.Mail zu versenden. Der In-Memory-Ansatz eliminiert Lese- und Schreibvorgänge auf der Festplatte, vereinfacht containerisierte Bereitstellungen und skaliert auf Szenarien mit hohem Durchsatz, ohne dass eine Bereinigung temporärer Dateien 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.