Gerenciando Mensagens em Arquivos PST

Obter Informações de Mensagens de um Arquivo PST do Outlook

Em Ler Arquivos PST e Recuperar Informações No artigo discutimos como carregar um arquivo PST do Outlook e navegar em suas pastas para obter os nomes das pastas e o número de mensagens nelas. Este artigo explica como ler todas as pastas e subpastas no arquivo PST e exibir informações sobre as mensagens, por exemplo, assunto, remetente e destinatários. O arquivo PST do Outlook pode conter pastas aninhadas. Para obter informações de mensagens dessas pastas, bem como das pastas de nível superior, use um método recursivo para ler todas as pastas. O trecho de código a seguir mostra como ler um arquivo PST do Outlook e exibir o conteúdo das pastas e mensagens de forma recursiva.

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

Extraindo Mensagens de Arquivos PST

Este artigo mostra como ler arquivos PST do Microsoft Outlook e extrair mensagens. As mensagens são então salvas em disco no formato MSG.

Experimente!

Execute o ConversationThread projeto de aplicativo simples, e explore um uso interessante dos recursos do Aspose.Email para ler e‑mails de PST e encontrar tópicos de conversa.

O trecho de código a seguir mostra como extrair mensagens de um arquivo PST:

Use um método recursivo para percorrer todas as pastas (incluindo pastas aninhadas) e chame o método PersonalStorage.ExtractMessage() para obter mensagens do Outlook em uma instância da MapiMessage classe.
Depois disso, chame o método MapiMessage.Save() para salvar a mensagem em disco ou em um stream no formato 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);
        }
    }
}

Identificando Tipos de Item MAPI

O MapiItemType enum representa um tipo de item MAPI que pode ser convertido explicitamente em um objeto da classe correspondente derivada de IMapiMessageItem interface. Dessa forma, os usuários podem evitar verificar o MessageClass valor da propriedade antes da conversão da mensagem.

O exemplo de código a seguir mostra como definir um tipo para o item a ser convertido:

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

Busca e Recuperação de Mensagens

Aspose.Email fornece os seguintes métodos sobrecarregados de FolderInfo classe para filtrar e recuperar mensagens:

IEnumerable EnumerateMessages(MailQuery mailQuery) - Filtrar mensagens usando um MailQuery.
IEnumerable EnumerateMessages(MessageKind kind) - Recuperar mensagens por tipo (MessageKind).
IEnumerable EnumerateMessages(int startIndex, int count) - Paginar a recuperação de mensagens usando um índice inicial e contagem.

Recuperação Paginada do Conteúdo da Pasta

Ao trabalhar com pastas PST grandes, recuperar todas as mensagens de uma só vez pode ser ineficiente. Para melhorar o desempenho e o controle, o Aspose.Email para .NET oferece suporte a paginação no FolderInfo.GetContents método. Este método recupera um subconjunto de mensagens que correspondem à consulta especificada, começando de um índice dado e limitado por uma contagem. Isso permite buscar mensagens em lotes menores e gerenciáveis. O método aceita os seguintes parâmetros:

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

query — um filtro a ser aplicado às mensagens (opcional)
startIndex — o índice base zero a partir do qual iniciar a recuperação
count — o número de mensagens a retornar

O exemplo de código abaixo demonstra como implementar este método em um projeto:

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

Salvar Mensagens Diretamente do PST para Stream

Para salvar mensagens de um arquivo PST diretamente para um stream, sem extrair o MsgInfo das mensagens, use o método SaveMessageToStream(). O trecho de código a seguir mostra como salvar mensagens diretamente do PST para um 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);
        }
    }
}

Extrair Número Específico de Mensagens

O trecho de código a seguir mostra como extrair um determinado número de mensagens de um PST. Basta informar o índice da primeira mensagem e o número total de mensagens a ser extraído.

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

Obter Contagem Total de Itens do PST

Aspose.Email fornece o GetTotalItemsCount() método do PersonalStorage.Store propriedade. Ela retorna o número total de itens de mensagem contidos no PST.

O exemplo de código a seguir mostra como recuperar a contagem total de itens (mensagens, compromissos, contatos, etc.) armazenados no arquivo PST:

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

Extrair anexos sem extrair a mensagem completa

A API Aspose.Email pode ser usada para extrair anexos de mensagens PST sem extrair a mensagem completa primeiro. O ExtractAttachments método de PersonalStorage pode ser usado para fazer isso. O trecho de código a seguir mostra como extrair anexos sem extrair uma mensagem completa.

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

Extrair Destinatários de Mensagens de Arquivos PST

Destinatários de uma mensagem podem ser extraídos de arquivos PST usando um ID de entrada de mensagem. Este recurso está disponível no PersonalStorage classe. Os exemplos de código abaixo demonstram como extrair destinatários de mensagens:

por EntryD (usando o ExtractRecipients(string entryId) método do PersonalStorage classe)

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

de MessageInfo (usando o MapiRecipientCollection ExtractRecipients(MessageInfo messageInfo) método)

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

Pesquisando Mensagens e Pastas

Pesquisar por Critério

Arquivos Personal Storage (PST) podem conter uma enorme quantidade de dados. Pesquisar por dados que atendam a um critério específico em arquivos tão grandes precisa incluir vários pontos de verificação no código para filtrar as informações. Com o PersonalStorageQueryBuilder classe, Aspose.Email torna possível pesquisar registros específicos em um PST com base em critérios de pesquisa especificados. Um PST pode ser pesquisado por mensagens usando parâmetros de pesquisa como remetente, destinatário, assunto, importância da mensagem, presença de anexos, tamanho da mensagem e até ID da mensagem. O PersonalStorageQueryBuilder também pode ser usado para pesquisar subpastas.

Procurando Mensagens e Pastas no PST

O trecho de código a seguir mostra como usar o PersonalStorageQueryBuilder classe para buscar conteúdos em um PST com base em diferentes critérios de pesquisa. Por exemplo, mostra a pesquisa em um PST baseada em:

Importância da mensagem.
Classe da mensagem.
Presença de anexos.
Tamanho da mensagem.
Mensagens não lidas.
Mensagens não lidas com anexos, e
pastas com nome de subpasta específico.

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

Pesquisa com Parâmetro Ignorar Maiúsculas/Minúsculas

O trecho de código a seguir mostra como pesquisar uma string no PST com o parâmetro de ignorar maiúsculas/minúsculas.

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

Pesquisar Assuntos de Mensagens por Múltiplas Palavras‑Chave

Você pode usar MailQueryBuilder.Or método para encontrar mensagens com um assunto que contenha ao menos uma das palavras especificadas, como mostrado abaixo:

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

Manipular Mensagens

Mover Itens para Outras Pastas

Aspose.Email torna possível mover itens de uma pasta de origem para outra pasta no mesmo arquivo de Armazenamento Pessoal (PST). Isso inclui:

Movendo uma pasta especificada para uma nova pasta pai.
Movendo mensagens especificadas para uma nova pasta.
Movendo o conteúdo para uma nova pasta.
Movendo subpastas para uma nova pasta pai.

O trecho de código a seguir mostra como mover itens, como mensagens e pastas, de uma pasta de origem para outra pasta no mesmo arquivo 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);
}

Atualizar Propriedades da Mensagem

Às vezes é necessário atualizar certas propriedades de mensagens, como alterar o assunto, marcar a importância da mensagem e similares. Atualizar uma mensagem em um arquivo PST, com tais mudanças nas propriedades da mensagem, pode ser feito usando o FolderInfo.ChangeMessages método. Este artigo mostra como atualizar mensagens em massa em um arquivo PST para alterações nas propriedades. O trecho de código a seguir mostra como atualizar propriedades de mensagens em modo em lote para várias mensagens em um arquivo 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);

Atualizar Propriedades Personalizadas

Às vezes é necessário marcar itens que foram processados dentro do arquivo PST. A API Aspose.Email permite fazer isso usando MapiProperty e MapiNamedProperty. Os métodos a seguir são úteis para isso.

ctor MapiNamedProperty(long propertyTag, string nameIdentifier, Guid propertyGuid, byte[] propertyValue)
ctor MapiNamedProperty(long propertyTag, long nameIdentifier, Guid propertyGuid, byte[] propertyValue)
FolderInfo.ChangeMessages(MapiPropertyCollection updatedProperties) - altera todas as mensagens na pasta
PersonalStorage.ChangeMessage(string entryId, MapiPropertyCollection updatedProperties) - altera propriedades da mensagem

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

Excluir Mensagens

Este artigo mostra como usar o FolderInfo classe para acessar pastas específicas em um arquivo PST. Para excluir mensagens da subpasta Enviados de um arquivo PST previamente carregado ou criado:

Crie uma instância do FolderInfo classe e carregue‑a com o conteúdo da subpasta Enviados.
Exclua mensagens da pasta Enviados chamando o FolderInfo.DeleteChildItem() método e passando o MessageInfo.EntryId como parâmetro. O trecho de código a seguir mostra como excluir mensagens da subpasta Enviados de um arquivo 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");
    }
}

Excluir Pastas

Você pode excluir uma pasta PST movendo‑a para a pasta Itens Excluídos.

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

A vantagem deste método é que a pasta excluída pode ser facilmente recuperada.

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

Você também pode remover permanentemente uma pasta da pasta Itens Excluídos, se necessário.

deletedItemsFolder.DeleteChildItem(emptyFolder.EntryId);

O DeleteChildItem() método pode ser usado em quaisquer pastas se você quiser excluir imediatamente e permanentemente uma subpasta, contornando a pasta Itens Excluídos.

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

Excluir Itens do PST

Exclua itens (pastas ou mensagens) de um Personal Storage Table (PST) usando o entryId único associado ao item, chamando o método DeleteItem(string entryId) da PersonalStorage classe.

O trecho de código a seguir pode ser usado para chamar o método DeleteItem e passar o entryId como parâmetro:

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

// ...

pst.DeleteItem(entryId);

// ...

Observação:

Este método excluirá permanentemente o item do PST e não pode ser desfeito. Tenha cautela ao usar este método para evitar perda acidental de dados.
De acordo com as convenções padrão, certifique‑se de que o entryId seja válido e corresponda a um item existente dentro do PST.
Caso contrário, será lançada uma exceção. É aconselhável ter um backup do PST ou implementar medidas adequadas para recuperar itens excluídos, se necessário.

Exclusão em Massa

A API Aspose.Email pode ser usada para excluir itens em massa de um arquivo PST. Isso é conseguido usando o DeleteChildItems() método que aceita uma lista de itens Entry ID referentes aos itens a serem excluídos. O trecho de código a seguir mostra como excluir itens em massa de um arquivo 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);
}

Recuperar Itens Excluídos Suavemente de Arquivos PST e OST

Aspose.Email para .NET fornece um método para recuperar itens excluídos suavemente de arquivos PST e OST. Essa funcionalidade é implementada por meio do PersonalStorage classe, que inclui o FindAndExtractSoftDeletedItems método. Este método permite localizar e restaurar itens que foram excluídos suavemente, possibilitando a recuperação de dados importantes que poderiam ser perdidos. Os itens recuperados são salvos em suas respectivas pastas como .msg arquivos, garantindo que a estrutura original de pastas seja mantida. O exemplo de código abaixo demonstra como implementar esse recurso em seu projeto:

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

Enumerar Mensagens Excluídas Suavemente em Arquivos PST

Mensagens excluídas suavemente em um arquivo PST são itens que foram excluídos duas vezes — primeiro movidos para Itens Excluídos, depois removidos novamente. Essas mensagens não são apagadas permanentemente e ainda podem ser acessadas programaticamente. Aspose.Email para .NET suporta a recuperação dessas mensagens excluídas suavemente para revisão ou recuperação.

Para enumerar e recuperar itens que foram excluídos suavemente (excluídos duas vezes) em arquivos PST, use o FindAndEnumerateSoftDeletedItems() método. Este método recupera uma lista enumerável desses itens, cada um inclui tanto a mensagem quanto o ID da pasta de onde foi excluído.

O exemplo de código a seguir demonstra como enumerar e recuperar e‑mails que foram excluídos duas vezes. Ele retorna o RestoredItemEntry classe que representa uma entrada para um item excluído suavemente recuperado de um arquivo PST. A classe contém as seguintes propriedades:

Item (MapiMessage): O objeto de mensagem recuperado.
FolderId (string): O identificador da pasta da qual a mensagem foi originalmente excluída.

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

Dividir Arquivos PST

Dividir em Múltiplos PSTs

A API Aspose.Email fornece a capacidade de dividir um único arquivo PST em vários arquivos PST do tamanho desejado.

O exemplo de código abaixo descreve o processo de divisão de um arquivo:

Ele, primeiro, usa o FromFile método do PersonalStorage classe para especificar o nome do arquivo.
Em seguida, chama o StorageProcessedEventHandler delegate para lidar com um evento StorageProcessed.
O StorageProcessingEventArgs fornece dados para o evento PersonalStorage.StorageProcessing. Seu StorageProcessingEventArgs.FileName propriedade permite recuperar o nome do arquivo PST. Para MergeWith método será o nome do PST atual a ser mesclado com o principal, e para SplitInto método será o nome da parte atual.
Finalmente, SplitInto(long chunkSize, string partFileNamePrefix, string path) O método sobrecarregado iniciará a divisão do armazenamento PST em partes menores. Ele recebe os seguintes parâmetros:

chunkSize: O tamanho aproximado de cada fragmento em bytes.
partFileNamePrefix: O prefixo a ser adicionado ao nome de arquivo de cada parte do PST. Se fornecido, o prefixo será adicionado ao início de cada nome de arquivo. Se não fornecido (null ou vazio), as partes do PST serão criadas sem prefixo.
path: O caminho da pasta onde os fragmentos serão criados.

O nome de arquivo de cada parte segue o modelo: {prefix}part{number}.pst, onde {prefix} representa o prefixo do nome de arquivo (se fornecido) e {number} representa o número do arquivo de fragmento.

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

Dividir PST com Base em Critério Especificado

O trecho de código a seguir mostra como dividir o PST com base em um critério especificado.

Mesclar Arquivos PST

Mesclar em um Único PST

Ele também pode mesclar vários arquivos PST em um único arquivo PST. Tanto as operações de divisão quanto as de mesclagem de PSTs podem ser acompanhadas adicionando eventos a essas operações.

O trecho de código a seguir mostra como mesclar em um único PST.