Extension Points and Extensions
A typical Mono.Addins based application is composed of:
- A host application (or add-in host), which defines several extension points.
- Several add-ins, which extend extension points defined by a host.
Implementing an add-in host
The following code is a basic example of an add-in host application. This application runs a set of commands which can be implemented by add-ins:
[assembly:AddinRoot ("HelloWorld", "1.0")]
public static void Main ()
foreach (ICommand cmd in AddinManager.GetExtensionObjects<ICommand> ())
This code shows some declarations and initializations that you have to do in all extensible applications:
- The [AddinRoot] attribute applied to an assembly declares that this assembly is an add-in host. All add-in hosts must have an identifier and a version number.
- The AddinManager.Initialize call initializes the add-in engine. It must be called before doing any operation with the AddinManager class.
- When calling AddinManager.Registry.Update, the add-in engine will scan the application directory (and other user-defined add-in directories) looking for add-ins, and will update an internal
add-in registry which is used to cache add-in information.
- The AddinManager.GetExtensionObjects call can be used to
query an extension point. It returns a list of objects registered in that extension point.
However, for this example to be complete, the extension point must be declared.
Declaring the Extension Point
The extension point for the above example can be declared like this:
public interface ICommand
void Run ();
attribute when applied to a class or interface declares an extension point which accepts objects of that type. In this example, we are creating an extension point for objects implementing the type ICommand.
Implementing the add-in
An add-in extending the above extension point would look like this:
[assembly:AddinDependency ("HelloWorld", "1.0")]
public class HelloCommand: ICommand
public void Run ()
Console.WriteLine ("Hello World!");
Add-ins are implemented in separate assemblies, which must be marked with the
attribute to be recognized as add-ins. Add-ins must also declare the add-in hosts they are extending by using the
attribute. Notice that an add-in can extend several add-in hosts, and it can even extend other add-ins which declare their own extension points. The AddinDependency attribute must specify the host/add-in id and its version number.
By applying the [Extension]
attribute to a class we are declaring a new extension node of that type which is added to an extension point. The extension point is determined by looking at the base types and interfaces of the class. So in this example the
class implements the ICommand interface, and there is an extension point defined for that interface, so that's the extension point where the type will be registered. If a class implements several interfaces, we can select the extension point by specifying
the type name in the attribute, for example: [Extension (typeof(ICommand))]
Description of Add-ins and Add-in Roots
section in the reference manual has more information about creating extensions and extension points, including:
Querying Extension Points