# E-Mails mit .NET senden

> Senden Sie E-Mails aus ASP.NET Core und .NET mit dem Emailit-NuGet-Paket, MailKit oder System.Net.Mail per SMTP und verifizieren Sie Emailit-Webhooks.

Diese Anleitung zeigt, wie Sie E-Mails aus einer .NET-App mit dem offiziellen NuGet-Paket `Emailit` senden, wie Sie stattdessen MailKit oder `System.Net.Mail` per SMTP verwenden und wie Sie Webhooks in einer Minimal API von ASP.NET Core verifizieren.

## Voraussetzungen

- .NET 8 oder neuer.
- Eine [verifizierte Versanddomain](/de/docs/domains/add-a-domain/), zum Beispiel `acme.com`.
- Ein [API-Schlüssel](/de/docs/developers/api-keys/). Ein reiner Sende-Schlüssel, der auf Ihre Domain beschränkt ist, genügt.
- Solange Ihr Workspace keinen [Produktionszugang](/de/docs/workspaces/production-access/) hat, können Sie nur an die Konto-E-Mail-Adressen von Workspace-Mitgliedern senden.

## SDK installieren

```bash
dotnet add package Emailit
```

## API-Schlüssel konfigurieren

ASP.NET Core liest die Konfiguration aus Umgebungsvariablen, in denen `__` die Abschnitte trennt. Setzen Sie in der Produktion `Emailit__ApiKey`:

```bash
```

Bewahren Sie den Schlüssel während der Entwicklung in den User Secrets statt in `appsettings.json` auf:

```bash
dotnet user-secrets init
dotnet user-secrets set "Emailit:ApiKey" "secret_••••••••••••••••••••••••••••••••"
```

## E-Mail senden

Registrieren Sie einen Client und injizieren Sie ihn in Ihre Endpunkte:

```csharp title="Program.cs"
using Emailit;
using Emailit.Options;
using Emailit.Resources;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton(new EmailitClient(builder.Configuration["Emailit:ApiKey"]!));

var app = builder.Build();

app.MapPost("/orders/{id}/confirm", (string id, EmailitClient emailit) =>
{
    Email email = emailit.Emails.Send(new EmailSendOptions
    {
        From = "Acme <orders@acme.com>",
        To = new[] { "ada@example.com" },
        Subject = $"Order {id} confirmed",
        Html = $"<p>We've received order {id}.</p>",
    });

    return Results.Ok(new { emailId = email.Id });
});

app.Run();
```

`Send` ist synchron; führen Sie Massenversände in einem Hintergrunddienst aus, damit die Request-Threads frei bleiben. Die Optionen akzeptieren außerdem `Cc`, `Bcc`, `ReplyTo`, `Attachments`, `Template` mit `Variables`, `ScheduledAt` und `Tracking`; siehe [E-Mail senden](/de/docs/api-reference/emails/send/).

Wenn Ihr Code bereits Objekte vom Typ `System.Net.Mail.MailMessage` erstellt, kann das SDK sie über die API senden:

```csharp
using System.Net.Mail;

var message = new MailMessage("orders@acme.com", "ada@example.com", "Order confirmed", "<p>Thanks!</p>")
{
    IsBodyHtml = true,
};

Email email = emailit.Emails.Send(message);
```

### Fehler behandeln

```csharp
using Emailit.Exceptions;

try
{
    emailit.Emails.Send(options);
}
catch (RateLimitException)
{
    // 429: back off and retry
}
catch (AuthenticationException)
{
    // 401: the API key is missing or invalid
}
catch (UnprocessableEntityException ex)
{
    // 422: for example, the from domain isn't verified
    logger.LogWarning("Emailit rejected the email: {Message}", ex.Message);
}
catch (ApiErrorException ex)
{
    logger.LogError("Emailit error {Status}: {Body}", ex.HttpStatus, ex.HttpBody);
}
```

## Alternativ per SMTP senden

### MailKit

Microsoft empfiehlt [MailKit](https://github.com/jstedfast/MailKit) für neuen SMTP-Code. Installieren Sie es mit `dotnet add package MailKit`:

```csharp
using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;

var message = new MimeMessage();
message.From.Add(new MailboxAddress("Acme", "orders@acme.com"));
message.To.Add(MailboxAddress.Parse("ada@example.com"));
message.Subject = "Order confirmed";
message.Body = new TextPart("html") { Text = "<p>We've received your order.</p>" };

using var smtp = new SmtpClient();
await smtp.ConnectAsync("smtp.emailit.com", 587, SecureSocketOptions.StartTls);
await smtp.AuthenticateAsync("emailit", builder.Configuration["Emailit:ApiKey"]);
await smtp.SendAsync(message);
await smtp.DisconnectAsync(true);
```

Für implizites TLS verbinden Sie sich mit Port 465 und `SecureSocketOptions.SslOnConnect`.

### System.Net.Mail

Der integrierte Client reicht für einfache Fälle. Er unterstützt nur STARTTLS; verwenden Sie daher Port 587 (oder 2525 bzw. 2587):

```csharp
using System.Net;
using System.Net.Mail;

using var client = new SmtpClient("smtp.emailit.com", 587)
{
    EnableSsl = true,
    Credentials = new NetworkCredential("emailit", apiKey),
};

client.Send(new MailMessage("orders@acme.com", "ada@example.com", "Order confirmed", "We've received your order."));
```

Alle Ports finden Sie unter [SMTP-Einstellungen](/de/docs/smtp/settings/).

## Webhooks empfangen

[Erstellen Sie einen Webhook](/de/docs/webhooks/set-up/) und speichern Sie sein Signatur-Secret als `Emailit:WebhookSecret`. Lesen Sie den unveränderten Body, verifizieren Sie ihn und parsen Sie dann das Array der Events:

```csharp title="Program.cs"
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;

app.MapPost("/webhooks/emailit", async (HttpRequest request, IConfiguration config) =>
{
    using var reader = new StreamReader(request.Body, Encoding.UTF8);
    var body = await reader.ReadToEndAsync();

    var signature = request.Headers["X-Emailit-Signature"].ToString();
    var timestamp = request.Headers["X-Emailit-Timestamp"].ToString();

    if (!long.TryParse(timestamp, out var ts) ||
        Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - ts) > 300)
    {
        return Results.Unauthorized();
    }

    using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(config["Emailit:WebhookSecret"]!));
    var expected = Convert.ToHexString(hmac.ComputeHash(Encoding.UTF8.GetBytes($"{timestamp}.{body}"))).ToLowerInvariant();

    if (!CryptographicOperations.FixedTimeEquals(Encoding.UTF8.GetBytes(expected), Encoding.UTF8.GetBytes(signature)))
    {
        return Results.Unauthorized();
    }

    // The body is a JSON array of up to 100 events.
    using var events = JsonDocument.Parse(body);
    foreach (var evt in events.RootElement.EnumerateArray())
    {
        if (evt.GetProperty("type").GetString() == "email.bounced")
        {
            var address = evt.GetProperty("data").GetProperty("object").GetProperty("to").GetString();
            // Stop emailing this address.
        }
    }

    return Results.Ok();
});
```

Geben Sie innerhalb von 30 Sekunden einen `2xx`-Status zurück; bei anderen Antworten wird die Anfrage wiederholt. Siehe [Anfragesignatur](/de/docs/webhooks/request-signature/).

## Tipps für den Produktivbetrieb

- **Client als Singleton registrieren.** Ein `EmailitClient` pro App genügt.
- **Massen-E-Mails in eine Warteschlange stellen.** Senden Sie aus einem `BackgroundService` oder mit einer Job-Bibliothek wie Hangfire und drosseln Sie den Versand, um unter Ihren [Versandlimits](/de/docs/limits/) zu bleiben (standardmäßig 2 E-Mails pro Sekunde).
- **Wiederholungen sicher machen.** Wenn Sie nach einem Timeout erneut senden, übergeben Sie mit `HttpClient` einen Header `Idempotency-Key`; siehe [Idempotenz](/de/docs/email-api/idempotency/).
- **Webhooks deduplizieren**, indem Sie jede verarbeitete `event_id` speichern.

## Nächste Schritte

  - [E-Mails per API senden](/de/docs/email-api/send-email/): Anhänge, Planung und Tracking.
  - [Webhook-Event-Typen](/de/docs/webhooks/event-types/): Alle Events und ihre Payloads.
  - [SMTP-Fehlerbehebung](/de/docs/smtp/troubleshooting/): Authentifizierungs- und Verbindungsfehler beheben.
  - [SDKs und Bibliotheken](/de/docs/sdks/): Alle offiziellen Bibliotheken.

---
Quelle: https://emailit.com/de/docs/frameworks/dotnet/