Converti e Trasforma i Messaggi con Codice Minimo

Convertire un’email significava caricarla in un MailMessage, scegliendo il giusto SaveOptions, collegando gli stream, e ricordando quale formato richiede quali switch. Il Aspose.Email.LowCode lo spazio dei nomi comprime tutto in una singola chiamata statica. Gli passi uno stream, il nome file e il formato desiderato — capisce il resto e scrive il risultato dove gli indichi.5899c1__](../src/LowCodeEmailConversion) progetto che viene fornito insieme ad esso.

Perché uno spazio dei nomi "low-code"?

Aspose.Email.LowCode è una superficie leggera, orientata al compito, sopra l’intera API email. Esiste per il caso dell'80% — "Devo solo trasformare questo messaggio in quel formato" — dove non vuoi pensare a modelli di messaggio, MIME o opzioni di persistenza.

È costruito attorno a tre tipi:

L’API Converter in sintesi

Ogni metodo è static, restituisce un Task, e segue la stessa forma:

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

I formati sorgente supportati sono EML e MSG; i target supportati sono EML, MSG, HTML, MHT e MHTML.

Nota: questi metodi sono asincroni — sempre await loro. Il Converter > scrive sul gestore come parte di quel compito, quindi l’output non è garantito di essere > svuotato finché non viene restituito il Task completa.

Rilevamento automatico della conversione

Convert legge l’estensione di nameWithExtension, rileva il formato di origine e produce qualunque outputType che chiedi. Questo è il punto di ingresso più flessibile quando il formato di destinazione è deciso a run time (ad esempio, da input utente o configurazione).

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

Quando la destinazione è fissa e nota al momento della compilazione, preferisci il metodo esplicito che rivela l’intento. ConvertToEml trasforma un Outlook .msg in 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

La direzione inversa. Usa ConvertToMsg quando un’applicazione o destinatario si aspetta elementi nativi di Outlook:

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

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

Email → HTML

ConvertToHtml renderizza un messaggio come un documento HTML autonomo — ideale per l’anteprima di email nel browser o per incorporarlo in una pagina web. Accetta sia .eml oppure .msg input:

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

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

Email → MHT e MHTML

Entrambi i formati raggruppano il corpo del messaggio e le sue risorse in un unico file di archivio web, comodo per archiviare o condividere uno snapshot autonomo. MHTML è la variante più ricca e tipicamente conserva le intestazioni email (Da / A / Oggetto / Data) nell’output renderizzato.

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

Converti solo quando necessario

ConvertEmlOrMsg converte l’input nel formato richiesto solo se non è già in quel formato. Puntalo su un mucchio misto di .eml e .msg i file e chiedi di "eml": il .eml i file passano attraverso, il .msg i file vengono convertiti — senza che tu debba gestire l’estensione manualmente. Questo lo rende perfetto per normalizzare una casella di posta in un unico formato.

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

Conversione batch di una cartella

Poiché ogni conversione è solo una chiamata di metodo, scalare a lavori di massa richiede quasi nessun codice aggiuntivo — elenca i file e riutilizza il gestore. Qui ogni messaggio in una cartella è renderizzato in 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");
}

Suggerimento: FolderOutputHandler scrive in una cartella esistente ma non > la crea. Chiama Directory.CreateDirectory(...) prima. Assegnare a ogni origine la sua > propria sottocartella previene anche le collisioni quando più messaggi condividono un nome base > (due message.* i file altrimenti vorrebbero entrambi scrivere message.html).

Invio dell’output altrove rispetto al disco

Questo è dove il IOutputHandler l’astrazione paga. L’interfaccia è minuscola:

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

Il Converter chiama una di queste overload con il nome del file di output e un writer. La tua implementazione fornisce un Stream e decide cosa fare con i byte. Un handler che cattura tutto in memoria appare così:

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

La chiamata di conversione stessa è invariata — solo l’handler differisce:

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

Da qui è un breve passo verso un Stream-a-cloud o Stream-a-handler di risposta HTTP.

Scelta del metodo corretto

Converti file MBOX in vari formati in C#