C#

///
/// Written by Matthew Proctor
/// www.matthewproctor.com
///
using System;
using System.Linq;
using System.IO;
using Outlook = Microsoft.Office.Interop.Outlook;

namespace OutlookAttachmentExtractor
{
    class Program
    {

        // Path where attachments will be saved
        static string basePath = @"c:\temp\DownloadedEmails\";
        // Integer to store to the total size of all the files - displayed
        // after processing to indicate possible PST file size saving
        static int totalfilesize = 0;

        static void Main(string[] args)
        {
            EnumerateAccounts();
        }
 
        // Uses recursion to enumerate Outlook subfolders.
       static void EnumerateFolders(Outlook.Folder folder)
        {
            Outlook.Folders childFolders = folder.Folders;
            if (childFolders.Count > 0)
            {
                // loop through each childFolder (aka sub-folder) in current folder
                foreach (Outlook.Folder childFolder in childFolders)
                {
                    // We only want Inbox folders - ignore Contacts and others
               if (childFolder.FolderPath.Contains(@"Inbox"))
                 
                    {
                        // Write the folder path.
                        Console.WriteLine(childFolder.FolderPath);
                        // Call EnumerateFolders using childFolder, to see if there are any sub-folders within this one
                        EnumerateFolders(childFolder);
                    }
                
                }
            }
            // pass folder to IterateMessages which processes individual email messages
            Console.WriteLine("Looking for items in " + folder.FolderPath);
            IterateMessages(folder);
        }
        
  
        // Loops through each item (aka email) in a folder
        static void IterateMessages(Outlook.Folder folder)
        {
            // attachment extensions to save
            string[] extensionsArray = { ".xls" };

            // Iterate through all items ("messages") in a folder
            var fi = folder.Items;
            if (fi != null)
            {

                try
                {
                    foreach (Object item in fi)
                    {
                        Outlook.MailItem mi = (Outlook.MailItem)item;
                        var attachments = mi.Attachments;
                        // Only process item if it has one or more attachments
                        if (attachments.Count != 0)
                        {

                            // Create a directory to store the attachment 
                            if (!Directory.Exists(basePath))
                            {
                                Directory.CreateDirectory(basePath);
                            }

                            // Loop through each attachment
                            for (int i = 1; i <= mi.Attachments.Count; i++)
                            {
                                // Check wither any of the strings in the extensionsArray are contained within the filename
                                var fn = mi.Attachments[i].FileName.ToLower();
                                if (extensionsArray.Any(fn.Contains))
                                {

                                    // Create a further sub-folder for the sender
                                    if (!Directory.Exists(basePath))
                                    {
                                        Directory.CreateDirectory(basePath);
                                    }
                                    totalfilesize = totalfilesize + mi.Attachments[i].Size;
                                    if (!File.Exists(basePath + @"\" + mi.Sender.Address + @"\" + mi.Attachments[i].FileName))
                                    {
                                        Console.WriteLine("Saving " + mi.Attachments[i].FileName);
                                        mi.Attachments[i].SaveAsFile(basePath + @"\" + mi.Attachments[i].FileName);
                                        // Uncomment next line to delete attachment after saving it
                                        // mi.Attachments[i].Delete();
                                    }
                                    else
                                    {
                                        Console.WriteLine("Already saved " + mi.Attachments[i].FileName);
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    // Console.WriteLine("An error occurred: '{0}'", e);
                }
            }
        }

        // Retrieves the email address for a given account object
        static string EnumerateAccountEmailAddress(Outlook.Account account)
        {
            try
            {
                if (string.IsNullOrEmpty(account.SmtpAddress) || string.IsNullOrEmpty(account.UserName))
                {
                    Outlook.AddressEntry oAE = account.CurrentUser.AddressEntry as Outlook.AddressEntry;
                    if (oAE.Type == "EX")
                    {
                        Outlook.ExchangeUser oEU = oAE.GetExchangeUser() as Outlook.ExchangeUser;
                        return oEU.PrimarySmtpAddress;
                    }
                    else
                    {
                        return oAE.Address;
                    }
                }
                else
                {
                    return account.SmtpAddress;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return "";
            }
        }

        // Displays introduction text, lists each Account, and prompts user to select one for processing.
        static void EnumerateAccounts()
        {
            Console.Clear();
            Console.WriteLine("Outlook XLS Extractor");
            Console.WriteLine("---------------------------------");
            int id;
            Outlook.Application Application = new Outlook.Application();
            Outlook.Accounts accounts = Application.Session.Accounts;

            string response = "";
            while (true == true)
            {
                id = 1;
                foreach (Outlook.Account account in accounts)
                {
                    Console.WriteLine(id + ":" + EnumerateAccountEmailAddress(account));
                    id++;
                }
                Console.WriteLine("Q: Quit Application");

                response = Console.ReadLine().ToUpper();
                if (response == "Q")
                {
                    Console.WriteLine("Quitting");
                    return;
                }
                if (response != "")
                {
                    if (Int32.Parse(response.Trim()) >= 1 && Int32.Parse(response.Trim()) < id)
                    {
                        Console.WriteLine("Processing: " + accounts[Int32.Parse(response.Trim())].DisplayName);
                        Console.WriteLine("Processing: " + EnumerateAccountEmailAddress(accounts[Int32.Parse(response.Trim())]));

                        Outlook.Folder selectedFolder = Application.Session.DefaultStore.GetRootFolder() as Outlook.Folder;
                        selectedFolder = GetFolder(@"\\" + accounts[Int32.Parse(response.Trim())].DisplayName);
                        EnumerateFolders(selectedFolder);
                        Console.WriteLine("Finished Processing " + accounts[Int32.Parse(response.Trim())].DisplayName);
                        Console.WriteLine("");
                    }
                    else
                    {
                        Console.WriteLine("Invalid Account Selected");
                    }
                }
            }
        }

        // Returns Folder object based on folder path
        static Outlook.Folder GetFolder(string folderPath)
        {
            Console.WriteLine("Looking for: " + folderPath);
            Outlook.Folder folder;
            string backslash = @"\";
            try
            {
                if (folderPath.StartsWith(@"\\"))
                {
                    folderPath = folderPath.Remove(0, 2);
                }
                String[] folders = folderPath.Split(backslash.ToCharArray());
                Outlook.Application Application = new Outlook.Application();
                folder = Application.Session.Folders[folders[0]] as Outlook.Folder;
                if (folder != null)
                {
                    for (int i = 1; i <= folders.GetUpperBound(0); i++)
                    {
                        Outlook.Folders subFolders = folder.Folders;
                        folder = subFolders[folders[i]] as Outlook.Folder;
                        if (folder == null)
                        {
                            return null;
                        }
                    }
                }
                return folder;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return null;
            }
        }


    }

}

public class ShipperFactory
    {
        private static TShip Create<TShip>()
            where TShip : IShip, // interface contract constraint
            new() // public parameter-less constructor constraint
        {
            return new TShip();
        }

        public static readonly IDictionary<Shipper, Func<IShip>> Creators =
            new Dictionary<Shipper, Func<IShip>>()
        {
            { Shipper.UPS, () => Create<ShipperUPS>() },
            { Shipper.FedEx, () => Create<ShipperFedEx>() },
            { Shipper.Purolator, () => Create<ShipperPurolator>() }
        };

        public static IShip CreateInstance(Shipper enumModuleName)
        {
            return Creators[enumModuleName]();
        }
    }

public static readonly IDictionary<Shipper, Func<IShip>> Creators =
            new Dictionary<Shipper, Func<IShip>>()
        {
            { Shipper.UPS, () => Create<ShipperUPS>() },
            { Shipper.FedEx, () => Create<ShipperFedEx>() },
            { Shipper.Purolator, () => Create<ShipperPurolator>() }
        };

private void btnUPS_Click(object sender, EventArgs e)
        {
            ShipperFactory.CreateInstance(Shipper.UPS).Ship();
        }

        private void btnFedEx_Click(object sender, EventArgs e)
        {
            ShipperFactory.CreateInstance(Shipper.FedEx).Ship();
        }

        private void btnPurolator_Click(object sender, EventArgs e)
        {
            ShipperFactory.CreateInstance(Shipper.Purolator).Ship();
        }

    public enum Shipper
    {
        UPS,
        FedEx,
        Purolator
    }

    public interface IShip
    {
        void Ship();
    }

    public abstract class ShipperBase : IShip
    {
        //Etc
        public abstract void Ship();

    }

    public class ShipperUPS : ShipperBase
    {
        public override void Ship()
        {
            //-- code logic to implement shipping method for Purolator
            MessageBox.Show("UPS ship start");
        }
    }

    public class ShipperFedEx : ShipperBase
    {
        public override void Ship()
        {
            //-- code logic to implement shipping method for Purolator
            MessageBox.Show("FedEX ship start");
        }
    }

    public class ShipperPurolator : ShipperBase
    {
        public override void Ship()
        {
            //-- code logic to implement shipping method for Purolator
            MessageBox.Show("Purolator ship start");
        }
    }

    public class ShipperFactory
    {
        private static TShip Create<TShip>()
            where TShip : IShip, // interface contract constraint
            new() // public parameter-less constructor constraint
        {
            return new TShip();
        }

        public static readonly IDictionary<Shipper, Func<IShip>> Creators =
            new Dictionary<Shipper, Func<IShip>>()
        {
            { Shipper.UPS, () => Create<ShipperUPS>() },
            { Shipper.FedEx, () => Create<ShipperFedEx>() },
            { Shipper.Purolator, () => Create<ShipperPurolator>() }
        };

        public static IShip CreateInstance(Shipper enumModuleName)
        {
            return Creators[enumModuleName]();
        }
    }