Sub Workbook_Open()
   
   Dim comAddIn As Office.comAddIn
   ...
   'Set reference to COM add-in by using its ProgId property value.
   Set comAddIn = Application.COMAddIns("RhythmOfTheBusiness.Connect")
   comAddIn.Connect = True
   ...
End Sub

<?xml version="1.0" encoding="utf-8" ?>
<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" 
         onLoad="GetRibbonXControl">
   <ribbon startFromScratch="false">
   <tabs>
      <tab id="ROB_Tab" label="Rhythm of the Business" 
   getVisible ="GetItemVisible" 
   insertBeforeMso="TabHome">
   . . .

<?xml version="1.0" encoding="utf-8" ?>
<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" 
         onLoad="GetRibbonXControl" 
         loadImage="GetItemIcon">
   <ribbon startFromScratch="false">
   <tabs>
      <tab id="ROB_Tab" label="Rhythm of the Business" 
   getVisible ="GetItemVisible" 
   insertBeforeMso="TabHome">
      <group id="ROBGroup1" label="ROB Tools" >
         <button id="ROB_Button" 
         size="large" 
         image="ROB_Button.bmp" 
         supertip="Launches ROB Team intranet site"/>

internal ResourceManager Resources = new ResourceManager();
. . .
public stdole.IPictureDisp GetItemIcon(string image_id)
{
return Resources.GetIcon(image_id);
}

class ResourceManager
   {
      Assembly thisAssembly = Assembly.GetExecutingAssembly();
      string[] resources=
         Assembly.GetExecutingAssembly().GetManifestResourceNames();
      //Load custom icon for Ribbon control from embedded assembly resources
      public stdole.IPictureDisp GetIcon(string resourceName)
      {
         foreach (string resource in resources)
         {
            if (resource.EndsWith(resourceName))
            {
               try
               {
                  System.IO.BinaryReader customIconReader =
                     new System.IO.BinaryReader(
                     thisAssembly.GetManifestResourceStream(resource));
                  if (customIconReader != null)
                  {
                     if (resourceName.ToUpper().EndsWith(".ICO"))
                     {
                        System.Drawing.Icon customIcon =
                           new System.Drawing.Icon(
                             customIconReader.BaseStream);
                        return 
            ConvertImage.Convert(customIcon.ToBitmap());
                     }
                     if (resourceName.ToUpper().EndsWith(".BMP"))
                     {
                        System.Drawing.Bitmap customBitmap =
                           new System.Drawing.Bitmap(
                           customIconReader.BaseStream);   
                        customBitmap.MakeTransparent(
                           customBitmap.GetPixel(0,0));
                        return ConvertImage.Convert(customBitmap);
                      }
                  }
               }
               catch (Exception e)
               {
                  Connect.RobApp.appFuncCaller.MakeLogEntry("Error 
         Loading " + resourceName + "-" + e.Message);
               }
            }
         }
         return null;
      }
   }

   //Helper class to convert image to IPictureDisp -
   //OLE type is the only type recognized by callback function
   //SOURCE: http://msdn2.microsoft.com/en-us/library/ms268747.aspx
   sealed internal class ConvertImage : System.Windows.Forms.AxHost
   {
      private ConvertImage(): base(null)
      {
      }
      public static stdole.IPictureDisp Convert(System.Drawing.Image image)
      {
         return (stdole.IPictureDisp)System.Windows.Forms.AxHost
            .GetIPictureDispFromPicture(image);
      }
   }

<?xml version="1.0" encoding="utf-8" ?> 
   <customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" 
   onLoad="GetRibbonXControl" 
   loadImage="GetItemIcon">
   <ribbon startFromScratch="false">
   <tabs>
   <tab id="ROB_Tab" 
      label="Rhythm of the Business" 
      getVisible="GetItemVisible" 
      insertBeforeMso="TabHome">
      <group id="ROBGroup1" label="ROB Tools">
      <button id="ROB_Button" 
      size="large" 
      image="ROB_Button.ico"      
      getLabel="GetItemLabel" 
      onAction="ExecuteItemOnAction" 
      getVisible="GetItemVisible" 
      getEnabled="GetItemEnabled" /> 
      <button id="ROB_Tree_Button" 
      image="DeckTree.bmp" 
      size="large" 
      getLabel="GetItemLabel" 
      onAction="ExecuteItemOnAction" 
      getVisible="GetItemVisible" 
      getEnabled="GetItemEnabled" /> 
. . .
     </group>
   </tab>
   </tabs>
   </ribbon>
   </customUI>

public partial class Connect
   {
      //RibbonX reference for callbacks
      internal IRibbonUI ribbonX;
      //Application reference to enable all event handlers access to application state  
      internal static Connect RobApp;
      //ROB Ribbon Items collection
      internal Dictionary<string, IRibbonBasicItem> AllRibbonItems = new 
      Dictionary<string, IRibbonBasicItem>();

      region Ribbon CustomUI callbacks
      //Callback to set RibbonX control reference 
      public void GetRibbonXControl(IRibbonUI ribbon)
      {
         //Reference to enable access to RibbonX
         //So we can call Invalidate and InvalidateControl methods inside this code
         ribbonX = ribbon;
      }

      //Generic calls that expose Ribbon items in a command bar-like way
      public string GetItemLabel(IRibbonControl control)
      {
         return AllRibbonItems[control.Id].Label;
      }

      public bool GetItemVisible(IRibbonControl control)
      {
         return AllRibbonItems[control.Id].Visible;
      }

      public bool GetItemEnabled(IRibbonControl control)
      {
         return AllRibbonItems[control.Id].Enabled;
      }
      
      //More complex Ribbon items with type-specific test
      public void ExecuteItemOnAction(IRibbonControl control)
      {
         if (AllRibbonItems[control.Id] is IRibbonItemWithAction)
         {
            ((IRibbonItemWithAction)AllRibbonItems[control.Id]).ExecuteOnAction();
         }
      }
. . .

interface IRibbonBasicItem
   {
      string ControlID { get; }
      bool Enabled { get; set; }
      string Label { get; set; }
      bool Visible { get; set; }
   }

   interface IRibbonItemWithAction
   {
      void ExecuteOnAction();
   }

internal class RibbonBasicItem : IRibbonBasicItem
   {
      string controlID = "";
      string label = "Label not set!";
      bool visible = false;
      bool enabled = false;
      internal RobRibbonItemType ItemType;

      internal RibbonBasicItem(string ControlID)
      {
         this.controlID = ControlID;
         Connect.RobApp.AllRibbonItems.Add(controlID, this);
      }

      region RibbonItem properties

      //Read-only control ID
      public string ControlID
      {
         get
         {
            return controlID;
         }
      }

      public string Label
      {
         get
         {
            return label;
         }

         set
         {
            //Restricting the label length
            if (value.Length <= 50)
            {
               label = value;
            }
            else
            {
               label = value.Substring(0, 50);
            }

            if (Connect.RobApp.ribbonX != null)
            {
               Connect.RobApp.ribbonX.InvalidateControl(controlID);
            }
         }
      }

      public bool Visible
      {
         get
         {
            return visible;
         }

         set
         {
            this.visible = value;
            if (Connect.RobApp.ribbonX != null)
            {
               Connect.RobApp.ribbonX.InvalidateControl(controlID);
            }
         }
      }

      public bool Enabled
      {
         get
         {
            return enabled;
         }
         set
         {
            this.enabled = value;
            if (Connect.RobApp.ribbonX != null)
            {
               Connect.RobApp.ribbonX.InvalidateControl(controlID);
            }
         }
      }

      endregion
      }

//Ribbon item dynamic onAction method signature
   internal delegate void RibbonAction(RibbonBasicItem ribbonItem);

   internal class RibbonButtonItem : RibbonBasicItem, IRibbonItemWithAction
   {
      //Control-specific
      internal RibbonAction OnControlAction;

      internal RibbonButtonItem(string ControlID)
         : base(ControlID)
      {
      }

      //Using a dedicated method to perform test and ensure delegate is not null
      //instead of a try-catch block
      public void ExecuteOnAction()
      {
         if (OnControlAction != null)
         {
            try
            {
               OnControlAction(this);
            }

            catch (Exception e)
            {
               MessageBox.Show("Error executing action for: "+this.ControlID+"\n"+
                  e.Message+"\nCheck application error log. "+
                  "You might need to restart the application.","Rhythm of the 
                   Business");
            }
         }
      }
   }

   //All other specific implementations of Ribbon items 
   //must derive from RibbonBasicItem
}

  internal class RibbonItemsCreator
   {
      OnControlAction ribbonActions = new OnControlAction();
      
      internal void CreateRibbonItems()
      {
         //Temporary type-specific variables used to construct
         //application-level collection
         RibbonBasicItem itemBasic;
         RibbonButtonItem itemButton;
         . . .
         //ROB_Tab
         itemBasic = new RibbonBasicItem("ROB_Tab");
         itemBasic.Label = "Rhythm of the Business";
         itemBasic.Enabled = true;
         itemBasic.Visible = true;

         //ROB_Button
         itemButton = new RibbonButtonItem("ROB_Button");
         itemButton.Label = "Link to ROB Homepage";
         itemButton.Enabled = true;
         itemButton.Visible = true;
         itemButton.OnControlAction = new 
            RibbonAction(ribbonActions.ROB_Button_OnAction);
         
         //ROB_Tree_Button
         itemButton = new RibbonButtonItem("ROB_Tree_Button");
         itemButton.Label = "Show GEO Tree View";
         itemButton.Enabled = true;
         itemButton.Visible = true;
         itemButton.OnControlAction = new 
            RibbonAction(ribbonActions.ROB_Tree_Button_OnAction);
            . . . 
}
   }

   class OnControlAction
   {
      Connect thisApp = Connect.RobApp;
      . . .
      public void ROB_Button_OnAction(RibbonBasicItem ribbonItem)
      {
         thisApp.appFuncCaller.OpenHomepage();
      }

      public void ROB_Tree_Button_OnAction(RibbonBasicItem ribbonItem)
      {
         thisApp.ShowTreeViewTaskPane();
      }
   . . .
   }

 internal class XlaAddinLoader
   {
      internal Excel._Workbook xla;
      object mv = Missing.Value;

      /// <summary>
      /// Opens the specified VBA file
      /// </summary>
      /// <param name="xl">Excel application instance in which to open the file 
      /// specified</param>
      /// <param name="addInName">Add-in file name</param>
      /// <returns></returns>
      internal bool OpenAddin(Excel._Application xl, string addInName)
      {
         if (!addInExists(addInName)) return false;

         try
         {
            xla = xl.Workbooks.Open(addInName, mv, mv, mv, mv, mv, mv, mv, mv, mv, 
              mv, mv, mv, mv, mv);
            return true;
         }
         //Add specific error trapping
         catch
         {
            throw;
         }
      }

      private bool addInExists(string addInName)
      {
         try
         {
            FileInfo addinFile = new FileInfo(addInName);
            return addinFile.Exists;
         }
         //Add specific error trapping
         catch
         {
            throw;
         }
      }
   }

   /// <summary>
   /// Base class for executing VBA code call-throughs
   /// </summary>
   public class XlaFunctionsWrapper
   {
      protected Excel.Application xl;
      protected Excel._Workbook xla;
      protected object mv = Missing.Value;
      protected string addInName = "";
      XlaAddinLoader AddIn;
      string addInPath = "";

      public XlaFunctionsWrapper(Excel.Application xlInstance, string addInName, 
         string addInPath)
      {
         xl = xlInstance;
         AddIn = new XlaAddinLoader();
         if (AddIn.OpenAddin(xl, addInPath))
         {
            xla = AddIn.xla;
            this.addInName = addInName;
            this.addInPath = addInPath;
         }
         else
         {
            MessageBox.Show("Unable to open: \n" + addInPath);
         }
      }

      //Parameterless void VBA call-through overload
      public void ExecuteCall(string funcName)
      {
         if (xla != null)
         {
            xl.Run(addInName + "!" + funcName, mv, mv, mv, mv, mv, mv, mv, mv, mv, 
               mv, mv, mv, mv, mv, mv, mv, mv, mv, mv, mv, mv, mv, mv, mv, mv, mv, 
               mv, mv, mv, mv);
         }
      }
      
      //Parameterized VBA call-through overload
      public void ExecuteCall(string funcName, params object[] parameters)
      {
         //Initializing optional parameters
         //Application.Run takes 30 parameters
         object[] par = GetVBAParameters(parameters);

         if (xla != null)
         {
            xl.Run(addInName + "!" + funcName, par[0], par[1], par[2], par[3], 
               par[4], par[5], par[6], par[7], par[8], par[9], par[10], par[11],
               par[12], par[13], par[14], par[15], par[16], par[17], par[18],
               par[19], par[20], par[21], par[22], par[23], par[24], par[25], 
               par[26], par[27], par[28], par[29]);
         }
      }

      //Parameterized VBA call-through overload with object return type
      //NOTE: Returned object needs to be cast to its proper type in the calling 
      //function
      public object ExecuteGetValue(string funcName, params object[] parameters)
      {
         //Initializing optional parameters
         //Application.Run takes 30 parameters
         object[] par = GetVBAParameters(parameters);

         if (xla != null)
         {
            return xl.Run(addInName + "!" + funcName, par[0], par[1], par[2], par[3],
               par[4], par[5], par[6], par[7], par[8], par[9], par[10], par[11], 
               par[12], par[13], par[14], par[15], par[16], par[17], par[18],
               par[19], par[20], par[21], par[22], par[23], par[24], par[25], 
               par[26], par[27], par[28], par[29]);
         }

         return null;
      }

      //Parameters builder
      internal object[] GetVBAParameters(params object[] parameters)
      {
         //Initializing optional parameters
         //Application.Run takes 30 parameters
         object[] par = new object[30];
         for (int i = 0; i <= 29; i++)
         {
            if (parameters!=null && parameters.Length - 1 >= i)
            {
               par[i] = parameters[i];
            }
            else
            {
               par[i] = mv;
            }
         }
         return par;
      }
   }

   /// <summary>
   /// ROB-specific extended VBA call-through methods
   /// </summary>
   public class RobFunctionsWrapper : XlaFunctionsWrapper
   {
      public RobFunctionsWrapper(Excel.Application xlInstance, string robAddInName, 
         string robAddInPath):base(xlInstance, robAddInName, robAddInPath)
      {
      }

      //Using facade design pattern
      //Legacy code calls to be replaced by managed code without impact
      //on core application
      . . .
      public void ShowAboutForm()
      {
         ExecuteCall("ShowAboutForm");
      }

      public void OpenHomepage()
      {
         ExecuteCall("OpenHomepage");
      }

      public void MakeLogEntry(string logEntry)
      {
         ExecuteCall("MakeLogEntry", "[Managed Code]: " + logEntry);
      }

      //Global variables in VBA handlers
      public object GetGlobalVarValue(string varName)
      {
         return ExecuteGetValue("GetGlobalVarValue", varName);
      }

      public void SetGlobalVarValue(string varName, object varValue)
      {
         ExecuteCall("SetGlobalVarValue", varName, varValue);
      }

      . . .
      //Explicit unmanaged resources clean up to prevent password 
      //prompt on Excel session shutdown
      ~RobFunctionsWrapper()
      {
         if (xla != null)
         {
            try
            {
               xla.Close(false, mv, mv);
            }
            catch
            {
               throw; //TODO: add proper error handler here
            }

            finally
            {
               System.Runtime.InteropServices.Marshal.ReleaseComObject(xla);
               xla = null;
            }
         }
      }
   }

  public partial class Connect : Object, Extensibility.IDTExtensibility2,
      ICustomTaskPaneConsumer, IRibbonExtensibility
   {
      internal Excel.Application excelApp = null;
      //application-specific VBA call wrapper/facade
      internal RobFunctionsWrapper appFuncCaller = null;
      
      Public void OnConnection(object application,
         Extensibility.ext_ConnectMode connectMode, 
         object addInInst, ref System.Array custom)
      {
         . . .
         excelApp = (Excel.Application)application;
         appFuncCaller=
          new RobFunctionsWrapper(excelApp, "ROB.XLA", userAppsPath + "\\ROB.XLA");
         . . .
      }

      . . .
      public void OnBeginShutdown(ref System.Array custom)
      {
         //releasing COM resources
         //IMPACT: If COM objects are not properly released, get 
         //password prompts
         //implemented by using destructor in the respective class. 
         //Unavoidable coupling
         //to ensure proper resources clean up
         appFuncCaller = null;
         
         GC.Collect();
         GC.WaitForPendingFinalizers();
         GC.Collect();
         GC.WaitForPendingFinalizers();
      }
         }