Aanmaken en beheren van PST‑bestanden

Naast het parseren van een bestaand PST‑bestand biedt Aspose.Email de mogelijkheid om een PST‑bestand vanaf nul te creëren. Dit artikel toont hoe u Outlook‑PST‑bestanden maakt en submappen of berichten eraan toevoegt.

PST‑bestanden maken

Om een nieuw PST‑bestand op een lokale schijf te maken, moet u de PersonalStorage klasse. Met deze klasse kunt u PST‑bestanden maken, lezen en manipuleren in uw .NET‑toepassingen. Maak een opslagbestand vanaf nul met één regel code:

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

Submappen toevoegen aan PST

Voeg een submap toe aan de root van het PST‑bestand door de Root‑map te benaderen en vervolgens de AddSubFolder methode.

De volgende codefragment toont hoe u een submap met de naam Inbox kunt toevoegen:

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

Controleer de mapcontainerklasse

Bij het maken van nieuwe mappen of het toevoegen van items aan bestaande mappen is het belangrijk ervoor te zorgen dat de containerklasse van het nieuwe item of de map overeenkomt met de containerklasse van de bovenliggende map om de organisatorische hiërarchie binnen het PST-opslagbestand te behouden. Hiervoor heeft Aspose.Email de EnforceContainerClassMatching eigenschap van de FolderCreationOptions klasse. De eigenschap geeft aan of het controleren van de containerklasse van de toe te voegen map tegen de containerklasse van de bovenliggende map moet worden afgedwongen. Als deze op ’true’ is ingesteld, wordt er een uitzondering gegooid als de containerklassen niet overeenkomen. Standaard is ‘false’.

De volgende code‑voorbeeld toont het gebruik van de EnforceContainerClassMatching eigenschap om te bepalen of er een uitzondering moet worden gegooid bij het toevoegen van mappen met niet‑overeenkomende containerklassen:

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

Opmerking: zorg voor juiste afhandeling van uitzonderingen bij het afdwingen van overeenstemming van container‑klassen om onverwacht gedrag tijdens het aanmaken van mappen in een PST te voorkomen.

Wijzig de folder‑containerklasse

Soms is het nodig om de container‑klasse van een map te wijzigen. Een veelvoorkomend voorbeeld is wanneer berichten van verschillende types (afspraken, berichten, enz.) aan dezelfde map worden toegevoegd. In dergelijke gevallen moet de mapklasse voor alle elementen in de map worden aangepast zodat ze correct worden weergegeven. De volgende code‑snippet laat zien hoe je de container‑klasse van een map in een PST kunt wijzigen voor dit doel.

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

folder.ChangeContainerClass("IPF.Note");

Bestanden toevoegen aan PST

De kernfunctionaliteit van Microsoft Outlook is het beheren van e‑mails, agenda’s, taken, contacten en journaalitems. Bovendien kunnen bestanden ook worden toegevoegd aan een PST‑map en houdt de resulterende PST een overzicht bij van de toegevoegde documenten. Aspose.Email biedt de mogelijkheid om bestanden aan een map toe te voegen op dezelfde manier als berichten, contacten, taken en journaalitems toe te voegen aan een PST. De volgende code‑snippet laat zien hoe je documenten toevoegt aan een PST‑map met 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);
}

Berichten toevoegen aan PST‑bestanden

Met Aspose.Email kun je berichten toevoegen aan submappen van een PST‑bestand dat je hebt aangemaakt of geladen. Dit artikel voegt twee berichten van de schijf toe aan de Inbox‑submap van een PST. Gebruik de PersonalStorage en FolderInfo klassen om berichten toe te voegen aan PST‑bestanden. Om berichten toe te voegen aan de Inbox‑map van een PST‑bestand:

  1. Maak een instantie van de FolderInfo‑klasse en laad deze met de inhoud van de Inbox‑map.
  2. Voeg berichten van een schijf toe aan de Inbox‑map door de FolderInfo.AddMessage() methode. De FolderInfo klasse exposeert de AddMessages methode die het mogelijk maakt om een groot aantal berichten toe te voegen aan de map, waardoor I/O‑bewerkingen naar de schijf worden verminderd en de prestaties verbeteren.

De onderstaande code‑snippet toont hoe je berichten toevoegt aan een PST‑submap genaamd Inbox.

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

Berichten in bulk toevoegen met verbeterde prestaties

Het toevoegen van individuele berichten aan een PST betekent meer I/O‑bewerkingen naar de schijf en kan de prestaties vertragen. Om de prestaties te verbeteren, kunnen berichten in bulk aan de PST worden toegevoegd om I/O‑bewerkingen te minimaliseren. De AddMessages methode stelt u in staat berichten in bulk toe te voegen en kan worden gebruikt in de volgende scenario’s. Bovendien, de MessageAdded evenement treedt op wanneer een bericht aan de map wordt toegevoegd.

Berichten toevoegen uit een andere PST

Om berichten uit een andere PST toe te voegen, gebruik de FolderInfo.EnumerateMapiMessages methode die retourneert 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}");
}

Berichten toevoegen uit map

Om berichten uit een map toe te voegen, maak de GetMessages(string pathToDir) genaamd iterator‑methode die retourneert 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}");
}

Berichten laden van schijf

De volgende code‑snippet laat zien hoe je berichten van een schijf laadt.

// 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‑implementatie

De volgende code‑snippet laat zien hoe de IEnumerable‑implementatie kan worden gebruikt.

// 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()
    {
    }
}
Asynchrone bewerkingen met PST‑bestanden