Converter e Transformar Mensagens com Código Mínimo

Converter um e‑mail costumava significar carregá‑lo em um MailMessage, escolhendo o certo SaveOptions, conectando fluxos, e lembrando qual formato necessita de quais switches. O Aspose.Email.LowCode namespace compacta tudo isso em uma única chamada estática. Você fornece um fluxo, o nome do arquivo e o formato desejado — ele descobre o resto e grava o resultado onde você indicar.5899c1__](../src/LowCodeEmailConversion) projeto que acompanha.

Por que um namespace "low-code"?

Aspose.Email.LowCode é uma camada fina, orientada a tarefas, sobre a API completa de e‑mail. Existe para o caso de 80% — "Eu só preciso transformar esta mensagem naquele formato" — onde você não quer pensar em modelos de mensagens, MIME ou opções de persistência.

É construído em torno de três tipos:

| Tipo | Função | | — | — | | Converter | Métodos estáticos que realizam a conversão. | |94b97d5590014b04_IOutputHandler) é a ideia de design principal: a mesma conversão de uma linha pode direcionar para disco, memória, banco de dados, bucket na nuvem ou resposta HTTP simplesmente trocando o manipulador.

A API do Conversor de forma resumida

Cada método é static, retorna um Task, e segue a mesma 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);

Os formatos de origem suportados são EML e MSG; os destinos suportados são EML, MSG, HTML, MHT e MHTML.

Nota: esses métodos são assíncronos — sempre await eles. O Conversor > grava no manipulador como parte dessa tarefa, então a saída não está garantida como > descarregada até o retorno do Task conclui.

Detecção automática de conversão

Convert lê a extensão de nameWithExtension, detecta o formato de origem e produz o que for outputType você pede. Este é o ponto de entrada mais flexível quando o formato alvo é decidido em tempo de execução (por exemplo, a partir de entrada do usuário ou configuração).

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 o destino é fixo e conhecido em tempo de compilação, prefira o método explícito e revelador de intenção. ConvertToEml converte um Outlook .msg para um padrão 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

A direção inversa. Use ConvertToMsg quando um aplicativo ou destinatário espera itens nativos do 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 renderiza uma mensagem como um documento HTML independente — ideal para pré‑visualizar e‑mail em um navegador ou incorporá‑lo em uma página web. Aceita tanto .eml ou .msg entrada:

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

Ambos os formatos agrupam o corpo da mensagem e seus recursos em um único arquivo de arquivo da web, o que é conveniente para arquivar ou compartilhar um instantâneo autocontido. MHTML é a variante mais rica e normalmente preserva os cabeçalhos de e‑mail (De / Para / Assunto / Data) na saída renderizada.

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

Converter somente quando necessário

ConvertEmlOrMsg converte a entrada para o formato solicitado apenas se ainda não estiver nesse formato. Aponte-o para um pilha mista de .eml e .msg arquivos e pede por "eml": o .eml os arquivos passam, o .msg os arquivos são convertidos — sem que você precise ramificar na extensão você mesmo. Isso o torna perfeito para normalizar uma caixa de entrada para um 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");

Conversão em lote de uma pasta

Como cada conversão é apenas uma chamada de método, escalar para trabalho em lote quase não requer código extra — enumere os arquivos e reutilize o manipulador. Aqui cada mensagem em uma pasta é renderizada para 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");
}

Dica: FolderOutputHandler escreve em uma pasta existente mas não > a cria. Chame Directory.CreateDirectory(...) primeiro. Dar a cada origem sua > própria subpasta também impede colisões quando várias mensagens compartilham um nome base > (duas message.* os arquivos de outra forma ambos desejariam gravar message.html).

Enviando a saída para algum lugar que não seja o disco

É aqui que o IOutputHandler abstração que compensa. A interface é mínima:

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

O Conversor chama uma dessas sobrecargas com o nome do arquivo de saída e um escritor. Sua implementação fornece um Stream e decide o que fazer com os bytes. Um manipulador que captura tudo na memória se parece com isto:

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

A chamada de conversão em si permanece inalterada — apenas o manipulador difere:

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

A partir daqui é um passo curto até um Stream-para-nuvem ou Stream-para-manipulador de resposta HTTP.

Escolhendo o método correto

Converter arquivos MBOX para vários formatos em C#