Convertir et transformer les messages avec un code minimal

Convertir un courriel signifiait auparavant le charger dans un MailMessage, choisir le bon SaveOptions, brancher les flux, et se souvenir de quel format nécessite quels commutateurs. Le Aspose.Email.LowCode espace de noms condense tout cela en un seul appel statique. Vous lui fournissez un flux, le nom de fichier et le format souhaité — il se charge du reste et écrit le résultat où vous le lui indiquez.5899c1__](../src/LowCodeEmailConversion) projet qui est fourni avec.

Pourquoi un espace de noms « low‑code » ?

Aspose.Email.LowCode est une surface fine, orientée tâche, au-dessus de l’API complète de courriel. Elle existe pour le cas des 80 % — « Je veux juste convertir ce message en ce format » — où vous ne voulez pas réfléchir aux modèles de messages, MIME ou aux options de persistance.

Il est construit autour de trois types :

L’API du Convertisseur en un clin d’œil

Chaque méthode est static, renvoie un Task, et suit la même forme :

Task Converter.ConvertToEml  (Stream input, string nameWithExtension, IOutputHandler handler);
Task Converter.ConvertToMsg  (Stream input, string nameWithExtension, IOutputHandler handler);
Task Converter.ConvertToHtml (Stream input, string nameWithExtension, IOutputHandler handler);
Task Converter.ConvertToMht  (Stream input, string nameWithExtension, IOutputHandler handler);
Task Converter.ConvertToMhtml(Stream input, string nameWithExtension, IOutputHandler handler);

// Format chosen at run time via the outputType string ("eml", "msg", "html", ...):
Task Converter.Convert        (Stream input, string nameWithExtension, IOutputHandler handler, string outputType);
Task Converter.ConvertEmlOrMsg(Stream input, string nameWithExtension, IOutputHandler handler, string outputType);

Les formats source pris en charge sont EML et MSG ; les cibles prises en charge sont EML, MSG, HTML, MHT et MHTML.

Note : ces méthodes sont asynchrones — toujours await ils. Le Convertisseur > écrit dans le gestionnaire dans le cadre de cette tâche, de sorte que la sortie n’est pas garantie d’être > vidée tant que le retour Task se termine.

Détection automatique de la conversion

Convert lit l’extension de nameWithExtension, détecte le format source, et produit tout ce que outputType vous demandez. C’est le point d’entrée le plus flexible lorsque le format cible est décidé à l’exécution (par exemple, à partir d’une entrée utilisateur ou d’une configuration).

using Aspose.Email.LowCode;

using FileStream input = File.OpenRead("message.msg");
var handler = new FolderOutputHandler(@"C:\output\auto");

await Converter.Convert(input, "message.msg", handler, "eml");

MSG → EML

Lorsque la destination est fixe et connue à la compilation, privilégiez la méthode explicite, révélatrice d’intention. ConvertToEml transforme un Outlook .msg dans un RFC 822 standard .eml:

using FileStream input = File.OpenRead("message.msg");
var handler = new FolderOutputHandler(@"C:\output\eml");

await Converter.ConvertToEml(input, "message.msg", handler);

EML → MSG

Le sens inverse. Utilisez ConvertToMsg lorsqu’une application ou un destinataire attend des éléments natifs Outlook :

using FileStream input = File.OpenRead("message.eml");
var handler = new FolderOutputHandler(@"C:\output\msg");

await Converter.ConvertToMsg(input, "message.eml", handler);

Courriel → HTML

ConvertToHtml rend un message comme un document HTML autonome — idéal pour prévisualiser le courriel dans un navigateur ou l’intégrer dans une page web. Il accepte soit .eml ou .msg entrée :

using FileStream input = File.OpenRead("message.eml");
var handler = new FolderOutputHandler(@"C:\output\html");

await Converter.ConvertToHtml(input, "message.eml", handler);

Courriel → MHT et MHTML

Les deux formats encapsulent le corps du message et ses ressources dans un seul fichier d’archive web, ce qui est pratique pour l’archivage ou le partage d’un instantané autonome. MHTML est la variante plus riche et préserve généralement les en‑têtes de courriel (De / À / Objet / Date) dans la sortie rendue.

// MHT
using (FileStream input = File.OpenRead("message.msg"))
    await Converter.ConvertToMht(input, "message.msg", new FolderOutputHandler(@"C:\output\mht"));

// MHTML
using (FileStream input = File.OpenRead("message.eml"))
    await Converter.ConvertToMhtml(input, "message.eml", new FolderOutputHandler(@"C:\output\mhtml"));

Convertir uniquement si nécessaire

ConvertEmlOrMsg convertit l’entrée au format demandé uniquement si ce n’est pas déjà ce format. Pointez‑le vers un tas mixte de .eml et .msg fichiers et demandez "eml" : le .eml les fichiers passent, le .msg les fichiers sont convertis — sans que vous ayez à gérer vous‑même l’extension. Cela le rend parfait pour normaliser une boîte de réception en un seul format.

// .eml input requesting "eml" -> passes through
using (FileStream input = File.OpenRead("message.eml"))
    await Converter.ConvertEmlOrMsg(input, "message.eml", handler, "eml");

// .msg input requesting "eml" -> converted
using (FileStream input = File.OpenRead("message.msg"))
    await Converter.ConvertEmlOrMsg(input, "message.msg", handler, "eml");

Conversion par lots d’un dossier

Comme chaque conversion n’est qu’un appel de méthode, passer à du travail en masse nécessite presque aucun code supplémentaire — énumérez les fichiers et réutilisez le gestionnaire. Ici chaque message d’un dossier est rendu en HTML :

foreach (string path in Directory.EnumerateFiles(inputDir)
             .Where(f => f.EndsWith(".eml") || f.EndsWith(".msg")))
{
    var handler = new FolderOutputHandler(Path.Combine(outputDir, Path.GetFileNameWithoutExtension(path)));
    using FileStream input = File.OpenRead(path);
    await Converter.Convert(input, Path.GetFileName(path), handler, "html");
}

Astuce : FolderOutputHandler écrit dans un dossier existant mais ne > le crée pas. Appelez Directory.CreateDirectory(...) d’abord. Donner à chaque source son > propre sous‑dossier empêche également les collisions lorsque plusieurs messages partagent un nom de base > (deux message.* les fichiers voudraient sinon tous les deux écrire message.html).

Envoyer la sortie ailleurs que sur le disque

C’est ici que le IOutputHandler l’abstraction porte ses fruits. L’interface est minuscule :

public interface IOutputHandler
{
    void AddOutputStream(string name, Action<Stream> writeAction);
    Task AddOutputStream(string name, Func<Stream, Task> writeActionAsync);
}

Le Convertisseur appelle l’une de ces surcharges avec le nom du fichier de sortie et un writer. Votre implémentation fournit un Stream et décide quoi faire avec les octets. Un gestionnaire qui capture tout en mémoire ressemble à ceci :

public sealed class InMemoryOutputHandler : IOutputHandler
{
    private readonly Dictionary<string, byte[]> _files = new(StringComparer.OrdinalIgnoreCase);
    public IReadOnlyDictionary<string, byte[]> Files => _files;

    public void AddOutputStream(string name, Action<Stream> writeAction)
    {
        using var buffer = new MemoryStream();
        writeAction(buffer);
        _files[name] = buffer.ToArray();
    }

    public async Task AddOutputStream(string name, Func<Stream, Task> writeActionAsync)
    {
        using var buffer = new MemoryStream();
        await writeActionAsync(buffer);
        _files[name] = buffer.ToArray();
    }
}

L’appel de conversion lui‑même reste inchangé – seul le gestionnaire change :

var handler = new InMemoryOutputHandler();
using (FileStream input = File.OpenRead("message.msg"))
    await Converter.ConvertToHtml(input, "message.msg", handler);

byte[] html = handler.Files["message.html"]; // stream it, store it, return it...

À partir d’ici, il suffit d’un court pas vers un Stream-vers le cloud ou Stream-vers le gestionnaire de réponse HTTP.

Choisir la bonne méthode

Convertir des fichiers MBOX en divers formats en C#