Overview

When existing software lacks certain features, extending its functionality becomes necessary. Plugin-based architecture provides a standardized approach to adding new capabilities without modifying the original application. This pattern is widely used in development environments like Visual Studio, where extensions enhance the core IDE functionality.

For a host application to support plugins, it must expose specific extension points. If the original software wasn't designed with extensibility in mind, adding features becomes significantly more challenging—typically only the original developers can modify such applications.

Core Concepts

Plugin architecture relies on three fundamental principles:

Communication Protocol

The host application and its plugins must communicate through a well-defined interface. Without this communication channel, plugins cannot determine when to execute their functionality.

Data Exchange

The host must pass relevant data to plugins. For instance, when saving an image, plugins need access to the bitmap data to perform operations like adding watermarks.

Extensibility Contract

During host application development, extension interfaces must be designed upfront. All plugins must conform to these contracts, understanding when the host will invoke them and what responses are expected.

Architecture Pattern

The relationship between a host application and plugins mirrors the relationship between a framework and client code. The host defines extension points, and plugins provide implementations at those points.

┌─────────────────────┐
│    Host Application │
│                     │
│  ┌───────────────┐  │
│  │ Extension     │  │
│  │ Points        │  │
│  └───────────────┘  │
└──────────┬──────────┘
           │ Protocol
           ▼
┌─────────────────────┐
│      Plugins        │
│                     │
│  ┌───────────────┐  │
│  │ Custom        │  │
│  │ Extensions    │  │
│  └───────────────┘  │
└─────────────────────┘

The host application defines multiple interaction points where plugins can intervene. A host might expose 100 extension points, but a specific plugin may only respond to a subset of them based on its requirements.

Implementation Example

Consider a simple drawing application with plugin support. The host provides a drawing canvas, basic shapes (circle, rectangle), and file save functionality supporting JPG and native PIC formats.

The solution consists of three components:

1. DrawingHost - The main application being extended
2. ExtensionContract - Interfaces defining the extension contract
3. WatermarkPlugin - A sample plugin demonstrating extension capabilities

Extension Contract

The IExtension interface defines when the host communicates with plugins:

/// <summary>
/// Extension contract for all plugins
/// </summary>
public interface IExtension
{
    void OnApplicationStartup(HostContext context);
    void OnImageSaving(Bitmap imageData, string outputPath);
    void OnProjectSaving(ProjectDocument document);
    void OnBeforeFileSave(Dictionary<string, FileSaveHandler> availableFormats);
    void OnBeforeFileOpen(Dictionary<string, FileOpenHandler> supportedFormats);
    void OnApplicationShutdown();
}

Shape Interface

For extending drawing capabilities, a shape contract is required:

/// <summary>
/// Contract for custom shapes
/// </summary>
public interface IDrawableShape
{
    int PositionX { get; set; }
    int PositionY { get; set; }
    void Render(Graphics canvas);
    BoundingBox GetBounds();
}

Plugin Development Process

To create a plugin, developers need only the extension contract assembly. The implementation involves:

1. Create a class library project
2. Reference the extension contract assembly
3. Implement the IExtension interface
4. Override desired lifecycle methods
5. Deploy the compiled assembly to the host's extensions directory

Practical Demonstration

Extending the drawing application with a plugin demonstrates several capabilities:

Adding Menu Items

The plugin registers custom menu entries that appear in the host aplication's menu bar.

Extending Shape Library

New geometric shapes (such as triangles) become available in the toolbar after plugin installation.

Modifying Save Behavior

When saving images as JPG, the plugin injects a watermark into the final output.

Adding File Formats

New export formats (similar to how Photoshop supports ICO files through plugins) can be registered.

Comparison: Before and After Plugin Installation

Original Host Application:

• Supports circle and rectangle shapes only
• Saves files as JPG or PIC format
• Basic menu structure

After Plugin Installation:

• Additional triangle shape available
• New "About" menu entry appears
• JPG saves include watermark overlay
• New "newpic" format option available in save dialog

Deployment

Plugin deployment follows a straightforward pattern:

DrawingHost/
├── DrawingHost.exe
├── ExtensionContract.dll
└── extensions/
    └── WatermarkPlugin.dll

Placing compiled plugins into the extensions directory and restarting the host application triggers automatic plugin discovery and initialization.