Defer the Final Implementation to Another More Knowledgeable Class
	Formally Hide or Encapsulate the Implementation for Flexibility
	Allow Runtime Variation in Implementation (Polymorphism)
	Mark Thyself

In this chapter I am going to demonstrate the use of encapsulation and polymorphism to allow the dynamic loading of a "plug in" class at runtime. The loading of a third  party plug in class at runtime is useful when you want to add new functionality to an existing program. Since the application does not know the name of the plug in class at compile time, the application must "discover" the new class at runtime.  Runtime discovery is done using reflection. The framework supports discovery with classes in the System.Reflection.Assembly and System.Type namespaces. In this tutorial you will use the method Assembly.Load to dynamically load a class at runtime.

The application must also create an instance of the new class at runtime using System.Activator. In this tutorial you will use the method Activator.CreateInstance to create an instance of the dynamically loaded class. As long as the plug in class implements the expected abstract method or interface, say IDrawable.DrawYourself(), then the new functionality can be invoked at runtime through the magic of polymorphism! Unfortunately, implementing this solution is not simple, so I will be your guide.

Define the Interface

public interface IDrawable
{
	void DrawYourself(Graphics g, Point p, int size);
}

using System;
using System.Drawing;

// compile as a class library
// creates a dll as output
// this project references the System.Drawing.dll
namespace MyInterface
{
	public interface IDrawable
	{
		void DrawYourself(Graphics g, Point p, int size);
	}
}

using System;
using System.Drawing; // project references System.Drawing.dll
using MyInterface; // project references MyInterface.dll

namespace DrawPlugIn
{
	public class Triangle : IDrawable 
	{
		public void DrawYourself(Graphics g, Point p, int size){
			Console.WriteLine("Triangle");
		}
	}
}

public static void Main() 
{
	AppDomain currentDomain = AppDomain.CurrentDomain;
	Console.WriteLine(currentDomain.BaseDirectory);
	Application.Run(new Form1());
}

	public class Circle : MyInterface.IDrawable 
	{
		public void DrawYourself(Graphics g, Point p, int size){
			Console.WriteLine("Circle");
		}
	}
	public class Square : MyInterface.IDrawable 
	{
		public void DrawYourself(Graphics g, Point p, int size) {
			Console.WriteLine("Square");
		}
	}

/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.Container components = null;

private ArrayList drawableList= new ArrayList();

public Form1()
{
	//
	// Required for Windows Form Designer support
	//
	InitializeComponent();

	//
	// TODO: Add any constructor code after InitializeComponent call
	//

	// thanks to Jon Skeet for his suggestions

	// add statically compiled objects
	drawableList.Add(new Circle());
	drawableList.Add(new Square());

	// now dynamically load class DrawPlugIn.Triangle which
	// implements interface MyInterface.IDrawable
	Assembly assembly= null;
	try 
	{        
		// tell app where to look for plugins
		AppDomain.CurrentDomain.AppendPrivatePath("plugins");

		// get absolute path to our private assemblies
		string path= AppDomain.CurrentDomain.BaseDirectory+"plugins";
				

		// create plugins folder if one does not exist
		DirectoryInfo info= new DirectoryInfo(path);
		if (!info.Exists){ info.Create();}

		// discover all dlls in plugins folder
		string[] dir= Directory.GetFiles(path,"*.dll");

		// iterate over files in folder plugins
		foreach (string s in dir)
		{
			string dll= Path.GetFileNameWithoutExtension(s);
			assembly= Assembly.Load(dll);  // in folder plugins
			//Type[] types= assembly.GetTypes();
			Type[] types= assembly.GetExportedTypes(); //safer

			foreach(Type t in types) 
			{
				Console.WriteLine("Type: {0}",t);
				try 			
				{
					// only load if implements IDrawable
					// use fully qualified name!
					//if (t.GetInterface("MyInterface.IDrawable")!= null) 
					if (typeof(IDrawable).IsAssignableFrom(t) // safer call
							&& !t.IsAbstract) // even safer call ) 
					{
						// dynamically load this class
						object obj= Activator.CreateInstance(t);
						drawableList.Add(obj); // no need to cast
					}
				}
				catch(Exception e) 
				{
					Console.WriteLine(e);
				}
			}
				}
	}
	catch(Exception e) 
	{
		Console.WriteLine(e);
	}
			

	// exercse our arraylist
	foreach (IDrawable d in drawableList)
	{
		d.DrawYourself(null,new Point(0,0),0);  // throws exception if not IDrawable
	}
}

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using System.Reflection;
using System.IO; // FileNotFoundException
using MyInterface; // this project references MyInterface.dll

	// create an arraylist
	private ArrayList drawableList= new ArrayList();

	// add statically compiled objects in the Form1 constructor
	drawableList.Add(new Circle());
	drawableList.Add(new Square));

	// tell app where to look for plugins
	AppDomain.CurrentDomain.AppendPrivatePath("plugins");

	// get absolute path to our private assemblies
	string path= AppDomain.CurrentDomain.BaseDirectory+"plugins";

	// create plugins folder if one does not exist
	DirectoryInfo info= new DirectoryInfo(path);
	if (!info.Exists){info.Create();}

	// discover all dlls in plugins folder
	string[] dir= Directory.GetFiles(path,"*.dll");

	// iterate over files in folder plugins
	foreach (string s in dir)
	{
		string dll= Path.GetFileNameWithoutExtension(s);
		assembly= Assembly.Load(dll);  // in folder plugins
		...
	}

	assembly= Assembly.Load(dll);  // in folder plugins
	//Type[] types= assembly.GetTypes();
	Type[] types= assembly.GetExportedTypes(); //safer
	foreach(Type t in types) 
	{
		Console.WriteLine("Type: {0}",t);
		try 			
		{
			// only load if implements MyInterface.IDrawable
			// use fully qualified name!			
			//if (t.GetInterface("MyInterface.IDrawable")!= null)// or use
			if (typeof(IDrawable).IsAssignableFrom(t) // safer call
				&& !t.IsAbstract) // even safer call 
			{
				// dynamically load this class
				object obj= Activator.CreateInstance(t);
				drawableList.Add(obj); // no need to cast
			}
		}
		catch(Exception e) 
		{
			Console.WriteLine(e);
		}
	}

	foreach (IDrawable id in drawableList)
	{
		id.DrawYourself(null,new Point(0,0),0);
	}

Type: DrawPlugIn.Triangle
Circle
Square
Triangle
The program '[3888] DrawDemo.exe' has exited with code 0 (0x0).

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
   <runtime>
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <probing privatePath="Plugins"/>
     </assemblyBinding>
   </runtime>
</configuration>

		protected override void OnPaint(PaintEventArgs e) 
		{
			Graphics g= e.Graphics;
			int x=0;
			int y=0;
			int position= 20;
			foreach (IBasicShape ibs in basicShapeList) 
			{
				ibs.Size= 20;
				ibs.Position= new Point(x,y);
				ibs.DrawYourself(g);
				y += position;
			}
		}