המרה ושינוי הודעות עם קוד מינימלי

המרת אימייל הייתה אומרת לטעון אותו אל MailMessage, בוחר את ה‑ SaveOptions, מחבר זרמים, וזוכר איזה פורמט צריך אילו מתגים. ה‑ Aspose.Email.LowCode מרחב שם מצמצם את כל זה לפונקציה סטטית יחידה. אתה מספק זרם, שם הקובץ והפורמט הרצוי — הוא מגלח את השאר וכותב את התוצאה למקום שאתה מצביע עליו.5899c1__](../src/LowCodeEmailConversion) פרויקט שנשלח יחד איתו.

למה מרחב שם "קוד‑נמוך"?

Aspose.Email.LowCode היא ממשק דק, ממוקד משימה על פני ה‑API המלא של האימייל. היא קיימת למקרה של 80% — "פשוט צריך להמיר הודעה זו לפורמט זה" — כאשר אינך רוצה לחשוב על מודלי הודעה, MIME, או אפשרויות שמירה.

זה נבנה סביב שלושה סוגים:

| סוג | תפקיד | | — | — | | Converter | מתודות סטטיות שמבצעות את ההמרה. | |94b97d5590014b04_IOutputHandler) הוא הרעיון העיקרי בתכנון: המרה של שורה אחת יכולה למקד לדיסק, לזיכרון, למסד נתונים, לדלי ענן, או לתשובה HTTP פשוט על ידי החלפת המטפל.

מבט כללי על ממשק ה‑Converter

כל מתודה היא static, מחזיר Task, ועוקב אחרי אותה הצורה:

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

| פרמטר | משמעות | | — | — | | input | הודעת המקור כ‑ Stream (קובץ, העלאה, מאגר בזיכרון…). | | nameWithExtension | שם הקובץ המקורי, לדוגמה "message.msg". הסיומת מודיעה לממיר את פורמט המקור, ולכן חייבת להיות מדויקת. | | handler | ה‑ IOutputHandler שמקבלת את זרם הפלט המומר. | | outputType | (רק עומסי ריצה) פורמט היעד כמחרוזת. |

הפורמטים הנתמכים כמקורות הם EML ו‑MSG; היעדים הנתמכים הם EML, MSG, HTML, MHT, ו‑MHTML.

הערה: שיטות אלו א-סינכרוניות — תמיד await הקונברטר > כותב למטפל כחלק מהמשימה, ולכן הפלט אינו מובטח ש‑> יזרום עד שהפונקציה מוחזרת Task מתקיימת.

גילוי אוטומטי של המרה

Convert קורא את הסיומת של nameWithExtension, מזהה את פורמט המקור, ומייצר כל מה ש‑ outputType אתה מבקש. זהו נקודת הכניסה הגמישה ביותר כאשר פורמט היעד נקבע בזמן ריצה (למשל, מקלט קלט משתמש או תצורה).

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

כאשר היעד קבוע וידוע בזמן הידור, העדף את המתודה המפורשת, המשקפת כוונה. ConvertToEml הופך Outlook .msg לתוך RFC 822 תקני .eml:

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

await Converter.ConvertToEml(input, "message.msg", handler);

EML → MSG

הכיוון ההפוך. השתמש ב‑ ConvertToMsg כאשר יישום או נמען מצפים לפריטים מקומיים של Outlook:

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

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

אימייל → HTML

ConvertToHtml מיצג הודעה כמסמך HTML נפרד — אידיאלי לתצוגה מקדימה של אימייל בדפדפן או לשילובו בדף אינטרנט. הוא מקבל או .eml או .msg קלט:

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

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

אימייל → MHT ו‑MHTML

שני הפורמטים אוגדים את גוף ההודעה ואת המשאבים שלו לקובץ ארכיון רשת יחיד, מה שנוח לארכוב או שיתוף של תצלום מצולם עצמי. MHTML הוא הגרסה העשירה יותר ובדרך כלל משמר את כותרות האימייל (From / To / Subject / Date) בפלט המוצג.

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

המרה רק כאשר נדרש

ConvertEmlOrMsg מחזיר את הקלט לפורמט המבוקש רק אם הוא עדיין לא בפורמט זה. הפנה אותו לערימה מעורבת של .eml ו .msg קבצים ושאל עבור "eml": ה‑ .eml קבצים עוברים דרכם, ה‑ .msg קבצים מומרצים — ללא צורך לנתב את הסיומת בעצמך. זה עושה זאת מושלם ל‑נרמול תיבת נכנס לפורמט אחיד.

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

המרה גורפת של תיקייה

כיוון שכל המרה היא רק קריאת ​​מתודה, הרחבה לעבודה בכמות גדולה דורשת כמעט אין קוד נוסף — למנות את הקבצים ולש reutilize את המטפל. כאן כל הודעה בתיקייה מומרת ל‑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");
}

טיפ: FolderOutputHandler כותב לתיקייה קיימת אך לא יוצר אותה. קרא Directory.CreateDirectory(...) קודם. מתן תת‑תיקייה משלה לכל מקור מונע גם התנגשויות כאשר מספר הודעות חולקות שם בסיס (שניים message.* הקבצים היו רוצים לרשום גם הם message.html).

שליחת פלט במקום אחר מאשר לדיסק

זה המקום שבו IOutputHandler הפשטה משולמת. הממשק מזערי:

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

ה‑Converter קורא לאחת מה‑overloads עם שם קובץ הפלט והכותב. המימוש שלך מספק Stream והוא מחליט מה לעשות עם הבייטים. מטפל הקולט את הכול בזיכרון נראה כך:

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

קריאת ההמרה עצמה אינה משתנה — רק המטפל שונה:

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

מכאן צעד קצר ל‑ Stream-לענן או Stream-לטיפול בתשובה ל‑HTTP.

בחירת השיטה הנכונה

| Goal | Use | | — | — | | פורמט יעד ידוע בזמן הקומפילציה | ConvertToEml / ConvertToMsg / ConvertToHtml / ConvertToMht / ConvertToMhtml | | פורמט היעד נקבע בזמן ריצה | Convert(..., outputType) | | נורמליזציית קבצים, דילוג על אלה שכבר בפורמט היעד | ConvertEmlOrMsg(..., outputType) | | כתיבת תוצאות לתיקייה | FolderOutputHandler | | כתיבת תוצאות לזיכרון / ענן / HTTP / מסד נתונים | רכיב מותאם IOutputHandler |

המרת קבצי MBOX לפורמטים שונים ב‑C#