Question

I’m looking for a way to open the user’s default e-mail program to write a new e-mail and specify an attachment from within a C# application. Right now, I can start an e-mail and specify the recipient, subject, body, etc., but I can’t find any way to also specify an attachment.

System.Diagnostics.Process.Start(@"mailto:[e-mail]&subject=Hi&body=%0D%0DSent from my Kinect");

This works great for the basic e-mail, but there’s no way to add an attachment. For a bit of background, my boss wants to use voice commands to get a snapshot from the Kinect and then e-mail it to someone.

Looking through the “Question with similar titles”, I found this, which may be the wrong language but it makes me think that there may be a way to at least do it with Microsoft Outlook. That’s what the large majority of the people at my work use, but I was really hoping for something that would work with any mail client.

I don’t want to just send the e-mail through C#, as I want the user to be able to edit the e-mail within their mail client before sending it.

So, the question: Is there a way to specify an attachment when opening a user’s default e-mail program? And if not, where can I find resources on using C# to create an e-mail in Microsoft Outlook with an attachment?

Answer 1

I have used the code here to open the users default email client with an attachment.

// Below is the source code and simple test class for creating and displaying emails. 
// It uses the MAPI API and is therefore not subject to the same restrictions as 
// the "mailto" shell extension.
// 
// Using the MapiMailMessage you can set the title, subject, recipients and attach files. 
// Then show the resulting email to the user, ready from them to send. This class is very 
// useful for supporting applications and enriching addins.
// 
// Note, that the class is a port from a VB version I had and although it does have 
// comments, it is not up to my usual standard. I will be revisiting this and tidying 
// it up shortly.

using System;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading;

#region Test Class

public class TestMapiMessageClass
{
    /// <summary>
    /// Test method to create and show an email
    /// </summary>
    /// <param name="args"></param>
    static void Main(string[] args)
    {
        MapiMailMessage message = new MapiMailMessage("Test Message", "Test Body");
        message.Recipients.Add("[e-mail]");
        message.Files.Add(@"C:\del.txt");
        message.ShowDialog();
        Console.ReadLine();
    }
}
#endregion Test Class

#region Public MapiMailMessage Class

/// <summary>
/// Represents an email message to be sent through MAPI.
/// </summary>
public class MapiMailMessage
{
    #region Private MapiFileDescriptor Class

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    private class MapiFileDescriptor
    {
        public int reserved = 0;
        public int flags = 0;
        public int position = 0;
        public string path = null;
        public string name = null;
        public IntPtr type = IntPtr.Zero;
    }

    #endregion Private MapiFileDescriptor Class

    #region Enums

    /// <summary>
    /// Specifies the valid RecipientTypes for a Recipient.
    /// </summary>
    public enum RecipientType : int
    {
        /// <summary>
        /// Recipient will be in the TO list.
        /// </summary>
        To = 1,

        /// <summary>
        /// Recipient will be in the CC list.
        /// </summary>
        CC = 2,

        /// <summary>
        /// Recipient will be in the BCC list.
        /// </summary>
        BCC = 3
    };

    #endregion Enums

    #region Member Variables

    private string _subject;
    private string _body;
    private RecipientCollection _recipientCollection;
    private ArrayList _files;
    private ManualResetEvent _manualResetEvent;

    #endregion Member Variables

    #region Constructors

    /// <summary>
    /// Creates a blank mail message.
    /// </summary>
    public MapiMailMessage()
    {
        _files = new ArrayList();
        _recipientCollection = new RecipientCollection();
        _manualResetEvent = new ManualResetEvent(false);
    }

    /// <summary>
    /// Creates a new mail message with the specified subject.
    /// </summary>
    public MapiMailMessage(string subject)
        : this()
    {
        _subject = subject;
    }

    /// <summary>
    /// Creates a new mail message with the specified subject and body.
    /// </summary>
    public MapiMailMessage(string subject, string body)
        : this()
    {
        _subject = subject;
        _body = body;
    }

    #endregion Constructors

    #region Public Properties

    /// <summary>
    /// Gets or sets the subject of this mail message.
    /// </summary>
    public string Subject
    {
        get { return _subject; }
        set { _subject = value; }
    }

    /// <summary>
    /// Gets or sets the body of this mail message.
    /// </summary>
    public string Body
    {
        get { return _body; }
        set { _body = value; }
    }

    /// <summary>
    /// Gets the recipient list for this mail message.
    /// </summary>
    public RecipientCollection Recipients
    {
        get { return _recipientCollection; }
    }

    /// <summary>
    /// Gets the file list for this mail message.
    /// </summary>
    public ArrayList Files
    {
        get { return _files; }
    }

    #endregion Public Properties

    #region Public Methods

    /// <summary>
    /// Displays the mail message dialog asynchronously.
    /// </summary>
    public void ShowDialog()
    {
        // Create the mail message in an STA thread
        Thread t = new Thread(new ThreadStart(_ShowMail));
        t.IsBackground = true;
        t.ApartmentState = ApartmentState.STA;
        t.Start();

        // only return when the new thread has built it's interop representation
        _manualResetEvent.WaitOne();
        _manualResetEvent.Reset();
    }

    #endregion Public Methods

    #region Private Methods

    /// <summary>
    /// Sends the mail message.
    /// </summary>
    private void _ShowMail(object ignore)
    {
        MAPIHelperInterop.MapiMessage message = new MAPIHelperInterop.MapiMessage();

        using (RecipientCollection.InteropRecipientCollection interopRecipients
                    = _recipientCollection.GetInteropRepresentation())
        {

            message.Subject = _subject;
            message.NoteText = _body;

            message.Recipients = interopRecipients.Handle;
            message.RecipientCount = _recipientCollection.Count;

            // Check if we need to add attachments
            if (_files.Count > 0)
            {
                // Add attachments
                message.Files = _AllocAttachments(out message.FileCount);
            }

            // Signal the creating thread (make the remaining code async)
            _manualResetEvent.Set();

            const int MAPI_DIALOG = 0x8;
            //const int MAPI_LOGON_UI = 0x1;
            const int SUCCESS_SUCCESS = 0;
            int error = MAPIHelperInterop.MAPISendMail(IntPtr.Zero, IntPtr.Zero, message, MAPI_DIALOG, 0);

            if (_files.Count > 0)
            {
                // Deallocate the files
                _DeallocFiles(message);
            }

            // Check for error
            if (error != SUCCESS_SUCCESS)
            {
                _LogErrorMapi(error);
            }
        }
    }

    /// <summary>
    /// Deallocates the files in a message.
    /// </summary>
    /// <param name="message">The message to deallocate the files from.</param>
    private void _DeallocFiles(MAPIHelperInterop.MapiMessage message)
    {
        if (message.Files != IntPtr.Zero)
        {
            Type fileDescType = typeof(MapiFileDescriptor);
            int fsize = Marshal.SizeOf(fileDescType);

            // Get the ptr to the files
            int runptr = (int)message.Files;
            // Release each file
            for (int i = 0; i < message.FileCount; i++)
            {
                Marshal.DestroyStructure((IntPtr)runptr, fileDescType);
                runptr += fsize;
            }
            // Release the file
            Marshal.FreeHGlobal(message.Files);
        }
    }

    /// <summary>
    /// Allocates the file attachments
    /// </summary>
    /// <param name="fileCount"></param>
    /// <returns></returns>
    private IntPtr _AllocAttachments(out int fileCount)
    {
        fileCount = 0;
        if (_files == null)
        {
            return IntPtr.Zero;
        }
        if ((_files.Count <= 0) || (_files.Count > 100))
        {
            return IntPtr.Zero;
        }

        Type atype = typeof(MapiFileDescriptor);
        int asize = Marshal.SizeOf(atype);
        IntPtr ptra = Marshal.AllocHGlobal(_files.Count * asize);

        MapiFileDescriptor mfd = new MapiFileDescriptor();
        mfd.position = -1;
        int runptr = (int)ptra;
        for (int i = 0; i < _files.Count; i++)
        {
            string path = _files[i] as string;
            mfd.name = Path.GetFileName(path);
            mfd.path = path;
            Marshal.StructureToPtr(mfd, (IntPtr)runptr, false);
            runptr += asize;
        }

        fileCount = _files.Count;
        return ptra;
    }

    /// <summary>
    /// Sends the mail message.
    /// </summary>
    private void _ShowMail()
    {
        _ShowMail(null);
    }


    /// <summary>
    /// Logs any Mapi errors.
    /// </summary>
    private void _LogErrorMapi(int errorCode)
    {
        const int MAPI_USER_ABORT = 1;
        const int MAPI_E_FAILURE = 2;
        const int MAPI_E_LOGIN_FAILURE = 3;
        const int MAPI_E_DISK_FULL = 4;
        const int MAPI_E_INSUFFICIENT_MEMORY = 5;
        const int MAPI_E_BLK_TOO_SMALL = 6;
        const int MAPI_E_TOO_MANY_SESSIONS = 8;
        const int MAPI_E_TOO_MANY_FILES = 9;
        const int MAPI_E_TOO_MANY_RECIPIENTS = 10;
        const int MAPI_E_ATTACHMENT_NOT_FOUND = 11;
        const int MAPI_E_ATTACHMENT_OPEN_FAILURE = 12;
        const int MAPI_E_ATTACHMENT_WRITE_FAILURE = 13;
        const int MAPI_E_UNKNOWN_RECIPIENT = 14;
        const int MAPI_E_BAD_RECIPTYPE = 15;
        const int MAPI_E_NO_MESSAGES = 16;
        const int MAPI_E_INVALID_MESSAGE = 17;
        const int MAPI_E_TEXT_TOO_LARGE = 18;
        const int MAPI_E_INVALID_SESSION = 19;
        const int MAPI_E_TYPE_NOT_SUPPORTED = 20;
        const int MAPI_E_AMBIGUOUS_RECIPIENT = 21;
        const int MAPI_E_MESSAGE_IN_USE = 22;
        const int MAPI_E_NETWORK_FAILURE = 23;
        const int MAPI_E_INVALID_EDITFIELDS = 24;
        const int MAPI_E_INVALID_RECIPS = 25;
        const int MAPI_E_NOT_SUPPORTED = 26;
        const int MAPI_E_NO_LIBRARY = 999;
        const int MAPI_E_INVALID_PARAMETER = 998;

        string error = string.Empty;
        switch (errorCode)
        {
            case MAPI_USER_ABORT:
                error = "User Aborted.";
                break;
            case MAPI_E_FAILURE:
                error = "MAPI Failure.";
                break;
            case MAPI_E_LOGIN_FAILURE:
                error = "Login Failure.";
                break;
            case MAPI_E_DISK_FULL:
                error = "MAPI Disk full.";
                break;
            case MAPI_E_INSUFFICIENT_MEMORY:
                error = "MAPI Insufficient memory.";
                break;
            case MAPI_E_BLK_TOO_SMALL:
                error = "MAPI Block too small.";
                break;
            case MAPI_E_TOO_MANY_SESSIONS:
                error = "MAPI Too many sessions.";
                break;
            case MAPI_E_TOO_MANY_FILES:
                error = "MAPI too many files.";
                break;
            case MAPI_E_TOO_MANY_RECIPIENTS:
                error = "MAPI too many recipients.";
                break;
            case MAPI_E_ATTACHMENT_NOT_FOUND:
                error = "MAPI Attachment not found.";
                break;
            case MAPI_E_ATTACHMENT_OPEN_FAILURE:
                error = "MAPI Attachment open failure.";
                break;
            case MAPI_E_ATTACHMENT_WRITE_FAILURE:
                error = "MAPI Attachment Write Failure.";
                break;
            case MAPI_E_UNKNOWN_RECIPIENT:
                error = "MAPI Unknown recipient.";
                break;
            case MAPI_E_BAD_RECIPTYPE:
                error = "MAPI Bad recipient type.";
                break;
            case MAPI_E_NO_MESSAGES:
                error = "MAPI No messages.";
                break;
            case MAPI_E_INVALID_MESSAGE:
                error = "MAPI Invalid message.";
                break;
            case MAPI_E_TEXT_TOO_LARGE:
                error = "MAPI Text too large.";
                break;
            case MAPI_E_INVALID_SESSION:
                error = "MAPI Invalid session.";
                break;
            case MAPI_E_TYPE_NOT_SUPPORTED:
                error = "MAPI Type not supported.";
                break;
            case MAPI_E_AMBIGUOUS_RECIPIENT:
                error = "MAPI Ambiguous recipient.";
                break;
            case MAPI_E_MESSAGE_IN_USE:
                error = "MAPI Message in use.";
                break;
            case MAPI_E_NETWORK_FAILURE:
                error = "MAPI Network failure.";
                break;
            case MAPI_E_INVALID_EDITFIELDS:
                error = "MAPI Invalid edit fields.";
                break;
            case MAPI_E_INVALID_RECIPS:
                error = "MAPI Invalid Recipients.";
                break;
            case MAPI_E_NOT_SUPPORTED:
                error = "MAPI Not supported.";
                break;
            case MAPI_E_NO_LIBRARY:
                error = "MAPI No Library.";
                break;
            case MAPI_E_INVALID_PARAMETER:
                error = "MAPI Invalid parameter.";
                break;
        }

        Debug.WriteLine("Error sending MAPI Email. Error: " + error + " (code = " + errorCode + ").");
    }
    #endregion Private Methods

    #region Private MAPIHelperInterop Class

    /// <summary>
    /// Internal class for calling MAPI APIs
    /// </summary>
    internal class MAPIHelperInterop
    {
        #region Constructors

        /// <summary>
        /// Private constructor.
        /// </summary>
        private MAPIHelperInterop()
        {
            // Intenationally blank
        }

        #endregion Constructors

        #region Constants

        public const int MAPI_LOGON_UI = 0x1;

        #endregion Constants

        #region APIs

        [DllImport("MAPI32.DLL", CharSet = CharSet.Ansi)]
        public static extern int MAPILogon(IntPtr hwnd, string prf, string pw, int flg, int rsv, ref IntPtr sess);

        #endregion APIs

        #region Structs

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
            public class MapiMessage
        {
            public int Reserved = 0;
            public string Subject = null;
            public string NoteText = null;
            public string MessageType = null;
            public string DateReceived = null;
            public string ConversationID = null;
            public int Flags = 0;
            public IntPtr Originator = IntPtr.Zero;
            public int RecipientCount = 0;
            public IntPtr Recipients = IntPtr.Zero;
            public int FileCount = 0;
            public IntPtr Files = IntPtr.Zero;
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
            public class MapiRecipDesc
        {
            public int Reserved = 0;
            public int RecipientClass = 0;
            public string Name = null;
            public string Address = null;
            public int eIDSize = 0;
            public IntPtr EntryID = IntPtr.Zero;
        }

        [DllImport("MAPI32.DLL")]
        public static extern int MAPISendMail(IntPtr session, IntPtr hwnd, MapiMessage message, int flg, int rsv);

        #endregion Structs
    }

    #endregion Private MAPIHelperInterop Class
}

#endregion Public MapiMailMessage Class

#region Public Recipient Class

/// <summary>
/// Represents a Recipient for a MapiMailMessage.
/// </summary>
public class Recipient
{
    #region Public Properties

    /// <summary>
    /// The email address of this recipient.
    /// </summary>
    public string Address = null;

    /// <summary>
    /// The display name of this recipient.
    /// </summary>
    public string DisplayName = null;

    /// <summary>
    /// How the recipient will receive this message (To, CC, BCC).
    /// </summary>
    public MapiMailMessage.RecipientType RecipientType = MapiMailMessage.RecipientType.To;

    #endregion Public Properties

    #region Constructors

    /// <summary>
    /// Creates a new recipient with the specified address.
    /// </summary>
    public Recipient(string address)
    {
        Address = address;
    }

    /// <summary>
    /// Creates a new recipient with the specified address and display name.
    /// </summary>
    public Recipient(string address, string displayName)
    {
        Address = address;
        DisplayName = displayName;
    }

    /// <summary>
    /// Creates a new recipient with the specified address and recipient type.
    /// </summary>
    public Recipient(string address, MapiMailMessage.RecipientType recipientType)
    {
        Address = address;
        RecipientType = recipientType;
    }

    /// <summary>
    /// Creates a new recipient with the specified address, display name and recipient type.
    /// </summary>
    public Recipient(string address, string displayName, MapiMailMessage.RecipientType recipientType)
    {
        Address = address;
        DisplayName = displayName;
        RecipientType = recipientType;
    }

    #endregion Constructors

    #region Internal Methods

    /// <summary>
    /// Returns an interop representation of a recepient.
    /// </summary>
    /// <returns></returns>
    internal MapiMailMessage.MAPIHelperInterop.MapiRecipDesc GetInteropRepresentation()
    {
        MapiMailMessage.MAPIHelperInterop.MapiRecipDesc interop = new MapiMailMessage.MAPIHelperInterop.MapiRecipDesc();

        if (DisplayName == null)
        {
            interop.Name = Address;
        }
        else
        {
            interop.Name = DisplayName;
            interop.Address = Address;
        }

        interop.RecipientClass = (int)RecipientType;

        return interop;
    }

    #endregion Internal Methods
}

#endregion Public Recipient Class

#region Public RecipientCollection Class

/// <summary>
/// Represents a colleciton of recipients for a mail message.
/// </summary>
public class RecipientCollection : CollectionBase
{
    /// <summary>
    /// Adds the specified recipient to this collection.
    /// </summary>
    public void Add(Recipient value)
    {
        List.Add(value);
    }

    /// <summary>
    /// Adds a new recipient with the specified address to this collection.
    /// </summary>
    public void Add(string address)
    {
        this.Add(new Recipient(address));
    }

    /// <summary>
    /// Adds a new recipient with the specified address and display name to this collection.
    /// </summary>
    public void Add(string address, string displayName)
    {
        this.Add(new Recipient(address, displayName));
    }

    /// <summary>
    /// Adds a new recipient with the specified address and recipient type to this collection.
    /// </summary>
    public void Add(string address, MapiMailMessage.RecipientType recipientType)
    {
        this.Add(new Recipient(address, recipientType));
    }

    /// <summary>
    /// Adds a new recipient with the specified address, display name and recipient type to this collection.
    /// </summary>
    public void Add(string address, string displayName, MapiMailMessage.RecipientType recipientType)
    {
        this.Add(new Recipient(address, displayName, recipientType));
    }

    /// <summary>
    /// Returns the recipient stored in this collection at the specified index.
    /// </summary>
    public Recipient this[int index]
    {
        get
        {
            return (Recipient)List[index];
        }
    }

    internal InteropRecipientCollection GetInteropRepresentation()
    {
        return new InteropRecipientCollection(this);
    }

    /// <summary>
    /// Struct which contains an interop representation of a colleciton of recipients.
    /// </summary>
    internal struct InteropRecipientCollection : IDisposable
    {
        #region Member Variables

        private IntPtr _handle;
        private int _count;

        #endregion Member Variables

        #region Constructors

        /// <summary>
        /// Default constructor for creating InteropRecipientCollection.
        /// </summary>
        /// <param name="outer"></param>
        public InteropRecipientCollection(RecipientCollection outer)
        {
            _count = outer.Count;

            if (_count == 0)
            {
                _handle = IntPtr.Zero;
                return;
            }

            // allocate enough memory to hold all recipients
            int size = Marshal.SizeOf(typeof(MapiMailMessage.MAPIHelperInterop.MapiRecipDesc));
            _handle = Marshal.AllocHGlobal(_count * size);

            // place all interop recipients into the memory just allocated
            int ptr = (int)_handle;
            foreach (Recipient native in outer)
            {
                MapiMailMessage.MAPIHelperInterop.MapiRecipDesc interop = native.GetInteropRepresentation();

                // stick it in the memory block
                Marshal.StructureToPtr(interop, (IntPtr)ptr, false);
                ptr += size;
            }
        }

        #endregion Costructors

        #region Public Properties

        public IntPtr Handle
        {
            get { return _handle; }
        }

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Disposes of resources.
        /// </summary>
        public void Dispose()
        {
            if (_handle != IntPtr.Zero)
            {
                Type type = typeof(MapiMailMessage.MAPIHelperInterop.MapiRecipDesc);
                int size = Marshal.SizeOf(type);

                // destroy all the structures in the memory area
                int ptr = (int)_handle;
                for (int i = 0; i < _count; i++)
                {
                    Marshal.DestroyStructure((IntPtr)ptr, type);
                    ptr += size;
                }

                // free the memory
                Marshal.FreeHGlobal(_handle);

                _handle = IntPtr.Zero;
                _count = 0;
            }
        }

        #endregion Public Methods
    }
}

#endregion Public RecipientCollection Class