PST .NET

https://www.independentsoft.de/pst/
Admin
PST .NET is a Microsoft Outlook .pst file API for .NET that enables reading, parsing, and exporting...
Tokens:12,775
Snippets:35
Trust Score:7.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Get Tasks from PST File using C#

Source: https://www.independentsoft.de/pst/tutorial/gettasks

This C# example demonstrates how to open a PST file, access the 'Tasks' folder, retrieve all items within it, and then extract and display properties of each item identified as a 'Task'. It requires the Independentsoft.Pst library.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            PstFile file = new PstFile("c:\\testfolder\\Outlook.pst");
            using (file) {
                Folder tasksFolder = file.MailboxRoot.GetFolder("Tasks");
                if (tasksFolder != null) {
                    IList<Item> items = tasksFolder.GetItems();
                    for (int m = 0; m < items.Count; m++) {
                        if (items[m] is Task) {
                            Task task = (Task)items[m];
                            Console.WriteLine("Id: " + task.Id);
                            Console.WriteLine("Subject: " + task.Subject);
                            Console.WriteLine("StartDate: " + task.StartDate);
                            Console.WriteLine("DueDate: " + task.DueDate);
                            Console.WriteLine("Owner: " + task.Owner);
                            Console.WriteLine("Body: " + task.Body);
                            Console.WriteLine("----------------------------------------------------------------");
                        }
                    }
                }
            }
            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}
```

--------------------------------

### Get Tasks from PST File using VB.NET

Source: https://www.independentsoft.de/pst/tutorial/gettasks

This VB.NET example shows how to open a PST file, navigate to the 'Tasks' folder, fetch its contents, and then process each item to display properties if it's a 'Task' object. The Independentsoft.Pst library is a prerequisite.

```vbnet
Imports System
Imports System.Collections.Generic
Imports Independentsoft.Pst

Namespace Sample
    Class Module1
        Shared Sub Main(ByVal args As String())
            Dim file As New PstFile("c:\\testfolder\\Outlook.pst")
            Using file
                Dim tasksFolder As Folder = file.MailboxRoot.GetFolder("Tasks")
                If tasksFolder IsNot Nothing Then
                    Dim items As IList(Of Item) = tasksFolder.GetItems()
                    For m As Integer = 0 To items.Count - 1
                        If TypeOf items(m) Is Task Then
                            Dim task As Task = DirectCast(items(m), Task)
                            Console.WriteLine("Id: " & task.Id)
                            Console.WriteLine("Subject: " & task.Subject)
                            Console.WriteLine("StartDate: " & task.StartDate)
                            Console.WriteLine("DueDate: " & task.DueDate)
                            Console.WriteLine("Owner: " & task.Owner)
                            Console.WriteLine("Body: " & task.Body)
                            Console.WriteLine("----------------------------------------------------------------")
                        End If
                    Next
                End If
            End Using
            Console.WriteLine("Press ENTER to exit.")
            Console.Read()
        End Sub
    End Class
End Namespace
```

--------------------------------

### Get Contacts from PST File (C#)

Source: https://www.independentsoft.de/pst/tutorial/getcontacts

This C# example retrieves all contacts from the 'Contacts' folder within a specified PST file. It iterates through the items, checks if they are contacts, and then prints various properties of each contact. Ensure you have the Independentsoft.Pst library referenced.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            PstFile file = new PstFile("c:\\testfolder\\Outlook.pst");
            using (file) {
                Folder contacts = file.MailboxRoot.GetFolder("Contacts");
                if (contacts != null) {
                    IList<Item> items = contacts.GetItems();
                    for (int m = 0; m < items.Count; m++) {
                        if (items[m] is Contact) {
                            Contact contact = (Contact)items[m];
                            Console.WriteLine("Id: " + contact.Id);
                            Console.WriteLine("GivenName: " + contact.GivenName);
                            Console.WriteLine("Email1Address: " + contact.Email1Address);
                            Console.WriteLine("Email1DisplayName: " + contact.Email1DisplayName);
                            Console.WriteLine("BusinessPhone: " + contact.BusinessPhone);
                            Console.WriteLine("BusinessAddress: " + contact.BusinessAddress);
                            Console.WriteLine("----------------------------------------------------------------");
                        }
                    }
                }
            }
            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}
```

--------------------------------

### Open PST File and Get Info (C#)

Source: https://www.independentsoft.de/pst/tutorial/getfileinfo

Opens a specified .pst file and retrieves its properties like message store name, mailbox root folder, encryption type, size, and 64-bit status. Requires the Independentsoft.Pst library.

```csharp
using System;
using Independentsoft.Pst;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            PstFile file = new PstFile("c:\\testfolder\\Outlook.pst");
            using (file) {
                Console.WriteLine("Message store name: " + file.MessageStore.DisplayName);
                Console.WriteLine("Mailbox root folder: " + file.MailboxRoot.DisplayName);
                Console.WriteLine("Encryption type: " + file.EncryptionType);
                Console.WriteLine("File size: " + file.Size);
                Console.WriteLine("Is 64-bit: " + file.Is64Bit);
            }
            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}
```

--------------------------------

### Open PST File and Get Info (VB.NET)

Source: https://www.independentsoft.de/pst/tutorial/getfileinfo

Opens a specified .pst file and retrieves its properties like message store name, mailbox root folder, encryption type, size, and 64-bit status. Requires the Independentsoft.Pst library.

```vbnet
Imports System
Imports Independentsoft.Pst

Namespace Sample
    Class Module1
        Shared Sub Main(ByVal args As String())
            Dim file As New PstFile("c:\testfolder\Outlook.pst")
            Using file
                Console.WriteLine("Message store name: " & file.MessageStore.DisplayName)
                Console.WriteLine("Mailbox root folder: " & file.MailboxRoot.DisplayName)
                Console.WriteLine("Encryption type: " & file.EncryptionType)
                Console.WriteLine("File size: " & file.Size)
                Console.WriteLine("Is 64-bit: " & file.Is64Bit)
            End Using
            Console.WriteLine("Press ENTER to exit.")
            Console.Read()
        End Sub
    End Class
End Namespace
```

--------------------------------

### List PST Folders Recursively in C#

Source: https://www.independentsoft.de/pst/tutorial/listallfolders

This C# example shows how to recursively get and list all folders from a PST file. It utilizes the Independentsoft.Pst library to access the PST file structure. The output includes folder ID, display name, container class, item count, and the full folder path. Ensure the Independentsoft.Pst library is referenced.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            PstFile file = new PstFile("c:\\testfolder\\Outlook.pst");
            using (file) {
                IList<Folder> folders = file.MailboxRoot.GetFolders(true);
                string parentFolder = file.MailboxRoot.DisplayName;
                Dictionary<long, string> parents = new Dictionary<long, string>();
                parents.Add(file.MailboxRoot.Id, parentFolder);
                
                for (int i = 0; i < folders.Count; i++) {
                    Folder currentFolder = folders[i];
                    parentFolder = (string)parents[currentFolder.ParentId];
                    string currentFolderPath = parentFolder + "\\" + currentFolder.DisplayName;
                    parents.Add(currentFolder.Id, currentFolderPath);
                    
                    Console.WriteLine("Id: " + currentFolder.Id);
                    Console.WriteLine("Name: " + currentFolder.DisplayName);
                    Console.WriteLine("Type: " + currentFolder.ContainerClass);
                    Console.WriteLine("Item count: " + currentFolder.ItemCount);
                    Console.WriteLine("Path: " + currentFolderPath);
                    Console.WriteLine("----------------------------------------------------------------");
                }
            }
            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}
```

--------------------------------

### Display Message Bodies from PST (VB.NET)

Source: https://www.independentsoft.de/pst/tutorial/displaymessagebody

This VB.NET example demonstrates how to open a PST file, retrieve messages from the 'Inbox' folder, and display their plain text, HTML, and RTF content. It uses the Independentsoft.Pst library for PST file operations.

```vbnet
Imports System
Imports System.Collections.Generic
Imports Independentsoft.Pst

Namespace Sample
    Class Module1
        Shared Sub Main(ByVal args As String())
            Dim file As New PstFile("c:\testfolder\Outlook.pst")
            Using file
                Dim inbox As Folder = file.MailboxRoot.GetFolder("Inbox")
                If inbox IsNot Nothing Then
                    Dim items As IList(Of Item) = inbox.GetItems()
                    For m As Integer = 0 To items.Count - 1
                        Console.WriteLine("Id: " & items(m).Id)
                        Console.WriteLine("Subject: " & items(m).Subject)
                        Console.WriteLine("Plain body:")
                        Console.WriteLine(items(m).Body)
                        Console.WriteLine("-------------------------------------------------------")
                        Console.WriteLine("Html body:")
                        Console.WriteLine(items(m).BodyHtmlText)
                        Console.WriteLine("-------------------------------------------------------")
                        If items(m).BodyRtf IsNot Nothing Then
                            Console.WriteLine("Rtf body:")
                            Console.WriteLine(System.Text.Encoding.UTF8.GetString(items(m).BodyRtf))
                            Console.WriteLine("-------------------------------------------------------")
                        End If
                    Next
                End If
            End Using
            Console.WriteLine("Press ENTER to exit.")
            Console.Read()
        End Sub
    End Class
End Namespace
```

--------------------------------

### Get Appointments from PST Calendar Folder using C#

Source: https://www.independentsoft.de/pst/tutorial/getappointments

This C# code snippet shows how to open a PST file, access the Calendar folder, iterate through its items, and extract details for each appointment. It requires the Independentsoft.Pst library.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            PstFile file = new PstFile("c:\\testfolder\\Outlook.pst");
            using (file) {
                Folder calendar = file.MailboxRoot.GetFolder("Calendar");
                if (calendar != null) {
                    IList<Item> items = calendar.GetItems();
                    for (int m = 0; m < items.Count; m++) {
                        if (items[m] is Appointment) {
                            Appointment appointment = (Appointment)items[m];
                            Console.WriteLine("Id: " + appointment.Id);
                            Console.WriteLine("Subject: " + appointment.Subject);
                            Console.WriteLine("StartTime: " + appointment.StartTime);
                            Console.WriteLine("EndTime: " + appointment.EndTime);
                            Console.WriteLine("----------------------------------------------------------------");
                        }
                    }
                }
            }
            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}
```

--------------------------------

### Get Appointments from PST Calendar Folder using VB.NET

Source: https://www.independentsoft.de/pst/tutorial/getappointments

This VB.NET code snippet demonstrates how to open a PST file, access the Calendar folder, iterate through its items, and extract details for each appointment. It requires the Independentsoft.Pst library.

```vbnet
Imports System
Imports System.Collections.Generic
Imports Independentsoft.Pst

Namespace Sample
    Class Module1
        Shared Sub Main(ByVal args As String())
            Dim file As New PstFile("c:\\testfolder\\Outlook.pst")
            Using file
                Dim calendar As Folder = file.MailboxRoot.GetFolder("Calendar")
                If calendar IsNot Nothing Then
                    Dim items As IList(Of Item) = calendar.GetItems()
                    For m As Integer = 0 To items.Count - 1
                        If TypeOf items(m) Is Appointment Then
                            Dim appointment As Appointment = DirectCast(items(m), Appointment)
                            Console.WriteLine("Id: " & appointment.Id)
                            Console.WriteLine("Subject: " & appointment.Subject)
                            Console.WriteLine("StartTime: " & appointment.StartTime)
                            Console.WriteLine("EndTime: " & appointment.EndTime)
                            Console.WriteLine("----------------------------------------------------------------")
                        End If
                    Next
                End If
            End Using
            Console.WriteLine("Press ENTER to exit.")
            Console.Read()
        End Sub
    End Class
End Namespace
```

--------------------------------

### Get Contacts from PST File (VB.NET)

Source: https://www.independentsoft.de/pst/tutorial/getcontacts

This VB.NET example shows how to extract contacts from a PST file's 'Contacts' folder. It uses the Independentsoft.Pst library to access the file and iterate through contacts, displaying their details. Make sure the Independentsoft.Pst library is added to your project references.

```vbnet
Imports System
Imports System.Collections.Generic
Imports Independentsoft.Pst

Namespace Sample
    Class Module1
        Shared Sub Main(ByVal args As String())
            Dim file As New PstFile("c:\\testfolder\\Outlook.pst")
            Using file
                Dim contacts As Folder = file.MailboxRoot.GetFolder("Contacts")
                If contacts IsNot Nothing Then
                    Dim items As IList(Of Item) = contacts.GetItems()
                    For m As Integer = 0 To items.Count - 1
                        If TypeOf items(m) Is Contact Then
                            Dim contact As Contact = DirectCast(items(m), Contact)
                            Console.WriteLine("Id: " & contact.Id)
                            Console.WriteLine("GivenName: " & contact.GivenName)
                            Console.WriteLine("Email1Address: " & contact.Email1Address)
                            Console.WriteLine("Email1DisplayName: " & contact.Email1DisplayName)
                            Console.WriteLine("BusinessPhone: " & contact.BusinessPhone)
                            Console.WriteLine("BusinessAddress: " & contact.BusinessAddress)
                            Console.WriteLine("----------------------------------------------------------------")
                        End If
                    Next
                End If
            End Using
            Console.WriteLine("Press ENTER to exit.")
            Console.Read()
        End Sub
    End Class
End Namespace
```

--------------------------------

### Display Message Bodies from PST (C#)

Source: https://www.independentsoft.de/pst/tutorial/displaymessagebody

This C# example shows how to open a PST file, access the 'Inbox' folder, iterate through its items, and display the plain text, HTML, and RTF bodies of each message. It utilizes the Independentsoft.Pst library for PST file manipulation.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            PstFile file = new PstFile("c:\\testfolder\\Outlook.pst");
            using (file) {
                Folder inbox = file.MailboxRoot.GetFolder("Inbox");
                if (inbox != null) {
                    IList<Item> items = inbox.GetItems();
                    for (int m = 0; m < items.Count; m++) {
                        Console.WriteLine("Id: " + items[m].Id);
                        Console.WriteLine("Subject: " + items[m].Subject);
                        Console.WriteLine("Plain body:");
                        Console.WriteLine(items[m].Body);
                        Console.WriteLine("-------------------------------------------------------");
                        Console.WriteLine("Html body:");
                        Console.WriteLine(items[m].BodyHtmlText);
                        Console.WriteLine("-------------------------------------------------------");
                        if (items[m].BodyRtf != null) {
                            Console.WriteLine("Rtf body:");
                            Console.WriteLine(System.Text.Encoding.UTF8.GetString(items[m].BodyRtf));
                            Console.WriteLine("-------------------------------------------------------");
                        }
                    }
                }
            }
            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}
```

--------------------------------

### Open PST File and Get File Information with C#

Source: https://context7.com/context7/independentsoft_de_pst/llms.txt

Opens a PST file and retrieves essential metadata such as the message store name, mailbox root folder, encryption type, file size, and whether the file is 64-bit. Requires the Independentsoft.Pst namespace.

```csharp
using System;
using Independentsoft.Pst;

namespace Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            PstFile file = new PstFile(@"c:\\testfolder\\Outlook.pst");

            using (file)
            {
                Console.WriteLine("Message store name: " + file.MessageStore.DisplayName);
                Console.WriteLine("Mailbox root folder: " + file.MailboxRoot.DisplayName);
                Console.WriteLine("Encryption type: " + file.EncryptionType);
                Console.WriteLine("File size: " + file.Size);
                Console.WriteLine("Is 64-bit: " + file.Is64Bit);
            }

            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}
```

--------------------------------

### Export PST items to .msg files (C#)

Source: https://www.independentsoft.de/pst/tutorial/export

This C# example exports all items from a PST file to individual .msg files. It recreates the folder structure locally and handles file naming to avoid invalid characters. Dependencies include the Independentsoft.Pst library. Inputs are a PST file path. Outputs are .msg files and a local directory structure.

```csharp
using System;
using System.IO;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            PstFile file = new PstFile("c:\\testfolder\\Outlook.pst");
            using (file) {
                IList<Folder> folders = file.MailboxRoot.GetFolders(true);
                Dictionary<long, string> parents = new Dictionary<long, string>();
                string parentFolderPath = "c:\\temp";
                string currentFolderPath = parentFolderPath + "\\" + file.MailboxRoot.DisplayName;
                Directory.CreateDirectory(currentFolderPath);
                parents.Add(file.MailboxRoot.Id, currentFolderPath);

                //Create folder structure
                for (int i = 0; i < folders.Count; i++) {
                    Folder currentFolder = folders[i];
                    parentFolderPath = (string)parents[currentFolder.ParentId];
                    currentFolderPath = parentFolderPath + "\\" + currentFolder.DisplayName;
                    Directory.CreateDirectory(currentFolderPath);
                    parents.Add(currentFolder.Id, currentFolderPath);
                }

                //Get items and save to folders as .msg files
                for (int j = 0; j < folders.Count; j++) {
                    for (int k = 0; k < folders[j].ChildrenCount; k += 100) {
                        IList<Item> items = folders[j].GetItems(k, k + 100);
                        for (int m = 0; m < items.Count; m++) {
                            string parentFolder = (string)parents[items[m].ParentId];
                            string fileName = GetFileName(items[m].Subject);
                            string filePath = parentFolder + "\\" + fileName;
                            if (filePath.Length > 244) {
                                filePath = filePath.Substring(0, 244);
                            }
                            filePath = filePath + "-" + items[m].Id + ".msg";
                            items[m].Save(filePath);
                        }
                    }
                }
            }
        }

        private static string GetFileName(string subject) {
            if (subject == null || subject.Length == 0) {
                string fileName = "NoSubject";
                return fileName;
            } else {
                string fileName = "";
                for (int i = 0; i < subject.Length; i++) {
                    if (subject[i] > 31 && subject[i] < 127) {
                        fileName += subject[i];
                    }
                }
                fileName = fileName.Replace("\\\", "_");
                fileName = fileName.Replace("/", "_");
                fileName = fileName.Replace(":", "_");
                fileName = fileName.Replace("*", "_");
                fileName = fileName.Replace("?", "_");
                fileName = fileName.Replace('"', "_");
                fileName = fileName.Replace("<", "_");
                fileName = fileName.Replace(">", "_");
                fileName = fileName.Replace("|", "_");
                return fileName;
            }
        }
    }
}
```

--------------------------------

### List PST Mailbox Root Folders in C#

Source: https://www.independentsoft.de/pst/tutorial/listmailboxrootfolder

This C# example iterates through the folders in the PST file's mailbox root, printing their ID, display name, type, and item count. It requires the Independentsoft.Pst library and a valid PST file path.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            PstFile file = new PstFile("c:\\testfolder\\Outlook.pst");
            using (file) {
                IList<Folder> folders = file.MailboxRoot.GetFolders();
                for (int i = 0; i < folders.Count; i++) {
                    Console.WriteLine("Id: " + folders[i].Id);
                    Console.WriteLine("Name: " + folders[i].DisplayName);
                    Console.WriteLine("Type: " + folders[i].ContainerClass);
                    Console.WriteLine("Item count: " + folders[i].ItemCount);
                    Console.WriteLine("--------------------------------------------------------");
                }
            }
            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}
```

--------------------------------

### List PST Folders Recursively in VB.NET

Source: https://www.independentsoft.de/pst/tutorial/listallfolders

This VB.NET example demonstrates how to recursively retrieve and list all folders from a PST file using the Independentsoft.Pst library. It outputs folder details such as ID, name, type, item count, and the complete path. The Independentsoft.Pst library must be referenced for this code to function.

```vbnet
Imports System
Imports System.Collections.Generic
Imports Independentsoft.Pst

Namespace Sample
    Class Module1
        Shared Sub Main(ByVal args As String())
            Dim file As New PstFile("c:\\testfolder\\Outlook.pst")
            Using file
                Dim folders As IList(Of Folder) = file.MailboxRoot.GetFolders(True)
                Dim parentFolder As String = file.MailboxRoot.DisplayName
                Dim parents As New Dictionary(Of Long, String)()
                parents.Add(file.MailboxRoot.Id, parentFolder)
                
                For i As Integer = 0 To folders.Count - 1
                    Dim currentFolder As Folder = folders(i)
                    parentFolder = DirectCast(parents(currentFolder.ParentId), String)
                    Dim currentFolderPath As String = parentFolder & "\" & currentFolder.DisplayName
                    parents.Add(currentFolder.Id, currentFolderPath)
                    
                    Console.WriteLine("Id: " & currentFolder.Id)
                    Console.WriteLine("Name: " & currentFolder.DisplayName)
                    Console.WriteLine("Type: " & currentFolder.ContainerClass)
                    Console.WriteLine("Item count: " & currentFolder.ItemCount)
                    Console.WriteLine("Path: " & currentFolderPath)
                    Console.WriteLine("----------------------------------------------------------------")
                Next
            End Using
            Console.WriteLine("Press ENTER to exit.")
            Console.Read()
        End Sub
    End Class
End Namespace
```

--------------------------------

### Export PST to EML in VB.NET

Source: https://www.independentsoft.de/pst/tutorial/exporttomimemessages

This VB.NET code provides the same functionality as the C# example, exporting PST content to EML files. It also recreates the PST folder structure locally and cleans up subject lines for valid filenames.

```vbnet
Imports System
Imports System.IO
Imports System.Collections.Generic
Imports Independentsoft.Pst

Namespace Sample
    Class Program
        Shared Sub Main(ByVal args As String())
            Dim file As New PstFile("c:\\testfolder\\Outlook.pst")
            Using file
                Dim folders As IList(Of Folder) = file.MailboxRoot.GetFolders(True)
                Dim parents As New Dictionary(Of Long, String)()
                Dim parentFolderPath As String = "c:\\temp\\eml"
                Dim currentFolderPath As String = parentFolderPath & "\\" & file.MailboxRoot.DisplayName
                Directory.CreateDirectory(currentFolderPath)
                parents.Add(file.MailboxRoot.Id, currentFolderPath)

                'Create folder structure
                For i As Integer = 0 To folders.Count - 1
                    Dim currentFolder As Folder = folders(i)
                    parentFolderPath = DirectCast(parents(currentFolder.ParentId), String)
                    currentFolderPath = parentFolderPath & "\\" & currentFolder.DisplayName
                    Directory.CreateDirectory(currentFolderPath)
                    parents.Add(currentFolder.Id, currentFolderPath)
                Next

                'Get items and save to folders as .msg files
                For j As Integer = 0 To folders.Count - 1
                    For k As Integer = 0 To folders(j).ChildrenCount - 1 Step 1000
                        Dim items As IList(Of Item) = folders(j).GetItems(k, k + 1000)
                        For m As Integer = 0 To items.Count - 1
                            Dim parentFolder As String = DirectCast(parents(items(m).ParentId), String)
                            Dim fileName As String = GetFileName(items(m).Subject)
                            Dim filePath As String = parentFolder & "\\" & fileName
                            If filePath.Length > 244 Then
                                filePath = filePath.Substring(0, 244)
                            End If
                            filePath = filePath & "-" & items(m).Id & ".eml"
                            items(m).GetMessageFile().ConvertToMimeMessage().Save(filePath)
                        Next
                    Next
                Next
            End Using
        End Sub

        Private Shared Function GetFileName(ByVal subject As String) As String
            If subject Is Nothing OrElse subject.Length = 0 Then
                Dim fileName As String = "NoSubject"
                Return fileName
            Else
                Dim fileName As String = ""
                For i As Integer = 0 To subject.Length - 1
                    If subject(i) > Chr(31) AndAlso subject(i) < Chr(127) Then
                        fileName += subject(i)
                    End If
                Next
                fileName = fileName.Replace("\\", "_")
                fileName = fileName.Replace("/", "_")
                fileName = fileName.Replace(":", "_")
                fileName = fileName.Replace("*", "_")
                fileName = fileName.Replace("?", "_")
                fileName = fileName.Replace("\"", "_")
                fileName = fileName.Replace("<", "_")
                fileName = fileName.Replace(">", "_")
                fileName = fileName.Replace("|", "_")
                Return fileName
            End If
        End Function
    End Class
End Namespace
```

--------------------------------

### List PST Mailbox Root Folders in VB.NET

Source: https://www.independentsoft.de/pst/tutorial/listmailboxrootfolder

This VB.NET example retrieves and displays details for each folder in the PST file's mailbox root, including ID, name, type, and item count. Ensure you have the Independentsoft.Pst library referenced and a correct PST file path.

```vbnet
Imports System
Imports System.Collections.Generic
Imports Independentsoft.Pst

Namespace Sample
    Class Module1
        Shared Sub Main(ByVal args As String())
            Dim file As New PstFile("c:\testfolder\Outlook.pst")
            Using file
                Dim folders As IList(Of Folder) = file.MailboxRoot.GetFolders()
                For i As Integer = 0 To folders.Count - 1
                    Console.WriteLine("Id: " & folders(i).Id)
                    Console.WriteLine("Name: " & folders(i).DisplayName)
                    Console.WriteLine("Type: " & folders(i).ContainerClass)
                    Console.WriteLine("Item count: " & folders(i).ItemCount)
                    Console.WriteLine("--------------------------------------------------------")
                Next
            End Using
            Console.WriteLine("Press ENTER to exit.")
            Console.Read()
        End Sub
    End Class
End Namespace
```

--------------------------------

### Export PST items to .msg files (VB.NET)

Source: https://www.independentsoft.de/pst/tutorial/export

This VB.NET example exports all items from a PST file to individual .msg files, mirroring the PST's folder structure. It includes a helper function to sanitize filenames. This requires the Independentsoft.Pst library. The input is a PST file path, and the output is .msg files organized into corresponding directories.

```vbnet
Imports System
Imports System.IO
Imports System.Collections.Generic
Imports Independentsoft.Pst

Namespace Sample
    Class Program
        Shared Sub Main(ByVal args As String())
            Dim file As New PstFile("c:\\testfolder\\Outlook.pst")
            Using file
                Dim folders As IList(Of Folder) = file.MailboxRoot.GetFolders(True)
                Dim parents As New Dictionary(Of Long, String)()
                Dim parentFolderPath As String = "c:\\temp"
                Dim currentFolderPath As String = parentFolderPath & "\\" & file.MailboxRoot.DisplayName
                Directory.CreateDirectory(currentFolderPath)
                parents.Add(file.MailboxRoot.Id, currentFolderPath)

                'Create folder structure
                For i As Integer = 0 To folders.Count - 1
                    Dim currentFolder As Folder = folders(i)
                    parentFolderPath = DirectCast(parents(currentFolder.ParentId), String)
                    currentFolderPath = parentFolderPath & "\\" & currentFolder.DisplayName
                    Directory.CreateDirectory(currentFolderPath)
                    parents.Add(currentFolder.Id, currentFolderPath)
                Next

                'Get items and save to folders as .msg files
                For j As Integer = 0 To folders.Count - 1
                    For k As Integer = 0 To folders[j].ChildrenCount - 1 Step 1000
                        Dim items As IList(Of Item) = folders(j).GetItems(k, k + 1000)
                        For m As Integer = 0 To items.Count - 1
                            Dim parentFolder As String = DirectCast(parents(items(m).ParentId), String)
                            Dim fileName As String = GetFileName(items(m).Subject)
                            Dim filePath As String = parentFolder & "\\" & fileName
                            If filePath.Length > 244 Then
                                filePath = filePath.Substring(0, 244)
                            End If
                            filePath = filePath & "-" & items(m).Id & ".msg"
                            items(m).Save(filePath)
                        Next
                    Next
                Next
            End Using
        End Sub

        Private Shared Function GetFileName(ByVal subject As String) As String
            If subject Is Nothing OrElse subject.Length = 0 Then
                Dim fileName As String = "NoSubject"
                Return fileName
            Else
                Dim fileName As String = ""
                For i As Integer = 0 To subject.Length - 1
                    If subject(i) > Chr(31) AndAlso subject(i) < Chr(127) Then
                        fileName += subject(i)
                    End If
                Next
                fileName = fileName.Replace("\\\", "_")
                fileName = fileName.Replace("/", "_")
                fileName = fileName.Replace(":", "_")
                fileName = fileName.Replace("*", "_")
                fileName = fileName.Replace("?", "_")
                fileName = fileName.Replace("""", "_")
                fileName = fileName.Replace("<", "_")
                fileName = fileName.Replace(">", "_")
                fileName = fileName.Replace("|", "_")
                Return fileName
            End If
        End Function
    End Class
End Namespace
```

--------------------------------

### Get Inbox Messages from PST File (C#)

Source: https://www.independentsoft.de/pst/tutorial/getinboxmessages

This C# code snippet retrieves messages from the 'Inbox' folder of a specified PST file. It iterates through the items, identifies 'Message' objects, and prints details like Id, Subject, DisplayTo, DisplayCc, SenderName, and SenderEmailAddress. Ensure the 'Independentsoft.Pst' library is referenced.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            PstFile file = new PstFile("c:\\testfolder\\Outlook.pst");
            using (file) {
                Folder inbox = file.MailboxRoot.GetFolder("Inbox");
                if (inbox != null) {
                    IList<Item> items = inbox.GetItems();
                    for (int m = 0; m < items.Count; m++) {
                        if (items[m] is Message) {
                            Message message = (Message)items[m];
                            Console.WriteLine("Id: " + message.Id);
                            Console.WriteLine("Subject: " + message.Subject);
                            Console.WriteLine("DisplayTo: " + message.DisplayTo);
                            Console.WriteLine("DisplayCc: " + message.DisplayCc);
                            Console.WriteLine("SenderName: " + message.SenderName);
                            Console.WriteLine("SenderEmailAddress: " + message.SenderEmailAddress);
                            Console.WriteLine("----------------------------------------------------------------");
                        }
                    }
                }
            }
            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}
```

--------------------------------

### Get Inbox Messages from PST File (VB.NET)

Source: https://www.independentsoft.de/pst/tutorial/getinboxmessages

This VB.NET code snippet retrieves messages from the 'Inbox' folder of a specified PST file. It iterates through the items, identifies 'Message' objects, and prints details like Id, Subject, DisplayTo, DisplayCc, SenderName, and SenderEmailAddress. Ensure the 'Independentsoft.Pst' library is referenced.

```vbnet
Imports System
Imports System.Collections.Generic
Imports Independentsoft.Pst

Namespace Sample
    Class Module1
        Shared Sub Main(ByVal args As String())
            Dim file As New PstFile("c:\\testfolder\\Outlook.pst")
            Using file
                Dim inbox As Folder = file.MailboxRoot.GetFolder("Inbox")
                If inbox IsNot Nothing Then
                    Dim items As IList(Of Item) = inbox.GetItems()
                    For m As Integer = 0 To items.Count - 1
                        If TypeOf items(m) Is Message Then
                            Dim message As Message = DirectCast(items(m), Message)
                            Console.WriteLine("Id: " & message.Id)
                            Console.WriteLine("Subject: " & message.Subject)
                            Console.WriteLine("DisplayTo: " & message.DisplayTo)
                            Console.WriteLine("DisplayCc: " & message.DisplayCc)
                            Console.WriteLine("SenderName: " & message.SenderName)
                            Console.WriteLine("SenderEmailAddress: " & message.SenderEmailAddress)
                            Console.WriteLine("----------------------------------------------------------------")
                        End If
                    Next
                End If
            End Using
            Console.WriteLine("Press ENTER to exit.")
            Console.Read()
        End Sub
    End Class
End Namespace
```

--------------------------------

### Retrieve Tasks from PST File in C#

Source: https://context7.com/context7/independentsoft_de_pst/llms.txt

This C# code snippet retrieves task items from the 'Tasks' folder within a PST file. It displays the ID, subject, start date, due date, owner, and body of each task. The 'Independentsoft.Pst' library is necessary for this operation.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            PstFile file = new PstFile(@"c:\testfolder\Outlook.pst");

            using (file)
            {
                Folder tasksFolder = file.MailboxRoot.GetFolder("Tasks");

                if (tasksFolder != null)
                {
                    IList<Item> items = tasksFolder.GetItems();

                    for (int m = 0; m < items.Count; m++)
                    {
                        if (items[m] is Task)
                        {
                            Task task = (Task)items[m];

                            Console.WriteLine("Id: " + task.Id);
                            Console.WriteLine("Subject: " + task.Subject);
                            Console.WriteLine("StartDate: " + task.StartDate);
                            Console.WriteLine("DueDate: " + task.DueDate);
                            Console.WriteLine("Owner: " + task.Owner);
                            Console.WriteLine("Body: " + task.Body);
                            Console.WriteLine("----------------------------------------------------------------");
                        }
                    }
                }
            }

            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}

// Expected output:
// Id: 152678
// Subject: Complete quarterly review
// StartDate: 2025-10-01
// DueDate: 2025-10-31
// Owner: John Smith
// Body: Review all project metrics and prepare summary report
```

--------------------------------

### Retrieve Calendar Appointments from PST File in C#

Source: https://context7.com/context7/independentsoft_de_pst/llms.txt

This C# code retrieves and displays details of calendar appointments from a PST file's 'Calendar' folder. It iterates through items, checks if they are appointments, and prints their ID, subject, start time, and end time. The 'Independentsoft.Pst' library is required.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            PstFile file = new PstFile(@"c:\testfolder\Outlook.pst");

            using (file)
            {
                Folder calendar = file.MailboxRoot.GetFolder("Calendar");

                if (calendar != null)
                {
                    IList<Item> items = calendar.GetItems();

                    for (int m = 0; m < items.Count; m++)
                    {
                        if (items[m] is Appointment)
                        {
                            Appointment appointment = (Appointment)items[m];

                            Console.WriteLine("Id: " + appointment.Id);
                            Console.WriteLine("Subject: " + appointment.Subject);
                            Console.WriteLine("StartTime: " + appointment.StartTime);
                            Console.WriteLine("EndTime: " + appointment.EndTime);
                            Console.WriteLine("----------------------------------------------------------------");
                        }
                    }
                }
            }

            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}

// Expected output:
// Id: 142567
// Subject: Team Meeting
// StartTime: 2025-10-15 10:00:00 AM
// EndTime: 2025-10-15 11:00:00 AM
// ----------------------------------------------------------------
// Id: 142589
// Subject: Client Presentation
// StartTime: 2025-10-16 2:00:00 PM
// EndTime: 2025-10-16 3:30:00 PM
```

--------------------------------

### List All Folders Recursively in PST File

Source: https://context7.com/context7/independentsoft_de_pst/llms.txt

This C# code snippet demonstrates how to recursively retrieve all folders within a PST file. It constructs the full path for each folder by traversing the parent-child folder hierarchy. Dependencies include the Independentsoft.Pst library. The output includes folder ID, name, type, item count, and its constructed path.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            PstFile file = new PstFile(@"c:\\testfolder\\Outlook.pst");

            using (file)
            {
                IList<Folder> folders = file.MailboxRoot.GetFolders(true);
                string parentFolder = file.MailboxRoot.DisplayName;
                Dictionary<long, string> parents = new Dictionary<long, string>();
                parents.Add(file.MailboxRoot.Id, parentFolder);

                for (int i = 0; i < folders.Count; i++)
                {
                    Folder currentFolder = folders[i];
                    parentFolder = (string)parents[currentFolder.ParentId];
                    string currentFolderPath = parentFolder + "\\" + currentFolder.DisplayName;
                    parents.Add(currentFolder.Id, currentFolderPath);

                    Console.WriteLine("Id: " + currentFolder.Id);
                    Console.WriteLine("Name: " + currentFolder.DisplayName);
                    Console.WriteLine("Type: " + currentFolder.ContainerClass);
                    Console.WriteLine("Item count: " + currentFolder.ItemCount);
                    Console.WriteLine("Path: " + currentFolderPath);
                    Console.WriteLine("----------------------------------------------------------------");
                }
            }

            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}

// Expected output:
// Id: 8798
// Name: Inbox
// Type: IPF.Note
// Item count: 245
// Path: Root\Inbox
// ----------------------------------------------------------------
// Id: 8810
// Name: Important
// Type: IPF.Note
// Item count: 12
// Path: Root\Inbox\Important
```

--------------------------------

### Export PST to EML in C#

Source: https://www.independentsoft.de/pst/tutorial/exporttomimemessages

This C# code exports all items from a PST file to EML format, creating a directory structure mirroring the PST's folders. It handles subject line cleaning for valid filenames and ensures proper file path lengths.

```csharp
using System;
using System.IO;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            PstFile file = new PstFile("c:\\testfolder\\Outlook.pst");
            using (file) {
                IList<Folder> folders = file.MailboxRoot.GetFolders(true);
                Dictionary<long, string> parents = new Dictionary<long, string>();
                string parentFolderPath = "c:\\temp\\eml";
                string currentFolderPath = parentFolderPath + "\\" + file.MailboxRoot.DisplayName;
                Directory.CreateDirectory(currentFolderPath);
                parents.Add(file.MailboxRoot.Id, currentFolderPath);

                //Create folder structure
                for (int i = 0; i < folders.Count; i++) {
                    Folder currentFolder = folders[i];
                    parentFolderPath = (string)parents[currentFolder.ParentId];
                    currentFolderPath = parentFolderPath + "\\" + currentFolder.DisplayName;
                    Directory.CreateDirectory(currentFolderPath);
                    parents.Add(currentFolder.Id, currentFolderPath);
                }

                //Get items and save to folders as .msg files
                for (int j = 0; j < folders.Count; j++) {
                    for (int k = 0; k < folders[j].ChildrenCount; k += 100) {
                        IList<Item> items = folders[j].GetItems(k, k + 100);
                        for (int m = 0; m < items.Count; m++) {
                            string parentFolder = (string)parents[items[m].ParentId];
                            string fileName = GetFileName(items[m].Subject);
                            string filePath = parentFolder + "\\" + fileName;
                            if (filePath.Length > 244) {
                                filePath = filePath.Substring(0, 244);
                            }
                            filePath = filePath + "-" + items[m].Id + ".eml";
                            items[m].GetMessageFile().ConvertToMimeMessage().Save(filePath);
                        }
                    }
                }
            }
        }

        private static string GetFileName(string subject) {
            if (subject == null || subject.Length == 0) {
                string fileName = "NoSubject";
                return fileName;
            } else {
                string fileName = "";
                for (int i = 0; i < subject.Length; i++) {
                    if (subject[i] > 31 && subject[i] < 127) {
                        fileName += subject[i];
                    }
                }
                fileName = fileName.Replace("\\", "_");
                fileName = fileName.Replace("/", "_");
                fileName = fileName.Replace(":", "_");
                fileName = fileName.Replace("*", "_");
                fileName = fileName.Replace("?", "_");
                fileName = fileName.Replace("\"", "_");
                fileName = fileName.Replace("<", "_");
                fileName = fileName.Replace(">", "_");
                fileName = fileName.Replace("|", "_");
                return fileName;
            }
        }
    }
}
```

--------------------------------

### Display Message Recipients in PST using C#

Source: https://www.independentsoft.de/pst/tutorial/displaymessagerecipients

This C# code snippet shows how to open a PST file, access the Inbox folder, and iterate through messages to display recipient information. It utilizes the Independentsoft.Pst library. Ensure the 'Outlook.pst' file exists at the specified path.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            PstFile file = new PstFile("c:\\testfolder\\Outlook.pst");
            using (file) {
                Folder inbox = file.MailboxRoot.GetFolder("Inbox");
                if (inbox != null) {
                    IList<Item> items = inbox.GetItems();
                    for (int m = 0; m < items.Count; m++) {
                        if (items[m] is Message) {
                            Message message = (Message)items[m];
                            Console.WriteLine("Id: " + message.Id);
                            Console.WriteLine("Subject: " + message.Subject);
                            for (int r = 0; r < message.Recipients.Count; r++) {
                                Recipient recipient = message.Recipients[r];
                                Console.WriteLine("Name: " + recipient.DisplayName);
                                Console.WriteLine("Email address: " + recipient.EmailAddress);
                                Console.WriteLine("Recipient type: " + recipient.RecipientType);
                            }
                            Console.WriteLine("-------------------------------------------------------");
                        }
                    }
                }
            }
            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}
```

--------------------------------

### Display Message Recipients in PST using VB.NET

Source: https://www.independentsoft.de/pst/tutorial/displaymessagerecipients

This VB.NET code snippet demonstrates how to open a PST file, access the Inbox folder, and iterate through messages to display recipient information using the Independentsoft.Pst library. The 'Outlook.pst' file must be present at the specified path.

```vbnet
Imports System
Imports Independentsoft.Pst

Namespace Sample
    Class Module1
        Shared Sub Main(ByVal args As String())
            Dim file As New PstFile("c:\testfolder\Outlook.pst")
            Using file
                Dim inbox As Folder = file.MailboxRoot.GetFolder("Inbox")
                If inbox IsNot Nothing Then
                    Dim items As IList(Of Item) = inbox.GetItems()
                    For m As Integer = 0 To items.Count - 1
                        If TypeOf items(m) Is Message Then
                            Dim message As Message = DirectCast(items(m), Message)
                            Console.WriteLine("Id: " & message.Id)
                            Console.WriteLine("Subject: " & message.Subject)
                            For r As Integer = 0 To message.Recipients.Count - 1
                                Dim recipient As Recipient = message.Recipients(r)
                                Console.WriteLine("Name: " & recipient.DisplayName)
                                Console.WriteLine("Email address: " & recipient.EmailAddress)
                                Console.WriteLine("Recipient type: " & recipient.RecipientType.ToString())
                            Next
                            Console.WriteLine("-------------------------------------------------------")
                        End If
                    Next
                End If
            End Using
            Console.WriteLine("Press ENTER to exit.")
            Console.Read()
        End Sub
    End Class
End Namespace
```

--------------------------------

### Retrieve Contacts from PST File in C#

Source: https://context7.com/context7/independentsoft_de_pst/llms.txt

This snippet shows how to open a PST file, navigate to the Contacts folder, and iterate through items to extract contact details. It requires the Independentsoft.Pst library. The input is a PST file path, and the output is contact information printed to the console.

```csharp
using System;
using System.Collections.Generic;
using Independentsoft.Pst;

namespace Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            PstFile file = new PstFile(@"c:\\testfolder\\Outlook.pst");

            using (file)
            {
                Folder contacts = file.MailboxRoot.GetFolder("Contacts");

                if (contacts != null)
                {
                    IList<Item> items = contacts.GetItems();

                    for (int m = 0; m < items.Count; m++)
                    {
                        if (items[m] is Contact)
                        {
                            Contact contact = (Contact)items[m];

                            Console.WriteLine("Id: " + contact.Id);
                            Console.WriteLine("GivenName: " + contact.GivenName);
                            Console.WriteLine("Email1Address: " + contact.Email1Address);
                            Console.WriteLine("Email1DisplayName: " + contact.Email1DisplayName);
                            Console.WriteLine("BusinessPhone: " + contact.BusinessPhone);
                            Console.WriteLine("BusinessAddress: " + contact.BusinessAddress);
                            Console.WriteLine("----------------------------------------------------------------");
                        }
                    }
                }
            }

            Console.WriteLine("Press ENTER to exit.");
            Console.Read();
        }
    }
}

// Expected output:
// Id: 162789
// GivenName: John
// Email1Address: john.smith@company.com
// Email1DisplayName: John Smith
// BusinessPhone: +1-555-0123
// BusinessAddress: 123 Business St, City, State 12345

```
Tokens:
Raw