Documentation – עבודה עם קבצי אחסון Outlook

Net: יצירת וניהול קבצי PST

Mon, 01 Jan 0001 00:00:00 +0000

חלק מהיכולת לנתח קובץ PST קיים, Aspose.Email מספקת גם אמצעים ליצירת קובץ PST מאפס. מאמר זה מציג כיצד ליצור קבצי Outlook PST ולהוסיף להם תתי‑תיקיות או הודעות.

יצירת קבצי PST

כדי ליצור קובץ PST חדש בדיסק מקומי, יהיה עליך להשתמש ב‑ PersonalStorage מחלקה. עם מחלקה זו, ניתן ליצור, לקרוא ולבצע מניפולציות בקבצי PST ביישומים של .NET. צור קובץ אחסון מאפס עם שורת קוד אחת:

// Create new PST
using var pst = PersonalStorage.Create(path, FileFormatVersion.Unicode);

הוסף תתי-תיקיות ל‑PST

הוסף תיקיית משנה בשורש קובץ ה‑PST על ידי גישה לתיקיית Root ולאחר מכן קריאה ל‑ AddSubFolder שיטה.

הקטע הקוד הבא מציג כיצד להוסיף תיקיית משנה בשם Inbox:

// Add new folder "Test"
pst.RootFolder.AddSubFolder("Inbox");

בדוק את מחלקת המכולה של התיקייה

בעת יצירת תיקיות חדשות או הוספת פריטים לתיקיות קיימות, חשוב לוודא שמחלקת המכולה של הפריט או התיקייה החדשה תתאים למחלקת המכולה של תיקיית האב על מנת לשמור על היררכיית הארגון בקובץ האחסון PST. למטרה זו, Aspose.Email מספקת את EnforceContainerClassMatching מאפיין של FolderCreationOptions מחלקה. המאפיין מציין האם לאכוף בדיקת מחלקת המכולה של התיקייה שמתווספת מול מחלקת המכולה של תיקיית האב. אם מוגדר ל-’true’, ייזרק wyjąט אם מחלקות המכולה אינן תואמות. ברירת המחדל היא ‘false’.

דוגמת הקוד הבאה מדגימה את השימוש ב- EnforceContainerClassMatching מאפיין לבקר האם לזרוק חריגה בעת הוספת תיקיות עם מחלקות קונטיינר לא תואמות:

using (var pst = PersonalStorage.Create("storage.pst", FileFormatVersion.Unicode))
{
    // Create a standard Contacts folder with the IPF.Contacts container class.
    var contacts = pst.CreatePredefinedFolder("Contacts", StandardIpmFolder.Contacts);
    
    // An exception will not arise. EnforceContainerClassMatching is false by default.
    contacts.AddSubFolder("Subfolder1", "IPF.Note");
    
    // An exception will occur as the container class of the subfolder being added (IPF.Note) 
    // does not match the container class of the parent folder (IPF.Contact).
    contacts.AddSubFolder("Subfolder3", new FolderCreationOptions {EnforceContainerClassMatching = true, ContainerClass = "IPF.Note"});
}

הערה: ודאו טיפול נכון בחריגות בעת אכיפת התאמת מחלקת הקונטיינר כדי למנוע התנהגות בלתי צפויה בעת יצירת תיקייה ב-PST.

שינוי מחלקת הקונטיינר של התיקייה

לפעמים נדרש לשנות את מחלקת הקונטיינר של תיקייה. דוגמה נפוצה היא כאשר הודעות מסוגים שונים (פגישות, הודעות, וכו’) מתווספות לאותה תיקייה. במקרים כאלה, יש לשנות את מחלקת התיקייה לכל האיברים בתיקייה כדי להציגם כראוי. קטע הקוד הבא מראה כיצד לשנות את מחלקת הקונטיינר של תיקייה ב-PST למטרה זו.

using var pst = PersonalStorage.FromFile("PersonalStorage1.pst);
var folder = pst.RootFolder.GetSubFolder("Inbox");

folder.ChangeContainerClass("IPF.Note");

הוספת קבצים ל‑PST

הפונקציונליות המרכזית של Microsoft Outlook היא ניהול אימיילים, יומנים, משימות, אנשי קשר ורשומות יומן. בנוסף, ניתן גם להוסיף קבצים לתיקיית PST וה-PST שנוצר שומר רישום של המסמכים שנוספו. Aspose.Email מספקת אפשרות להוסיף קבצים לתיקייה באותו אופן יחד עם הוספת הודעות, אנשי קשר, משימות ורשומות יומן ל-PST. קטע הקוד הבא מציג כיצד להוסיף מסמכים לתיקיית PST באמצעות Aspose.Email.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
using (var personalStorage = PersonalStorage.Create(dataDir + "Ps1_out.pst", FileFormatVersion.Unicode))
{
    var folder = personalStorage.RootFolder.AddSubFolder("Files");

    // Add Document.doc file with the "IPM.Document" message class by default.
    folder.AddFile(dataDir + "attachment_1.doc", null);
}

הוספת הודעות לקבצי PST

עם Aspose.Email ניתן להוסיף הודעות לתתי-תיקיות של קובץ PST שיצרת או טעבת. מאמר זה מוסיף שתי הודעות מהדיסק לתת-תיקיית Inbox של PST. השתמש ב- PersonalStorage ו FolderInfo מחלקות להוספת הודעות לקבצי PST. כדי להוסיף הודעות לתיקיית Inbox של קובץ PST:

צור מופע של מחלקת FolderInfo וטען אותו בתכולת תיקיית Inbox.
הוסף הודעות מהדיסק לתיקיית Inbox על ידי קריאה ל- FolderInfo.AddMessage() מתודה. ה‑ FolderInfo המחלקה מציגה את AddMessages מתודה המאפשרת להוסיף מספר גדול של הודעות לתיקייה, מה שמפחית פעולות קלט/פלט לדיסק ומשפר ביצועים.

קטע הקוד שלהלן מציג כיצד להוסיף הודעות לתת-תיקייה בשם Inbox ב-PST.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Create new PST            
var personalStorage = PersonalStorage.Create(dataDir, FileFormatVersion.Unicode);

// Add new folder "Inbox"
personalStorage.RootFolder.AddSubFolder("Inbox");

// Select the "Inbox" folder
var inboxFolder = personalStorage.RootFolder.GetSubFolder("Inbox");

// Add some messages to "Inbox" folder
inboxFolder.AddMessage(MapiMessage.FromFile(RunExamples.GetDataDir_Outlook() + "MapiMsgWithPoll.msg"));

הוספת הודעות במצב הצטברות עם ביצועים משופרים

הוספת הודעות בודדות ל-PST גורמת ליותר פעולות קלט/פלט לדיסק ועלולה להאט את הביצועים. כדי לשפר ביצועים, ניתן להוסיף הודעות ל-PST במצב מוני כדי למזער פעולות קלט/פלט. AddMessages שיטה מאפשרת להוסיף הודעות במצב הצטברות וניתן להשתמש בה במקרים הבאים. בנוסף, ה‑ MessageAdded אירוע מתרחש כאשר הודעה מתווספת לתיקייה.

הוספת הודעות מ‑PST אחר

כדי להוסיף הודעות מ‑PST אחר, השתמש ב‑ FolderInfo.EnumerateMapiMessages שיטה שמחזירה IEnumerable<MapiMessage>:

using var srcPst = PersonalStorage.FromFile(@"source.pst", false);
using var destPst = PersonalStorage.FromFile(@"destination.pst");

// Get the folder by name
var srcFolder = srcPst.RootFolder.GetSubFolder("SomeFolder");
var destFolder = destPst.RootFolder.GetSubFolder("SomeFolder");

destFolder.MessageAdded += new MessageAddedEventHandler(OnMessageAdded);
destFolder.AddMessages(srcFolder.EnumerateMapiMessages());


// Handles the MessageAdded event.
static void OnMessageAdded(object sender, MessageAddedEventArgs e)
{
    Console.WriteLine($"Added: {e.EntryId}");
}

הוספת הודעות מספרייה

כדי להוסיף הודעות מספרייה, צור את GetMessages(string pathToDir) מתודת iterator בשם שמחזירה IEnumerable<MapiMessage>:

using var pst = PersonalStorage.FromFile(@"storage.pst");
var folder = pst.RootFolder.GetSubFolder("SomeFolder");
folder.MessageAdded += OnMessageAdded;
folder.AddMessages(GetMessages(@"MessageDirectory"));

// Named iterator method to read messages from directory.
static IEnumerable<MapiMessage> GetMessages(string pathToDir)
{
    string[] files = Directory.GetFiles(pathToDir, "*.msg");

    foreach (var file in files)
    {
        yield return MapiMessage.Load(file);
    }
}

// Handles the MessageAdded event.
static void OnMessageAdded(object sender, MessageAddedEventArgs e)
{
    Console.WriteLine($"Added: {e.EntryId}");
}

טעינת הודעות מהדיסק

קטע הקוד הבא מציג כיצד לטעון הודעות מהדיסק.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
private static void AddMessagesInBulkMode(string fileName, string msgFolderName)
{
    using (PersonalStorage personalStorage = PersonalStorage.FromFile(fileName))
    {
        FolderInfo folder = personalStorage.RootFolder.GetSubFolder("myInbox");
        folder.MessageAdded += OnMessageAdded;
        folder.AddMessages(new MapiMessageCollection(msgFolderName));
    }
}
static void OnMessageAdded(object sender, MessageAddedEventArgs e)
{
    Console.WriteLine(e.EntryId);
    Console.WriteLine(e.Message.Subject);
}

מימוש IEnumerable

קטע הקוד הבא מציג כיצד ניתן להשתמש במימוש IEnumerable.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
public class MapiMessageCollection : IEnumerable<MapiMessage>
{
    private string path;

    public MapiMessageCollection(string path)
    {
        this.path = path;
    }

    public IEnumerator<MapiMessage> GetEnumerator()
    {
        return new MapiMessageEnumerator(path);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class MapiMessageEnumerator : IEnumerator<MapiMessage>
{
    private readonly string[] files;

    private int position = -1;

    public MapiMessageEnumerator(string path)
    {
        string path1 = RunExamples.GetDataDir_Outlook();
        files = Directory.GetFiles(path1);
    }

    public bool MoveNext()
    {
        position++;
        return (position < files.Length);
    }

    public void Reset()
    {
        position = -1;
    }

    object IEnumerator.Current
    {
        get
        {
            return Current;
        }
    }

    public MapiMessage Current
    {
        get
        {
            try
            {
                return MapiMessage.FromFile(files[position]);
            }
            catch (IndexOutOfRangeException)
            {
                throw new InvalidOperationException();
            }
        }
    }
    public void Dispose()
    {
    }
}

Net: פעולות אסינכרוניות עם קבצי PST

Mon, 01 Jan 0001 00:00:00 +0000

כדי לשפר את הקנה מידה והתגובתיות ביישומים מודרניים, Aspose.Email עבור .NET מספקת מתודות אסינכרוניות לעבודה עם קבצי PST. ה‑APIs החדשות הללו מאפשרות למפתחים ליצור, לפתוח, למזג ולפצל קבצי PST ללא חסימת תהליך הראשי, מה שהופך אותם אידיאליים ליישומי ממשק משתמש ולשירותים בעומסים גבוהים.

צור קבצי PST באופן אסינכרוני

ה PersonalStorage.CreateAsync מתודה זו מאפשרת ליצור קובץ PST חדש באופן אסינכרוני, מה שמאפשר ביצוע ללא חסימות ביישומים שעובדים עם נתונים גדולים או דורשים ממשק משתמש מגיב. דוגמת הקוד הבאה מציגה כיצד ליישם תכונה זו בפרויקט C#.

string pstFilePath = "newMailbox.pst";
var format = FileFormatVersion.Unicode;

// Create a new PST file asynchronously
using (var pst = await PersonalStorage.CreateAsync(pstFilePath, format, CancellationToken.None))
{
     Console.WriteLine($"PST file created at: {pstFilePath}");
}

פתח קבצי PST באופן אסינכרוני

כדי לפתוח קובץ PST קיים באופן אסינכרוני, השתמש ב‑ PersonalStorage.FromFileAsync מתודה של Aspose.Email API. דוגמת הקוד הבאה מציגה כיצד ליישם תכונה זו בפרויקט C#.

string pstFilePath = "newMailbox.pst";
var format = FileFormatVersion.Unicode;

// Open the PST file asynchronously
        using (var pst = await PersonalStorage.FromFileAsync(pstFilePath, CancellationToken.None))
        {
            Console.WriteLine("PST file opened successfully.");

            // Access folders or messages here
            Console.WriteLine($"Root folder name: {pst.RootFolder.DisplayName}");
}

מזג קבצי PST באופן אסינכרוני

ה MergeWithAsync מתודה של Aspose.Email PersonalStorage מחלקה זו מאפשרת למזג את תוכן קובץ PST אחד לתוך אחר באופן אסינכרוני. זאת שימושית במקרים כמו איחוד ארכיוני דואר, צירוף גיבויים, או עיבוד נתוני אימייל בכמות גדולה - ללא חסימת תהליך הראשי של היישום. דוגמת הקוד שלהלן מציגה כיצד להשתמש במתודה זו בפרויקט C# שלך:

string targetPstPath = "mainMailbox.pst";
string sourcePstPath = "archiveToMerge.pst";

// Open both PST files asynchronously
using (var targetPst = await PersonalStorage.FromFileAsync(targetPstPath, CancellationToken.None))
using (var sourcePst = await PersonalStorage.FromFileAsync(sourcePstPath, CancellationToken.None))
{
    // Merge the source PST into the target PST
    await targetPst.MergeWithAsync(sourcePst, CancellationToken.None);

    Console.WriteLine("Merge operation completed successfully.");
}

פצל קבצי PST באופן אסינכרוני

דוגמת הקוד שלהלן מציגה כיצד לפתוח אסינכרונית קובץ PST קיים באמצעות FromFileAsync, ולאחר מכן לפצל אותו לחלקים מרובים באמצעות SplitIntoAsync. כל חלק יהיה בגודל שלא עולה על 50 מב והישמר בתיקיית הפלט המצויינת. ביצוע אסינכרוני מבטיח שהפעולה לא תחסום את תהליך הראשי, מה שמאפשר להשתמש בו ביישומים שמעבדים ארכיוני PST גדולים.

using (var pst = await PersonalStorage.FromFileAsync("input.pst"))
{
    await pst.SplitIntoAsync(50 * 1024 * 1024, "part_", "outputDirectory", CancellationToken.None);
}

Net: ניהול הודעות בקבצי PST

Mon, 01 Jan 0001 00:00:00 +0000

קבלת מידע על הודעות מקובץ Outlook PST

ב‑ קריאת קבצי PST ושליפת מידע במאמר דיברנו כיצד לטעון קובץ Outlook PST ולגלוש בתיקיותיו כדי לקבל את שמות התיקיות ומספר ההודעות בכל אחת מהן. מאמר זה מסביר כיצד לקרוא את כל התיקיות והתת‑תיקיות בקובץ PST ולהציג מידע על ההודעות, לדוגמה נושא, שולח, ונמענים. קובץ Outlook PST עשוי להכיל תיקיות מקוננות. כדי לקבל מידע על הודעות מתיקיות אלו וכן מהתיקיות ברמה העליונה, השתמש במתודה רקורסיבית לקריאת כל התיקיות. הקטע הקוד הבא מציג כיצד לקרוא קובץ Outlook PST ולהציג את תכולת התיקיות וההודעות באופן רקורסיבי.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
public static void Run()
{            
    string dataDir = RunExamples.GetDataDir_Outlook();

    // Load the Outlook file
    string path = dataDir + "PersonalStorage.pst";

    try
    {
       
        // Load the Outlook PST file
        PersonalStorage personalStorage = PersonalStorage.FromFile(path);

        // Get the Display Format of the PST file
        Console.WriteLine("Display Format: " + personalStorage.Format);

        // Get the folders and messages information
        FolderInfo folderInfo = personalStorage.RootFolder;

        // Call the recursive method to display the folder contents
        DisplayFolderContents(folderInfo, personalStorage);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);               
    }            
}

/// <summary>
/// This is a recursive method to display contents of a folder
/// </summary>
/// <param name="folderInfo"></param>
/// <param name="pst"></param>
private static void DisplayFolderContents(FolderInfo folderInfo, PersonalStorage pst)
{
    // Display the folder name
    Console.WriteLine("Folder: " + folderInfo.DisplayName);
    Console.WriteLine("==================================");
    // Display information about messages inside this folder
    MessageInfoCollection messageInfoCollection = folderInfo.GetContents();
    foreach (MessageInfo messageInfo in messageInfoCollection)
    {
        Console.WriteLine("Subject: " + messageInfo.Subject);
        Console.WriteLine("Sender: " + messageInfo.SenderRepresentativeName);
        Console.WriteLine("Recipients: " + messageInfo.DisplayTo);
        Console.WriteLine("------------------------------");
    }

    // Call this method recursively for each subfolder
    if (folderInfo.HasSubFolders == true)
    {
        foreach (FolderInfo subfolderInfo in folderInfo.GetSubFolders())
        {
            DisplayFolderContents(subfolderInfo, pst);
        }
    }
}

חילוץ הודעות מקבצי PST

מאמר זה מציג כיצד לקרוא קבצי PST של Microsoft Outlook ולחלץ הודעות. לאחר מכן ההודעות נשמרות על דיסק בפורמט MSG.

נסו זאת!

הפעל את ה‑ ConversationThread פרויקט אפליקציה פשוט, ולחקור שימוש מעניין בתכונות של Aspose.Email לקריאת אימיילים מ‑PST ומציאת שרשרות שיחה.

קטע הקוד הבא מראה כיצד לחלץ הודעות מקובץ PST:

השתמש במתודה רקורסיבית כדי לעבור על כל התיקיות (כולל תיקיות מקוננות) וקרא למתודה PersonalStorage.ExtractMessage() כדי לקבל הודעות Outlook למופע של ה- MapiMessage מחלקה.
לאחר מכן, קרא למתודה MapiMessage.Save() כדי לשמור את ההודעה לתוך דיסק או stream בפורמט MSG.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
public static void Run()
{            
    // The path to the file directory.
    string dataDir = RunExamples.GetDataDir_Outlook();

    // Load the Outlook file
    string path = dataDir + "PersonalStorage.pst";

    try
    {
        // load the Outlook PST file
        PersonalStorage pst = PersonalStorage.FromFile(path);

        // get the Display Format of the PST file
        Console.WriteLine("Display Format: " + pst.Format);

        // get the folders and messages information
        FolderInfo folderInfo = pst.RootFolder;

        // Call the recursive method to extract msg files from each folder
        ExtractMsgFiles(folderInfo, pst);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }            
}

/// <summary>
/// This is a recursive method to display contents of a folder
/// </summary>
/// <param name="folderInfo"></param>
/// <param name="pst"></param>
private static void ExtractMsgFiles(FolderInfo folderInfo, PersonalStorage pst)
{
    // display the folder name
    Console.WriteLine("Folder: " + folderInfo.DisplayName);
    Console.WriteLine("==================================");
    // loop through all the messages in this folder
    MessageInfoCollection messageInfoCollection = folderInfo.GetContents();
    foreach (MessageInfo messageInfo in messageInfoCollection)
    {
        Console.WriteLine("Saving message {0} ....", messageInfo.Subject);
        // get the message in MapiMessage instance
        MapiMessage message = pst.ExtractMessage(messageInfo);
        // save this message to disk in msg format
        message.Save(message.Subject.Replace(":", " ") + ".msg");
        // save this message to stream in msg format
        MemoryStream messageStream = new MemoryStream();
        message.Save(messageStream);
    }

    // Call this method recursively for each subfolder
    if (folderInfo.HasSubFolders == true)
    {
        foreach (FolderInfo subfolderInfo in folderInfo.GetSubFolders())
        {
            ExtractMsgFiles(subfolderInfo, pst);
        }
    }
}

זיהוי סוגי פריטי MAPI

ה MapiItemType enum מייצג סוג פריט MAPI שניתן להמיר באופן מפורש לאובייקט של המחלקה המתאימה היוצאת מ- IMapiMessageItem ממשק. כך המשתמשים יכולים להימנע מבחינת MessageClass ערך המאפיין לפני המרת ההודעה.

דוגמת הקוד הבאה מציגה כיצד להגדיר טיפוס לפריט שיומר:

foreach (var messageInfo in folder.EnumerateMessages())
{
    var msg = pst.ExtractMessage(messageInfo);

    switch (msg.SupportedType)
    {
        // Non-supported type. MapiMessage cannot be converted to an appropriate item type.
        // Just use in MSG format.
        case MapiItemType.None:
            break;
        // An email message. Conversion isn't required.
        case MapiItemType.Message:
            break;
        // A contact item. Can be converted to MapiContact.
        case MapiItemType.Contact:
            var contact = (MapiContact)msg.ToMapiMessageItem();
            break;
        // A calendar item. Can be converted to MapiCalendar.
        case MapiItemType.Calendar:
            var calendar = (MapiCalendar)msg.ToMapiMessageItem();
            break;
        // A distribution list. Can be converted to MapiDistributionList.
        case MapiItemType.DistList:
            var dl = (MapiDistributionList)msg.ToMapiMessageItem();
            break;
        // A Journal entry. Can be converted to MapiJournal.
        case MapiItemType.Journal:
            var journal = (MapiJournal)msg.ToMapiMessageItem();
            break;
        // A StickyNote. Can be converted to MapiNote.
        case MapiItemType.Note:
            var note = (MapiNote)msg.ToMapiMessageItem();
            break;
        // A Task item. Can be converted to MapiTask.
        case MapiItemType.Task:
            var task = (MapiTask)msg.ToMapiMessageItem();
            break;
    }
}

חיפוש והשליפה של הודעות

Aspose.Email מספקת את המתודות העומסות הבאות של ה- FolderInfo מחלקה לסינון ושליפת הודעות:

IEnumerable EnumerateMessages(MailQuery mailQuery) - סינון הודעות באמצעות MailQuery.
IEnumerable EnumerateMessages(MessageKind kind) - קבל הודעות לפי סוג (MessageKind).
IEnumerable EnumerateMessages(int startIndex, int count) - דף את שליפת ההודעות באמצעות אינדקס התחלה וכמות.

שליפה מדורגת של תוכן תיקייה

כאשר עובדים עם תיקיות PST גדולות, שליפת כל ההודעות בבת אחת יכולה להיות לא יעילה. כדי לשפר ביצועים ושליטה, Aspose.Email עבור .NET מציע תמיכה בפגינציה ב- FolderInfo.GetContents מתודה. מתודה זו מחזירה תת‑קבוצה של הודעות התואמות לשאילתה המוגדרת, מתחילה מאינדקס נתון ומוגבלת על‑פי ספירה. זה מאפשר לקבל הודעות בקבוצות קטנות, ניתנות לניהול. המתודה מקבלת את הפרמטרים הבאים:

IList<MessageInfo> FolderInfo.GetContents(MailQuery query, int startIndex, int count)

query — פילטר ליישום על הודעות (אופציונלי)
startIndex — האינדקס מבוסס‑אפס שממנו מתחילים את השאיבה
count — מספר ההודעות שיחזירו

דוגמת הקוד למטה מדגימה כיצד ליישם מתודה זו בפרויקט:

// Load the PST file
using (var pst = PersonalStorage.FromFile(fileName))
{
    // Access a specific subfolder
    var folder = pst.RootFolder.GetSubFolder("Inbox");

    // Build a query to filter messages by sender address
    var queryBuilder = new PersonalStorageQueryBuilder();
    queryBuilder.From.Contains("report-service", true);

    // Define the page size
    int pageSize = 5;

    // Retrieve and process messages in pages
    for (int pageIndex = 0; pageIndex < 6; pageIndex++)
    {
        int startIndex = pageIndex * pageSize;

        // Get a page of messages
        var messages = folder.GetContents(queryBuilder.GetQuery(), startIndex, pageSize);

        foreach (MessageInfo messageInfo in messages)
        {
            // Output basic info about each message
            Console.WriteLine($"Subject: {messageInfo.Subject}, Sender: {messageInfo.SenderRepresentativeName}");
        }
    }
}

שמירת הודעות ישירות מ‑PST ל‑Stream

כדי לשמור הודעות מקובץ PST ישירות ל‑stream, מבלי לחלץ את MsgInfo עבור ההודעות, השתמש במתודה SaveMessageToStream(). קטע הקוד הבא מראה כיצד לשמור הודעות ישירות מ‑PST ל‑stream.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the file directory.
string dataDir = RunExamples.GetDataDir_Outlook();

// Load the Outlook file
string path = dataDir + "PersonalStorage.pst";

// Save message to MemoryStream
using (PersonalStorage personalStorage = PersonalStorage.FromFile(path))
{
    FolderInfo inbox = personalStorage.RootFolder.GetSubFolder("Inbox");
    foreach (MessageInfo messageInfo in inbox.EnumerateMessages())
    {
        using (MemoryStream memeorystream = new MemoryStream())
        {
            personalStorage.SaveMessageToStream(messageInfo.EntryIdString, memeorystream);
        }
    }
}

// Save message to file
using (PersonalStorage pst = PersonalStorage.FromFile(path))
{
    FolderInfo inbox = pst.RootFolder.GetSubFolder("Inbox");
    foreach (MessageInfo messageInfo in inbox.EnumerateMessages())
    {
        using (FileStream fs = File.OpenWrite(messageInfo.Subject + ".msg"))
        {
            pst.SaveMessageToStream(messageInfo.EntryIdString, fs);
        }
    }
}

using (PersonalStorage pst = PersonalStorage.FromFile(path))
{
    FolderInfo inbox = pst.RootFolder.GetSubFolder("Inbox");
    
    // To enumerate entryId of messages you may use FolderInfo.EnumerateMessagesEntryId() method:
    foreach (string entryId in inbox.EnumerateMessagesEntryId())
    {
        using (MemoryStream ms = new MemoryStream())
        {
            pst.SaveMessageToStream(entryId, ms);
        }
    }
}

חילוץ מספר ספציפי של הודעות

קטע הקוד הבא מראה כיצד לחלץ מספר מסוים של הודעות מ‑PST. פשוט ספק את האינדקס של ההודעה הראשונה ואת מספר ההודעות הכולל שברצונך לחלץ.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
FolderInfo inbox = personalStorage.RootFolder.GetSubFolder("Inbox");

// Extracts messages starting from 10th index top and extract total 100 messages
MessageInfoCollection messages = inbox.GetContents(10, 100);

קבלת סך הפריטים ב‑PST

Aspose.Email מספקת את GetTotalItemsCount() שיטה של PersonalStorage.Store מאפיין. הוא מחזיר את המספר הכולל של פריטי הודעה הכלולים ב‑PST.

דוגמת הקוד הבאה מראה כיצד לאחזר את הספירה הכוללת של פריטים (הודעות, פגישות, אנשי קשר וכו’) המאוכסנים בקובץ PST:

using (var pst = PersonalStorage.FromFile("my.pst", false))
{
    var count = pst.Store.GetTotalItemsCount();
}

חילוץ קבצים מצורפים ללא חילוץ ההודעה המלאה

ניתן להשתמש ב‑API של Aspose.Email כדי לחלץ קבצים מצורפים מהודעות PST ללא חילוץ ההודעה המלאה תחילה. ה‑ ExtractAttachments מתודה של PersonalStorage ניתן להשתמש בזה. קטע הקוד הבא מראה כיצד לחלץ קבצים מצורפים מבלי לחלץ הודעה שלמה.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
string dataDir = RunExamples.GetDataDir_Outlook();

using (PersonalStorage personalstorage = PersonalStorage.FromFile(dataDir + "Outlook.pst"))
{
    FolderInfo folder = personalstorage.RootFolder.GetSubFolder("Inbox");

    foreach (var messageInfo in folder.EnumerateMessagesEntryId())
    {
        MapiAttachmentCollection attachments = personalstorage.ExtractAttachments(messageInfo);

        if (attachments.Count != 0)
        {
            foreach (var attachment in attachments)
            {
                if (!string.IsNullOrEmpty(attachment.LongFileName))
                {
                    if (attachment.LongFileName.Contains(".msg"))
                    {
                        continue;
                    }
                    else
                    {
                        attachment.Save(dataDir + @"\Attachments\" + attachment.LongFileName);
                    }
                }
            }
        }
    }
}

חילוץ נמעני הודעה מקבצי PST

ניתן לחלץ נמענים של הודעה מקבצי PST באמצעות מזהה כניסת הודעה. תכונה זו זמינה ב- PersonalStorage class. דוגמאות הקוד למטה מדגימות כיצד לחלץ נמענים של הודעה:

ב‑EntryD (using the ExtractRecipients(string entryId) שיטה של PersonalStorage class)

using (var pst = PersonalStorage.FromFile(fileName))
{  
    // Recipients are extracted using the entry ID
    var recipients = pst.ExtractRecipients("AAAAADzSMygQQFJOkKwVhb8v5EUkASAA");
}

מ-MessageInfo (using the MapiRecipientCollection ExtractRecipients(MessageInfo messageInfo) method)

using (var pst = PersonalStorage.FromFile(fileName))
{  
    // The "Inbox" folder is obtained
    var folder = pst.RootFolder.GetSubfolder("Inbox");

    // Each message in the "Inbox" folder is iterated
    foreach (var messageInfo in folder.EnumerateMessages())
    {
        // Recipients are extracted from each message
        var recipients = pst.ExtractRecipients(messageInfo);
    }
}

חיפוש הודעות ותיקיות

חיפוש לפי קריטריון

קבצי Personal Storage (PST) יכולים להכיל כמות עצומה של נתונים. חיפוש נתונים שעומדים בקריטריון ספציפי בקבצים גדולים כאלה דורש לכלול נקודות בדיקה מרובות בקוד כדי לסנן את המידע. עם ה PersonalStorageQueryBuilder מחלקה, Aspose.Email מאפשר לחפש רשומות ספציפיות ב‑PST על בסיס קריטריונים מוגדרים. ניתן לחפש הודעות ב‑PST לפי פרמטרי חיפוש כגון שולח, נמען, נושא, חשיבות הודעה, קיום קבצים מצורפים, גודל הודעה ואף מזהה הודעה. ה‑ PersonalStorageQueryBuilder גם ניתן להשתמש בו לחיפוש תיקיות משנה.

חיפוש הודעות ותיקיות ב‑PST

קטעת הקוד הבא מראה לך כיצד להשתמש ב- PersonalStorageQueryBuilder מחלקה לחיפוש תוכן ב‑PST בהתבסס על קריטריונים שונים. לדוגמה, מציג חיפוש PST על בסיס:

חשיבות ההודעה.
מחלקת הודעה.
קיום קבצים מצורפים.
גודל הודעה.
הודעות שלא נקראו.
הודעות שלא נקראו עם קבצים מצורפים, ו-
תיקיות עם שם תיקיית משנה ספציפית.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Outlook();

using (PersonalStorage personalStorage = PersonalStorage.FromFile(dataDir + "Outlook.pst"))
{
    FolderInfo folder = personalStorage.RootFolder.GetSubFolder("Inbox");
    PersonalStorageQueryBuilder builder = new PersonalStorageQueryBuilder();

    // High importance messages
    builder.Importance.Equals((int)MapiImportance.High);
    MessageInfoCollection messages = folder.GetContents(builder.GetQuery());
    Console.WriteLine("Messages with High Imp:" + messages.Count);

    builder = new PersonalStorageQueryBuilder();
    builder.MessageClass.Equals("IPM.Note");
    messages = folder.GetContents(builder.GetQuery());
    Console.WriteLine("Messages with IPM.Note:" + messages.Count);

    builder = new PersonalStorageQueryBuilder();
    // Messages with attachments AND high importance
    builder.Importance.Equals((int)MapiImportance.High);
    builder.HasFlags(MapiMessageFlags.MSGFLAG_HASATTACH);
    messages = folder.GetContents(builder.GetQuery());
    Console.WriteLine("Messages with atts: " + messages.Count);

    builder = new PersonalStorageQueryBuilder();
    // Messages with size > 15 KB
    builder.MessageSize.Greater(15000);
    messages = folder.GetContents(builder.GetQuery());
    Console.WriteLine("messags size > 15Kb:" + messages.Count);

    builder = new PersonalStorageQueryBuilder();
    // Unread messages
    builder.HasNoFlags(MapiMessageFlags.MSGFLAG_READ);
    messages = folder.GetContents(builder.GetQuery());
    Console.WriteLine("Unread:" + messages.Count);

    builder = new PersonalStorageQueryBuilder();
    // Unread messages with attachments
    builder.HasNoFlags(MapiMessageFlags.MSGFLAG_READ);
    builder.HasFlags(MapiMessageFlags.MSGFLAG_HASATTACH);
    messages = folder.GetContents(builder.GetQuery());
    Console.WriteLine("Unread msgs with atts: " + messages.Count);

    // Folder with name of 'SubInbox'
    builder = new PersonalStorageQueryBuilder();
    builder.FolderName.Equals("SubInbox");
    FolderInfoCollection folders = folder.GetSubFolders(builder.GetQuery());
    Console.WriteLine("Folder having subfolder: " + folders.Count);

    builder = new PersonalStorageQueryBuilder();
    // Folders with subfolders
    builder.HasSubfolders();
    folders = folder.GetSubFolders(builder.GetQuery());
    Console.WriteLine(folders.Count);
}

חיפוש פרמטר ללא רגישות לרישיות

קטע הקוד הבא מראה כיצד לחפש מחרוזת ב‑PST עם פרמטר ההתעלמות מרגישות לאותיות גדולות/קטנות.

using (PersonalStorage personalStorage = PersonalStorage.Create("CaseSensitivity.pst", FileFormatVersion.Unicode))
{
	FolderInfo folderinfo = personalStorage.CreatePredefinedFolder("Inbox", StandardIpmFolder.Inbox);
	folderinfo.AddMessage(MapiMessage.FromMailMessage(MailMessage.Load("Sample.eml")));
	PersonalStorageQueryBuilder builder = new PersonalStorageQueryBuilder();
	// IgnoreCase is True
	builder.From.Contains("automated", true);
	MailQuery query = builder.GetQuery();
	MessageInfoCollection coll = folderinfo.GetContents(query);
	Console.WriteLine(coll.Count);
}

חיפוש נושאי הודעות לפי מילות מפתח מרובות

אתה יכול להשתמש ב MailQueryBuilder.Or שיטה למציאת הודעות עם נושא המכיל לפחות אחד מהמילים המוגדרות כפי שמוצג למטה:

var builder1 = new PersonalStorageQueryBuilder();
builder1.Subject.Contains("Review"); // 'Review' is key word for the search

var builder2 = new PersonalStorageQueryBuilder();
builder2.Subject.Contains("Error"); // 'Error' is also key word for the search

var queryBuilder = new PersonalStorageQueryBuilder();
queryBuilder.Or(builder1.GetQuery(), builder2.GetQuery()); // message subjects must contain 'Review' or 'Error' words

using (var storage = PersonalStorage.FromFile("example.pst"))
{
    var folderInfo = storage.RootFolder.GetSubFolder("Inbox");
    var messageInfos = folderInfo.GetContents(queryBuilder.GetQuery());

    foreach (var messageInfo in messageInfos)
    {
        Console.WriteLine(messageInfo.Subject);
    }
}

טיפול בהודעות

הזזת פריטים לתיקיות אחרות

Aspose.Email מאפשר להעביר פריטים מתיקייה מקור לתיקייה אחרת באותו קובץ אחסון אישי (PST). זה כולל:

העברת תיקייה ספציפית לתיקיית אב חדשה.
העברת הודעות ספציפיות לתיקייה חדשה.
העברת התוכן לתיקייה חדשה.
העברת תיקיות משנה לתיקיית אב חדשה.

קטע הקוד הבא מראה כיצד להעביר פריטים כגון הודעות ותיקיות מתיקייה מקור לתיקייה אחרת באותו קובץ PST.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET

using(PersonalStorage personalStorage = PersonalStorage.FromFile("test.pst"))
{
    FolderInfo inbox = personalStorage.GetPredefinedFolder(StandardIpmFolder.Inbox);
    FolderInfo deleted = personalStorage.GetPredefinedFolder(StandardIpmFolder.DeletedItems);
    FolderInfo subfolder = inbox.GetSubFolder("Subfolder");

    // Move folder and message to the Deleted Items
    personalStorage.MoveItem(subfolder, deleted);
    MessageInfoCollection contents = subfolder.GetContents();
    personalStorage.MoveItem(contents[0], deleted);

    // Move all inbox subfolders and subfolder contents to the Deleted Items
    inbox.MoveSubfolders(deleted);
    subfolder.MoveContents(deleted);
}

עדכון תכונות הודעה

לעיתים יש צורך לעדכן תכונות מסוימות של הודעות כגון שינוי הנושא, סימון חשיבות ההודעה וכדומה. עדכון הודעה בקובץ PST עם שינויים אלו בתכונות ההודעה ניתן לבצע באמצעות FolderInfo.ChangeMessages מתודה. מאמר זה מציג כיצד לעדכן הודעות במצב גורף בקובץ PST עבור שינויי תכונות. קוד הדוגמה הבא מראה כיצד לעדכן תכונות של הודעות במצב גורף למספר הודעות בקובץ PST.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Outlook() + "Sub.pst";

// Load the Outlook PST file
PersonalStorage personalStorage = PersonalStorage.FromFile(dataDir);
            
// Get Requierd Subfolder 
FolderInfo inbox = personalStorage.RootFolder.GetSubFolder("Inbox");

// find messages having From = "someuser@domain.com"
PersonalStorageQueryBuilder queryBuilder = new PersonalStorageQueryBuilder();
queryBuilder.From.Contains("someuser@domain.com");

// Get Contents from Query
MessageInfoCollection messages = inbox.GetContents(queryBuilder.GetQuery());

// Save (MessageInfo,EntryIdString) in List
IList<string> changeList = new List<string>();
foreach (MessageInfo messageInfo in messages)
{
    changeList.Add(messageInfo.EntryIdString);
}

// Compose the new properties
MapiPropertyCollection updatedProperties = new MapiPropertyCollection();
updatedProperties.Add(MapiPropertyTag.PR_SUBJECT_W, new MapiProperty(MapiPropertyTag.PR_SUBJECT_W, Encoding.Unicode.GetBytes("New Subject")));
updatedProperties.Add(MapiPropertyTag.PR_IMPORTANCE, new MapiProperty(MapiPropertyTag.PR_IMPORTANCE, BitConverter.GetBytes((long)2)));

// update messages having From = "someuser@domain.com" with new properties
inbox.ChangeMessages(changeList, updatedProperties);

עדכון מאפיינים מותאמים אישית

לעיתים נדרש לסמן פריטים שעובדו בתוך קובץ PST. API של Aspose.Email מאפשר זאת באמצעות MapiProperty ו‑MapiNamedProperty. המתודות הבאות מועילות להשגת מטרה זו.

ctor MapiNamedProperty(long propertyTag, string nameIdentifier, Guid propertyGuid, byte[] propertyValue)
ctor MapiNamedProperty(long propertyTag, long nameIdentifier, Guid propertyGuid, byte[] propertyValue)
FolderInfo.ChangeMessages(MapiPropertyCollection updatedProperties) - משנה את כל ההודעות בתיקייה
PersonalStorage.ChangeMessage(string entryId, MapiPropertyCollection updatedProperties) - משנה מאפייני הודעה

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET

public static void Run()
{
	// Load the Outlook file
	string dataDir = RunExamples.GetDataDir_Outlook() + "Sub.pst";
	using (PersonalStorage personalStorage = PersonalStorage.FromFile(dataDir))
	{
		FolderInfo testFolder = personalStorage.RootFolder.GetSubFolder("Inbox");

		// Create the collection of message properties for adding or updating
		MapiPropertyCollection newProperties = new MapiPropertyCollection();

		// Normal,  Custom and PidLidLogFlags named  property
		MapiProperty property = new MapiProperty(MapiPropertyTag.PR_ORG_EMAIL_ADDR_W,Encoding.Unicode.GetBytes("test_address@org.com"));
		MapiProperty namedProperty1 = new MapiNamedProperty(GenerateNamedPropertyTag(0, MapiPropertyType.PT_LONG),"ITEM_ID",Guid.NewGuid(),BitConverter.GetBytes(123));
		MapiProperty namedProperty2 = new MapiNamedProperty(GenerateNamedPropertyTag(1, MapiPropertyType.PT_LONG),0x0000870C,new Guid("0006200A-0000-0000-C000-000000000046"),BitConverter.GetBytes(0));
		newProperties.Add(namedProperty1.Tag, namedProperty1);
		newProperties.Add(namedProperty2.Tag, namedProperty2);
		newProperties.Add(property.Tag, property);
		testFolder.ChangeMessages(testFolder.EnumerateMessagesEntryId(), newProperties);
	}
}

private static long GenerateNamedPropertyTag(long index, MapiPropertyType dataType)
{
	return (((0x8000 | index) << 16) | (long)dataType) & 0x00000000FFFFFFFF;
}

מחיקת הודעות

מאמר זה מראה כיצד להשתמש ב‑ FolderInfo מחלקה לגישה לתיקיות ספציפיות בקובץ PST. למחיקת הודעות מתת‑תיקיית Sent של קובץ PST שכבר נטען או נוצר:

צור מופע של FolderInfo מחלקה וטעון אותה בתוכן של תת‑תיקיית Sent.
מחק הודעות מתיקיית Sent על ידי קריאה ל‑ FolderInfo.DeleteChildItem() שיטה והעברת ה‑ MessageInfo.EntryId כפרמטר. קטע הקוד הבא מראה כיצד למחוק הודעות מתיקיית תת‑תיקיית Sent בקובץ PST.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Outlook() + "Sub.pst";

// Load the Outlook PST file
PersonalStorage personalStorage = PersonalStorage.FromFile(dataDir);

// Get the Sent items folder
FolderInfo folderInfo = personalStorage.GetPredefinedFolder(StandardIpmFolder.SentItems);

MessageInfoCollection msgInfoColl = folderInfo.GetContents();
foreach (MessageInfo msgInfo in msgInfoColl)
{
    Console.WriteLine(msgInfo.Subject + ": " + msgInfo.EntryIdString);
    if (msgInfo.Subject.Equals("some delete condition") == true)
    {
        // Delete this item
        folderInfo.DeleteChildItem(msgInfo.EntryId);
        Console.WriteLine("Deleted this message");
    }
}

מחיקת תיקיות

ניתן למחוק תיקיית PST על ידי העברתها לתיקיית הפריטים המחוקים.

using (PersonalStorage pst = PersonalStorage.FromFile(@"test.pst"))
{
    FolderInfo deletedItemsFolder = pst.GetPredefinedFolder(StandardIpmFolder.DeletedItems);
    FolderInfo emptyFolder = pst.RootFolder.GetSubFolder("Empty folder");
	  FolderInfo someFolder = pst.RootFolder.GetSubFolder("Some folder");
    pst.MoveItem(emptyFolder, deletedItemsFolder);
	  pst.MoveItem(someFolder, deletedItemsFolder);
}

היתרון של שיטה זו הוא שניתן לשחזר בקלות את התיקייה המחוקה.

FolderInfo someFolder = deletedItemsFolder.GetSubFolder("Some folder");
pst.MoveItem(someFolder, pst.RootFolder);

אתה יכול גם להסיר לצמיתות תיקייה מתיקיית הפריטים המחוקים, אם יש צורך.

deletedItemsFolder.DeleteChildItem(emptyFolder.EntryId);

ה DeleteChildItem() מתודה זו ניתנת לשימוש עבור כל תיקייה אם ברצונך למחוק באופן מיידי וצמתי תת‑תיקייה, לדלג על תיקיית Deleted Items.

FolderInfo someFolder = pst.RootFolder.GetSubFolder("Some folder");
pst.RootFolder.DeleteChildItem(someFolder.EntryId);

מחיקת פריטים מ‑PST

מחק פריטים (תיקיות או הודעות) מטבלת אחסון אישית (PST) באמצעות entryId הייחודי המשוייך לפריט על‑ידי קריאה למתודת DeleteItem(string entryId) של ה‑ PersonalStorage מחלקה.

ניתן להשתמש בקטע הקוד הבא כדי לקרוא למתודת DeleteItem ולשלוח את ה‑entryId כפרמטר:

var pst = PersonalStorage.FromFile("sample.pst");

// ...

pst.DeleteItem(entryId);

// ...

שימו לב:

מתודה זו תמחק לצמיתות את הפריט מה‑PST ולא ניתן לבטל זאת. שים לב לשימוש בזהירות בכדי למנוע אובדן נתונים בטעות.
בהתאם למוסכמות הסטנדרטיות, וודא שמזהה ה‑entryId תקין ומתאים לפריט קיים בתוך ה‑PST.
אחרת, ייזרק חריג. מומלץ שיהיה גיבוי של קובץ ה‑PST או ליישם אמצעים מתאימים לשחזור פריטים שנמחקו במקרה הצורך.

מחיקה גורפת

ניתן להשתמש ב‑Aspose.Email API למחיקת פריטים במקצה מתוך קובץ PST. זה מתבצע באמצעות ה‑ DeleteChildItems() שיטה שמקבלת רשימה של פריטי Entry ID המתייחסים לפריטים שברצונך למחוק. קטע הקוד הבא מראה כיצד למחוק פריטים במקצה מתוך קובץ PST.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// The path to the File directory.
string dataDir = RunExamples.GetDataDir_Outlook() + @"Sub.pst";
using (PersonalStorage personalStorage = PersonalStorage.FromFile(dataDir))
{
    // Get Inbox SubFolder from Outlook file
    FolderInfo inbox = personalStorage.RootFolder.GetSubFolder("Inbox");

    // Create instance of PersonalStorageQueryBuilder
    PersonalStorageQueryBuilder queryBuilder = new PersonalStorageQueryBuilder();

    queryBuilder.From.Contains("someuser@domain.com");
    MessageInfoCollection messages = inbox.GetContents(queryBuilder.GetQuery());
    IList<string> deleteList = new List<string>();
    foreach (MessageInfo messageInfo in messages)
    {
        deleteList.Add(messageInfo.EntryIdString);
    }

    // delete messages having From = "someuser@domain.com"
    inbox.DeleteChildItems(deleteList);
}

שחזור פריטים מחוקו רך מקבצי PST ו‑OST

Aspose.Email עבור .NET מספק מתודה לשחזור פריטים שנמחקו רך מקבצי PST ו‑OST. פונקציונליות זו מיושמת באמצעות ה‑ PersonalStorage מחלקה, הכוללת את FindAndExtractSoftDeletedItems מתודה. מתודה זו מאפשרת לאתר ולשחזר פריטים שנמחקו רך, ובכך לשחזר נתונים חשובים שעלולים otherwise להיטמרו. הפריטים המשוחזרים נשמרים בתיקיות המתאימות שלהם כ‑ .msg קבצים, תוך שמירה על מבנה התיקיות המקורי. הקוד למטה מדגים כיצד ליישם תכונה זו בפרויקט שלך:

using (var pst = PersonalStorage.FromFile(fileName))
{
    // Soft deleted items are found and extracted
    var entries = pst.FindAndExtractSoftDeletedItems();

    // The recovered items are iterated through
    for (var index = 0; index < entries.Count; index++)
    {
        // Folder information is obtained by ID
        var folderInfo = pst.GetFolderById(entries[index].FolderId);

        // A directory for the folder is created if it doesn't exist
        if (!Directory.Exists(folderInfo.DisplayName))
        {
            Directory.CreateDirectory(Path.Combine(path, folderInfo.DisplayName));
        }
        
        // The restored item is obtained
        var msg = entries[index].Item;
        
        // The restored item is saved as a .msg file
        msg.Save(Path.Combine(path, folderInfo.DisplayName, $"{index}.msg"));
    }
}

ספירת הודעות מחוקות רכות בקבצי PST

הודעות שנמחקו רך בקובץ PST הן פריטים שנמחקו פעמיים — תחילה הועברו לתיקיית Deleted Items, ולאחר מכן הוסרו שוב. הודעות אלו אינן מוחקות לצמיתות וניתן עדיין לגשת אליהן בתכנות. Aspose.Email עבור .NET תומך בשליפה של הודעות רכות אלו למטרות סקירה או שחזור.

כדי למנות ולשחזר פריטים שנמחקו רך (פעמיים) בקובצי PST, השתמש ב‑ FindAndEnumerateSoftDeletedItems() מתודה. מתודה זו מחזירה רשימה ממונה של פריטים כאלה, שכל אחד כולל הן את ההודעה והן את מזהה התיקייה שממנה הוא נמחק.

דוגמת הקוד הבאה מדגימה כיצד למנות ולשחזר אימיילים שנמחו פעמיים. היא מחזירה את RestoredItemEntry מחלקה המייצגת רשומה של פריט מוחק רך ששוחזר מקובץ PST. המחלקה מכילה את המאפיינים הבאים:

Item (MapiMessage): אובייקט ההודעה השוחזר.
FolderId (string): מזהה התיקייה שממנה ההודעה נמחקה במקור.

// Load the PST file
using (var pst = PersonalStorage.FromFile("archive.pst"))
{
    // Enumerate soft-deleted items
    foreach (var entry in pst.FindAndEnumerateSoftDeletedItems())
    {
        var message = entry.Item;
        var folderId = entry.FolderId;

        Console.WriteLine($"Subject: {message.Subject}");
        Console.WriteLine($"Deleted from Folder ID: {folderId}");
        Console.WriteLine("-----------------------------------");
    }
}

פצל קבצי PST

פצל למספר קבצי PST

API של Aspose.Email מספק אפשרות לפצל קובץ PST יחיד לכמה קבצי PST בגודל קובץ הרצוי.

דוגמת הקוד למטה מתארת את תהליך פיצול הקובץ:

זה, בתחילה, משתמש ב‑ FromFile שיטה של PersonalStorage מחלקה כדי לציין את שם הקובץ.
לאחר מכן, היא קוראת ל‑ StorageProcessedEventHandler delegate לטיפול באירוע StorageProcessed.
ה‑StorageProcessingEventArgs מספק נתונים לאירוע PersonalStorage.StorageProcessing. ה‑ StorageProcessingEventArgs.FileName המאפיין מאפשר לך לקבל את שם קובץ ה‑PST. עבור MergeWith מתודה זאת יהיה שם של קובץ ה‑PST הנוכחי שיש למזג עם הראשי, ו‑ SplitInto מתודה זאת יהיה שם של החלק הנוכחי.
לבסוף, SplitInto(long chunkSize, string partFileNamePrefix, string path) מתודת העומס תחלץ את פיצול אחסון ה‑PST לחלקים קטנים יותר. היא מקבלת את הפרמטרים הבאים:

chunkSize: הגודל המשוער של כל חלק בבאייטים.
partFileNamePrefix: הקידומת שתתווסף לשם הקובץ של כל חלק של ה‑PST. אם סופקה, הקידומת תתווסף בתחילת כל שם קובץ. אם לא סופקה (null או ריק), חלקי ה‑PST יווצרו ללא קידומת.
path: נתיב התיקייה שבה יווצרו החלקים.

שם הקובץ של כל חלק עומד בתבנית: {prefix}part{number}.pst, כאשר {prefix} הוא קידומת שם הקובץ (אם סופקה), ו‑{number} הוא מספר קובץ החלק.

var pst = PersonalStorage.FromFile("sample.pst");

// ...

pst.StorageProcessing += (sender, args) =>
{
    Console.WriteLine("Storage processing event raised for file: " + args.FileName);
};

// ...

pst.SplitInto(5000000, "prefix_", outputFolderPath);

פצל PST על פי קריטריון מוגדר

הקוד הבא מציג כיצד לפצל קובץ PST בהתבסס על קריטריון מסוים.

מיזוג קובצי PST

מיזוג לקובץ PST יחיד

זה גם יכול למזג מספר קבצי PST לקובץ PST יחיד. הן פיצול והן מיזוג של פעולות PST ניתנות למעקב על‑ידי הוספת אירועים לפעולות אלה.

קטע הקוד הבא מראה כיצד למזג לתוך קובץ PST יחיד.

נסו זאת!

מזג ושלב קבצי אימייל מרובים באופן מקוון עם גרסת החינם Aspose.Email Merger App.

מיזוג תיקיות מ‑PST אחר

קטע הקוד הבא מראה כיצד למזג תיקיות מ‑PST אחר.

Net: ניהול אנשי קשר בקבצי PST

Mon, 01 Jan 0001 00:00:00 +0000

הוספה ושמירת אנשי קשר

הוסף אנשי קשר ל‑PST

הקטע יצירת וניהול קבצי PST מציג כיצד ליצור קובץ PST ולהוסיף לו תיקיית משנה. עם Aspose.Email ניתן להוסיף MapiContact לתיקיית Contacts של קובץ PST שיצרת או טעית. להלן השלבים להוספת MapiContact ל‑PST:

צור MapiContact אובייקט.
הגדר את מאפייני MapiContact שימוש בבונים ושיטות שונים.
צור PST באמצעות ה‑ PersonalStorage.Create() שיטה.
צור תיקייה מוגדרת מראש (Contacts) ברמת השורש של קובץ PST על‑ידי גישה לתיקיית השורש ולאחר מכן קריאה ל‑ AddMapiMessageItem() שיטה.

קטע הקוד הבא מציג כיצד ליצור אובייקט MapiContact ולאחר מכן להוסיף אותו לתיקיית אנשי הקשר של קובץ PST שנוצר זה עתה.

// Create three Contacts 
var contact1 = new MapiContact("Sebastian Wright", "SebastianWright@dayrep.com");
var contact2 = new MapiContact("Wichert Kroos", "WichertKroos@teleworm.us", "Grade A Investment");
var contact3 = new MapiContact("Christoffer van de Meeberg", "ChristoffervandeMeeberg@teleworm.us", "Krauses Sofa Factory", "046-630-4614046-630-4614");

// Contact #4
var contact4 = new MapiContact{NameInfo = new MapiContactNamePropertySet("Margaret", "J.", "Tolle")};
contact4.PersonalInfo.Gender = MapiContactGender.Female;
contact4.ProfessionalInfo = new MapiContactProfessionalPropertySet("Adaptaz", "Recording engineer");
contact4.PhysicalAddresses.WorkAddress.Address = "4 Darwinia Loop EIGHTY MILE BEACH WA 6725";
contact4.ElectronicAddresses.Email1 = new MapiContactElectronicAddress("Hisen1988", "SMTP", "MargaretJTolle@dayrep.com");
contact4.Telephones.BusinessTelephoneNumber = "(08)9080-1183";
contact4.Telephones.MobileTelephoneNumber = "(925)599-3355(925)599-3355";

// Contact #5
var contact5 = new MapiContact{NameInfo = new MapiContactNamePropertySet("Matthew", "R.", "Wilcox")};
contact5.PersonalInfo.Gender = MapiContactGender.Male;
contact5.ProfessionalInfo = new MapiContactProfessionalPropertySet("Briazz", "Psychiatric aide");
contact5.PhysicalAddresses.WorkAddress.Address = "Horner Strasse 12 4421 SAASS";
contact5.Telephones.BusinessTelephoneNumber = "0650 675 73 300650 675 73 30";
contact5.Telephones.HomeTelephoneNumber = "(661)387-5382(661)387-5382";

// Contact #6
var contact6 = new MapiContact
{
    NameInfo = new MapiContactNamePropertySet("Bertha", "A.", "Buell"),
    ProfessionalInfo = new MapiContactProfessionalPropertySet("Awthentikz", "Social work assistant")
};
contact6.PersonalInfo.PersonalHomePage = "B2BTies.com";
contact6.PhysicalAddresses.WorkAddress.Address = "Im Astenfeld 59 8580 EDELSCHROTT";
contact6.ElectronicAddresses.Email1 = new MapiContactElectronicAddress("Experwas", "SMTP", "BerthaABuell@armyspy.com");
contact6.Telephones = new MapiContactTelephonePropertySet("06605045265");

using (PersonalStorage personalStorage = PersonalStorage.Create("SampleContacts_out.pst", FileFormatVersion.Unicode))
{
    var contactFolder = personalStorage.CreatePredefinedFolder("Contacts", StandardIpmFolder.Contacts);
    contactFolder.AddMapiMessageItem(contact1);
    contactFolder.AddMapiMessageItem(contact2);
    contactFolder.AddMapiMessageItem(contact3);
    contactFolder.AddMapiMessageItem(contact4);
    contactFolder.AddMapiMessageItem(contact5);
    contactFolder.AddMapiMessageItem(contact6);
}

שמירת אנשי קשר בתבנית MSG

מאמר זה מסביר כיצד לגשת למידע על אנשי קשר מקובץ Outlook PST ולשמור את איש הקשר בדיסק בתבנית MSG. השלבים לקבלת מידע על איש הקשר הם:

טען את קובץ PST ב‑ PersonalStorage אובייקט.
עיין בתיקיית אנשי הקשר.
קבל את תוכן תיקיית Contacts על‑ידי לולאה דרך ההודעות.
אמת שה‑ MessageInfo.MessageClass ערך המאפיין תואם ל‑"IPM.Contact".
הפעל את PersonalStorage.ExtractMessage() מתודה לקבלת ה- MapiMessage אובייקט.
קרא לשיטת MapiMessage.Save() כדי לשמור את איש הקשר בדיסק בתבנית MSG.

קטע הקוד הבא מראה כיצד לאחזר את כל מידע הקשר מקובץ PST ולשמור אותו לדיסק בפורמט MSG.

// Load the Outlook PST file
var pst = PersonalStorage.FromFile("SampleContacts.pst");

// Get the Contacts folder
var contactsFolder = pst.RootFolder.GetSubFolder("Contacts");

// Loop through all the contacts in this folder
foreach (MessageInfo messageInfo in contactsFolder.EnumerateMessages())
{
    if (messageInfo.MessageClass == "IPM.Contact")
    {
        // Get the contact information
        var msg = pst.ExtractMessage(messageInfo);
        
        // Save to disk in msg format
        string contactName = msg.Subject.Replace(":", " ").Replace("\\", " ").Replace("?", " ").Replace("/", " ");
        msg.Save($"{contactName}.msg", SaveOptions.DefaultMsgUnicode);
    }
}

שמירת אנשי קשר בתבנית VCF

מאמר זה מציג כיצד לגשת למידע על אנשי קשר מקובץ Microsoft Outlook PST ולשמור את איש הקשר בדיסק בתבנית vCard (VCF). השתמש ב‑ PersonalStorage ו MapiContact מחלקות לקבלת מידע על אנשי קשר מקובץ PST. כדי לקבל את המידע על אנשי הקשר:

טען את קובץ PST ב‑ PersonalStorage מחלקה.
עיין בתיקיית אנשי הקשר.
קבל את תוכן תיקיית Contacts על‑ידי לולאה דרך ההודעות.
אמת שה‑ MessageInfo.MessageClass ערך המאפיין תואם ל‑"IPM.Contact".
הפעל את PersonalStorage.ExtractMessage() מתודה לקבלת ה- MapiMessage אובייקט.
הפעל את MapiMessage.ToMapiMessageItem() ולבצע המרה של IMapiMessageItem אל MapiContact סוג.
הפעל את MapiContact.Save() שיטה לשמירת איש הקשר בדיסק בתבנית VCard.

התוכנית שלמטה טוענת קובץ PST מהדיסק ושומרת את כל אנשי הקשר בפורמט vCard (VCF). קבצי VCF יכולים לאחר מכן לשמש בכל תוכנה אחרת שמסוגלת לטעון קובץ vCard סטנדרטי. אם תפתח קובץ VCF כלשהו ב‑Microsoft Outlook, הוא יראה כמו בתצלום המסך שלהלן.

הקטע הקוד הבא מציג כיצד לייצא אנשי קשר מ‑Outlook PST לתבנית vCard (VCF).

// Load the Outlook PST file
var pst = PersonalStorage.FromFile("SampleContacts.pst");

// Get the Contacts folder
var contactsFolder = pst.RootFolder.GetSubFolder("Contacts");

// Loop through all the contacts in this folder
foreach (MessageInfo messageInfo in contactsFolder.EnumerateMessages())
{
    if (messageInfo.MessageClass == "IPM.Contact")
    {
        // Get the contact information
        var msg = pst.ExtractMessage(messageInfo);
        var contact = (MapiContact)msg.ToMapiMessageItem();

        // Display some contents on screen
        Console.WriteLine("Name: " + contact.NameInfo.DisplayName);

        // Save to disk in VCard format
        string contactName = contact.Subject.Replace(":", " ").Replace("\\", " ").Replace("?", " ").Replace("/", " ");
        contact.Save($"{contactName}.vcf", ContactSaveFormat.VCard);
    }
}

ראו גם: ניהול רשימות הפצה בקבצי PST

Net: ניהול רשימות הפצה בקבצי PST

Mon, 01 Jan 0001 00:00:00 +0000

יצירת וניהול רשימות הפצה

צור ושמור רשימות הפצה

ניתן ליצור רשימת הפצה באמצעות Aspose.Email API שהיא אוסף של מספר אנשי קשר. רשימת הפצה ניתן לשמור לתקייה בפורמט Outlook MSG וניתן לצפות/לערוך אותה בפתיחה ב-MS Outlook. קטע הקוד הבא מציג כיצד ליצור ולשמור רשימת הפצה.

קריאת רשימות הפצה

קטע הקוד הבא מראה כיצד לקרוא רשימת תפוצה מ‑PST.

using Aspose.Email.Storage.Pst;
using Aspose.Email.Mapi;

// Load the PST file
using (var pst = PersonalStorage.FromFile("your.pst"))
{
    // Get the Contacts folder
    var folder = pst.GetPredefinedFolder(StandardIpmFolder.Contacts);

    if (folder != null)
    {
        foreach (var msgInfo in folder.EnumerateMessages())
        {
            // Check if the message has the "IPM.DistList" message class
            if (msgInfo.MessageClass == "IPM.DistList")
            {
                // Extract the distribution list
                var distList = (MapiDistributionList)pst.ExtractMessage(msgInfo).ToMapiMessageItem();
                
                // Now, you can work with the distribution list
                // (e.g., access its members, display its properties, or make modifications)
            }
        }
    }
}

עדכון רשימות הפצה

קטע הקוד הבא מציג כיצד לעדכן רשימת הפצה ב-PST.

using Aspose.Email.Mapi;
using Aspose.Email.Storage.Pst;

// Load PST file
using (PersonalStorage pst = PersonalStorage.FromFile("my.pst"))
{
    // Get Contacts folder
    var folder = pst.GetPredefinedFolder(StandardIpmFolder.Contacts);

    // Add a new member to each distribution list in PST
    foreach (var msg in folder.EnumerateMessages())
    {
        // Check if the message has the "IPM.DistList" message class
        if (msg.MessageClass == "IPM.DistList")
        {
            var distList = pst.ExtractMessage(msg).ToMapiMessageItem();

            // Create a new member to add
            var member = new MapiDistributionListMember("Edward R. Manuel", "EdwardRManuel@example.com");
            distList.Members.Add(member);

            // Update Distribution List in PST
            folder.UpdateMessage(msg.EntryIdString, distList);
        }
    }
}

Net: ניהול פריטי יומן בקבצי PST

Mon, 01 Jan 0001 00:00:00 +0000

הוסף יומן MAPI ל‑PST

יצירת וניהול קבצי PST מראה כיצד ליצור קובץ PST ולהוסיף לו תיקיית משנה. עם Aspose.Email ניתן להוסיף MapiCalendar לתיקיית Calendar של קובץ PST שיצרת או טעית. להלן השלבים להוספת MapiCalendar ל‑PST:

צור MapiCalendar אובייקט.
הגדר את MapiCalendar תכונות באמצעות קונסטרוקטור ושיטות.
צור PST באמצעות ה‑ PersonalStorage.Create() שיטה.
צור תיקייה מוגדרת מראש (Calendar) בשורש קובץ PST על ידי גישה לתיקיית השורש ולאחר מכן קריאה ל‑ AddMapiMessageItem() שיטה.

קטע הקוד הבא מציג כיצד ליצור MapiCalendar ואז להוסיף אותו לתיקיית היומן של קובץ PST שנוצר זה עתה.

שמירת פריטי יומן לדיסק בתבניתICS

מאמר זה מציג כיצד לגשת לפריטי יומן מקובץ Outlook PST ולשמור את היומן בדיסק בתבנית ICS. השתמש ב‑ PersonalStorage ו MapiCalendar מחלקות לקבלת מידע על היומן. להלן השלבים לשמירת פריטי יומן:

טען את קובץ PST ב‑ PersonalStorage מחלקה.
עיון בתיקיית היומן.
קבל את תוכן תיקיית היומן כדי לקבל את אוסף ההודעות.
עבור על איסוף ההודעות.
קרא PersonalStorage.ExtractMessage() שיטה לקבלת מידע איש הקשר ב‑ MapiCalendar מחלקה.
הפעל את MapiCalendar.Save() מתודה לשמירת פריט היומן לדיסק בפורמט ICS.

התוכנית שלמטה טוענת קובץ PST מהדיסק ושומרת את כל פריטי היומן בפורמט ICS. קבצי ה‑ICS יכולים לאחר מכן לשמש בכל תוכנה אחרת שמסוגלת לטעון קובץ יומן סטנדרטי בפורמט זה. כאשר נפתח קובץ ICS ב‑Microsoft Outlook, הוא נראה כמו בתצלום המסך שלהלן.

הקטע הקוד הבא מציג כיצד לייצא פריטי יומן מ‑Outlook PST לתבנית ICS.

שמור עם חותמת זמן מקורית

המאפיינים הבאים זמינים לשמירת פריטי יומן בתבנית ICS תוך שמירה על מידע התאריך והשעה המקוריים:

MapiCalendarIcsSaveOptions - מאפשר לציין אפשרויות נוספות בעת שמירת MapiCalendar לתבנית Ics.
MapiCalendarIcsSaveOptions.KeepOriginalDateTimeStamp - מאפשר לשמור את ערך DateTimeStamp המקורי בקובץ הפלט.

השתמש בדוגמת הקוד שלהלן כדי ליישם את התכונות בפרויקט שלך:

var cal = pst.ExtractMessage(msgInfo).ToMapiMessageItem() as MapiCalendar;

if (cal != null)
{
  cal.Save("cal.ics", new MapiCalendarIcsSaveOptions() { KeepOriginalDateTimeStamp = true});
}

שינוי/מחיקת מופעים מרצפים

ניתן להוסיף חריגות למחזוריות קיימות באמצעות Aspose.Email for .NET API. קטע הקוד הבא מציג את השימוש בתכונה זו.

Net: ניהול משימות, יומנים ופתקיות בקבצי PST

Mon, 01 Jan 0001 00:00:00 +0000

הוספת משימת MAPI ל-PST

ה יצירת וניהול קבצי PST מאמר זה מציג כיצד ליצור קובץ PST ולהוסיף לו תת-תיקייה. עם Aspose.Email ניתן להוסיף MapiTask לתת תתי-תיקיית המשימות של קובץ PST שיצרת או טעבת. להלן הצעדים להוספת MapiTask ל-PST:

צור MapiTask אובייקט.
הגדר את MapiTask מאפיינים באמצעות קונסטרוקטור ושיטות שונות.
צור PST באמצעות ה‑ PersonalStorage.Create() שיטה.
צור תיקייה מוגדרת מראש (Tasks) בשורש קובץ PST על ידי גישה לתיקיית Root ולאחר מכן קריאה ל‑ AddMapiMessageItem() שיטה.

קטע הקוד הבא מציג כיצד ליצור MapiTask ואז להוסיף אותה לתיקיית המשימות של קובץ PST שנוצר זה עתה.

הוספת יומן MAPI ל-PST

Aspose.Email מאפשרת גם להוסיף MapiJournal לתת תתי-תיקיית יומן של קובץ PST שיצרת או טעבת. להלן הצעדים להוספת MapiJournal ל‑PST:

צור MapiJournal אובייקט
הגדר את MapiJournal תכונות באמצעות קונסטרוקטור ושיטות.
צור PST באמצעות ה‑ PersonalStorage.Create() שיטה.
צור תיקייה מוגדרת מראש (Journals) בשורש קובץ ה‑PST על ידי גישה לתיקיית השורש ולאחר מכן קריאה ל‑ AddMapiMessageItem() שיטה.

קטע הקוד הבא מציג כיצד ליצור MapiJournal ואז להוסיף אותה לתיקיית היומן של קובץ PST שנוצר זה עתה.

הוספת קבצים מצורפים ליומן MAPI

קטע הקוד הבא מציג כיצד להוסיף קבצים מצורפים ל- MapiJournal.

הוספת פתק MAPI ל-PST

עם Aspose.Email ניתן להוסיף MapiNote לתיקיית הפתקיות של קובץ PST שנוצר או נטען. כדי להוסיף MapiNote ל‑PST:

צור תבנית MapiNote באמצעות Microsoft Outlook ושמור אותו כקובץ MSG.
טען את הפתק MSG השמור לתוך MapiMessage אובייקט.
צור MapiNote אובייקט וטען את תבנית ההודעה MSG.
הגדר את מאפייני MapiNote.
צור PST באמצעות ה‑ PersonalStorage.Create() שיטה.
צור תיקייה מוגדרת מראש (Notes) בשורש קובץ PST על‑ידי גישה לתיקיית השורש ולאחר מכן קריאה ל‑ AddMapiMessageItem() שיטה.

קטע הקוד הבא מציג כיצד ליצור MapiNote ואז להוסיף אותה לתיקיית הפתקיות של קובץ PST שנוצר זה עתה.

Net: עבודה עם הגנת סיסמא לקובצי PST

Mon, 01 Jan 0001 00:00:00 +0000

עבודה עם הגנת סיסמא לקובץ PST

Microsoft Outlook מאפשר למשתמשים להגן על קובצי PST באמצעות סיסמה כדי להגביל גישה אליהם. Aspose.Email יכולה לאתר הגנת סיסמה בקובץ PST. הגנת הסיסמה מיושמת בפועל רק ב‑Outlook; הנתונים אינם מוצפנים כלל. וזה מאפשר להשתמש ב‑API כדי לחלץ אימיילים מבלי לדעת את הסיסמה.

נסו זאת!

הפעל את ה‑ PstPasswordManager פרויקט אפליקציה פשוט, ולחוות את תכונות Aspose.Email לניהול סיסמאות PST.

קריאת קבצי PST מוגנים בסיסמה

ניתן לקרוא קבצים מוגנים בסיסמא כמו קבצי pst רגילים ללא הגנה.

using var pst = PersonalStorage.FromFile(fileName);
foreach (var folder in pst.RootFolder.GetSubFolders())
{
    foreach (var msg in folder.EnumerateMessages())
    {

    }
}

בדוק אם PST מוגן בסיסמה

ה‑API מספק את PersonalStorage.Store.IsPasswordProtected המאפיין. ה- PersonalStorage.Store.IsPasswordProtected המאפיין מחזיר true אם קובץ PST מוגן בסיסמה ו‑false אם הוא אינו מוגן.

קטע הקוד הבא מדגים את השימוש ב‑ PersonalStorage.Store.IsPasswordProtected מאפיין.

using var pst = PersonalStorage.FromFile("passwordprotectedPST.pst");
Console.WriteLine($"The storage is password protected - {pst.Store.IsPasswordProtected}");

אימות סיסמה

ה PersonalStorage.Store.IsPasswordValid() שיטה מקבלת את מחרוזת הסיסמה כפרמטר ומחזירה true אם הסיסמה נכונה ו‑false אם היא שגויה.

קטע הקוד הבא מדגים את השימוש ב‑ PersonalStorage.Store.IsPasswordValid() שיטה.

using var pst = PersonalStorage.FromFile("passwordprotectedPST.pst");
Console.WriteLine($"Password is valid - {pst.Store.IsPasswordValid("Password1")}");

הוספה/שינוי/הסרת סיסמאות

ה PersonalStorage.Store.ChangePassword שיטה משמשת להוספה, שינוי או מחיקת סיסמה.

כדי לעשות זאת, פעל לפי הצעדים הבאים:

טעינת PST מקובץ או זרם.
הפעל את PersonalStorage.Store.ChangePassword שיטה. כדי להוסיף או לשנות את הסיסמה, העבר מחרוזת סיסמה כפרמטר, וכדי להסיר את הסיסמה, העבר ערך null.

using var pst = PersonalStorage.Create("SetPasswordOnPST_out.pst", FileFormatVersion.Unicode);
// Add or change the password
const string password = "Password1";
pst.Store.ChangePassword(password);
// Remove the password
pst.Store.ChangePassword(null);

Net: קריאת קבצי PST ושליפת מידע

Mon, 01 Jan 0001 00:00:00 +0000

קריאת קבצי PST ושליפת מידע

Aspose.Email עבור .NET מספקת API לקריאת קבצי Microsoft Outlook PST. ניתן לטעון קובץ PST מהדיסק או מזרם למופע של PersonalStorage מחלקה לקבלת מידע על תוכן הקובץ, כגון תיקיות, תתי‑תיקיות והודעות. ה‑API גם מספקת אפשרות לכלול תיקיות חיפוש במהלך מעבר על הודעות מתיקיות PST.

Load PST File

קובץ Outlook PST ניתן לטעון במופע של PersonalStorage מחלקה. קטע הקוד הבא מראה כיצד לטעון את קובץ ה‑PST.

הצגת מידע על תיקיות

לאחר טעינת קובץ PST ב‑ PersonalStorage המחלקה מאפשרת לקבל מידע על שם התצוגה של הקובץ, תיקיית השורש, תתי‑תיקיות וספירת הודעות. קטע הקוד הבא מציג כיצד להציג את שם קובץ PST, תיקיותיו ומספר ההודעות בתיקיות.

קבל רק תיקיות שהוגדרו על‑ידי המשתמש

קבצי PST/OST עשויים להכיל תיקיות שנוצרו על ידי משתמש. Aspose.Email מספקת אפשרות לגישה רק לתיקיות שהוגדרו על ידי משתמש באמצעות ה‑ PersonalStorageQueryBuilder.OnlyFoldersCreatedByUser מאפיין. ניתן להגדיר את ה‑ PersonalStorageQueryBuilder.OnlyFoldersCreatedByUser הגדרת המאפיין ל‑true כדי לקבל רק תיקיות שהוגדרו על ידי המשתמש. קטע הקוד הבא מדגים את השימוש ב‑ PersonalStorageQueryBuilder.OnlyFoldersCreatedByUser כדי לקבל תיקיות שהוגדרו על ידי המשתמש.

בדוק אם תיקייה מוגדרת מראש

כאשר פותחים ובודקים את התיקיות בתוך קובץ PST (Personal Storage Table), ניתן לבדוק האם כל תיקייה היא מסוג תיקייה מוגדרת מראש או תיקיית משנה של תיקייה מוגדרת מראש, ולקבל מידע על כל תיקייה.

ה FolderInfo.GetPredefinedTypeשיטה (bool getForTopLevelParent) מאפשרת לבדוק האם תיקייה היא מ StandardIpmFolder. אם הפרמטר getForTopLevelParent הוא true, השיטה מחזירה StandardIpmFolder ערך enum לתיקיית האב ברמה העליונה. זה קובע האם התיקייה הנוכחית היא תתי‑תיקייה של תיקייה מוגדרת מראש. אם הפרמטר getForTopLevelParent הוא false, הוא מחזיר StandardIpmFolder ערך enum לתיקייה הנוכחית.

דוגמת הקוד שלהלן מציגה כיצד ליישם תכונה זו בפרויקט שלך:

PersonalStorage.FromFile("my.pst"))
        {
            FolderInfoCollection folders = pst.RootFolder.GetSubFolders();

            foreach (FolderInfo folder in folders)
            {
                Console.WriteLine($"Folder: {folder.DisplayName}");
                Console.WriteLine($"Is predefined: {folder.GetPredefinedType(false) != StandardIpmFolder.Unspecified}");
                Console.WriteLine("-----------------------------------");
            }
        }

שלוף מידע על תיקיית האב

קוד הדוגמה הבא מראה כיצד לאחזר מידע על תיקיית האב מ‑ MessageInfo.

קבל תת‑תיקייה לפי נתיב

ה FolderInfo.GetSubFolder(string name, bool ignoreCase, bool handlePathSeparator) העמסה של השיטה תאפשר לך לקבל תת‑תיקייה בשם שצויין מתוך תיקיית PST הנוכחית.

המתודה מקבלת את הפרמטרים הבאים:

name - מציין את שם תת‑התיקייה שיש לקבל.
ignoreCase - קובע האם החיפוש בשם תת‑התיקייה יהיה רגיש לאותיות גדולות/קטנות או לא. אם מוגדר לtrue, החיפוש יהיה לא רגיש לאותיות (case‑insensitive), אחרת יהיה רגיש לאותיות.
handlePathSeparator - מציין האם יש להתייחס לשם התיקייה שהוגדר כנתיב אם הוא כולל קווים אחוריים. אם מוגדר לtrue, השיטה תפרש את שם התיקייה כנתיב, ותנסה לנווט לתת‑תיקייה באמצעות הנתיב. אם מוגדר לfalse, השיטה תתייחס לשם התיקייה כשם פשוט, ותחפש תת‑תיקייה עם התאמה מדויקת של השם.

דוגמת הקוד הבאה מפגימה כיצד ליישם שיטה זו בפרויקט שלך:

var folder = pst.RootFolder.GetSubFolder(@"Inbox\Reports\Jan", true, true);
In this sample, the method will return a ‘Jan’ named folder that is located at the Inbox\Reports\ path relative to the root folder.

פיד RSS ותיקיות ניתנות לחיפוש

תיקיית RSS Feeds סטנדרטית ב‑PersonalStorage

Aspose.Email מאפשר לקבל הפנייה לתיקייה המוגדרת מראש המוחזקת ערוצי RSS. זה יכול להיות שימושי אם ברצונך לגשת ולטפל בתוכנו של ערוצי RSS המאוחסנים בקובץ Outlook PST בצורה תכנותית. העבר את ערך RssFeeds ל‑ StandardIpmFolder enum.

דוגמת הקוד הבאה מציגה כיצד לקבל תיקיית RSS Feeds.

using (var pst = PersonalStorage.FromFile("my.pst", false))
{
    var rssFolder = pst.GetPredefinedFolder(StandardIpmFolder.RssFeeds);
}

כדי להוסיף תיקיית RSS Feeds, השתמש בקטע הקוד הבא:

using (var pst = PersonalStorage.Create("my.pst", FileFormatVersion.Unicode))
{
    var rssFolder = pst.CreatePredefinedFolder("RSS Feeds", StandardIpmFolder.RssFeeds);
}

פענוח תיקיות חיפוש

קבצי PST/OST עשויים להכיל תיקיות בעלות אפשרות חיפוש בנוסף לסוגי התיקיות הרגילים. Aspose.Email מספק את FolderKind ממחולל להגדרת ההודעות מתיקיות חיפוש כאלה עם EnumerateFolders ו GetSubFolders שיטות. קטע הקוד הבא מציג כיצד לנתח תיקיות ניתנות לחיפוש.

using (PersonalStorage pst = PersonalStorage.FromFile("my.pst"))
        {
            FolderInfoCollection folders = pst.RootFolder.GetSubFolders(FolderKind.Search | FolderKind.Normal);

            // Browse through each folder to display folder name and number of messages
            foreach (FolderInfo folder in folders)
            {
                Console.WriteLine($"Folder: {folder.DisplayName}");

                FolderInfoCollection subFolders = folder.GetSubFolders(FolderKind.Search | FolderKind.Normal);
                foreach (FolderInfo subFolder in subFolders)
                {
                    Console.WriteLine($"Sub-folder: {subFolder.DisplayName}");
                }
            }
        }

API לניווט בקבצי PST

API הניווט מאפשר לחלץ את כל פריטי ה‑PST במידת האפשר, מבלי לזרוק חריגות, אפילו אם חלק מהנתונים של הקובץ המקורי פגומים. השלבים הבאים מראים כיצד להשתמש ב‑API זה.

השתמש PersonalStorage קונסטרוקטור ו‑ Load שיטה במקום השיטה FromFile.

הקונסטרוקטור מאפשר להגדיר שיטת קולבק.

using (var currentPst = new PersonalStorage((exception, itemId) => { /* Exception handling  code. */ }))

חריגות טעינה וניווט יהיו זמינות דרך שיטת הקולבק.

ה Load השיטה מחזירה ’true’ אם הקובץ נטען בהצלחה והמשך הניווט אפשרי. אם הקובץ פגום ואין אפשרות לניווט, מחזירה ‘false’.

if (currentPst.Load(inputStream))

זה מאפשר לפתוח ולעבור גם על קבצי PST פגומים מבלי לזרוק חריגות. חריגות ופריטים פגומים יטופלו על‑ידי שיטת הקריאה חזרה.

using (PersonalStorage pst = new PersonalStorage((exception, itemId) => { /* Exception handling  code. */ }))
{
    if (pst.Load(@"test.pst"))
    {
        GetAllMessages(pst, pst.RootFolder);
    }
}

private static void GetAllMessages(PersonalStorage pst, FolderInfo folder)
{
    foreach (var messageEntryId in folder.EnumerateMessagesEntryId())
    {
        MapiMessage message = pst.ExtractMessage(messageEntryId);
    }
    foreach (var subFolder in folder.GetSubFolders())
    {
        GetAllMessages(pst, subFolder);
    }
}

שחזור צבעי קטגוריות פריט מקבצי PST

Aspose.Email מאפשרת למשתמשים לשחזר מידע על קטגוריות, כולל שמות וצבעים, מקבצי PST. ניתן לחלץ נתוני קטגוריה ולתאם אותם עם פריטים בודדים ב‑PST. השתמש בחברי ה‑API הבאים:

OutlookCategoryColor enum - מייצג את הצבע המשויך לקטגוריה.
PstItemCategory מחלקה - מספקת מאפיינים לשם הקטגוריה ולצבעה.
GetCategories שיטה - משחזרת רשימת קטגוריות עם שמותיהן וצבעיהן.

דוגמאות הקוד הבאות מדגימות כיצד לשחזר את כל הקטגוריות הזמינות מקובץ PST ולתאם את אלו המשויכות להודעה ספציפית.

שחזור קטגוריות זמינות מ‑PST

using (var pst = PersonalStorage.FromFile("mailbox.pst"))
{
   var categories = pst.GetCategories();
   
   foreach(var category in categories)
   {
       Console.WriteLine(category);
   }
}

התאם שם קטגוריה לצבע שלה

using (var pst = PersonalStorage.FromFile("mailbox.pst"))
{
    // Get all categories from the PST
    var availableCategories = pst.GetCategories();
    
    // Extract a message from the PST and retrieve the list of category names for the message
    var messageCategoryList = FollowUpManager.GetCategories(pst.ExtractMessage(messageInfo));
    
    // Iterate through each category in the message and match it with the PST category list
    foreach (var messageCategory in messageCategoryList)
    {
        var category = availableCategories.Find(c => c.Name.Equals(messageCategory, StringComparison.OrdinalIgnoreCase));

        if (category != null)
        {
            // Print the category name and its associated color
            Console.WriteLine(category);
        }
        else
        {
            Console.WriteLine($"Category: {messageCategory}, Color: Not found");
        }
    }
}

Net: קריאת קבצי PST/OST פגומים

Mon, 01 Jan 0001 00:00:00 +0000

טיפול בקבצי אחסון פגומים

לעיתים לא יהיה אפשרי לקרוא קובץ PST/OST עקב כמה בעיות. לדוגמה, חלקי נתונים עשויים להיות פגומים. במקרים כאלה, יוצאות חריגות בדרך כלל כשמקוראים את EnumerateFolders, EnumerateMessages, GetContents, GetSubfolders, וכו׳. עם זאת, הודעות או תיקיות בודדות עשויות להישאר שלמות באחסון.

מתודות למציאת מזהי הפריטים

המתודות הבאות מאפשרות למצוא מזהי פריטים באופן היררכי.

FindMessages(string parentEntryId) - מוצא את המזהים של הודעות עבור התיקייה.
FindSubfolders(string parentEntryId) - מוצא את המזהים של תת‑תיקיות עבור התיקייה.

המזהים שהושגו באמצעות המתודות ניתנים לשימוש לקבלת הודעות ותיקיות.

הערה: יש לציין שלמרות היתרונות שלו, קיימים אחסונים פגומים שלא ניתן לקרוא גם בעזרת שיטות אלה.

חיפוש בקובץ PST

דוגמת הקוד הבאה מציגה חיפוש בקובץ PST וחילוץ תיקיות והודעות. כדי לקבל את רשימת המזהים, השתמש במתודות FindMessages ו‑FindSubfolders. לאחר מכן המזהה נשלח ל‑ ExtractMessage או GetFolderById שיטה לחילוץ אלמנטים.

using (var pst = PersonalStorage.FromFile(fileName))
{
    ExploreCorruptedPst(pst, pst.RootFolder.EntryIdString);
}

public static void ExploreCorruptedPst(PersonalStorage pst, string rootFolderId)
{
    var messageIdList = pst.FindMessages(rootFolderId);

    foreach (var messageId in messageIdList)
    {
        try
        {
            var msg = pst.ExtractMessage(messageId);
            Console.WriteLine( "- " + msg.Subject);
        }
        catch
        {
            Console.WriteLine("Message reading error. Entry id: " + messageId);
        }
    }

    var folderIdList = pst.FindSubfolders(rootFolderId);

    foreach (var subFolderId in folderIdList)
    {
        if (subFolderId != rootFolderId)
        {
            try
            {
                FolderInfo subfolder = pst.GetFolderById(subFolderId);
                Console.WriteLine(subfolder.DisplayName);
            }
            catch
            {
                Console.WriteLine("Message reading error. Entry id: " + subFolderId);
            }

            ExplodeCorruptedPst(pst, subFolderId);
        }
    }
}

Net: עבודה עם קבצי PST גדולים

Mon, 01 Jan 0001 00:00:00 +0000

הביצועים עשויים להיפגע בעת עיבוד קבצי PST גדולים. הפתרונות הבאים יעזרו לך לשפר את ביצועי האפליקציה שלך כאשר אתה מעבד קבצים גדולים.

שקול שיטות המחזירות IEnumerable בזמן ניווט בתיקיות או הודעות ב-PST.

using var pst = PersonalStorage.FromFile(@"storage.pst");

foreach (var folder in pst.RootFolder.EnumerateFolders())
foreach (var messageInfo in folder.EnumerateMessages())
{
    // Do something with message
}

העדף MessageInfo לגישה למאפייני הודעה בסיסיים.

foreach (var messageInfo in folder.EnumerateMessages())
{
    Console.WriteLine($"Subject: {messageInfo.Subject}");
    Console.WriteLine($"To: {messageInfo.DisplayTo}");
    Console.WriteLine($"Importance: {messageInfo.Importance}");
    Console.WriteLine($"Message Class: {messageInfo.MessageClass}");
}

הימנע משימוש ב- ExtractMessage או EnumerateMapiMessages שיטות לכל ההודעות אלא אם נדרש גישה לכל המאפיינים.

שקול להשתמש ב- EnumerateMessagesEntryId כדי לאחזר בקלות את כל מזהי ההודעות המוכרות בתיקייה.

foreach (var id in folder.EnumerateMessagesEntryId())
{
  // Use id to retrieve a property (ExtractProperty),
    // extract a MapiMessage (ExtractMessage),
    // extarct message attachments (ExtractAttachments),
    // save msg to a stream(SaveMessageToStream).
}

שקול להשתמש ב- ExtractProperty לקריאת מאפיין יחיד החסר ב-MessageInfo.

foreach (var msgId in folder.EnumerateMessagesEntryId())
{
   var transportMessageHeaders =
       pst.ExtractProperty(Convert.FromBase64String(msgId), KnownPropertyList.TransportMessageHeaders.Tag)
           .GetString();
}

שקול להשתמש ב- ExtractAttachments אם נדרשים רק הקבצים המצורפים.

foreach (var msgId in folder.EnumerateMessagesEntryId())
{
   var attachments = pst.ExtractAttachments(msgId);
}

השתמש חיפוש לפי קריטריהסינון מבוסס - לקבלת ההודעות הדרושות.

using var pst = PersonalStorage.FromFile(@"storage.pst");

var builder = new PersonalStorageQueryBuilder();
// Unread messages
builder.HasNoFlags(MapiMessageFlags.MSGFLAG_READ);

foreach (var folder in pst.RootFolder.EnumerateFolders())
{
    var unread = folder.GetContents(builder.GetQuery());
}

שקול להשתמש ב- SaveMessageToStream אם יש צורך לשמור הודעות מ-PST.

במקום להשתמש ב-

foreach (var id in folder.EnumerateMessagesEntryId())
{
    var msg = pst.ExtractMessage(id);
    msg.Save(@"message.msg");
}

השתמש:

foreach (var id in folder.EnumerateMessagesEntryId())
{
    pst.SaveMessageToStream(id, File.OpenWrite(@"message.msg"));
}

העדף שיטות מוני כדי להוסיף או מחיקה פריטים מרובים.

Net: קריאה והמרה של קבצי Outlook

Mon, 01 Jan 0001 00:00:00 +0000

עבודה עם קבצי OST

Aspose.Email עבור .NET מספקת API לקריאת קבצי Microsoft Outlook OST. ניתן לטעון קובץ OST מדיסק או מ‑stream למופע של ה- Aspose.Email.Outlook.Pst.PersonalStorage מחלקה לגישה לתוכנה, כגון תיקיות, תתי‑תיקיות והודעות. Microsoft Outlook יוצר קובץ PST לאחסון הודעות דואר כאשר משתמשים ב‑POP3 או ב‑IMAP. לעומת זאת, הוא יוצר קובץ OST כאשר שרת המייל הוא Microsoft Exchange. קבצי OST תומכים גם בגודל קובץ גדול יותר מקבצי PST.

קריאת קבצי OST

תהליך קריאת קובץ OST עם Aspose.Email הוא בדיוק זהה לתהליך קריאת קובץ PST. אותו קוד יכול לקרוא קבצי PST ו-OST כאחד: פשוט ספק את שם הקובץ הנכון ל- PersonalStorage.FromFile() מתודה. הקוד הבא מראה כיצד לקרוא קבצי OST.

המרת OST ל‑PST

נסו זאת!

המרת אימיילים וארכיוני הודעות באופן מקוון בחינם יישום המרה של Aspose.Email.

Aspose.Email מאפשר המרת קובץ OST ל‑PST בשורת קוד אחת. באופן דומה, ניתן ליצור קובץ OST מתוך קובץ PST באמצעות אותה שורת קוד עם ה- FileFormat enumerator. נכון לעכשיו, ה‑API תומך בהמרת פורמטים של OST ל‑PST פרט לגרסאות 2013/2016/2019/2021 והגרסאות העתידיות. קטע הקוד הבא מראה כיצד להמיר OST ל‑PST.

לביצוע פעולות נוספות עם קובצי OST, אנא הפנה לדפים הבאים:

המרת PST ל‑OST

המרה מ‑PST ל‑OST אינה נתמכת ב‑Aspose.Email מכיוון ש‑OST תמיד נוצר על‑ידי Outlook בעת הוספת חשבון וסנכרון עם שרת הדואר. ההבדל בין קבצי PST ל‑OST הוא ש‑PST זמין רק באופן מקומי, בעוד שתוכן ה‑OST זמין גם על שרת הדוא"ל. לכן אין צורך להמיר PST ל‑OST לשימוש מקומי. אך ניתן לייבא PST לחשבון קיים באמצעות אשף ה‑Import/Export ב‑Outlook.

OLM הוא פורמט קובץ ספציפי המשמש את Microsoft Outlook לאחסון נתונים מקומיים כגון אימיילים, קבצים מצורפים, פתקים, נתוני לוח שנה, אנשי קשר, משימות, היסטוריה ועוד. קבצי OLM תואמים רק ל-Outlook עבור Mac ולא ניתן לפתוח או לגשת אליהם דרך Outlook עבור Windows, אשר משתמש בפורמט PST במקום זאת.

עבודה עם קבצי OLM

פתיחת קבצי OLM

קבצי פורמט OLM ניתן לפתוח בשתי דרכים:

בהשתמש בבונה
בהשתמש בשיטה הסטטית FromFile

קיימים הבדלים בהתנהגות בין השיטות הללו. ראה את הקטע למטה.

שימוש בבנאי

כדי לפתוח קובץ, קרא לבוני של ה‑ OlmStorage מחלקה והעבר את שם הקובץ המלא או הזרם כארגומנט אליה:

var fileName = "MyStorage.olm";
var olm = new OlmStorage(fileName);

שימוש במתודה סטטית FromFile

כדי לפתוח קובץ, השתמש בשיטה סטטית FromFile ועבר שם קובץ מלא או זרם כפרמטר אליו:

var fileName = "MyStorage.olm";
var olm = OlmStorage.FromFile(fileName);

קבל תיקיות

כדי לגשת למבנה הספריות של קובץ OLM, צור מופע של OlmStorage מחלקה באמצעות הבנאי שלה והעבר את הנתיב לקובץ. לאחר שהקובץ נפתח, גש למבנה הספריות שלו באמצעות ה- FolderHierarchy מאפיין. מאפיין זה מחזיר רשימה של OlmFolder אובייקטים, כל אחד מייצג ספרייה בקובץ OLM. כדי לחקור עוד יותר את מבנה הספריות, גש ל- SubFolders מאפיין של כל אובייקט, המחזיר רשימת תת-ספריות שלו. באמצעות מאפיינים אלה ניתן לנווט בכל ההיררכיה של קובץ OLM ולגשת לכל הספריות ותת-ספריות שהוא מכיל.

הדוגמא למטה מציגה את רשימת כל התיקיות בסדר היררכי:

using (var olm = new OlmStorage(fileName))
{
    PrintAllFolders(olm.FolderHierarchy, string.Empty);
}

private void PrintAllFolders(List<OlmFolder> folderHierarchy, string indent)
{
    foreach (var folder in folderHierarchy)
    {
        Console.WriteLine($"{indent}{folder.Name}");
        PrintAllFolders(folder.SubFolders, indent+"-");
    }
}

כאשר משתמשים ב‑ FromFile שיטה לפתיחת קובץ OLM, ה‑ FolderHierarchy המאפיין לא יאותחל באופן ברירת מחדל ויחזיר null. במקרה זה, יש להפעיל את המתודה GetFolders במפורש כדי לאתחל את FolderHierarchy מאפיין ולשלוף את רשימת הספריות בקובץ OLM:

using (var olm = OlmStorage.FromFile(fileName))
{
    var folders = olm.GetFolders();
}

גם אפשר לקבל כל תיקייה לפי שם:

קרא GetFolder שיטה.
העבר את שם התיקייה כפרמטר ראשון ואת הערך, שמציין האם להתעלם מרגישות לאותיות גדולות/קטנות בחיפוש תיקייה, כפרמטר שני.

using (var olm = OlmStorage.FromFile(fileName))
{
    // get inbox folder by name
    OlmFolder folder = olm.GetFolder("Inbox", true);
}

רשימת אימיילים

OlmFolder מחלקה, המייצגת תיקייה, כוללת את השיטות הבאות לקבלת רשימת האימיילים:

EnumerateMessages מיישמת איטרציה של אימיילים בתיקייה. במצב זה, כל איטרציה מחזירה OlmMessageInfo אובייקט המספק מידע קצר על האימייל.
EnumerateMapiMessages, בנוסף מיישמת איטרציה של אימיילים בתיקייה, אך במצב זה כל איטרציה מחזירה MapiMessage אובייקט המייצג את האימייל עצמו, עם כל המאפיינים.

שימוש במתודה EnumerateMessages

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);
    foreach (var messageInfo in folder.EnumerateMessages())
    {
        Console.WriteLine(messageInfo.Subject);
    }
}

שימוש במתודה EnumerateMapiMessages

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    foreach (var msg in folder.EnumerateMapiMessages())
    {
        // save message in MSG format
        msg.Save($"{msg.Subject}.msg");
    }
}

תכונות מועילות נוספות

המאפיינים השימושיים האחרים של המחלקה OlmFolder הם: HasMessages ו MessageCount מאפיינים שמחזירים את נוכחות ההודעות בתיקייה ואת הספירה שלהן.

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    if (folder.HasMessages)
    {
        Console.WriteLine($"Message count: {folder.MessageCount}");
    }
}

קבלה או קביעת תאריך שינוי של הודעה

התאריך המשופר מייצג את התאריך והשעה שבהם הודעת OLM שונתה לאחרונה. ניתן להשתמש ב‑ OlmMessageInfo.ModifiedDate מאפיין לקבלת או עדכון ערך התאריך המשופר של הודעת OLM.

הנה דוגמה שמדגימה את השימוש במאפיין:

foreach (OlmMessageInfo messageInfo in inboxFolder.EnumerateMessages())
{
   DateTime modifiedDate = messageInfo.ModifiedDate;
}

חילוץ אימיילים ופריטים

OlmStorage למחלקה יש ExtractMapiMessage מתודה המאפשרת לחלץ אימיילים. מתודה זו מקבלת OlmMessageInfo אובייקט.

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    foreach (var messageInfo in folder.EnumerateMessages())
    {
        if (messageInfo.Date == DateTime.Today)
        {
            // Extracts today's messages form Inbox
            var msg = olm.ExtractMapiMessage(messageInfo);
        }
    }
}

שימוש ב‑API של עיבוד

אתה יכול לחלץ את כל הפריטים מקובץ Outlook OLM ככל האפשר, מבלי לזרוק חריגות, אפילו אם חלק מהנתונים של הקובץ המקורי מושחתים. לביצוע זאת, השתמש ב- OlmStorage(TraversalExceptionsCallback callback) קונסטרוקטור ו‑ Load(string fileName) שיטה במקום שיטת FromFile. הבנאי מאפשר להגדיר שיטת callback.

using (var olm = new OlmStorage((exception, id) => { /* Exception handling  code. */ }))

שיטת ה-callback מאפשרת גישה לחריגות של טעינה וניווט.

if (olm.Load(fileName))

קטע הקוד הבא והשלבים מראים כיצד להשתמש ב-API זה:

צור מופע חדש של ה‑ OlmStorage מחלקה, תוך העברת callback לטיפול בהקשר של כל החריגות שמתרחשות במהלך התהליך.
טען את קובץ ה-OLM על ידי קריאה ל- Load שיטה במופע OlmStorage.
אם קובץ OLM נטען בהצלחה, קבל את היררכיית התיקיות על ידי קריאה ל- GetFolders שיטה במופע OlmStorage. היא מחזירה רשימת אובייקטים מסוג OlmFolder.
קרא לשיטת ExtractItems, תוך העברת מופע OlmStorage והרשימה של אובייקטים מסוג OlmFolder.
בשיטת ExtractItems, עבור על כל תיקייה ברשימת התיקיות.
אם התיקייה מכילה הודעות (אימיילים), הדפס את שם התיקייה לקונסול באמצעות Console.WriteLine(folder).
עבור על ההודעות בתיקייה הנוכחית על ידי קריאה לשיטת EnumerateMessages במופע OlmStorage, תוך העברת התיקייה הנוכחית כפרמטר.
הדפס את נושא כל הודעה לקונסול באמצעות Console.WriteLine(msg.Subject).
אם לתיקייה יש תיקיות משנה, קרא מחדש באופן רקורסיבי לשיטת ExtractItems, תוך העברת מופע OlmStorage ותיקיות המשנה של התיקייה הנוכחית.

using (var olm = new OlmStorage((exception, id) => { /* Exception handling  code. */ }))
{
    if (olm.Load(fileName))
    {
        var folderHierarchy = olm.GetFolders();
        ExtractItems(olm, folderHierarchy);
    }
}

private static void ExtractItems(OlmStorage olm, List<OlmFolder> folders)
{
    foreach (var folder in folders)
    {
        if (folder.HasMessages)
        {
            Console.WriteLine(folder);

            foreach (var msg in olm.EnumerateMessages(folder))
            {
                Console.WriteLine(msg.Subject);
            }
        }

        if (folder.SubFolders.Count > 0)
        {
            ExtractItems(olm, folder.SubFolders);
        }
    }
}

חילוץ הודעות לפי מזהים

לפעמים נדרש לחלץ הודעות נבחרות לפי מזהים. לדוגמה, האפליקציה שלך מאחסנת מזהים בבסיס נתונים ומחלצת הודעה לפי דרישה. זהו הדרך היעילה להימנע מלעבור על כל האחסון בכל פעם למצוא הודעה ספציפית לחילוץ. תכונה זו זמינה לאחסוני OLM. ה- EntryId מאפיין של OlmMessageInfo מחלקה משיגה את מזהה כניסת ההודעה. העומס על ExtractMapiMessage(string id) שיטה של OlmStorage מחלקה משיגה את ההודעה מ‑OLM.

הקוד למטה מציג כיצד לחלץ הודעות מ‑OLM לפי מזהים.

הקוד מבצע את הצעדים הבאים:

מתחילה לולאת foreach כדי לעבור על רשימת OlmMessageInfo אובייקטים. הלולאה משתמשת ב‑ EnumerateMessages מתודה של האובייקט olmFolder כדי לקבל רשימת כל ההודעות בתיקייה הנוכחית שמאופרת.
הLoop extracts the corresponding MapiMessage object from the storage by calling the ExtractMapiMessage(string id) מתודה של OlmStorage מחלקה, מעבירה את ה- EntryId של ההודעה הנוכחית כפרמטר.

הואבייקט MapiMessage שהתקבל ניתן להשתמש בו כדי לגשת ולשנות את תוכן ההודעה. הלולאה נמשכת עד שכל ההודעות בתיקייה עובדו.

  foreach (OlmMessageInfo msgInfo in olmFolder.EnumerateMessages())
  {
      MapiMessage msg = storage.ExtractMapiMessage(msgInfo.EntryId);
  }

קבלת נתיב תיקייה

גם תוכל לקבל את נתיב התיקייה של תיקיות בקובץ OML. Aspose.Email מספקת OlmFolder.Path מאפיין המחזיר את נתיב התיקייה. קטע הקוד הבא מדגים את השימוש ב‑ OlmFolder.Path מאפיין לקבלת נתיבי התיקיות בקובץ OML.

var storage = new OlmStorage("SampleOLM.olm");
PrintPath(storage, storage.FolderHierarchy);

public static void PrintPath(OlmStorage storage, List<OlmFolder> folders)
{
    foreach (OlmFolder folder in folders)
    {
        // print the current folder path
        Console.WriteLine(folder.Path);

        if (folder.SubFolders.Count > 0)
        {
            PrintPath(storage, folder.SubFolders);
        }
    }
}

ספירת פריטים בתיקייה

אתה גם יכול לספור את מספר הפריטים בתיקייה. Aspose.Email מספקת OlmFolder.MessageCount מאפיין המחזיר את מספר הפריטים בתיקייה. קטע הקוד הבא מדגים את השימוש ב‑ OlmFolder.MessageCount מאפיין לקבלת מספר הפריטים בתיקיות של קובץ OML.

var storage = new OlmStorage("SampleOLM.olm");
PrintMessageCount(storage.FolderHierarchy);

public static void PrintMessageCount(List<OlmFolder> folders)
{
    foreach (OlmFolder folder in folders)
    {
        Console.WriteLine("Message Count [" + folder.Name + "]: " + folder.MessageCount);
    }
}

קבל את ספירת הפריטים הכוללת של OlmStorage

OlmStorage למחלקה יש גם GetTotalItemsCount() מתודה המחזירה את המספר הכולל של פריטי הודעה שנמצאים באחסון OLM.

  using (var olm = new OlmStorage("storage.olm"))
  {
     var count = olm.GetTotalItemsCount();
  }

קבלת צבעי קטגוריות Outlook

לעבודה עם צבעי קטגוריות או קטגוריות פריט Outlook המשוכנות בקבצי OLM, Aspose.Email מציעה את הפתרונות הבאים:

OlmItemCategory מחלקה - מייצגת קטגוריות פריט Outlook הזמינות לפי שמן והצבעים המשויכים, מיוצגים בפורמט הקסדצימלי.
GetCategories() שיטה של OlmStorage מחלקה - משיגה רשימת קטגוריות.

דוגמת הקוד הבאה מדגימה כיצד לקבל את כל הקטגוריות המוצגות מאחסון OML:

using (var olm = OlmStorage.FromFile("storage.olm"))
{
    var categories = olm.GetCategories();
    
    foreach (var category in categories)
    {
        Console.WriteLine($"Category name: {category.Name}");
        
        //Color is represented as a hexadecimal value: #rrggbb
        Console.WriteLine($"Category color: {category.Color}");
    }
}

דוגמת הקוד למטה מציגה כיצד לקבל צבע קטגוריית הודעה:

foreach (var msg in olm.EnumerateMessages(folder))
{
    if (msg.Categories != null)
    {
        foreach (var msgCategory in msg.Categories)
        {
            Console.WriteLine($"Category name: {msgCategory}");
            var categoryColor = cat.First(c => c.Name.Equals(msgCategory, StringComparison.OrdinalIgnoreCase)).Color;
            Console.WriteLine($"Category color: {categoryColor}");
        }
    }
}

המרת OLM ל-PST

OLM הוא פורמט קובץ מסד נתונים המשמש את Microsoft Outlook למערכות macOS. קבצי OLM מאחסנים הודעות דוא״ל, נתוני לוח שנה, פרטי אנשי קשר והגדרות אפליקציה. קובץ OLM אינו נתמך ב‑Outlook עבור Windows. לכן, אין אפשרות לפתוח קובץ OLM של Outlook למק ב‑Outlook עבור Windows. אם ברצונך להעביר תיבת דוא״ל שלך מ‑Outlook למק ל‑Outlook עבור Windows, יש להמיר את קובץ OLM של Outlook למק לפורמט PST של Outlook.

שלבי קוד

להמרת קובץ OLM ל‑PST עקוב אחרי הצעדים הבאים:

צור מופע של OlmStorage מחלקה לפתיחת OLM מקור.
פתח קובץ OLM מקור.
צור קובץ PST חדש באמצעות Create שיטה.
צור מתודה GetContainerClass למיפוי מחלקת ההודעה למחלקת תיקייה.
צור מתודה AddToPst הקוראת רקורסיבית כל תיקייה והודעותיה מ‑OLM באמצעות המתודה EnumerateMapiMessages ומוסיפה אותן ל‑PST באותו סדר באמצעות המתודות AddSubFolder ו‑AddMessage.

דוגמת קוד

דוגמת הקוד הבאה מציגה כיצד להמיר OLM ל‑PST.

מתודת Main:

// create an instance of OlmStorage class to open source OLM
using (var olm = new OlmStorage("my.olm"))
// create a new PST file
using (var pst = PersonalStorage.Create("my.pst", FileFormatVersion.Unicode))
{
    // recursively reads each folder and its messages 
    // and adds them to the PST in the same order
    foreach (var olmFolder in olm.FolderHierarchy)
    {
        AddToPst(pst.RootFolder, olmFolder);
    }
}

מימוש המתודה GetContainerClass:

public string GetContainerClass(string messageClass)
{
    if (messageClass.StartsWith("IPM.Contact") || messageClass.StartsWith("IPM.DistList"))
    {
        return "IPF.Contact";
    }

    if (messageClass.StartsWith("IPM.StickyNote"))
    {
        return "IPF.StickyNote";
    }

    if (messageClass.StartsWith("IPM.Activity"))
    {
        return "IPF.Journal";
    }

    if (messageClass.StartsWith("IPM.Task"))
    {
        return "IPF.Task";
    }

    if (messageClass.StartsWith("IPM.Appointment") || messageClass.StartsWith("IPM.Schedule.meeting"))
    {
        return "IPF.Appointment";
    }

    return "IPF.Note";
}

מימוש המתודה AddToPst:

public void AddToPst(FolderInfo pstFolder, OlmFolder olmFolder)
{
    FolderInfo pstSubFolder = pstFolder.GetSubFolder(olmFolder.Name);

    foreach (var msg in olmFolder.EnumerateMapiMessages())
    {
        if (pstSubFolder == null)
        {
            pstSubFolder = pstFolder.AddSubFolder(olmFolder.Name, GetContainerClass(msg.MessageClass));
        }

        pstSubFolder.AddMessage(msg);
    }

    if (pstSubFolder == null)
    {

        pstSubFolder = pstFolder.AddSubFolder(olmFolder.Name);
    }

    foreach (var olmSubFolder in olmFolder.SubFolders)
    {
        AddToPst(pstSubFolder, olmSubFolder);
    }
}