“Not Loaded. A runtime error occurred during the loading of the COM Add-in”

There can be many reasons for this behavior and requires your step by step verification of each one. Note that the message descriptions given below are specific for Outlook 2003 and Outlook 2007 and may vary for other office applications.

1. Enable the Add-in (if it is found under disabled items)

Outlook 2003:

• Go to Help –> About Microsoft Office
• Click on “Disabled Items”
• Select your add-in (if found there) and click enable
• Close and start Outlook

Outlook 2007:

Use the following steps to access Disabled items:

• Go to Help—> Disabled Items

OR

• On the Tools menu, click Trust Center.
• In the Navigation Pane, click Add-ins.
• In the Manage list, select Disabled Items, and then click Go.

2. Enable the Add-in from  COM Add-in Window

Outlook 2003:

• Go to Tools –> Options –> Others –> Advanced Options –> COM Add-ins
• Select and Check your add-in (if found there as unchecked) and click OK
• Your outlook plug-in should load now, if not go back to COM Add-ins window and see if there are any error messages.

Outlook 2007:

Use the following steps to access Disabled items:

• On the Tools menu, click Trust Center.
• In the Navigation Pane, click Add-ins.
• In the Manage list, select COM Add-ins, and then click Go.
• Select and Check your add-in (if found there as unchecked) and click OK

3. Check registry settings

• Go to : HKEY_LOCAL_MACHINE\Software\Microsoft\Office\Outlook\Addins\<AddIn Name> (Or HKCU equivalent)
• Check the loadbehavior key value. If it is set to 2, change to 3 and start your Outlook
• If the Add-in does not load, go back to registry and check the loadbehavior value. You may notice that the value is changed back to 2 (indicating the problem while loading your plug-in) and we should go to next steps.

4. Check CAS (Code Access Security) permissions for the code group

Your Add-in assemblies code group should be given “FullTrust” permission. You can verify the current permission levels using one of the following.

• CASPOL.EXE : Use caspol tool to query the code groups and permission levels
• Use .NET Framework Configuration Tool (mscorcfg.msc)

If FullTrust permissions are not given, use caspol.exe to grant FullTrust to the add-in assemblies

Example: <From Visual Studio Command Prompt>

caspol -u -ag All_Code –url  “C:\<FolderName>\<FolderName>\*” FullTrust -n "<Name>" –d "<Description>"

More details on CAS is out of scope for this post. You can refer this for detailed instructions: How to: Grant Permissions to Folders and Assemblies

5. Check Primary Interop Assemblies (PIA) are installed correct

Verify whether Primary Interop Assemblies [for Office 2003 or Office 2007 depending upon your version of MS Office] installed correctly on your machine. To check this, go to GAC (%systemroot%\assembly) and look for assemblies named Microsoft.Office.Interop.*  and their versions.

If not installed, get it downloaded from the following URLs:

• Office 2003: Redistributable Primary Interop Assemblies
• Office 2007: Redistributable Primary Interop Assemblies

6. Add Custom Logging

Place the code in the Startup event to log exception details to  System Event Log which can give you if the exceptions are occurred during the load event.

<To be updated>

The above steps will help to identify/fix the load error. If you do not find the solution for your error get more help from this Microsoft Support Link to troubleshoot.

Well, that’s the high level summary, I will to go through MEF basics and revisit the comparison between MAF and MEF. You can get the MEF framework libraries from:

1) .NET Framework 4.0 Beta

2) Download from CodePlex

MEF Introduction

By definition “The Managed Extensibility Framework (or MEF for short) simplifies the creation of extensible applications. MEF offers discovery and composition capabilities that you can leverage to load application extensions “

• MEF provides a standard way for the host application to expose itself and consume external extensions. Extensions, by their nature, can be reused amongst different applications. However, an extension could still be implemented in a way that is application-specific. Extensions themselves can depend on one another and MEF will make sure they are wired together in the correct order (another thing you won’t have to worry about).
• MEF offers a set of discovery approaches for your application to locate and load available extensions.
• MEF allows tagging extensions with additional metadata which facilitates rich querying and filtering

For more information visit MEF on CodePlex

We can look at the implementation and architecture of MEF and the elements involved in extensibility support in Part 2

I had blogged earlier about Managed AddIn Framework and the resources to learn the basics. Making use of System.AddIn framework features can appear complex for beginners. In this example we develop a host application and AddIn using Managed AddIn Framework.

Source Code: You can download the source code for this example below.

 Source Code 

The diagram below demonstrates how we are going to implement each component in the Managed AddIn Framework in our sample application.

When you activate an Addin from host, you can load the Addin in its own application domain or in an existing application domain or even in a new process separate from host’s process.

Step -1 – HostView

Create a solution with the following solution folders. Create a class library project named HostView under the Pipeline solution folder.

It is important to set the project settings. For HostView, change the output path to ..\output\ (Visual Studio default will be \bin\debug or \bin\release)

The HostView is an abstract class with methods corresponding to the methods exposed by the Addin. In this example I go for a simple method which returns the sum of two integer numbers.

namespace Demo.HostView
{
    public abstract class HostView
    {
        public abstract int ComputeSum(int a, int b);
    }
}

Step -2 – Create Host Application

Create a Windows Application project named SampleHost under the HostApplication solution folder.

1. Change the output path to ..\output\

2. Add reference to assemblies System.AddIn and System.AddIn.Contract

3. Add reference to project HostView

The host application UI is given below. It aims to load our addin and use it for computing the sum of numbers supplied from the host application.

Add the following code in the Host to load the AddIn

Collection<AddInToken> _addinTokens;
Collection<HostView> _addinList = new Collection<HostView>();
HostView calcAddin;

private void btn_Load_Click(object sender, EventArgs e)
{
    LoadAddins();
}

public void LoadAddins()
{
    // Set root directory for finding Add-ins
    string addinRoot = Environment.CurrentDirectory;

    // Rebuild the add-ins and pipeline components
    AddInStore.Rebuild(addinRoot);

    // Find add-ins of type HostView
    _addinTokens = AddInStore.FindAddIns(typeof(HostView), addinRoot);

    foreach (AddInToken addinToken in _addinTokens)
    {
        // Activate the add-in
        _addinList.Add(
            addinToken.Activate<HostView>(AddInSecurityLevel.Internet));

        // Display Addin-Details
        richText1.AppendText(String.Format("Loaded Add-in {0} Version {1}",
            addinToken.Name, addinToken.Version));
    }

    calcAddin = _addinList[0];
}

And we are ready to use the addin instance. 

private void btn_Add_Click(object sender, EventArgs e)
{
    if (calcAddin != null)
    {
        //Invoking the AddIn method
        int sum = calcAddin.ComputeSum(
            Convert.ToInt32(textBox1.Text),
            Convert.ToInt32(textBox2.Text));
        lblResult.Text = sum.ToString();
    }
    else
        MessageBox.Show("AddIn is not loaded");
}

Step -3 –Create AddIn View

Create a class library project named AddInView under the Pipeline solution folder.

• Change the output path to ..\output\AddInViews\

• Add reference to assemblies System.AddIn and System.AddIn.Contract

The AddInView is an abstract class with methods corresponding to the methods exposed by the Addin. Note that this class should have the attribute [AddInBase]

using System.AddIn.Pipeline;
namespace Demo.AddinView
{
    [AddInBase]
    public abstract class AddInView
    {
        public abstract int ComputeSum(int a, int b);
    }
}

Step – 4 – Create Contract

The contract in the middle of the pipeline is loaded into both Host’s app domain and AddIn’s app domain.

Create a class library and;

• Change the output path to ..\output\Contracts\
• Add reference to assemblies System.AddIn and System.AddIn.Contract

The contract interface should have the [AddInContract] attribute as shown below.

using System.AddIn.Contract;
using System.AddIn.Pipeline;

namespace Demo.Contracts
{
    [AddInContract]
    public interface IContracts:IContract
    {
        int ComputeSum(int a, int b);
    }
}

Step -5 –Create Host Side Adapter

The host-side converts the flow of types between Host View and the contract.

Create a class library project named HostSideAdapters under the Pipeline solution folder

• Change the output path to ..\output\HostSideAdapters\

• Add reference to assemblies System.AddIn and System.AddIn.Contract

• Add reference to project Contracts, set Copy Local property to False

• Add reference to project HostView, set Copy Local property to False

Note the [HostAdapter] attribute of the ContractToHostViewAdapter Class below.

using System.AddIn.Pipeline;
using Demo.Contracts;
namespace Demo.HostSideAdapters
{
    [HostAdapter]
    public class ContractToHostViewAdapter : HostView.HostView
    {
        private IContracts _calcContract;
        private ContractHandle _handle;
        public ContractToHostViewAdapter(IContracts contract)
        {
            _calcContract = contract;
            _handle = new ContractHandle(_calcContract);
        }
        public override int ComputeSum(int a, int b)
        {
            return this._calcContract.ComputeSum(a,b);
        }
    }
}

Step -6 – Create AddIn Side Adapter

Create a class library project named AddInSideAdapters under the Pipeline solution folder

• Change the output path to ..\output\AddInSideAdapters\

• Add reference to assemblies System.AddIn and System.AddIn.Contract

• Add reference to project Contracts, set Copy Local property to False

• Add reference to project AddInView, set Copy Local property to False

Note the [AddInAdapter] attribute of the AddInViewToContractAdapter Class below. The adapter inherits from System.AddIn.Pipeline.ContractBase class and implements  IContracts interface.

using System.AddIn.Pipeline;
using Demo.AddinView;
using Demo.Contracts;
namespace Demo.AddInSideAdapters
{
    [AddInAdapter]
    public class AddInViewToContractAdapter: ContractBase, IContracts
    {
        private AddInView _view;
        public AddInViewToContractAdapter(AddInView view)
        {
            this._view = view;
        }
        public int ComputeSum(int a, int b)
        {
            return this._view.ComputeSum(a,b);
        }
     }
}

Step -7 –Implement AddIn

Create a class library project named CalcAdd under the AddIn solution folder

Change the output path to ..\output\AddIns\CalcAddin\  (If you have multiple Addin, each AddIn would be deployed into separate directories)

• Add reference to assemblies System.AddIn and System.AddInx.Contract

• Add reference to project AddInView, set Copy Local property to False

namespace Demo.CalcAddIn
{
    [System.AddIn.AddIn("Demo Add-In",
     Version = "1.0.0.0",
     Description = "Description of Demo AddIn",
     Publisher = "XYZ Company")]
    public class CalcAddIn : Demo.AddinView.AddInView
    {
        public override int ComputeSum(int a, int b)
        {
            return a+b;
        }
    }
}

Step -8 – Run the host application

Build the solution and run the host application. You should see the following result.

Alternately you can download the source code from the link below and run it.

Source Code

http://communitytechdays.com/

• Venu, Hari, Ranga, Sathish, Sathya (starting top left, clockwise)
• Prashanth, Biju, Praveen (Centre)

I installed the pipeline builder add-in to Visual Studio 2008 and it works great!  Matt Hidinger in his blog describes the steps to use pipeline builder with a sample.

The links that may be of interest to add-in developers are :

• CodePlex site for the Managed Extensibility and Add-In Team
• CLR Add-In Team Blog

We have used this model for couple of applications and it works pretty fine.  There were glitches initially but the framewrok is being stabilized as the new versions are out. 

Mono is an open source implementation of Microsoft’s .Net Framework based on the ECMA standards for C# and the Common Language Runtime.

Cross Platform? : This framework is not just for Linux.  Mono runs on Linux, Microsoft Windows, Mac OS X, BSD, and Sun Solaris, Nintendo Wii, Sony PlayStation 3, Apple iPhone. It also runs on x86, x86-64, IA64, PowerPC, SPARC (32), ARM, Alpha, s390, s390x (32 and 64 bits) and more. Developing your application with Mono allows you to run on nearly any computer in existance.

This portal (Office Development with Visual Studio) provides many resources related to Office Solutions development using .NET framework including Add-In development for MS Office 2003 and Office 2007 

How does Add-Ins work with MS Word, Excel etc?

Add-ins that are created by using Visual Studio Tools for Office consist of an assembly that is loaded into a Microsoft Office application as an add-in. Add-ins that are created by using Visual Studio Tools for Office have access to the Microsoft .NET Framework as well as the application’s object model. When you build an add-in project, Visual Studio compiles the assembly into a .dll file and creates a separate application manifest file. The application manifest points to the assembly, or to the deployment manifest if the solution uses one.

Visual Studio Tools for Office provides a loader for add-ins that are created by using Visual Studio Tools for Office. This loader is named AddinLoader.dll. When a user starts the Microsoft Office application, this loader starts the common language runtime (CLR) and the Visual Studio Tools for Office runtime, and then loads the add-in assembly. The assembly can capture events that are raised in the application.

The CLR enables the use of managed code that is written in a language supported by the Microsoft .NET Framework. In your solution, you can do the following:

• Respond to events that are raised in the application itself (for instance, when a user clicks a menu item).
• Write code against the object model to automate the application.

After the assembly has been loaded, the add-in has access to the application’s objects, such as documents or mail. The managed code communicates with the application’s COM components through the primary interop assembly in your add-in project.

“Application has generated an exception that could not be handled”

Resolution:

I found this link as a workaround to get this done. Yes, it works!