Factory Method 工厂方法模式简介与 C# 示例【创建型3】【设计模式来了_3】

〇、简介

1、什么是工厂方法模式？

一句话解释：

实体类和工厂类均为单独实现，不影响已实现的类，方便扩展。

工厂方法模式（Factory Method Pattern）是一种创建型模式，它允许客户端通过工厂方法来创建对象，而不是直接使用构造函数。这样可以让客户端代码更加灵活，同时保持实现的独立性。工厂方法可以返回同一类的对象，也可以返回不同的类对象。

官方意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类。AbstractMethod 是一个类的实例化延迟到其子类。

一个比喻：（班主任与班级）

一个班级对应一个班主任，当插班生超额时，则需要重新组成一个班级，那么此时就需要完成一个班级的各种条件，比如一个新的教室、班主任、班级编号等，当然这个新增的班级对原有的多个班级无影响。

2、优缺点和使用场景

优点：

工厂方法模式将对象的创建过程封装到了具体的工厂类中，使得客户端无需知道实际创建的具体对象是哪个类，降低了程序的耦合度。
通过定义抽象工厂类和具体工厂类，可以轻松添加新的产品类型，同时不影响现有代码的功能。
工厂方法模式可以适应开闭原则，即对扩展开放，对修改关闭。当需要增加新的产品时，只需要添加具体产品类和对应的具体工厂类即可，不必修改现有类的代码。
工厂方法模式提高了代码的可测试性，因为可以通过依赖注入的方式来模拟工厂对象并创建所需的产品对象。

缺点：

增加复杂性：工厂方法模式引入了额外的抽象层次，使得代码结构变得更加复杂，需要编写更多的代码。
在增加新产品类型时，可能需要添加大量的新类和代码，导致系统可维护性降低。

总之，工厂方法模式是一种常用且有效的设计模式，可以提高程序的灵活性和可扩展性，但也需要在实际开发中根据具体情况进行权衡和应用。

使用场景举例：

可以用于对象的创建过程比较复杂，需要创建不同类型的对象时，将创建过程封装起来，提高代码的可维护性和灵活性。
可以用于不确定对象的类别、个数或者依赖关系的情况。
可以用于需要重复使用的对象（例如资源池等）的情况。
可以用于测试驱动开发的框架下。

一、工厂方法模式简单实现

如下示例，先定义产品接口 IProduct 和工厂接口 IFactory，再分别进行实现：

#region 定义接口
interface IProduct
{
    void Use();
}
// 定义工厂接口  
interface IFactory
{
    IProduct CreateProduct();
}
#endregion

#region 产品 A
// 实现产品接口的具体产品类  
class ConcreteProductA : IProduct
{
    public void Use()
    {
        Console.WriteLine("使用具体产品 A");
    }
}
// 实现工厂接口的具体工厂类  
class ConcreteFactoryA : IFactory
{
    public IProduct CreateProduct()
    {
        return new ConcreteProductA();
    }
}
#endregion

#region 产品 B
class ConcreteProductB : IProduct
{
    public void Use()
    {
        Console.WriteLine("使用具体产品 B");
    }
}
class ConcreteFactoryB : IFactory
{
    public IProduct CreateProduct()
    {
        return new ConcreteProductB();
    }
}
#endregion

下边进行实际的调用：

// 工厂方法模式
IFactory factoryA = new ConcreteFactoryA();
IProduct productA1 = factoryA.CreateProduct(); // 将对象的创建进行了封装
IProduct productA2 = factoryA.CreateProduct();
productA1.Use();
productA2.Use();
IFactory factoryB = new ConcreteFactoryB();
IProduct productB = factoryB.CreateProduct();
productB.Use();
// 不用工厂方法模式的写法
ConcreteProductA concreteProductA1 = new ConcreteProductA(); // 直接创建对象
concreteProductA1.Use();
ConcreteProductA concreteProductA2 = new ConcreteProductA();
concreteProductA2.Use();
ConcreteProductB concreteProductB = new ConcreteProductB();
concreteProductB.Use();

由以上代码可见：通过工厂方法模式的实现，将对象的创建进行了封装，代码逻辑更清晰易读，当需要新增、删除或修改某个产品时，只需修改具体工厂类即可，既方便又安全。

二、工厂方法模式的结构

根据上一章节的示例代码，简单画一个 UML 图，如下：

IProduct：定义工厂方法所创建的对象的接口。描述了一个产品的共同特征。

ConcreteProductA：实现 IProduct 接口，是具体产品的实例。

IFactory：声明工厂接口（也可以是抽象类），该接口中声明了一个工厂方法，用于创建产品。

ConcreteFactoryA：实现工厂接口的具体工厂类，通过实现方法 CreateProduct() 方法，创建具体的产品实例。每一个工厂对应一种产品。

客户端通过调用抽象工厂的工厂方法来创建产品对象，而不需要直接实例化具体产品。这样可以实现解耦，使得客户端代码与具体产品的实现分离，并且可以方便地扩展和添加新的产品变体。

三、在 .NET 框架中的一个实际应用

依赖注入（Dependency Injection，简称DI）实际上是工厂方法模式的一种变体，通常与工厂方法模式一起使用。依赖注入可以帮助我们实现对象的创建和管理，使得对象的创建过程更加灵活和可控。

下面一个实例，在创建了语言接口 ILanguage、语言工厂抽象类 LanguageFactory 并实现后，又创建了一个 ClientCode 类来封装客户端代码的实现，并使用构造函数将具体工厂类作为参数传递给该类。客户端代码可以通过调用 Speak() 方法来创建相应的产品对象，并执行相关方法。

// 抽象语言类
public interface ILanguage {
   void Speak();
}
// 英语类
public class English : ILanguage {
   public void Speak() {
       Console.WriteLine("Speak English.");
   }
}
// 中文类
public class Chinese : ILanguage {
   public void Speak() {
       Console.WriteLine("说中文。");
   }
}
// 工厂方法抽象类
public abstract class LanguageFactory {
   public abstract ILanguage CreateLanguage();
}
// 英语工厂
public class EnglishFactory : LanguageFactory {
   public override ILanguage CreateLanguage() {
       return new English();
   }
}
// 中文工厂
public class ChineseFactory : LanguageFactory {
   public override ILanguage CreateLanguage() {
       return new Chinese();
   }
}
// 客户端代码
public class ClientCode {
   private readonly LanguageFactory _factory;
   public ClientCode(LanguageFactory factory) { // 依赖注入 LanguageFactory
       _factory = factory;
   }
   public void Speak() {
       ILanguage language = _factory.CreateLanguage();
       language.Speak();
   }
}
// 使用示例
static void Main(string[] args) 
{   
   ClientCode code1 = new ClientCode(new EnglishFactory()); // 依赖注入：英语工厂
   code1.Speak(); // Speak English.
   
   ClientCode code2 = new ClientCode(new ChineseFactory()); // 依赖注入：中文工厂
   code2.Speak(); // 说中文。
}

当然，如果后续有扩展需求，比如再新建一个俄语实现：

（只需增加两个独立的实现：语言接口 ILanguage、语言工厂抽象类 LanguageFactory）

// 俄语类
public class Russian : ILanguage
{
    public void Speak()
    {
        Console.WriteLine("По-русски.");
    }
}
// 俄语工厂
public class RussianFactory : LanguageFactory
{
    public override ILanguage CreateLanguage()
    {
        return new Russian();
    }
}

然后直接使用，注入俄语工厂new RussianFactory()即可输出俄语，而对原有的实现没有任何影响。

ClientCode code3 = new ClientCode(new RussianFactory()); // 依赖注入：俄语工厂
code3.Speak();

实际输出，见第三行：

实际上在 .net 框架中，还有许多类似的用法，例如：

在 ASP.NET MVC 中，可以使用 HtmlHelper 的扩展方法创建各种类型的 HTML 表单控件，如文本框、下拉框等，这些方法内部调用控件工厂来创建相应的控件对象。
在 log4net 框架中，可以使用 LogManager 类的 GetLogger() 方法来获取或创建指定名称的记录器对象。
使用 ADO.NET 进行数据库操作时，可以使用 DbProviderFactory 类作为通用的提供者工厂类，用来创建特定数据库提供程序的对象。通过调用 DbProviderFactories.GetFactory() 方法就可以获取该工厂类，并利用其创建具体的数据库连接、命令、数据适配器等对象。

方式都是类似的，详情自行查看源码吧。

四、相关模式

AbstractFactory 模式经常用工厂方法来实现。

工厂方法通常在 TemplateMethod 中被调用。

Prototype 原型模式不需要创建 Creator 的子类，但是，它们通常要求一个针对 Product 类的 Initialize 操作。Creator 使用 Initialize 来初始化对象，而 FactoryMethod 模式不需要这样的操作。

posted @ 2023-05-29 15:00 橙子家阅读(228) 评论(0) 编辑收藏举报

刷新页面返回顶部

橙子家