Convertir y Transformar Mensajes con Código Mínimo

Convertir un correo solía significar cargarlo en un MailMessage, eligiendo el correcto SaveOptions, conectando flujos y recordando qué formato necesita qué interruptores. El Aspose.Email.LowCode el espacio de nombres condensa todo eso en una sola llamada estática. Le pasas un flujo, el nombre del archivo y el formato que deseas — él determina el resto y escribe el resultado donde le indiques.5899c1__](../src/LowCodeEmailConversion) proyecto que se envía junto a él.

¿Por qué un espacio de nombres "low-code"?

Aspose.Email.LowCode es una superficie delgada, orientada a tareas, sobre la API completa de correo. Existe para el caso del 80% — "Solo necesito convertir este mensaje a ese formato" — donde no quieres pensar en modelos de mensaje, MIME o opciones de persistencia.

Está construido alrededor de tres tipos:

| Tipo | Rol | | — | — | | Converter | Métodos estáticos que realizan la conversión. | |94b97d5590014b04_IOutputHandler) es la idea de diseño clave: la misma conversión de una línea puede dirigirse a disco, memoria, una base de datos, un bucket en la nube o una respuesta HTTP simplemente cambiando el manejador.

La API del Convertidor de un vistazo

Cada método es static, devuelve un Task, y sigue la misma 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);

Los formatos de origen compatibles son EML y MSG; los destinos compatibles son EML, MSG, HTML, MHT y MHTML.

Nota: estos métodos son asíncronos — siempre await ellos. El Convertidor > escribe al manejador como parte de esa tarea, por lo que la salida no está garantizada a ser > vaciada hasta que se devuelva Task completa.

Detección automática de conversión

Convert lee la extensión de nameWithExtension, detecta el formato de origen y produce lo que sea outputType pides. Este es el punto de entrada más flexible cuando el formato de destino se decide en tiempo de ejecución (por ejemplo, a partir de la entrada del usuario o configuración).

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

Cuando el destino es fijo y conocido en tiempo de compilación, prefiere el método explícito que revela la intención. ConvertToEml convierte un Outlook .msg en un RFC 822 estándar .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 dirección inversa. Usa ConvertToMsg cuando una aplicación o destinatario espera elementos nativos de Outlook:

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

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

Correo → HTML

ConvertToHtml renderiza un mensaje como un documento HTML independiente — ideal para previsualizar correo en un navegador o incrustarlo en una página web. Acepta cualquiera de .eml o .msg entrada:

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

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

Correo electrónico → MHT y MHTML

Ambos formatos agrupan el cuerpo del mensaje y sus recursos en un solo archivo de web-archivo, lo cual es conveniente para archivar o compartir una instantánea autocontenida. MHTML es la variante más rica y típicamente preserva los encabezados del correo (De / Para / Asunto / Fecha) en la salida 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"));

Convertir solo cuando sea necesario

ConvertEmlOrMsg convierte la entrada al formato solicitado solo si no está ya en ese formato. Dirígelo a un montón mixto de .eml y .msg archivos y solicitan "eml": el .eml los archivos pasan, el .msg los archivos se convierten — sin que tengas que ramificar según la extensión tú mismo. Esto lo hace perfecto para normalizar una bandeja de entrada a un 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");

Conversión por lotes de una carpeta

Porque cada conversión es solo una llamada a método, escalar a trabajo masivo necesita casi código adicional — enumerate los archivos y reutiliza el manejador. Aquí cada mensaje en una carpeta se renderiza a 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");
}

Consejo: FolderOutputHandler escribe en una carpeta existente pero no > la crea. Llama a Directory.CreateDirectory(...) primero. Dar a cada origen su > propia subcarpeta también evita colisiones cuando varios mensajes comparten un nombre base > (dos message.* los archivos de otro modo ambos querrían escribir message.html).

Envío de salida a otro lugar que no sea el disco

Aquí es donde está el IOutputHandler la abstracción paga. La interfaz es diminuta:

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

El Convertidor llama a una de estas sobrecargas con el nombre del archivo de salida y un escritor. Su implementación suministra un Stream y decide qué hacer con los bytes. Un manejador que captura todo en memoria se ve así:

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 llamada de conversión en sí no cambia —solo difiere el manejador:

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

Desde aquí es un paso corto a un Stream-a-nube o Stream-a-manejador de respuesta HTTP.

Elegir el método correcto

Convertir archivos MBOX a varios formatos en C#