简单工厂模式
创建一个工厂类，对实现了同一个接口的多个类进行实例的创建。
//抽象类 人
public abstract class HuMan
{
public abstract void Talk();
}
//黑人实现类
public class BlackHuman : HuMan
{
public override void Talk()
{
Console.WriteLine("I am BlackHuman");
}
}
//白人实现类
public class WhiteHuman : HuMan
{
public override void Talk()
{
Console.WriteLine("I am WhiteHuman");
}
}
/// <summary>
/// 简单工厂
/// </summary>
public static class HumanFactory
{
public static HuMan CreateHuman(HumanEnum humanEnum)
{
HuMan huMan = null;
switch (humanEnum)
{
case HumanEnum.Black:
huMan = new BlackHuman();
break;
case HumanEnum.White:
huMan = new WhiteHuman();
break;
default:
throw new NullReferenceException();
}
return huMan;
}
}
//客户端调用
//创建一个白人
var whiteHuman1 = SimpleFactory.CreateHuman(HumanEnum.White);
whiteHuman1.Talk();
//创建一个黑人
var blackHuman1 = SimpleFactory.CreateHuman(HumanEnum.Black);
blackHuman1.Talk();
优点：工厂中包含了必要的逻辑判断，根据客户端的选择条件动态的创建相关的类，对于客户端来说，它只需要提供创建实现类的参数，隐藏了创建实例的细节，去除了对具体实现类的依赖。
缺点：当要新增一个实现类时，需要修改工厂类的代码（switch下增加一个Case），违背了开放-封闭原则。
当然上面的代码其实还存在很大的优化空间，我们可以先看下工厂模式的实现方案，对比下两种模式上的区别。
工厂模式
定义一个用于创建对象的接口，让子类决定实现哪个类。工厂方法将创建对象实例的职责移交给了子类。
//定义一个创建人类的工厂接口
public interface IHumanFactory
{
HuMan CreateHuman();
}
//定义一个创建白人的工厂
public class WhiteHumanFactory : IHumanFactory
{
public HuMan CreateHuman()
{
return new WhiteHuman();
}
}
//定义一个创建黑人的工厂
public class BlackHumanFactory : IHumanFactory
{
public HuMan CreateHuman()
{
return new BlackHuman();
}
}
//客户端调用
var whiteHumanFactory = new WhiteHumanFactory();
var whiteHuman2 = whiteHumanFactory .CreateHuman();
whiteHuman2.Talk();
var blackHumanFactory = new BlackHumanFactory();
var blackHuman2 = blackHumanFactory .CreateHuman();
blackHuman2.Talk();
优点：当要新增一个实现类时，只需要再增加一个实现类和创建实现类的工厂，不需要修改原有工厂的代码，保留了简单工厂对创建实例的封装，又体现了开放-封闭原则。
缺点：客户端需要决定实例化哪一个工厂来创建实现类，增加了客户端的复杂度。同时每增加一个实现类，也要增加一个工厂类，增加了代码复杂度。
简单工厂+反射
可以通过反射技术来强化简单工厂，让简单工厂同样符合开放封闭原则。
/// <summary>
/// 简单工厂
/// </summary>
public static class HumanFactory
{
public static HuMan CreateHuman(string humanType)
{
var a = Assembly.LoadFrom($"{AppDomain.CurrentDomain.BaseDirectory}DesignPatterns.Model.dll");
return (HuMan)a.CreateInstance($"DesignPatterns.Model.Factory.{humanType}");
}
}
客户端可以通过配置文件或者数据库中获取humanType(在程序或者数据库中维护一个参数类型+类名的字典)，通过反射技术动态的创建实例。
简单工厂+依赖注入
//工厂类
public class HumanFactory
{
private readonly Func<HumanEnum, Human> _func;
public HumanFactory(Func<HumanEnum, Human> func)
{
this._func = func;
}
public Human CreateHuman(HumanEnum humanEnum)
{
return _func(humanEnum);
}
}
public static class HunmanDependencyInjection
{
//维护一个实现类的字典
private static Dictionary<HumanEnum, Type> dicHuman = new Dictionary<QRCodeType, Type>() {
{ HumanEnum.White,typeof(WhiteHuman)},
{ HumanEnum.Black,typeof(BlackHuman)}
};
public static void AddHuman(this IServiceCollection serviceCollection)
{
serviceCollection.AddScoped<WhiteHuman>();
serviceCollection.AddScoped<BlackHuman>();
serviceCollection.AddScoped(factory=> {
Func<HumanEnum, Human> func = humanType=> {
return (Human)factory.GetService(dicHuman [humanType]);
};
return func;
});
serviceCollection.AddScoped<HumanFactory>();
}
}
//在Startup中注入实现类和工厂
public void ConfigureServices(IServiceCollection services)
{
services.AddHuman();
services.AddMvc();
}
//客户端在构造函数中引入HumanFactory
var whiteHuman = HumanFactory.CreateHuman(HumanEnum.White);
whiteHuman.Talk();
这样我们就用Ioc实现了一个简单工厂，上面的代码示例是将实现类的字典放在工厂中维护，其实可以将字典放到配置文件或者数据库中维护，这样我们再增加新的实现类时，就不需要在修改工厂的代码，实现了实现类的动态扩展。也体现了开闭原则。
