Berichten converteren en transformeren met minimale code

Een e‑mail converteren betekende vroeger het laden in een MailMessage, de juiste kiezen SaveOptions, streams aansluiten, en onthouden welk formaat welke schakelaars nodig heeft. De Aspose.Email.LowCode namespace samenvat dit alles in één statische aanroep. Je geeft het een stream, de bestandsnaam en het gewenste formaat — het regelt de rest en schrijft het resultaat waar jij het wilt.5899c1__](../src/LowCodeEmailConversion) project dat ernaast wordt geleverd.

Waarom een "low‑code" namespace?

Aspose.Email.LowCode is een dun, taak‑georiënteerd oppervlak over de volledige e‑mail‑API. Het bestaat voor het 80 % geval — "Ik moet dit bericht gewoon naar dat formaat omzetten" — waarbij je niet wilt nadenken over berichtmodellen, MIME of opslagopties.

Het is gebouwd rond drie typen:

| Type | Rol | | — | — | | Converter | Statische methoden die de conversie uitvoeren. | |94b97d5590014b04_IOutputHandler) is het kernontwerpidee: dezelfde één‑regelige conversie kan richten op schijf, geheugen, een database, een cloud‑bucket, of een HTTP‑respons simpelweg door de handler te wisselen.

De Converter‑API in één oogopslag

Elke methode is static, retourneert een Task, en volgt dezelfde vorm:

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

Ondersteunde bronformaten zijn EML en MSG; ondersteunde doelformaten zijn EML, MSG, HTML, MHT, en MHTML.

Opmerking: deze methoden zijn asynchroon — altijd await hen. De Converter > schrijft naar de handler als onderdeel van die taak, dus de output is niet gegarandeerd > geflusht tot de geretourneerde Task voltooid.

Automatisch detecteren van conversie

Convert leest de extensie van nameWithExtension, detecteert het bronformaat, en produceert wat dan ook outputType die je vraagt. Dit is het flexibelste toegangspunt wanneer het doelformaat wordt bepaald op runtime (bijvoorbeeld via gebruikersinvoer of configuratie).

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

Wanneer de bestemming vast staat en bekend is tijdens compilatie, geef dan de expliciete, intentie‑duidelijke methode de voorkeur. ConvertToEml verandert een Outlook .msg naar een standaard RFC 822 .eml:

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

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

EML → MSG

De omgekeerde richting. Gebruik ConvertToMsg wanneer een applicatie of ontvanger native Outlook‑items verwacht:

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

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

E‑mail → HTML

ConvertToHtml rendert een bericht als een op zichzelf staand HTML‑document — ideaal om e‑mail te bekijken in een browser of in te sluiten in een webpagina. Het accepteert zowel .eml of .msg invoer:

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

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

E‑mail → MHT en MHTML

Beide formaten bundelen de berichtinhoud en de bijbehorende bronnen in één webarchiefbestand, wat handig is voor archivering of het delen van een zelf-contained snapshot. MHTML is de rijkere variant en behoudt doorgaans de e‑mailheaders (Van / Aan / Onderwerp / Datum) in de gerenderde output.

// 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"));

Alleen converteren wanneer nodig

ConvertEmlOrMsg converteert de invoer naar het gevraagde formaat alleen als het nog niet in dat formaat is. Richt het op een gemengde stapel van .eml en .msg bestanden en vraag om "eml": de .eml bestanden gaan door, de .msg bestanden worden geconverteerd — zonder dat je zelf op de extensie hoeft te controleren. Dit maakt het perfect voor het normaliseren van een inbox naar één formaat.

// .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");

Batch-omzetting van een map

Omdat elke conversie slechts een methodeaanroep is, vereist het schalen naar bulkwerk bijna geen extra code — enumerateer de bestanden en hergebruik de handler. Hier wordt elk bericht in een map naar HTML gerenderd:

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

Tip: FolderOutputHandler schrijft naar een bestaande map maar maakt deze niet > aan. Roep Directory.CreateDirectory(...) eerst. Elke bron een > eigen submap geven voorkomt ook botsingen wanneer meerdere berichten een basisnaam delen > (twee message.* bestanden zouden anders allebei willen schrijven message.html).

Uitvoer verzenden naar een andere locatie dan de schijf

Dit is waar de IOutputHandler abstractie die loont. De interface is klein:

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

De Converter roept een van deze overloads aan met de bestandsnaam voor de uitvoer en een writer. Uw implementatie levert een Stream en beslist wat er met de bytes moet gebeuren. Een handler die alles in het geheugen opvangt ziet er zo uit:

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

De conversie‑aanroep zelf is ongewijzigd — alleen de handler verschilt:

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...

Van hieruit is het een korte stap naar een Stream-naar-cloud of Stream-naar-HTTP-respons‑handler.

De juiste methode kiezen

MBOX‑bestanden naar verschillende formaten converteren in C#