E-pasta konvertētājs
Kā pārvērst EML un MSG e-pasta failus HTML .NET

Kā pārvērst EML un MSG e-pasta failus HTML .NET

E-pasta failu konvertēšana HTML formātā ir būtiski tīmekļa lietojumprogrammām, e-pastu arhivēšanas sistēmām un mūsdienu dokumentu pārvaldības risinājumiem. HTML nodrošina daudzveidīgu formātu, kas ļauj viegli skatīt, stilizēt un integrēt elektronisko saturu tīmeklī. Aspose.Email LowCode Converter vienkāršo šo procesu, ļaujot izstrādātājiem pārveidot EML un MSG failus HTML ar minimālu koda sarežģītību.

Prerequisites

Pirms ieviešanas e-pastu uz HTML konversiju, pārliecinieties, ka jūsu attīstības vide ietver:

  • Visual Studio 2019 vai jaunāks (vai jebkura saderīga .NET IDE)
  • .NET 6.0 SDK vai augstāks
  • Aspose.Email NuGet iepakojums
  • Baziskās zināšanas par C# un failu apstrādi

1. solis: Instalēt Aspose.e-pastu caur NuGet

Instalēt Aspose.Email paketi, izmantojot vienu no šīm metodēm:

Pakalpojumu pārvaldītājs Konsole:

Install-Package Aspose.Email

Pakalpojumu pārvaldnieks UI:

  • Lūdzu, pareizi noklikšķiniet uz projektu Solution Explorer
  • Izvēlieties “Vienot NuGet Pakalpojumus”
  • Meklēt “Aspose.Email"
  • Noklikšķiniet uz “Install"

PaketeReference uz .csproj:

<PackageReference Include="Aspose.Email" Version="24.3.0" />

2. solis: Ievadiet konversijas kodu

Šeit ir pilns piemērs, kas demonstrē vienu failu konversiju no EML/MSG uz HTML:

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

namespace EmailToHtmlConverter
{
    class Program
    {
        static async Task Main(string[] args)
        {
            try
            {
                // Define input and output paths
                string inputFilePath = @"C:\Emails\sample.eml";
                string outputDirectory = @"C:\ConvertedEmails";
                
                // Create output directory if it doesn't exist
                Directory.CreateDirectory(outputDirectory);
                
                // Create input stream from the email file
                using var inputStream = File.OpenRead(inputFilePath);
                
                // Set up the output handler to save converted files
                var outputHandler = new FolderOutputHandler(outputDirectory);
                
                // Get the filename for processing
                string fileName = Path.GetFileName(inputFilePath);
                
                // Convert the email file to HTML
                await Converter.ConvertToHtml(inputStream, fileName, outputHandler);
                
                Console.WriteLine($"Successfully converted {fileName} to HTML format");
                Console.WriteLine($"Output saved to: {outputDirectory}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Conversion failed: {ex.Message}");
            }
        }
    }
}

Koda pārkāpums:

  • Input Stream izveidošana: File.OpenRead() izveido plūsmu no avota e-pasta faila
  • Izkraušanas pārvaldītāja iestatījums: FolderOutputHandler pārvaldīt, kur tiek saglabāti konvertētie HTML faili
  • Konversijas izpilde: Converter.ConvertToHtml() Tiek veikta reāla transformācija
  • Resursu pārvaldība: using paziņojumi nodrošina pareizu failu plūsmu izvietošanu

3. solis: vairāku failu apstrāde (Batch konversija)

Lai apstrādātu vairākas e-pasta failus vienlaicīgi, ievadiet batch konversiju:

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

public class BatchEmailConverter
{
    public static async Task ConvertMultipleEmailsToHtml()
    {
        try
        {
            // Define directories
            string inputDirectory = @"C:\EmailFiles";
            string outputDirectory = @"C:\ConvertedEmails";
            
            // Create output directory
            Directory.CreateDirectory(outputDirectory);
            
            // Get all EML and MSG files from input directory
            var emailFiles = Directory.GetFiles(inputDirectory, "*.*")
                .Where(file => file.EndsWith(".eml", StringComparison.OrdinalIgnoreCase) || 
                              file.EndsWith(".msg", StringComparison.OrdinalIgnoreCase))
                .ToArray();
            
            Console.WriteLine($"Found {emailFiles.Length} email files to convert");
            
            // Set up output handler
            var outputHandler = new FolderOutputHandler(outputDirectory);
            
            // Process each file
            var conversionTasks = emailFiles.Select(async filePath =>
            {
                try
                {
                    using var inputStream = File.OpenRead(filePath);
                    string fileName = Path.GetFileName(filePath);
                    
                    await Converter.ConvertToHtml(inputStream, fileName, outputHandler);
                    
                    Console.WriteLine($"✓ Converted: {fileName}");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"✗ Failed to convert {Path.GetFileName(filePath)}: {ex.Message}");
                }
            });
            
            // Execute all conversions concurrently
            await Task.WhenAll(conversionTasks);
            
            Console.WriteLine("Batch conversion completed!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Batch conversion failed: {ex.Message}");
        }
    }
}

Progresīvās tēmas

Custom Output nosaukums

Izveidojiet pielāgotu iznākuma pārziņu, lai kontrolētu failu nosaukumu:

public class TimestampOutputHandler : IOutputHandler
{
    private readonly string _basePath;
    
    public TimestampOutputHandler(string basePath)
    {
        _basePath = basePath;
        Directory.CreateDirectory(_basePath);
    }
    
    public async Task AddOutputStream(string name, Func<Stream, Task> writeAction)
    {
        // Add timestamp prefix to the filename
        var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
        var nameWithoutExtension = Path.GetFileNameWithoutExtension(name);
        var extension = ".html"; // Force HTML extension
        var newFileName = $"{timestamp}_{nameWithoutExtension}{extension}";
        var outputPath = Path.Combine(_basePath, newFileName);
        
        using var fileStream = File.Create(outputPath);
        await writeAction(fileStream);
        
        Console.WriteLine($"Created: {newFileName}");
    }
    
    public void AddOutputStream(string name, Action<Stream> writeAction)
    {
        // Synchronous version
        var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
        var nameWithoutExtension = Path.GetFileNameWithoutExtension(name);
        var extension = ".html";
        var newFileName = $"{timestamp}_{nameWithoutExtension}{extension}";
        var outputPath = Path.Combine(_basePath, newFileName);
        
        using var fileStream = File.Create(outputPath);
        writeAction(fileStream);
    }
}

// Usage example:
var customHandler = new TimestampOutputHandler(@"C:\ConvertedEmails");
await Converter.ConvertToHtml(inputStream, fileName, customHandler);

Visaptveroša kļūdu apstrāde

Īstenošana robusta kļūdu apstrāde ražošanas vidē:

public class RobustEmailConverter
{
    public static async Task<ConversionResult> ConvertEmailToHtml(string inputPath, string outputDirectory)
    {
        var result = new ConversionResult();
        
        try
        {
            // Validate input file exists
            if (!File.Exists(inputPath))
            {
                throw new FileNotFoundException($"Input file not found: {inputPath}");
            }
            
            // Validate file extension
            var extension = Path.GetExtension(inputPath).ToLower();
            if (extension != ".eml" && extension != ".msg")
            {
                throw new ArgumentException($"Unsupported file format: {extension}");
            }
            
            // Create output directory
            Directory.CreateDirectory(outputDirectory);
            
            // Perform conversion
            using var inputStream = File.OpenRead(inputPath);
            var outputHandler = new FolderOutputHandler(outputDirectory);
            string fileName = Path.GetFileName(inputPath);
            
            await Converter.ConvertToHtml(inputStream, fileName, outputHandler);
            
            result.Success = true;
            result.OutputPath = Path.Combine(outputDirectory, Path.ChangeExtension(fileName, ".html"));
            result.Message = "Conversion completed successfully";
        }
        catch (FileNotFoundException ex)
        {
            result.Success = false;
            result.ErrorType = "FileNotFound";
            result.Message = ex.Message;
        }
        catch (UnauthorizedAccessException ex)
        {
            result.Success = false;
            result.ErrorType = "AccessDenied";
            result.Message = $"Access denied: {ex.Message}";
        }
        catch (ArgumentException ex)
        {
            result.Success = false;
            result.ErrorType = "InvalidArgument";
            result.Message = ex.Message;
        }
        catch (Exception ex)
        {
            result.Success = false;
            result.ErrorType = "UnknownError";
            result.Message = $"Unexpected error: {ex.Message}";
        }
        
        return result;
    }
}

public class ConversionResult
{
    public bool Success { get; set; }
    public string Message { get; set; }
    public string ErrorType { get; set; }
    public string OutputPath { get; set; }
}

Conclusion

Aspose.Email LowCode Converter nodrošina vienkāršu risinājumu EML un MSG failu konvertēšanai HTML formātā:

  • Simplified API : minimālais kods, kas nepieciešams sarežģītām konversijām
  • Batch apstrāde : efektīvi apstrādā vairākas failus ar savstarpējām darbībām
  • Fleksibils iznākums : pielāgojami apstrādātāji specializētiem nosaukuma un uzglabāšanas prasībām
  • Robust Error Handling : Visaptveroša izņēmuma pārvaldība ražošanas lietošanai
  • Asynchronous atbalsts : neblokēšanas darbības, lai uzlabotu lietojumprogrammas veiktspēju

Šī pieeja ļauj izstrādātājiem integrēt e-pasta HTML konversiju tīmekļa lietojumprogrammās, dokumentu pārvaldības sistēmās un email arhivēšanas risinājumos. HTML iznākums saglabā oriģinālo email formātu, vienlaikus nodrošinot saderību ar mūsdienu web standartiem un reaģējošiem dizaina shēmām.

 Latviski