VSTO Outlook Add-in Event Handers not firing on start up

Question

enter code hereI have an VSTO add in that is intercepting custom events. I have event handlers. I am looking for Add, Edit and Delete Items on the default calendar folder in outlook.

I have a button for creating custom appointments and after that is pressed the event handlers work fine but I need the event handlers to function from start up to catch custom events created in the previous session and they are not always firing at start up.

Here is some example code.

    public partial class ThisAddIn
     {
         public string subjectName;
         public Outlook.AppointmentItem apptItem;
         public Outlook.Folder calendarFolder;
         Outlook.Items items;
         bool m_IsFirstTime = false;
         CalendarMonitor calendarMonitor;
    
         private void ThisAddIn_Startup(object sender, System.EventArgs e)
         {
             calendarMonitor = new CalendarMonitor(Application.ActiveExplorer());
             calendarMonitor.AppointmentAdded += new EventHandler<EventArgs<AppointmentItem>>(Monitor_AppointmentAdded);
             calendarMonitor.AppointmentModified += new EventHandler<EventArgs<AppointmentItem>>(Monitor_AppointmentModified);
             calendarMonitor.AppointmentDeleting += new EventHandler<CancelEventArgs<AppointmentItem>>(Monitor_AppointmentDeleting);
             Application.Inspectors.NewInspector += Inspectors_NewInspector;
             Outlook.NameSpace ns = Application.Session;
             calendarFolder = ns.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderCalendar) as Outlook.Folder;
             items = calendarFolder.Items;
             items.ItemChange += new Microsoft.Office.Interop.Outlook.ItemsEvents_ItemChangeEventHandler(Items_ItemChange);
    
         }
    }

//Calendar Monitor class

    public class CalendarMonitor
    {
        private Explorer m_explorer;
        private List<string> m_folderPaths;
        private List<MAPIFolder> m_calendarFolders;
        private List<Items> m_calendarItems;
        private MAPIFolder m_deletedItemsFolder;

        public event EventHandler<EventArgs<AppointmentItem>> AppointmentAdded;
        public event EventHandler<EventArgs<AppointmentItem>> AppointmentModified;
        public event EventHandler<CancelEventArgs<AppointmentItem>> AppointmentDeleting;

        public CalendarMonitor(Explorer anExplorer)
        {
            m_folderPaths = new List<string>();
            m_calendarFolders = new List<MAPIFolder>();
            m_calendarItems = new List<Items>();

            m_explorer = anExplorer;
            m_explorer.BeforeFolderSwitch +=
              new ExplorerEvents_10_BeforeFolderSwitchEventHandler(Explorer_BeforeFolderSwitch);

            NameSpace session = m_explorer.Session;
            try
            {
                m_deletedItemsFolder = session.GetDefaultFolder(OlDefaultFolders.olFolderDeletedItems);
                HookupDefaultCalendarEvents(session);
            }
            finally
            {
                Marshal.ReleaseComObject(session);
                session = null;
            }
        }

        private void HookupDefaultCalendarEvents(NameSpace aSession)
        {
            MAPIFolder folder = aSession.GetDefaultFolder(OlDefaultFolders.olFolderCalendar);
            if (folder != null)
            {
                try
                {
                    HookupCalendarEvents(folder);
                }
                finally
                {
                    Marshal.ReleaseComObject(folder);
                    folder = null;
                }
            }
        }

        private void Explorer_BeforeFolderSwitch(object aNewFolder, ref bool Cancel)
        {
            MAPIFolder folder = (aNewFolder as MAPIFolder);
            //
            // Hookup events to any other Calendar folder opened.
            //
            if (folder != null)
            {
                try
                {
                    if (folder.DefaultItemType == OlItemType.olAppointmentItem)
                    {
                        HookupCalendarEvents(folder);
                    }
                }
                finally
                {
                    Marshal.ReleaseComObject(folder);
                    folder = null;
                }
            }
        }

        private void HookupCalendarEvents(MAPIFolder aCalendarFolder)
        {
            if (aCalendarFolder.DefaultItemType != OlItemType.olAppointmentItem)
            {
                throw new ArgumentException("The MAPIFolder must use " +
                  "AppointmentItems as the default type.");
            }
            //
            // Ignore other user's calendars.
            //
            if ((m_folderPaths.Contains(aCalendarFolder.FolderPath) == false)
              && (IsUsersCalendar(aCalendarFolder)))
            {
                Items items = aCalendarFolder.Items;
                //
                // Store folder path to prevent double ups on our listeners.
                //
                m_folderPaths.Add(aCalendarFolder.FolderPath);
                //
                // Store a reference to the folder and to the items collection so that it remains alive for
                // as long as we want. This keeps the ref count up on the underlying COM object and prevents
                // it from being intermittently released (then the events don't get fired).
                //
                m_calendarFolders.Add(aCalendarFolder);
                m_calendarItems.Add(items);
                //
                // Add listeners for the events we need.
                //
                ((MAPIFolderEvents_12_Event)aCalendarFolder).BeforeItemMove +=
                  new MAPIFolderEvents_12_BeforeItemMoveEventHandler(Calendar_BeforeItemMove);
                items.ItemChange += new ItemsEvents_ItemChangeEventHandler(CalendarItems_ItemChange);
                items.ItemAdd += new ItemsEvents_ItemAddEventHandler(CalendarItems_ItemAdd);
            }
        }

        private void CalendarItems_ItemAdd(object anItem)
        {
            AppointmentItem appointment = (anItem as AppointmentItem);
            if (appointment != null)
            {
                try
                {
                    if (this.AppointmentAdded != null)
                    {
                        this.AppointmentAdded(this, new EventArgs<AppointmentItem>(appointment));
                    }
                }
                finally
                {
                    Marshal.ReleaseComObject(appointment);
                    appointment = null;
                }
            }
        }

        private void CalendarItems_ItemChange(object anItem)
        {
            AppointmentItem appointment = (anItem as AppointmentItem);
            if (appointment != null)
            {
                try
                {
                    if (this.AppointmentModified != null)
                    {
                        this.AppointmentModified(this, new EventArgs<AppointmentItem>(appointment));
                    }
                }
                finally
                {
                    Marshal.ReleaseComObject(appointment);
                    appointment = null;
                }
            }
        }

        private void Calendar_BeforeItemMove(object anItem, MAPIFolder aMoveToFolder, ref bool Cancel)
        {
            if ((aMoveToFolder == null) || (IsDeletedItemsFolder(aMoveToFolder)))
            {
                AppointmentItem appointment = (anItem as AppointmentItem);
                if (appointment != null)
                {
                    try
                    {
                        if (this.AppointmentDeleting != null)
                        {
                            //
                            // Listeners to the AppointmentDeleting event can cancel the move operation if moving
                            // to the deleted items folder.
                            //
                            CancelEventArgs<AppointmentItem> args = new CancelEventArgs<AppointmentItem>(appointment);
                            this.AppointmentDeleting(this, args);
                            Cancel = args.Cancel;
                        }
                    }
                    finally
                    {
                        Marshal.ReleaseComObject(appointment);
                        appointment = null;
                    }
                }
            }
        }

        private bool IsUsersCalendar(MAPIFolder aFolder)
        {
            return (aFolder.Store != null);
        }

        private bool IsDeletedItemsFolder(MAPIFolder aFolder)
        {
            return (aFolder.EntryID == m_deletedItemsFolder.EntryID);
        }
       }

Answer 1

You need to keep the source objects alive if you want to get events fired correctly:

Application.Inspectors.NewInspector += Inspectors_NewInspector;

Instead, declare the Inspectors instance at the class level:

Application.Inspectors inspectors = null;

// in the method you could use the following code
inspectors = Application.Inspectors;
inspectors.NewInspector += Inspectors_NewInspector;

Define the object (Inspectors) at the class level to prevent it from swiping by the garbage collector.

You may find the Implement a wrapper for inspectors and track item-level events in each inspector article helpful.

For example, the following code is a good sample to explain a possible issue:

private void HookupCalendarEvents(MAPIFolder aCalendarFolder)
        {
            if (aCalendarFolder.DefaultItemType != OlItemType.olAppointmentItem)
            {
                throw new ArgumentException("The MAPIFolder must use " +
                  "AppointmentItems as the default type.");
            }
            //
            // Ignore other user's calendars.
            //
            if ((m_folderPaths.Contains(aCalendarFolder.FolderPath) == false)
              && (IsUsersCalendar(aCalendarFolder)))
            {
                Items items = aCalendarFolder.Items;
                //
                // Store folder path to prevent double ups on our listeners.
                //
                m_folderPaths.Add(aCalendarFolder.FolderPath);
                //
                // Store a reference to the folder and to the items collection so that it remains alive for
                // as long as we want. This keeps the ref count up on the underlying COM object and prevents
                // it from being intermittently released (then the events don't get fired).
                //
                m_calendarFolders.Add(aCalendarFolder);
                m_calendarItems.Add(items);
                //
                // Add listeners for the events we need.
                //
                ((MAPIFolderEvents_12_Event)aCalendarFolder).BeforeItemMove +=
                  new MAPIFolderEvents_12_BeforeItemMoveEventHandler(Calendar_BeforeItemMove);
                items.ItemChange += new ItemsEvents_ItemChangeEventHandler(CalendarItems_ItemChange);
                items.ItemAdd += new ItemsEvents_ItemAddEventHandler(CalendarItems_ItemAdd);
            }
        }

The Items object is defined inside the method, so when the GC triggers the object can be swiped from the heap (if method finished its work). So, you will never get events fired after that. To prevent this from happening you need to declare the source object at the class level:

Items items = null;

private void HookupCalendarEvents(MAPIFolder aCalendarFolder)
        {
            if (aCalendarFolder.DefaultItemType != OlItemType.olAppointmentItem)
            {
                throw new ArgumentException("The MAPIFolder must use " +
                  "AppointmentItems as the default type.");
            }
            //
            // Ignore other user's calendars.
            //
            if ((m_folderPaths.Contains(aCalendarFolder.FolderPath) == false)
              && (IsUsersCalendar(aCalendarFolder)))
            {
                items = aCalendarFolder.Items;
                //
                // Store folder path to prevent double ups on our listeners.
                //
                m_folderPaths.Add(aCalendarFolder.FolderPath);
                //
                // Store a reference to the folder and to the items collection so that it remains alive for
                // as long as we want. This keeps the ref count up on the underlying COM object and prevents
                // it from being intermittently released (then the events don't get fired).
                //
                m_calendarFolders.Add(aCalendarFolder);
                m_calendarItems.Add(items);
                //
                // Add listeners for the events we need.
                //
                ((MAPIFolderEvents_12_Event)aCalendarFolder).BeforeItemMove +=
                  new MAPIFolderEvents_12_BeforeItemMoveEventHandler(Calendar_BeforeItemMove);
                items.ItemChange += new ItemsEvents_ItemChangeEventHandler(CalendarItems_ItemChange);
                items.ItemAdd += new ItemsEvents_ItemAddEventHandler(CalendarItems_ItemAdd);
            }
        }