Richard,

Thanks very much for your example.  I have been looking for weeks trying to
figure out how to implement event handlers.  I'm writing a simple app that
monitors incoming mail messages and then need to do some processing when I
get one from a particular organization with a specific subject.  I have it
implemented with a button at the moment but need to make it automatic and
that's where I ran into problems.  I'll take a look at your example and see
if I can apply it.

I've found it very difficult to find good examples in C# .  Most everything
for outlook is in VB and while I can follow most of it when the subject
turns to event handling and other issues that involve passing objects the
translation is not so obvious.  Do you have any other references you've
found useful?

Thanks again for sharing your code samples.  Examples are always helpful.

Ron

Ron,

Here is my OnConnect Method.

public void OnConnection(object application, Extensibility.ext_ConnectMode
connectMode, object addInInst, ref System.Array custom)
{
try
{
Connect.applicationObject = (Outlook.Application)application;
Connect.addInInstance = addInInst;
//Remember the group of explorers
Connect.exps = applicationObject.Explorers;
//Register to be notified when a new explorer is added
Connect.Exps.NewExplorer += new
Outlook.ExplorersEvents_NewExplorerEventHandler(NewExplorerMethod);
//Register to be notified when a new inspector is added
inspectors = Connect.applicationObject.Inspectors;
inspectors.NewInspector += new
Microsoft.Office.Interop.Outlook.InspectorsEvents_NewInspectorEventHandler(I
nspectors_NewInspector);
}
catch(Exception ex)
{
Debug.WriteLine(ex);
}
}
Notice that I do not call OnStartupComplete in this routine.  Outlook calls
that method after all the Add-ins that it is loading have had OnConnect
called and returned.  I do some other initialization in that routine that
caused problems if initialized twice.  In my class defiinition I have the
following code:
private static Outlook.Application applicationObject;
/// <summary>Gets the Outlook Application that was passed into this
Add-In.</summary>
public static Outlook.Application ApplicationObject
{
   get{return applicationObject;}
}
/// <summary>The instance of this add-in, as passed-in during
startup.</summary>
private static object addInInstance;
#region Explorers code
private static Outlook.Explorers exps;
/// <summary>Gets the explorers available in Outlook.</summary>
public static Outlook.Explorers Exps
{
   get{return exps;}
}
private void NewExplorerMethod(Outlook.Explorer newExplorer)
{
   try
   {
       //Watch that explorer, and track it well...
       Outlook.Explorer realNewExplorer =
Connect.ApplicationObject.Explorers[Connect.ApplicationObject.Explorers.Coun
t];
       Wrappers.ExplorerWrapper wrapper = new
Talisman.Wrappers.ExplorerWrapper(realNewExplorer);
   }
   catch(Exception ex)
   {
       Debug.WriteLine(ex);
   }
}
#endregion
#region Inspectors Code
private Outlook.Inspectors inspectors;
private void
Inspectors_NewInspector(Microsoft.Office.Interop.Outlook.Inspector
Inspector)
{
   try
   {
       Debug.WriteLine("New Inspector!");
       //TODO: get the item for this inspector, and attach events to it...
       Outlook.Inspector temp =
inspectors[applicationObject.Inspectors.Count];
       object currentItem = temp.CurrentItem;
       if(currentItem is Outlook.MailItem)
       {
           Outlook.MailItem currMailItem = (Outlook.MailItem)currentItem;
           if(!currMailItem.Sent)
           { //This is an active email that is waiting to be sent. Watch
the form and the MailItem
               EmailWrapper tempEmail = new EmailWrapper(currMailItem);
               InspectorWrapper tempInspector = new InspectorWrapper(temp);
           }
       }
   }
   catch(Exception ex)
   {
       Debug.WriteLine(ex);
   }
}
#endregion
So "Inspectors_NewInspector" is the routine that I have that gets called
whenever a new Inspector is added to the Inspectors collection (by the way,
this is where I tried to re-register for the event and got the exception).
I also keep a reference to the Inspectors collection ("private
Outlook.Inspectors inspectors") so that it does not get garbage collected by
the runtime.  I was not doing this before, and so referencing the collection
once through "Application.Inspectors" caused it to be created, and then
later collected because the runtime saw that it is no longer being used.
Storing it in a class-level variable like this keeps the runtime from ever
cleaning it up.
Here is my InspectorWrapper class that I use to keep a reference to an
Inspector as long as it is running:
public class InspectorWrapper
{
   #region Static Members
   private static ArrayList watchingItems;
   static InspectorWrapper()
   {
       watchingItems = new ArrayList();
   }
   #endregion
   public InspectorWrapper(Outlook.Inspector inspector)
   {
       this.inspector = inspector;
       ((Outlook.InspectorEvents_Event)this.inspector).Close += new
Microsoft.Office.Interop.Outlook.InspectorEvents_CloseEventHandler(Inspector
_Close);
       watchingItems.Add(this);
   }
   private Outlook.Inspector inspector;
   public Outlook.Inspector Inspector
   {get{return this.inspector;}}
   private void Inspector_Close()
   {   //Clean up this watcher
       ((Outlook.InspectorEvents_Event)this.inspector).Close -= new
Microsoft.Office.Interop.Outlook.InspectorEvents_CloseEventHandler(Inspector
_Close);
       watchingItems.Remove(this);
   }
}
Inside this class, I attach an event handler to the Inspector that is passed
into the constructor.  I'm just listening for the close event so that I can
clean up this object, and close it down.  Eventually I will be listening for
other events, and possibly raising my own in those routines, but this class
is at step along the way to that point.  I also have a static member on the
class ("watchingItems") keeping track of all the open Inspectors.  Since I
do not need to access them anywhere else, just in this Wrapper class, I am
just keeping a reference to these objects inside this static member.
I suspect that in your case, your OnStartUpcomplete code should look
something more like this:
public void OnStartupComplete(ref System.Array custom)
{
   // add the New Mail event handler
   try
   {
       applicationObject.NewMail += new
Outlook.ApplicationEvents_11_NewMailEventHandler(this.ssMail);
   }
   catch (System.Exception ex)
   {
       u.logErr(ex.Message,"ssProcessOrders Addin
Error","ssProcessOrders.dll","OnStartUpCompleted");
   }
}
In this case, you are directly attaching to the applicationObject that was
passed into the OnConnect method of the class.  Accessing the Application
member of the objects you are using probably will result in using
"non-trusted" code.  And since, in this case, you have a reference to the
trusted application object, you will not run into problems.  All objects in
Outlook have an "Application" property,  but I suspect that that property
always returns an "untrusted" reference to the application object, whereas
the only trusted instance is the one passed into the OnConnect method.  You
should always access the trusted Application object directly instead of
through any other objects in the Outlook model.  My second code block
defined a public static "ApplicationObject" property, that I use to allow
any other class in my Add-In to access the Outlook Application directly.
I hope this helps.  It has certainly helped me to understand what is going
on.
Richard