定义：
1.) 工厂方法模式是用来封装对象的创建，通过让子类来决定创建的对象是什么，来达到将对象创建的过程封装的目的；
2.) 定义了一个创建对象的接口，但由子类决定要实例的泪是哪一个。工厂方法让类把实例化推迟到子类。
适用场景：
代码中经常会出现：根据条件创建实现了同一个接口的不用类实例，而这些判定条件可能随时变动，导致我们这个不得不去改动很多代码。
备注：简单工厂在Head First中，被认为不是设计模式的一种，但人们经常使用，大家习惯性的叫，久了也就言传为“工厂方法模式”。
简单工厂方法
解决了什么问题
例如：
string dbName=string.Empty;
dbName="Access";
MemberDaoBase memberDao=null; if(dbName.ToUpper()=="ACCESS"){
memberDao=new Access.MemberDao();
}
else if(dbName.ToUpper()=="SQLSERVER")
{
memberDao=new SqlServer.MemberDao();
}
memberDao.Create(new Member());
memberDao.Modify(new Member());
memberDao.Remove();
如果代码中不再变动还好，但这种情况很多时候是不存在的，当来了一个新的领导，领导说Sqlite的性能好且免费，那你就不得不去重新去写一个Sqlite.MemberDao,之后再在这里的判断条件中添加上
else if(dbName.ToUpper()=="SQLITE")
{
memberDao=new SqlServer.SqliteDao();
}
当某天另外一个领导说我们不再支持SqlServer了，我们就不得不把else if(dbName.ToUpper()=="SQLSERVER") {...} 这块代码给注释了。我们就痛苦在这种“变动”中。
问题分析：
不稳定部分：
string dbName=string.Empty;
dbName="Access";
MemberDaoBase memberDao=null; if(dbName.ToUpper()=="ACCESS"){
memberDao=new Access.MemberDao();
}
else if(dbName.ToUpper()=="SQLSERVER")
{
memberDao=new SqlServer.MemberDao();
}稳定部分：
memberDao.Create(new Member()); memberDao.Modify(new Member()); memberDao.Remove();
如果我们将不稳定的部分给交给两外一个类单独管理，就能把这种耦合变得低一点，当我们需要“变动”时，只用去修改这个管理类；而这管理来是用来new 实例的，我们习惯。
“new管理类（简单工厂方法核心类）”：
/// <summary>
/// Description of MemberDaoFactory.
/// </summary>
public class MemberDaoFactory
{
public MemberDaoBase Create(string dbName)
{
if(dbName.ToUpper()=="ACCESS")
{
Console.WriteLine("new Access.MemberDao()");
return new Access.MemberDao();
}
else if(dbName.ToUpper()=="SQLSERVER")
{
Console.WriteLine("new SqlServer.MemberDao()");
return new SqlServer.MemberDao();
}
else
{
throw new NotSupportedException(string.Format("Not supported {0}",dbName));
}
}
}
按照简单工厂方法的定义调整
代码结构图：
Member.cs
/// <summary>
/// Description of Member.
/// </summary>
public class Member
{
private int id;
private string name; public Member()
{
} public int Id
{
get { return id; }
set{id=value;}
} public string Name
{
get { return name; }
set { name = value; }
}
}
Dao/MemberBO.cs
using System; namespace FactoryMethod
{
/// <summary>
/// Description of MemberBO.
/// </summary>
public class MemberBO
{
private MemberDaoFactory memberDaoFactory=null;
private string dbName=string.Empty; public MemberBO(string dbName,MemberDaoFactory memberDaoFactory)
{
this.dbName=dbName;
this.memberDaoFactory=memberDaoFactory;
} public void Create(Member member)
{
if(member==null)
{
throw new ArgumentNullException("member is null");
} MemberDaoBase memberDao=this.memberDaoFactory.Create(this.dbName); memberDao.Create(member);
}
}
}
Dao/MemberDaoBase.cs
using System; namespace FactoryMethod
{
public abstract class MemberDaoBase
{
public abstract void Create(Member member); public abstract void Modify(Member member); public abstract void Remove(int id);
}
}
Dao/SqlServer/MemberDao.cs
using System; namespace FactoryMethod.SqlServer
{
/// <summary>
/// Description of MemberDao.
/// </summary>
public class MemberDao:MemberDaoBase
{
public MemberDao()
{
} public override void Create(Member member)
{
//...
Console.WriteLine("Insert member into sqlserver db");
} public override void Modify(Member member)
{
//...
Console.WriteLine("modify member from sqlserver db");
} public override void Remove(int id)
{
//...
Console.WriteLine("remove member from sqlserver db");
}
}
}
Dao/Access/MemberDao.cs
using System; namespace FactoryMethod.Access
{
/// <summary>
/// Description of MemberDao.
/// </summary>
public class MemberDao:MemberDaoBase
{
public MemberDao()
{
} public override void Create(Member member)
{
//...
Console.WriteLine("Insert member into access db");
} public override void Modify(Member member)
{
//...
Console.WriteLine("modify member from access db");
} public override void Remove(int id)
{
//...
Console.WriteLine("remove member from access db");
}
}
}
客户端调用：
class Program
{
public static void Main(string[] args)
{
Console.WriteLine("Hello World!"); // TODO: Implement Functionality Here
MemberBO memberBO0=new MemberBO("access",new MemberDaoFactory());
memberBO0.Create(new Member()); MemberBO memberBO1=new MemberBO("sqlserver",new MemberDaoFactory());
memberBO1.Create(new Member()); Console.Write("Press any key to continue . . . ");
Console.ReadKey(true);
}
}
输出结果：
工厂方法
当系统要求不再是只有普通人员了，分出了管理层和基层，而且程序中要求不同等级的数据放在不同网络上，且数据库中的字段名称不同，但意义还是一样时。
我们当前系统的结构就不能很好的应对了，于是我们就需要这样处理：
提取出对应的抽象MemberBO类,和MemberBO的具体实现类ManagerBO,EmployeeBO,MemberBO包含所有的外部需要的功能外还包含一个抽象的FactoryMethod函数，ManagerBO和EmployeeBO要实现FactoryMethod函数：
对应的类：
public class Member
{
public Member() { } public int ID { get; set; } public string Name { get; set; }
} public abstract class MemberDaoBase
{
public abstract void Create(Member member); public abstract void Modify(Member member);
} public abstract class MemberBOBase
{
protected virtual void Create(Member member, string dbName)
{
if (member == null)
{
throw new ArgumentNullException("member is null!");
} this.FactoryMethod(dbName).Create(member);
} protected virtual void Modify(Member member, string dbName)
{
if (member == null)
{
throw new ArgumentNullException("member is null!");
} this.FactoryMethod(dbName).Modify(member);
} public abstract MemberDaoBase FactoryMethod(string dbName);
} public class ManagerBO : MemberBOBase
{
public override MemberDaoBase FactoryMethod(string dbName)
{
if (dbName.ToUpper() == "ACCESS")
{
return new ManagerAccessDao();
}
else if (dbName.ToUpper() == "SQLSERVER")
{
return new ManagerSqlServerDao();
}
else
{
throw new NotImplementedException(string.Format("{0} not implemented", dbName));
}
}
} public class EmployeeBO : MemberBOBase
{
public override MemberDaoBase FactoryMethod(string dbName)
{
if (dbName.ToUpper() == "ACCESS")
{
return new EmployeeAccessDao();
}
else if (dbName.ToUpper() == "SQLSERVER")
{
return new EmployeeSqlServerDao();
}
else
{
throw new NotImplementedException(string.Format("{0} not implemented", dbName));
}
}
} public class ManagerAccessDao : MemberDaoBase
{
public override void Create(Member member)
{
throw new NotImplementedException();
} public override void Modify(Member member)
{
throw new NotImplementedException();
}
} public class ManagerSqlServerDao : MemberDaoBase
{
public override void Create(Member member)
{
throw new NotImplementedException();
} public override void Modify(Member member)
{
throw new NotImplementedException();
}
} public class EmployeeAccessDao : MemberDaoBase
{
public override void Create(Member member)
{
throw new NotImplementedException();
} public override void Modify(Member member)
{
throw new NotImplementedException();
}
} public class EmployeeSqlServerDao : MemberDaoBase
{
public override void Create(Member member)
{
throw new NotImplementedException();
} public override void Modify(Member member)
{
throw new NotImplementedException();
}
}
简单工厂和工厂方法之间的差异
简单工厂是将全部的事情,在一个地方都处理完了，而工厂方法却是创建了一个框架，让子类决定要如何实现。
例如：在工厂方法中我们有一个FactoryMethod()方法提供了一般的框架，一边创建Dao，FactoryMethod()方法依赖工厂方法创建具体类，决定制造出的Dao是什么。
简单工厂的做法，可以将对象的创建封装起来，但是简单工厂不具备工厂方法的弹性，因为简单工厂不能变更正在创建的产品。
这样的调整好处在于什么？
当我们需要条件一个新扩展Member数据操作类时，我们有统一的接口来，具体的操作方法都可不变，改动部分只需要扩展现有的MemberDaoFactory.cs，降低了应用层的耦合度。
优缺点：
1.) 优点：
a.) 降低了应用层次调用的耦合度；
b.) 当扩展时，有统一的接口类，开发更规范；
c.) 代码逻辑更清晰，代码更易管理维护。
2.) 缺点：
a.) 适用性很有限，前提条件有局限性；当我们的接口类MemberDaoBase.cs变动时，我们就需要改动多处代码；
b.) 当需要扩展时，我们依然避免不了要改动代码（尽管可以进一步改进通过设置配置和反射达到避免MemberDaoFactory变动，但是当我们需要添加新的扩展时还避免不了改动代码）。
参考资料：《Head First 设计模式》
欢迎拍砖！请牛人们给指点。
