Working with Outlook attachments programmatically: C# code examples

Many Outlook developers have been faced with programmatically accessing and working with Outlook Item attachments. All Outlook items have the Attachments property, which means attachments can be added to MailItem, ContactItem and AppointmentItem items, to name a few.

In this article we’ll explore some facets of handling and interacting with attachments in Outlook. All code examples are written in C#, and of course you are free to re-write them using VB.NET or Visual C++.NET. The samples work for Outlook 2013, 2010 and 2007.

• Adding attachments to an Outlook item
• List all attachments of an Outlook item
• Saving all attachments of an Outlook item
• Outlook Attachment security
• Outlook Item Attachment events
• Access Outlook attachments on e-mail reply

Adding attachments to an Outlook item

For this example, we’ll add a new ribbon tab and button in order to choose and add a new attachment to an e-mail. As usual, we are going to use Add-in Express for Office and net.

Start by adding a new ADXRibbonTab component to the AddinModule designer surface and add a new ribbon group and button to the ribbon tab component.

Next, add an OpenFileDialog component to the AddinModule designer surface and set the following properties:

• Filter = All files|*.*
• Title = Select Attachment

Select the ribbon button, we’ve added earlier and create a new event handler for its OnClick event by double-clicking next to the event name.

Add the following code to the OnClick event handler:

private void adxAddAttachmentRibbonButton_OnClick(object sender, IRibbonControl control, bool pressed)
{
    Outlook.Inspector currInspector = null;
    Outlook.MailItem mail = null;
    Outlook.Attachments attachments = null;
 
    try
    {
        if (openFileDialog1.ShowDialog() == DialogResult.OK)
        {
            currInspector = OutlookApp.ActiveInspector();
            mail = (Outlook.MailItem)currInspector.CurrentItem;
            attachments = mail.Attachments;
            attachments.Add(openFileDialog1.FileName, Outlook.OlAttachmentType.olByValue);
        }
    }
    finally
    {
        if (attachments != null) Marshal.ReleaseComObject(attachments);
        if (mail != null) Marshal.ReleaseComObject(mail);
        if (currInspector != null) Marshal.ReleaseComObject(currInspector);
    }
}

The code above will display a file dialog to the user with which they can choose a file. The file will then be attached to the e-mail using the Add method of the Attachments collection property of the MailItem object.

List all attachments of an Outlook item

As mentioned previously, all Outlook items have the Attachments property, so in order to get a list of all attachments for an Outlook item, we’ll need to iterate over the Attachments collection. In the following code, we’ll loop through the list of attachments and write the file information to a string.

private void adxListAttachmentsRibbonButton_OnClick(object sender, IRibbonControl control, bool pressed)
{
    Outlook.Inspector currInspector = null;
    Outlook.MailItem mail = null;
    Outlook.Attachments attachments = null;
    string attachmentList = string.Empty;
 
    try
    {
        currInspector = OutlookApp.ActiveInspector();
        mail = (Outlook.MailItem)currInspector.CurrentItem;
        attachments = mail.Attachments;
 
        for (int i = 1; i <= attachments.Count; i++)
        {
            Outlook.Attachment attachment = attachments[i];
            attachmentList += "Display name: " + attachment.DisplayName + "Size: " + attachment.Size + " bytes." + Environment.NewLine;
            Marshal.ReleaseComObject(attachment);
        }
    }
    finally
    {
        if (attachments != null) Marshal.ReleaseComObject(attachments);
        if (mail != null) Marshal.ReleaseComObject(mail);
        if (currInspector != null) Marshal.ReleaseComObject(currInspector);
    }
}

Saving all attachments of an Outlook item

In the next example, we'll prompt the user to select a folder to which they want to save all the current Outlook item's attachments.

Start by adding a new FolderBrowserDialog component to the AddinModule designer surface. Next, we'll add a new button to the ribbon tab we've added earlier. Add the following code in this button's OnClick event handler:

 
private void adxSaveAllRibbonButton_OnClick(object sender, IRibbonControl control, bool pressed)
{
    Outlook.Inspector currInspector = null;
    Outlook.MailItem mail = null;
    Outlook.Attachments attachments = null;
 
    try
    {
        if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
        {
            currInspector = OutlookApp.ActiveInspector();
            mail = (Outlook.MailItem)currInspector.CurrentItem;
            attachments = mail.Attachments;
 
            for (int i = 1; i <= attachments.Count; i++)
            {
                Outlook.Attachment attachment = attachments[i];
                string path = Path.Combine(folderBrowserDialog1.SelectedPath, attachment.FileName);
                attachment.SaveAsFile(path);
                Marshal.ReleaseComObject(attachment);
            }
        }
    }
    finally
    {
        if (attachments != null) Marshal.ReleaseComObject(attachments);
        if (mail != null) Marshal.ReleaseComObject(mail);
        if (currInspector != null) Marshal.ReleaseComObject(currInspector);
    }
}

Outlook Attachment security

By default Outlook attachments with certain extension are automatically blocked by MS Outlook, for example files with extension .exe or .bat cannot be added to an e-mail message either manually or programmatically via the Outlook Object Model. When the user receives an email with such potentially unsecure attachments, Outlook won't let them open any and display the following warning message instead: "Outlook blocked access to the following potentially unsafe attachments".

Outlook 2007 added a new property called BlockLevel to the Attachment object. This property allows you to programmatically determine the security status of the attachment.  The values for the BlockLevel property are:

• olAttachmentBlockLevelOpen – The attachment has a restriction which will prevent the user from opening it from Outlook. The user must first save it to disk before opening it.
• olAttachmentBlockLevelNone – Which means there are no restrictions for this type of attachment and the user can open it directly from Outlook.

Outlook Item Attachment events

Outlook Items expose a number of events with which to interact with attachments. In order to respond to these events, we first need to add a new Outlook Items Events Class to our project.

After you've added the class, declare the OutlookItemsEventsClass in the AddinModule.cs class file:

private OutlookItemEventsClass outlookItemEvents = null;

Next, instantiate the OutlookItemEventsClass inside the AddinStartupComplete event:

private void AddinModule_AddinStartupComplete(object sender, EventArgs e)
{
    outlookItemEvents = new OutlookItemEventsClass(this);
}

Add a new ADXOutlookAppEvents object to the AddinModule designer and generate an event handler for the InspectorActivate event.

private void adxOutlookEvents_InspectorActivate(object sender, object inspector, string folderName)
{
    if (canConnect)
    {
        Outlook._Inspector olInsp = (Outlook._Inspector)inspector;
        object item = olInsp.CurrentItem;
 
        if (item is Outlook._MailItem)
        {
            outlookItemEvents.ConnectTo(item, true);
        }
        else
        {
            Marshal.ReleaseComObject(item);
        }
    }
}

Add the following method:

private void ConnectToSelectedItem(object explorer)
{
    Outlook.Selection sel = null;
 
    try
    {
        Outlook._Explorer expl = explorer as Outlook._Explorer;
        sel = expl.Selection;
        if (sel.Count == 1)
        {
            object item = sel[1];
            if (item is Outlook._MailItem)
                outlookItemEvents.ConnectTo(item, true);
            else
                Marshal.ReleaseComObject(item);
        }
    }
    finally
    {
        if (sel != null)
            Marshal.ReleaseComObject(sel);
    }
}

Also, add the following code for the ExplorerActivate, ExplorerClose and ItemSend events:

private void adxOutlookEvents_ExplorerActivate(object sender, object explorer)
{
    ConnectToSelectedItem(explorer);
}
 
private void adxOutlookEvents_ExplorerClose(object sender, object explorer)
{
    int count = 0;
    Outlook._Explorers expls = null;
 
    try
    {
        expls = OutlookApp.Explorers;
        count = expls.Count;
    }
    catch
    {
    }
    finally
    {
        if (expls != null)
            Marshal.ReleaseComObject(expls);
    }
 
    if (count == 0)
        canConnect = false;
}
 
private void adxOutlookEvents_ItemSend(object sender, ADXOlItemSendEventArgs e)
{
    if (outlookItemEvents != null)
        outlookItemEvents.RemoveConnection();
}

Open the OutlookItemEventsClass class, this class enables you to handle the following events:

AttachmentAdd

This event occurs after an attachment has been added to an Outlook item and an instance of the attachment that was added is passed to the event as a parameter.

public override void ProcessAttachmentAdd(object attachment)
{
    Outlook.Attachment attach = attachment as Outlook.Attachment;
    Console.Write("Display name: " + attach.DisplayName + "Size: " + attach.Size + " bytes. Has been added.");
}

AttachmentRead

Occurs after an Outlook attachment has been opened for reading. An instance of the attachment that was added is passed to the event as a parameter.

public override void ProcessAttachmentRead(object attachment)
{
    Outlook.Attachment attach = attachment as Outlook.Attachment;
    Console.Write("Display name: " + attach.DisplayName + ". Has been read.");
}

AttachmentRemove

The event fires when an Outlook attachment has been removed, the attachment that was removed is passed to the event as a parameter.

public override void ProcessAttachmentRemove(object attachment)
{
    Outlook.Attachment attach = attachment as Outlook.Attachment;
    Console.Write("Display name: " + attach.DisplayName + ". Has been removed.");
}

BeforeAttachmentAdd

This event is similar to the AttachmentAdd event, but occurs before the attachment is added to the Outlook item. The attachment that is added is passed as a parameter as well as a Cancel parameter, that when set to 'true' will cancel the operation.

public override void ProcessBeforeAttachmentAdd(object attachment, AddinExpress.MSO.ADXCancelEventArgs e)
{
    Outlook.Attachment attach = attachment as Outlook.Attachment;
    if (attach.FileName.Contains("DoNotAdd"))
        e.Cancel = true;
}

BeforeAttachmentPreview

Occurs before the attachment is previewed. An instance of the attachment and a Boolean to cancel the operation is passed as parameters.

public override void ProcessBeforeAttachmentPreview(object attachment, AddinExpress.MSO.ADXCancelEventArgs e)
{
    Outlook.Attachment attach = attachment as Outlook.Attachment;
    if (attach.FileName.Contains("DoNotPreview"))
        e.Cancel = true;
}

BeforeAttachmentRead

Similar to Outlook's AttachmentRead event, but occurs before the attachment is read from the file system. As with the previous events you also have the option to cancel this operation.

public override void ProcessBeforeAttachmentRead(object attachment, AddinExpress.MSO.ADXCancelEventArgs e)
{
    Outlook.Attachment attach = attachment as Outlook.Attachment;
    if (attach.FileName.Contains("DoNotRead"))
        e.Cancel = true;
}

BeforeAttachmentSave

Occurs before an attachment is saved. This event only occurs when the attachment is saved to the message store, if the user edits the attachments and saves it, the event will not be triggered.

public override void ProcessBeforeAttachmentSave(object attachment, AddinExpress.MSO.ADXCancelEventArgs e)
{
    Outlook.Attachment attach = attachment as Outlook.Attachment;
    if (attach.FileName.Contains("DoNotSave"))
        cancel = true; 
}

BeforeAttachmentWriteToTempFile

This event is triggered before the attachment is written to a temporary file. The attachment that is saved is passed as a parameter as well as a Cancel parameter, that when set to true will cancel the operation.

public override void ProcessBeforeAttachmentWriteToTempFile(object attachment, AddinExpress.MSO.ADXCancelEventArgs e)
{
    Outlook.Attachment attach = attachment as Outlook.Attachment;
    if (attach.FileName.Contains("DoNotSave"))
        cancel = true;
}

Access Outlook attachments on e-mail reply

In the past, we received a question about how to retrieve the attachments of an Outlook e-mail when replying to it. Outlook does not include file attachments when replying to an e-mail, fortunately we can use the ConversationTopic and ConversationIndex properties of the Outlook MailItem object to find the parent e-mail the user is replying to.

All message in a conversation has the same value for the ConversationTopic property and the ConversationIndex property is increased with 5 bytes for each reply. We'll use the OutlookItemsEventsClass, we've added earlier, to intercept the Reply event and gain access to the parent email's attachments.

Open the OutlookItemsEventsClass.cs file and add the following code to the ProcessReply method:

public override void ProcessReply(object response, AddinExpress.MSO.ADXCancelEventArgs e)
{
    string restrictString = string.Empty;
    string conversationIndex = string.Empty;
    Outlook.Folder inboxFolder = null;
    Outlook.Items foundItems = null;
    Outlook.NameSpace session = null;
    Outlook.MailItem mail = null;
 
    try
    {
        mail = response as Outlook.MailItem;
        session = mail.Session;
        conversationIndex = mail.ConversationIndex.Substring(0, mail.ConversationIndex.Length - 10);
        inboxFolder = session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox) as Outlook.Folder;
        restrictString = "[ConversationTopic] = \"" + mail.ConversationTopic + "\"";
        foundItems = inboxFolder.Items.Restrict(restrictString);
        for (int i = 1; i <= foundItems.Count; i++)
        {
            Outlook.MailItem parentMailItem = foundItems[i] as Outlook.MailItem;
            if (parentMailItem.ConversationIndex == conversationIndex)
            {
                Outlook.Attachments attachments = parentMailItem.Attachments;
                var count = attachments.Count;
                MessageBox.Show("Parent email had " + count + " attachments.");
                Marshal.ReleaseComObject(attachments);
            }
            Marshal.ReleaseComObject(parentMailItem);
        }
    }
    finally
    {
        if (session != null) Marshal.ReleaseComObject(session);
        if (foundItems != null) Marshal.ReleaseComObject(foundItems);
        if (inboxFolder != null) Marshal.ReleaseComObject(inboxFolder);
    }
}

The above code will find the parent email and display a simple message box showing the number of attachments the parent email had.

Thank you for reading. Until next time, keep coding!

Available downloads:

This sample Outlook add-in was developed using Add-in Express for Office and .net:

Outlook Attachments sample add-in (C#)