Elektroninio pašto formatų konvertuotojas .NET

Aspose.Email LowCode Converter suteikia supaprastintą, aukšto lygio API, skirtą elektroninio pašto pranešimų konvertavimui tarp skirtingų formatų su minimaliu kodo sudėtingumu.Šis kūrėjų vadovas apima pagrindines funkcijas, įgyvendinimo modelius ir geriausias praktikas konverterio naudojimui .NET programas.

Pašto kodas.LowCode

The Aspose.Email.LowCode namespace yra klasių, skirtų elektroninio pašto formato konvertavimo operacijoms supaprastinti Converter klasė, kuri siūlo statinius metodus elektroninio pašto pranešimų transformavimui tarp populiarių formatų, įskaitant EML, MSG, HTML, MHT ir MHTML.

Pagrindiniai komponentai

Converter : statinės konvertavimo metodai elektroninio pašto formato transformacijai
IoutputHandler : sąsaja, skirta konvertuoti išleidimo srautų tvarkymui
FolderOutputHandler : Įterptas įgyvendinimas lapo pagrįsto išleidimo saugojimui

pradėti

Installation

Įdiegti Aspose.Email paketą per NuGet Package Manager:

Install-Package Aspose.Email

Pavadinimas Deklaracija

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

Pagrindiniai konvertavimo metodai

Generinis formatas konvertavimas

The Convert metodas suteikia lanksčią formatų konvertavimą su aiškiu išleidimo tipo specifikacija:

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

Įgyvendinimo pavyzdys:

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

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

Specializuotas konvertavimo metodas

Konverteris siūlo skirtus metodus bendriems konvertavimo scenarijams:

Konvertavimas į HTML formatą

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

Konvertavimas į MSG formatą

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

Konvertavimas į EML formatą

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

Konvertavimas į MHTML/MHT formatus

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

EML / MSG specifinis konvertavimas

Automatinis formato aptikimas tarp EML ir MSG Iš formų:

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

Išleidimo operatorių įgyvendinimas

Naudokite „FolderOutputHandler

Įsikūręs į FolderOutputHandler klasė automatiškai išsaugo konvertuotus failus į nurodytą katalogą:

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

Naudojamas pavyzdys:

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

Kūrybinio išleidimo tvarkytojas

Įgyvendinimas The IOutputHandler sąsaja, skirta pritaikytam išleidimo apdorojimui:

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

Rekomenduojamas formatas Matrix

Įvesties formatas	Išleidimo formatas	Method
EML	HTML, MSG, MHTML ir MHT	`ConvertToHtml()`, `ConvertToMsg()`, ir tt.
MSG	HTML, EML, MHTML ir MHT	`ConvertToHtml()`, `ConvertToEml()`, ir tt.
Bet koks elektroninio pašto formatas	Naudotojo specifikacija	`Convert()` Išleidimo tipo parametras

Išplėstinės įgyvendinimo modeliai

Batch apdorojimo įgyvendinimas

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

Klaidų tvarkymo modelis

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

Atminties optimizuotas srovės apdorojimas

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

Konfiguravimas ir pritaikymas

Išleidimo direktorijos struktūra

Kai naudojama FolderOutputHandler, Konverteris palaiko originalią failų struktūrą:

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

Nuosavų pavadinimų strategija

Įdiegti pritaikytą failų pavadinimą per specializuotą išleidimo operatorių:

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
}

Veiksmingumo apžvalgos

Asynchrono operacijos

Visi konvertavimo metodai grįžta Task objektų, leidžiančių veiksmingą asynchroninį apdorojimą:

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

Išteklių valdymas

Tinkamas srautas yra labai svarbus optimaliam efektyvumui:

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

Atminties naudojimo optimizavimas

Dideliems el. pašto failams apsvarstykite streikimo metodus:

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

Integracijos pavyzdžiai

ASP.NET Core Web API integravimas

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

Windows“ paslaugų įgyvendinimas

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

Bendros problemos ir sprendimai

Issue	Solution
`FileNotFoundException`	Patikrinkite įvesties failo maršrutą ir leidimus
`UnauthorizedAccessException`	Patikrinkite išleidimo katalogą rašyti leidimus
`OutOfMemoryException`	Naudokite streaming metodą dideliems failams
`InvalidOperationException`	Užtikrinti galiojantį elektroninio pašto formatą įvesties failą

Debugging patarimai

Galima išsamiai registruoti problemų sprendimui:

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