设计模式学习笔记(一)

/* Notes:
* When the construction needed involves many objects, possible organised
* in multi-faceted arrangements, the entire construction can be delegated
* to an abstract factory. This exposes standardised creation functionality
* which can be customised in concrete implementation to suit your specific
* needs, and avoid embedding this information in higher level code - it
* just needs to know how to call the abstract factory.
*
* In this sample, we have a framework with three abstract operating classes,
* called DPDocument, DPWorkspace and DPView and one abstract construction
* class, called DPFactory. An application-level class, called DPApplication
* is responsible for construction.
*
* We have a series of application-level operating classes derived from this
* framework - MyDocument, MyWorkspace and MyView. For design reasons we
* assume we wish to instantiate these from inside DPApplication. As there
* are multiple objects needed and they could be arranged in different
* lattices, we use a factory, MyFactory (in our example, there are all
* simple siblings), which is called inside DPApplication.
*
*/

namespace AbstractFactory_DesignPattern
{
using System;

// These classes could be part of a framework,
// which we will call DP
// ===========================================

abstract class DPDocument
{
abstract public void Dump();
}

abstract class DPWorkspace
{
abstract public void Dump();
}

abstract class DPView
{
abstract public void Dump();
}

abstract class DPFactory
{
abstract public DPDocument CreateDocument();
abstract public DPView CreateView();
abstract public DPWorkspace CreateWorkspace();
}

abstract class DPApplication
{
protected DPDocument doc;
protected DPWorkspace workspace;
protected DPView view;

public void ConstructObjects(DPFactory factory)
{
// Create objects as needed
doc = factory.CreateDocument();
workspace = factory.CreateWorkspace();
view = factory.CreateView();
}

abstract public void Dump();

public void DumpState()
{
if (doc != null) doc.Dump();
if (workspace != null) workspace.Dump();
if (view != null) view.Dump();
}
}

// These classes could be part of an application
class MyApplication : DPApplication
{
MyFactory myFactory = new MyFactory();

override public void Dump()
{
Console.WriteLine("MyApplication exists");
}

public void CreateFamily()
{
MyFactory myFactory = new MyFactory();
ConstructObjects(myFactory);
}
}

class MyDocument : DPDocument
{
public MyDocument()
{
Console.WriteLine("in MyDocument constructor");
}

override public void Dump()
{
Console.WriteLine("MyDocument exists");
}
}

class MyWorkspace : DPWorkspace
{
override public void Dump()
{
Console.WriteLine("MyWorkspace exists");
}
}

class MyView : DPView
{
override public void Dump()
{
Console.WriteLine("MyView exists");
}
}

class MyFactory : DPFactory
{
override public DPDocument CreateDocument()
{
return new MyDocument();
}
override public DPWorkspace CreateWorkspace()
{
return new MyWorkspace();
}
override public DPView CreateView()
{
return new MyView();
}
}

/// <summary>
/// Summary description for Client.
/// </summary>
public class Client
{
public static int Main(string[] args)
{
MyApplication myApplication = new MyApplication();

myApplication.CreateFamily();

myApplication.DumpState();

return 0;
}
}
}