文章目录
前言
工厂模式是一种创建型 设计模式，它提供了一种将对象的实例化过程封装起来的方法，使得客户端代码不必直接依赖于具体类。这有助于降低代码的耦合度，提高代码的可维护性和可扩展性。在C#中，有三种常见的工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式。下面详细解释这三种工厂模式。
简单工厂模式
简单工厂模式是最基本的工厂模式，它通过一个工厂类来创建对象。客户端只需要知道要创建的产品的类型，而不需要知道具体的实现类。
- 首先定义一个抽象产品类。该类主要定义了产品的共有属性和方法，用于子类继承和实现。
cs
public abstract class Car
{
public abstract void GetName();
public void Refuel()
{
Console.WriteLine("汽车加油");
}
}- 其次定义每个产品的具体实现子类。该类实现并继承自抽象类，如需增加产品可直接创建新的子类并继承自抽象类即可。
cs
public class FordCar: Car
{
public override void GetName()
{
Console.WriteLine("我是福特汽车");
}
}
public class HondaCar: Car
{
public override void GetName()
{
Console.WriteLine("我是本田汽车");
}
}- 然后定义核心类，即工厂类。该类通过创建了一个枚举类型参数来选择需要创建的产品实例。
cs
public class CarFactory
{
public static Car CreateCar(CarType carType)
{
switch (carType)
{
case CarType.FordCar:
return new FordCar();
break;
case CarType.HondaCar:
return new HondaCar();
break;
default:
break;
}
return null;
}
public enum CarType
{
FordCar,
HondaCar
}
}- 最后客户端调用。
cs
class Program
{
static void Main(string[] args)
{
//通过CarFactory产品工厂创建了FordCar产品实例
Car car = CarFactory.CreateCar(CarFactory.CarType.FordCar);
car.GetName();
//通过CarFactory产品工厂创建了HondaCar产品实例
car = CarFactory.CreateCar(CarFactory.CarType.HondaCar);
car.GetName();
car.Refuel();
}
}对于客户端来说，其去除了与具体产品之间的依赖。
简单工厂模式 的缺点主要就是违背 了开闭原则
工厂方法模式
这是一种更高级的工厂模式，它通过抽象接口或基类中的工厂方法来创建对象。
具体实现由子类负责，因此更加灵活。这种设计方式有利于实现开闭原则 ，即对扩展开放 ，对修改封闭。
- 抽象产品类：
cs
public abstract class Car
{
public abstract void GetName();
public void Refuel()
{
Console.WriteLine("汽车加油");
}
}- 具体产品类：
cs
public class FordCar: Car
{
public override void GetName()
{
Console.WriteLine("我是福特汽车");
}
}
public class HondaCar: Car
{
public override void GetName()
{
Console.WriteLine("我是本田汽车");
}
}- 抽象工厂：
cs
public abstract class CarFactory
{
public abstract Car CreateCar();
}- 具体产品工厂：
cs
public class FordCarFactory: CarFactory
{
public override Car CreateCar()
{
return new FordCar();
}
}
public class HondaCarFactory: CarFactory
{
public override Car CreateCar()
{
return new HondaCar();
}
}- 客户端调用：
cs
class Program
{
static void Main(string[] args)
{
//创建一个汽车工厂，只负责生产福特汽车产品
CarFactory carFactory = new FordCarFactory();
//在福特汽车工厂中生产一个福特汽车产品
Car car = carFactory.CreateCar();
car.GetName();
//创建一个汽车工厂，只负责生产本田汽车产品
carFactory = new HondaCarFactory();
//在本田汽车工厂中生产一个本田汽车产品
car = carFactory.CreateCar();
car.GetName();
//汽车加油
car.Refuel();
}
}抽象工厂模式
抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。它是工厂方法模式的推广，不仅仅创建一个对象，而是创建一系列相关的对象。
- 抽象产品类，有多少个不同产品就创建多少个抽象产品类。实例中创建了两种产品，即汽车和轮胎。
cs
public abstract class Car
{
public abstract void GetName();
public void Refuel()
{
Console.WriteLine("汽车加油");
}
}
cs
public abstract class Tire
{
public abstract void GetName();
}- 具体产品类，不同产品继承不同抽象类。实例中定义了两种汽车和两种轮胎，汽车为一个产品等级，轮胎是另外一个产品等级。
cs
public class FordCar: Car
{
public override void GetName()
{
Console.WriteLine("我是福特汽车");
}
}
public class HondaCar: Car
{
public override void GetName()
{
Console.WriteLine("我是本田汽车");
}
}
public class FordTire: Tire
{
public override void GetName()
{
Console.WriteLine("我是福特轮胎。");
}
}
public class HondaTire: Tire
{
public override void GetName()
{
Console.WriteLine("我是本田轮胎。");
}
}- 抽象工厂类，有多少个系列就可以创建多少个抽象工厂类。
cs
public abstract class CarFactory
{
//生产汽车
public abstract Car CreateCar();
//生产轮胎
public abstract Tire CreateTire();
}- 具体工厂类，同一系列可以创建多个具体的工厂，负责同一系列下的不同产品出的创建。
cs
public class FordCarFactory: CarFactory
{
public override Car CreateCar()
{
return new FordCar();
}
public override Tire CreateTire()
{
return new FordTire();
}
}
public class HondaCarFactory: CarFactory
{
public override Car CreateCar()
{
return new HondaCar();
}
public override Tire CreateTire()
{
return new HondaTire();
}
}- 客户端调用：
cs
class Program
{
static void Main(string[] args)
{
//首先创建一个汽车工厂
CarFactory carFactory = new FordCarFactory();
//然后对应工厂中生产出对应的不同产品。
Car car = carFactory.CreateCar();
car.GetName();
Tire tire = carFactory.CreateTire();
tire.GetName();
carFactory = new HondaCarFactory();
car = carFactory.CreateCar();
car.GetName();
tire = carFactory.CreateTire();
tire.GetName();
}
}