Konvertera och transformera meddelanden med minimal kod

Att konvertera ett e‑postmeddelande brukade innebära att ladda in det i en MailMessage, väljer rätt SaveOptions, kopplar strömmar och minns vilket format som kräver vilka växlar. Aspose.Email.LowCode namnrymden slår ihop allt till ett enda statiskt anrop. Du ger den en ström, filnamnet och formatet du vill ha — den löser resten och skriver resultatet dit du talar om.5899c1__](../src/LowCodeEmailConversion) projekt som levereras tillsammans med det.

Varför ett "low‑code"‑namnrymd?

Aspose.Email.LowCode är ett tunt, uppgiftsorienterat yttre lager över det fullständiga e‑post‑API‑et. Det finns för 80 %-fallet — "Jag behöver bara omvandla detta meddelande till det formatet" — där du inte vill tänka på meddelandemodeller, MIME eller lagringsalternativ.

Den är byggd kring tre typer:

| Typ | Roll | | — | — | | Converter | Statiska metoder som utför konverteringen. | |94b97d5590014b04_IOutputHandler) är nyckelidéen i designen: samma enradskonvertering kan rikta sig mot disk, minne, en databas, en molnbucket eller ett HTTP‑svar helt enkelt genom att byta hanterare.

Konverterings‑API på ett ögonblick

Varje metod är static, returnerar en Task, och följer samma form:

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

Stödda källformat är EML och MSG; målformat är EML, MSG, HTML, MHT och MHTML.

Observera: dessa metoder är asynkrona — alltid await dem. Konvertern > skriver till hanteraren som en del av den uppgiften, så utdata garanteras inte att vara > spolat förrän den returnerade Task slutförs.

Automatisk upptäckt av konvertering

Convert läser filtillägget för nameWithExtension, upptäcker källformatet och producerar vad som helst outputType du begär. Detta är den mest flexibla ingångspunkten när målformatet bestäms vid körning (t.ex. från användarinmatning eller konfiguration).

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

När destinationen är fast och känd vid kompilerings‑tid, föredra den explicita, avsiktsavslöjande metoden. ConvertToEml omvandlar ett Outlook‑ .msg till en standard‑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

Den omvända riktningen. Använd ConvertToMsg när en applikation eller mottagare förväntar sig ursprungliga Outlook‑objekt:

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

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

E‑post → HTML

ConvertToHtml renderar ett meddelande som ett fristående HTML‑dokument – idealiskt för att förhandsgranska e‑post i en webbläsare eller bädda in den i en webbsida. Det accepterar antingen .eml eller .msg indata:

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

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

E‑post → MHT och MHTML

Båda formaten paketerar meddelandetexten och dess resurser i en enda webbarkivfil, vilket är bekvämt för arkivering eller delning av ett självständigt ögonblick. MHTML är den rikare varianten och bevarar normalt e-posthuvuden (Från / Till / Ämne / Datum) i den renderade utdata.

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

Konvertera endast vid behov

ConvertEmlOrMsg konverterar indata till det begärda formatet endast om det inte redan är i det formatet. Rikta det mot en blandad hög av .eml och .msg filer och begär "eml": .eml filer passerar igenom, .msg filer konverteras – utan att du själv grenar på filtillägget. Detta gör det perfekt för normalisering av en inkorg till ett 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");

Batchkonvertering av en mapp

Eftersom varje konvertering bara är ett metodanrop, kräver skalning till massarbete nästan ingen extra kod – iterera filerna och återanvänd hanteraren. Här renderas varje meddelande i en mapp till 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");
}

Tips: FolderOutputHandler skriver in i en existerande mapp men skapar den inte. Anropa Directory.CreateDirectory(...) först. Att ge varje källa sin > egen undermapp förhindrar också kollisioner när flera meddelanden delar ett basnamn > (två message.* filerna skulle annars båda vilja skriva message.html).

Skickar utdata någon annanstans än disk

Det här är där IOutputHandler abstraktion ger fördelar. Gränssnittet är litet:

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

Konverteraren anropar en av dessa överlagringar med output‑filnamnet och en writer. Din implementation tillhandahåller en Stream och bestämmer vad som ska göras med byten. En hanterare som fångar allt i minnet ser ut så här:

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

Själva konverteringsanropet är oförändrat – bara hanteraren skiljer sig:

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

Härifrån är det ett kort steg till en Stream-till-moln eller Stream-till-HTTP-svars‑hanterare.

Att välja rätt metod

Konvertera MBOX-filer till olika format i C#