做个笔记，自己留着，免得以后忘记了
#region 无模式调用
public abstract class Car
{
public abstract void Drive();
}
public class Bz : Car
{
public override void Drive()
{
Console.WriteLine("开奔驰");
}
}
public class Bmw : Car
{
public override void Drive()
{
Console.WriteLine("开宝马");
}
}
static void Main(string[] args)
{
Car car1 = new Bz();
car1.Drive();
Car car2 = new Bmw();
car2.Drive();
//这样没有模式的调用，会产生很多重复代码，将来维护和扩展都会有很大的问题
Console.ReadLine();
}
#endregion
public abstract class Car
{
public abstract void Drive();
}
public class Bz : Car
{
public override void Drive()
{
Console.WriteLine("开奔驰");
}
}
public class Bmw : Car
{
public override void Drive()
{
Console.WriteLine("开宝马");
}
}
public class Factory
{
public static Car CreateCar(string CarName)
{
Car NewCar = null;
if (CarName == "Bz")
{
NewCar = new Bz();
}
else if (CarName == "Bmw")
{
NewCar = new Bmw();
}
return NewCar;
}
}
static void Main(string[] args)
{
Car car1 = Factory.CreateCar("Bz");
car1.Drive();
Car car2 = Factory.CreateCar("Bmw");
car2.Drive();
Console.ReadLine();
}
#region 抽象工厂(工厂中的工厂)
public abstract class Car
{
public abstract void Drive();
}
public class Bz : Car
{
public override void Drive()
{
Console.WriteLine("开奔驰");
}
}
public class Bmw : Car
{
public override void Drive()
{
Console.WriteLine("开宝马");
}
}
public abstract class Factory
{
public abstract Car CreatCar();
}
public class BzFactory : Factory
{
public override Car CreatCar()
{
return new Bz();
}
}
public class BmwFactory : Factory
{
public override Car CreatCar()
{
return new Bmw();
}
}
static void Main(string[] args)
{
Car car1 = new BzFactory().CreatCar();
car1.Drive();
Car car2 = new BmwFactory().CreatCar();
car2.Drive();
Console.ReadLine();
}
上述代码，添加新类型，需要新增工厂类，工厂父类Factory不需要修改，这样对于已有的工厂不会产生任何潜在的改动影响——便于扩展。
对于这种方式，和直接new Benz(), new BMW()，每一种车有一个工厂类，不过还是上面讲的，如果返回一个实例要做很多事情，
不好直接写在构造函数里面，可以写在具体的工厂类里面，而且如果工厂父类要添加新的逻辑，所有工厂同时享有。
工厂方法就是每加一种类型，要添加汽车类，还要添加具体工厂类，增加开销。
#endregion
#region 反射+ 简单工厂
简单工厂，每增加一种车，就要在这个工厂里写一个判断
为了代码的可扩展性，就用反射
public class Factory
{
public static Car CreatCar(string car)
{
Car newCar = null;
if (car == "Benz")
{
newCar = new Benz();
}
else if (car == "BMW")
{
newCar = new BMW();
}
else if (car == "Ford")
{
newCar = new Ford();
}
return newCar;
}
}
public abstract class Car
{
public abstract void Drive();
}
public class Bz : Car
{
public override void Drive()
{
Console.WriteLine("开奔驰");
}
}
public class Bmw : Car
{
public override void Drive()
{
Console.WriteLine("开宝马");
}
}
public class ReflectionFactory
{
public static Car CreatCar(string carClass)
{
Assembly ass = Assembly.GetExecutingAssembly();
获取程序集中的类
Type t = ass.GetType(carClass);
创建类的实例对象
Car o = (Car)Activator.CreateInstance(t);
return o;
}
static void Main(string[] args)
{
反射 + 简单工厂
Car car1 = ReflectionFactory.CreatCar("Bz");
car1.Drive();
Car car2 = ReflectionFactory.CreatCar("Bmw");
car2.Drive();
Console.ReadLine();
}
#endregion
}
#region 反射+ 简单工厂
//简单工厂，每增加一种车，就要在这个工厂里写一个判断
//为了代码的可扩展性，就用反射
public class Factory
{
public static Car CreatCar(string car)
{
Car newCar = null;
if (car == "Benz")
{
newCar = new Benz();
}
else if (car == "BMW")
{
newCar = new BMW();
}
else if (car == "Ford")
{
newCar = new Ford();
}
return newCar;
}
}
public abstract class Car
{
public abstract void Drive();
}
public class Bz : Car
{
public override void Drive()
{
Console.WriteLine("开奔驰");
}
}
public class Bmw : Car
{
public override void Drive()
{
Console.WriteLine("开宝马");
}
}
public class ReflectionFactory
{
public static Car CreatCar(string carClass)
{
Assembly ass = Assembly.GetExecutingAssembly();
获取程序集中的类
Type t = ass.GetType(carClass);
创建类的实例对象
Car o = (Car)Activator.CreateInstance(t);
return o;
}
static void Main(string[] args)
{
//反射 + 简单工厂
Car car1 = ReflectionFactory.CreatCar("Bz");
car1.Drive();
Car car2 = ReflectionFactory.CreatCar("Bmw");
car2.Drive();
Console.ReadLine();
}
#endregion