JAL Computing

	Polymorphism
	Composite Extensible Interfaces
	Encapsulation
	Abstract Skeletal Base Class
	"Growable" Class Factory
	Extensible Classes
	Inheritance
	Containment
	Abstraction
	Types
	Object State and Behavior
	Dynamic Class Loading
	Explicit Preconditions and Exceptions
	Indirection

// Done loading factory
// Populate Shape Menu by
// iterating over objects in our type based factory

ICollection collection= typeFactory.Keys();
IEnumerator enumerator= collection.GetEnumerator();
while (enumerator.MoveNext())
{
	String menuName= (string)enumerator.Current;
	menuItemShape.MenuItems.Add(menuName,
		new EventHandler(this.shape_Click));
}

private String currentShape= "Circle"; // default value

private void shape_Click(object sender, System.EventArgs e)
{
	currentShape= ((MenuItem)sender).Text;
}

// default DrawableShape properties
private Color color= Color.Black;
private int brushWidth= 2;
private int size= 50;
private Point position= new Point(0,0);
private String currentShape= "Circle";

private void menuItemColorRed_Click(object sender, System.EventArgs e)
{
	this.color= Color.Red;
}

// trap mouse up and draw shape at mouse position
// add DrawableShape to ArrayList drawHistory
// use this ArrayList to refresh screen on Invalidate
private void Form1_MouseUp(object sender, MouseEventArgs e)
{
	Graphics g= Graphics.FromHwnd(this.Handle);

	if (e.X < 0 || e.Y < 0) 
	{
		g.DrawString("Invalid Mouse Coordinates.",
			new Font("Arial",10),
			new SolidBrush(Color.Red),
			10,
			10,
			StringFormat.GenericDefault);
		return;
	}

	IDrawableShape ds= typeFactory.GetInstance(currentShape);
	ds.Position= new Point(e.X,e.Y);
	ds.Size= this.size;
	ds.Color= this.color;
	ds.BrushWidth= this.brushWidth;
	ds.DrawYourself(g);
	drawHistory.Add(ds);
}

using System;

namespace DrawablePlugIns
{
	// Separate DLL used to create a new concrete class Triangle
	// This DLL can then be added to a "plugins" folder
	// An application can then dynamically add the Triangle class
	// at runtime!
	using System;
	using System.Drawing; // project references System.Drawing.dll
	using JALInterfaces; // project references JALInterfaces.dll
	// Create a new concrete class Triangle to be loaded dynamically
	public class Triangle : AbstractDrawableShape
	{
		public override void DrawYourself(Graphics g)
		{
			Pen p= new Pen(Color,BrushWidth);
			Point point1= new Point(Position.X+Size/2,Position.Y);
			Point point2= new Point(Position.X,Position.Y+Size);
			Point point3= new Point(Position.X+Size,Position.Y+Size);
			Point[] points= {point1,point2,point3};
			g.DrawPolygon(p,points);
		}		
	}
}

using System;
using System.Drawing;

namespace JALInterfaces
{
	// Refactored Drawable Interface
	public interface IDrawable
	{
		void DrawYourself(Graphics g);
	}
	// ASSERT P.X>=0 and P.Y>=0;
	public interface IPositional
	{
		Point Position
		{
			get;
			set;
		}
	}
	public interface ISizeable
	{
		int Size
		{
			get;
			set;
		}
	}
	public interface IColorable 
	{
		Color Color 
		{
			get;
			set;
		}
	}
	public interface IBrushWidth 
	{
		int BrushWidth
		{
			get;
			set;
		}
	}
	// Extensable Composite Interface IDrawableShape
	public interface IDrawableShape : 
				IDrawable, 
				IPositional, 
				IColorable, 
				ISizeable, 
				IBrushWidth {}
	

	// Factor repeated code into Abstract Class with Default Implementations
	// Concrete classes of IDrawableShape should inherit from this class
	// and override DrawYourself
	public abstract class AbstractDrawableShape : IDrawableShape 
	{
		private int size=1;
		private Point position= new Point(0,0);
		private Color color= Color.Black;
		private int brushWidth= 1;
		public int BrushWidth 
		{
			get {return brushWidth;}
			set 
			{
				if (value>0) {brushWidth= value;}
			}
		}
		public int Size
		{
			get {return size;}
			set 
			{
				if (value>0) {size= value;}
			}
		}
		// ASSERT p.x and p.y >=0
		public Point Position
		{
			get {return position;}
			set 
			{
				if ((value.X >=0) && (value.Y >=0))
				{
					position= value;
				}
				else 
				{
					throw new ArgumentException();
				}
			}
		}
		public Color Color
		{
			get{return color;}
			set 
			{
				color= value;
			}
		}
		virtual public void DrawYourself(Graphics g)
		{
			g.DrawString("Drawable",
				new Font("Arial",size),
				new SolidBrush(color),
				position.X, 
				position.Y,
				StringFormat.GenericDefault);
		}
	}
}

private void menuItemClear_Click(object sender, System.EventArgs e)
{
	drawHistory.Clear();
	this.Invalidate(); // repaint entire screen!
}

// Use array of DrawableShape objects to repaint
// and restore screen state on invalidate. Each object
// stores its own state and faithfully redraws itself! I now
// believe the framework is smart enough to limit repainting
// to the "dirty" area of the screen rather than repaint
// the entire screen.
protected override void OnPaint(PaintEventArgs e) 
{
	Graphics g= e.Graphics;
	foreach (IDrawableShape ds in drawHistory) 
	{
		ds.DrawYourself(g);
	}
}

// the class factory
class TypeBasedDrawableFactory 
{
	private Hashtable hash= new Hashtable();
	public bool Add(Type t) 
	{
		if ((t != null)&& 
			!hash.Contains(t.Name) 
			&& (typeof(IDrawableShape).IsAssignableFrom(t))
			&& !t.IsAbstract)
		{
			hash.Add(t.Name,t);
			return true;
		}
		else return false;
	}
	public int Count() 
	{
		return hash.Count;
	}
	public ICollection Keys() 
	{
		return hash.Keys;
	}
	public IDrawableShape GetInstance(string key) 
	{
		if (key == null || !hash.Contains(key)) 
		{
			return null;
		}
		else 
		{
			Type t= (Type)hash[key];
				// dynamically load this class
				return (IDrawableShape)Activator.CreateInstance(t);
			//else return null;
		}
	}
	public bool Contains(string key) 
	{
		if (key != null) 
		{
			return hash.Contains(key);
		}
		else {return false;}
	}
}