# Envoyer des e-mails avec .NET

> Envoyez des e-mails depuis ASP.NET Core et .NET avec le paquet NuGet Emailit, MailKit ou System.Net.Mail via SMTP, et vérifiez les webhooks Emailit.

Ce guide montre comment envoyer des e-mails depuis une application .NET avec le paquet NuGet officiel `Emailit`, comment utiliser plutôt MailKit ou `System.Net.Mail` via SMTP, et comment vérifier les webhooks dans une API minimale ASP.NET Core.

## Prérequis

- .NET 8 ou version ultérieure.
- Un [domaine d’envoi vérifié](/fr/docs/domains/add-a-domain/), par exemple `acme.com`.
- Une [clé API](/fr/docs/developers/api-keys/). Une clé Sending Only limitée à votre domaine suffit.
- Tant que votre espace de travail n’a pas l’[accès production](/fr/docs/workspaces/production-access/), vous ne pouvez envoyer qu’aux adresses e-mail des comptes des membres de l’espace de travail.

## Installer le SDK

```bash
dotnet add package Emailit
```

## Configurer votre clé API

ASP.NET Core lit la configuration depuis les variables d’environnement, où `__` sépare les sections. Définissez `Emailit__ApiKey` en production :

```bash
```

Pendant le développement, gardez la clé dans les secrets utilisateur plutôt que dans `appsettings.json` :

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

## Envoyer un e-mail

Enregistrez un seul client et injectez-le dans vos endpoints :

```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` est synchrone ; pour les envois en masse, exécutez-le depuis un service en arrière-plan afin de laisser les threads de requête libres. Les options acceptent aussi `Cc`, `Bcc`, `ReplyTo`, `Attachments`, `Template` avec `Variables`, `ScheduledAt` et `Tracking` ; consultez [Envoyer un e-mail](/fr/docs/api-reference/emails/send/).

Si votre code construit déjà des objets `System.Net.Mail.MailMessage`, le SDK peut les envoyer via l’API :

```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);
```

### Gérer les erreurs

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

## Envoyer plutôt via SMTP

### MailKit

Microsoft recommande [MailKit](https://github.com/jstedfast/MailKit) pour le nouveau code SMTP. Installez-le avec `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);
```

Pour le TLS implicite, connectez-vous au port 465 avec `SecureSocketOptions.SslOnConnect`.

### System.Net.Mail

Le client intégré convient aux cas simples. Il ne prend en charge que STARTTLS : utilisez donc le port 587 (ou 2525 ou 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."));
```

Pour tous les ports, consultez [Paramètres SMTP](/fr/docs/smtp/settings/).

## Recevoir des webhooks

[Créez un webhook](/fr/docs/webhooks/set-up/) et enregistrez son secret de signature dans `Emailit:WebhookSecret`. Lisez le corps brut, vérifiez-le, puis analysez le tableau d’événements :

```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();
});
```

Renvoyez un `2xx` dans les 30 secondes ; pour toute autre réponse, Emailit réessaie. Consultez [Signature des requêtes](/fr/docs/webhooks/request-signature/).

## Conseils pour la production

- **Enregistrez le client comme singleton.** Un seul `EmailitClient` par application suffit.
- **Mettez les envois en masse en file d’attente.** Envoyez depuis un `BackgroundService` ou une bibliothèque de tâches comme Hangfire, et limitez le débit pour rester sous vos [limites d’envoi](/fr/docs/limits/) (2 e-mails par seconde par défaut).
- **Sécurisez les relances.** Si vous relancez une requête après un timeout, envoyez un en-tête `Idempotency-Key` avec `HttpClient` ; consultez [Idempotence](/fr/docs/email-api/idempotency/).
- **Dédoublonnez les webhooks** en enregistrant chaque `event_id` traité.

## Étapes suivantes

  - [Envoyer des e-mails avec l’API](/fr/docs/email-api/send-email/): Pièces jointes, programmation et suivi.
  - [Types d’événements webhook](/fr/docs/webhooks/event-types/): Tous les événements et leur payload.
  - [Dépannage SMTP](/fr/docs/smtp/troubleshooting/): Corrigez les erreurs d’authentification et de connexion.
  - [SDK et bibliothèques](/fr/docs/sdks/): Toutes les bibliothèques officielles.

---
Source: https://emailit.com/fr/docs/frameworks/dotnet/