Converter de formato de correo electrónico para .NET

El Aspose.Email LowCode Converter proporciona una API simplificada, de alto nivel para la conversión de mensajes de correo electrónico entre diferentes formatos con una complejidad mínima de código. Esta guía de desarrolladores cubre la funcionalidad básica, los patrones de implementación y las mejores prácticas para el uso del convertidor en aplicaciones .NET.

Página de correo electrónico.LowCode

El Aspose.Email.LowCode namespace contiene clases diseñadas para simplificar las operaciones de conversión de formato de correo electrónico Converter clase, que ofrece métodos estáticos para transformar mensajes de correo electrónico entre formatos populares incluyendo EML, MSG, HTML, MHT, y MHTML.

Componentes clave

Converter : métodos de conversión estática para la transformación de formato de correo electrónico
IoutputHandler : Interfaz para el manejo de flujos de salida convertidos
FolderOutputHandler : Implementación integrada para almacenamiento de salida basado en la pasta

Comenzando

Instalación

Instalar el paquete Aspose.Email a través de NuGet Package Manager:

Install-Package Aspose.Email

Declaración del Nombre

using Aspose.Email.LowCode;
using System.IO;
using System.Threading.Tasks;

Métodos de conversión básica

Conversión de formato genérico

El Convert El método proporciona una conversión de formato flexible con una especificación explícita del tipo de salida:

public static Task Convert(Stream input, string nameWithExtension, IOutputHandler handler, string outputType)

Exemplos de implementación:

using var inputStream = File.OpenRead("email.eml");
var outputHandler = new FolderOutputHandler(@"C:\ConvertedEmails");

await Converter.Convert(inputStream, "email.eml", outputHandler, "html");

Métodos especializados de conversión

El convertidor proporciona métodos dedicados para los escenarios de conversión comunes:

Convertir en formato HTML

await Converter.ConvertToHtml(inputStream, "email.eml", outputHandler);

Convertir en formato MSG

await Converter.ConvertToMsg(inputStream, "email.eml", outputHandler);

Convertir en formato EML

await Converter.ConvertToEml(inputStream, "email.msg", outputHandler);

Convertir en formatos MHTML/MHT

await Converter.ConvertToMhtml(inputStream, "email.eml", outputHandler);
await Converter.ConvertToMht(inputStream, "email.eml", outputHandler);

EML/MSG Conversión específica

Para la detección de formato automático entre El EML y MSG Los formatos:

await Converter.ConvertEmlOrMsg(inputStream, "email.eml", outputHandler, "html");

Implementación del comerciante de salida

Utilización de FolderOutputHandler

El built-in FolderOutputHandler La clase almacenará automáticamente los archivos convertidos en un directorio especificado:

public class FolderOutputHandler : IOutputHandler
{
    public FolderOutputHandler(string path)
    public string Path { get; set; }
}

El ejemplo de uso:

var outputHandler = new FolderOutputHandler(@"C:\OutputDirectory");

Productos de exportación personalizados

La implementación de la IOutputHandler Interfaz para procesamiento de salida personalizado:

public class CustomOutputHandler : IOutputHandler
{
    public async Task AddOutputStream(string name, Func<Stream, Task> writeAction)
    {
        // Custom async implementation
        using var customStream = CreateCustomStream(name);
        await writeAction(customStream);
    }
    
    public void AddOutputStream(string name, Action<Stream> writeAction)
    {
        // Custom synchronous implementation
        using var customStream = CreateCustomStream(name);
        writeAction(customStream);
    }
}

Formato de Matrix

Formato de entrada	Formatos de salida	Método
El EML	HTML, MSG, MHTML y MHT	`ConvertToHtml()`, `ConvertToMsg()`, y etc.
MSG	HTML, EML, MHTML y MHT	`ConvertToHtml()`, `ConvertToEml()`, y etc.
cualquier formato de correo electrónico	Usuario especificado	`Convert()` Parámetros de tipo de salida

Modelo de implementación avanzada

Implementación del procesamiento de batch

public class EmailBatchConverter
{
    private readonly IOutputHandler _outputHandler;
    
    public EmailBatchConverter(IOutputHandler outputHandler)
    {
        _outputHandler = outputHandler;
    }
    
    public async Task ConvertBatch(IEnumerable<string> emailFiles, string outputFormat)
    {
        var conversionTasks = emailFiles.Select(async file =>
        {
            using var stream = File.OpenRead(file);
            var fileName = Path.GetFileName(file);
            
            await Converter.Convert(stream, fileName, _outputHandler, outputFormat);
        });
        
        await Task.WhenAll(conversionTasks);
    }
}

Modelo de trato de errores

public async Task<ConversionResult> SafeConvert(string inputFile, string outputFormat)
{
    try
    {
        using var inputStream = File.OpenRead(inputFile);
        var outputHandler = new FolderOutputHandler(@"C:\Output");
        var fileName = Path.GetFileName(inputFile);
        
        await Converter.Convert(inputStream, fileName, outputHandler, outputFormat);
        
        return new ConversionResult { Success = true };
    }
    catch (Exception ex)
    {
        return new ConversionResult 
        { 
            Success = false, 
            ErrorMessage = ex.Message 
        };
    }
}

Procesamiento de flujo optimizado de memoria

public async Task ConvertWithMemoryOptimization(string inputFile)
{
    using var inputStream = new FileStream(inputFile, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, useAsync: true);
    var outputHandler = new FolderOutputHandler(@"C:\Output");
    
    await Converter.ConvertToHtml(inputStream, Path.GetFileName(inputFile), outputHandler);
}

Configuración y Customización

Estructura del directorio de salida

Cuando se utiliza FolderOutputHandler, el convertidor mantiene la estructura de archivo original:

var outputHandler = new FolderOutputHandler(@"C:\ConvertedEmails");
// Original: sample.eml → Output: C:\ConvertedEmails\sample.html

Estrategia de nombramiento personalizado

Implementar el nombre de archivo personalizado a través de un operador de salida especializado:

public class TimestampOutputHandler : IOutputHandler
{
    private readonly string _basePath;
    
    public TimestampOutputHandler(string basePath)
    {
        _basePath = basePath;
    }
    
    public async Task AddOutputStream(string name, Func<Stream, Task> writeAction)
    {
        var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
        var newName = $"{timestamp}_{name}";
        var filePath = Path.Combine(_basePath, newName);
        
        using var fileStream = File.Create(filePath);
        await writeAction(fileStream);
    }
    
    // Synchronous implementation omitted for brevity
}

Consideraciones de rendimiento

Operaciones asíncronas

Todos los métodos de conversión de vuelta Task Objetos, que permiten un procesamiento sin síntesis eficiente:

public async Task ProcessMultipleEmailsAsync()
{
    var tasks = new[]
    {
        ConvertEmailAsync("email1.eml"),
        ConvertEmailAsync("email2.msg"),
        ConvertEmailAsync("email3.eml")
    };
    
    await Task.WhenAll(tasks);
}

Gestión de Recursos

La correcta disposición del flujo es fundamental para el rendimiento óptimo:

// Correct pattern
using (var inputStream = File.OpenRead("email.eml"))
{
    await Converter.ConvertToHtml(inputStream, "email.eml", outputHandler);
}

// Alternative using statement
using var inputStream = File.OpenRead("email.eml");
await Converter.ConvertToHtml(inputStream, "email.eml", outputHandler);

Optimización del uso de memoria

Para grandes archivos de correo electrónico, considere los enfoques de streaming:

public async Task ConvertLargeEmail(string inputPath)
{
    const int bufferSize = 65536; // 64KB buffer
    
    using var inputStream = new FileStream(inputPath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize, true);
    var outputHandler = new FolderOutputHandler(@"C:\Output");
    
    await Converter.ConvertToHtml(inputStream, Path.GetFileName(inputPath), outputHandler);
}

Ejemplos de integración

Introducción a ASP.NET Core Web API

[ApiController]
[Route("api/[controller]")]
public class EmailConverterController : ControllerBase
{
    [HttpPost("convert")]
    public async Task<IActionResult> ConvertEmail(IFormFile emailFile, [FromQuery] string format = "html")
    {
        if (emailFile == null || emailFile.Length == 0)
            return BadRequest("No file provided");
        
        try
        {
            using var inputStream = emailFile.OpenReadStream();
            var outputHandler = new MemoryOutputHandler();
            
            await Converter.Convert(inputStream, emailFile.FileName, outputHandler, format);
            
            return File(outputHandler.GetContent(), GetContentType(format), $"converted.{format}");
        }
        catch (Exception ex)
        {
            return StatusCode(500, $"Conversion failed: {ex.Message}");
        }
    }
    
    private string GetContentType(string format) => format.ToLower() switch
    {
        "html" => "text/html",
        "mhtml" => "message/rfc822",
        "eml" => "message/rfc822",
        _ => "application/octet-stream"
    };
}

Implementación de Windows Service

public class EmailConverterService : BackgroundService
{
    private readonly string _watchFolder;
    private readonly string _outputFolder;
    
    public EmailConverterService(IConfiguration config)
    {
        _watchFolder = config["EmailConverter:WatchFolder"];
        _outputFolder = config["EmailConverter:OutputFolder"];
    }
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var watcher = new FileSystemWatcher(_watchFolder, "*.eml");
        watcher.Created += async (sender, e) => await ProcessEmailFile(e.FullPath);
        watcher.EnableRaisingEvents = true;
        
        while (!stoppingToken.IsCancellationRequested)
        {
            await Task.Delay(1000, stoppingToken);
        }
    }
    
    private async Task ProcessEmailFile(string filePath)
    {
        using var inputStream = File.OpenRead(filePath);
        var outputHandler = new FolderOutputHandler(_outputFolder);
        
        await Converter.ConvertToHtml(inputStream, Path.GetFileName(filePath), outputHandler);
    }
}

Troubleshooting

Problemas Comunes y Soluciones

Problemas	Solución
`FileNotFoundException`	Verificar la ruta de archivo de entrada y las autorizaciones
`UnauthorizedAccessException`	Verificar el directorio de salida escribe permiso
`OutOfMemoryException`	Utilice un enfoque de streaming para grandes archivos
`InvalidOperationException`	Asegurar el formato de correo electrónico válido para el archivo de entrada

Tipos de Debugging

Permite un registro detallado para resolver problemas:

public async Task ConvertWithLogging(string inputFile)
{
    var logger = LoggerFactory.Create(builder => builder.AddConsole()).CreateLogger<EmailConverter>();
    
    try
    {
        logger.LogInformation($"Starting conversion of {inputFile}");
        
        using var inputStream = File.OpenRead(inputFile);
        var outputHandler = new FolderOutputHandler(@"C:\Output");
        
        await Converter.ConvertToHtml(inputStream, Path.GetFileName(inputFile), outputHandler);
        
        logger.LogInformation($"Successfully converted {inputFile}");
    }
    catch (Exception ex)
    {
        logger.LogError(ex, $"Failed to convert {inputFile}");
        throw;
    }
}