Converteur de format de courrier électronique pour .NET

L’Aspose.Email LowCode Converter fournit une API simplifiée et de haut niveau pour convertir les messages électroniques entre différents formats avec une complexité minimum de code. Ce guide de développeur couvre la fonctionnalité de base, les modèles d’implémentation et les meilleures pratiques pour utiliser le convertisseur dans les applications .NET.

Envoyé par email.LowCode

Le Aspose.Email.LowCode namespace contient des classes conçues pour rationaliser les opérations de conversion de format email Converter classe, qui offre des méthodes statiques pour transformer les messages électroniques entre les formats populaires tels que EML, MSG, HTML, MHT, et MHTML.

Les composants clés

  • Converter : méthodes de conversion statique pour la transformation du format email
  • IoutputHandler : interface pour traiter les flux de sortie convertis
  • FolderOutputHandler : mise en œuvre intégrée pour le stockage de sortie basé sur des dossiers

Iniziare

インストール

Installez le paquet Aspose.Email via NuGet Package Manager:

Install-Package Aspose.Email

Déclaration du nom 

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

Méthodes de conversion de base

Conversion de format générique

Le Convert La méthode fournit une conversion de format flexible avec une spécification explicite du type de sortie:

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

Exemple de mise en œuvre:

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

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

Méthodes de conversion spécialisées

Le convertisseur fournit des méthodes dédiées aux scénarios de conversion communs:

Conversion au format HTML 

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

Conversion au format MSG 

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

Convertir en format EML 

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

Conversion en formats MHTML/MHT 

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

EML/MSG Conversion spécifique

Pour la détection automatique de format entre EML et MSG Les formats:

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

La mise en œuvre de l’exportateur

Utiliser FolderOutputHandler

Le bâti-in FolderOutputHandler La classe enregistre automatiquement les fichiers convertis dans un catalogue spécifié:

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

Utiliser l’exemple:

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

Travailleur de sortie personnalisée

La mise en œuvre du IOutputHandler Interface pour le traitement de sortie personnalisé:

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

Les formats de Matrix

Formats d’entréeFormats de sortieMetodo
EMLHTML, MSG, MHTML et MHTConvertToHtml(), ConvertToMsg(), et etc.
MSGHTML, EML, MHTML et MHTConvertToHtml(), ConvertToEml(), et etc.
Tout format emailUtilisateur spécifiéConvert() Paramètres de type de sortie

Modèles de mise en œuvre avancés

La mise en œuvre du Batch Processing 

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

Traitement d’erreur de modèle 

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

Mémoire optimisée pour le traitement du courant 

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

Configuration et personnalisation

Structure du Directeur de sortie

Lorsque vous utilisez FolderOutputHandler, le convertisseur maintient la structure de fichier originale:

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

Stratégie de nomme personnalisée

Implémenter le nom de fichier personnalisé à travers un opérateur de sortie spécialisé:

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
}

Considérations de performance

Les opérations asynchroniques

Toutes les méthodes de conversion retour Task Objets permettant un traitement asynchronique efficace:

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

Gestion des ressources

La bonne disposition du courant est essentielle pour le rendement optimal:

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

Optimisation de la mémoire

Pour les fichiers de messagerie, considérez les approches 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);
}

Exemples d’intégration

ASP.NET Core Web API intégration 

[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"
    };
}

La mise en œuvre des services Windows 

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

Problemi Comuni e Soluzioni

ProblèmeLa solution
FileNotFoundExceptionVérifier la voie de fichier d’entrée et les autorisations
UnauthorizedAccessExceptionVérifier le catalogue d’écriture des permis
OutOfMemoryExceptionUtilisez une approche de streaming pour les fichiers majeurs
InvalidOperationExceptionAssurer le format électronique valide pour le fichier d’entrée

Débullition des conseils

Possibilité de logage détaillé pour résoudre les problèmes:

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;
    }
}
 Français