C# 简单工厂模式：构建灵活与可扩展的面向对象程序

最新推荐文章于 2025-08-22 21:35:45 发布

原创最新推荐文章于 2025-08-22 21:35:45 发布 · 527 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#c# #简单工厂模式 #java

C#设计模式专栏收录该内容

8 篇文章

订阅专栏

在面向对象编程（OOP）的世界中，简单工厂模式（Simple Factory Pattern）是一种非常常见且实用的设计模式。虽然它并不属于GoF（Gang of Four）定义的23种经典设计模式之一，但它是理解更复杂模式（如工厂方法模式）的重要铺垫。本文将深入解析简单工厂模式的工作原理、实现方式及其在实际项目中的作用。

一、什么是简单工厂模式？

简单工厂模式是一种创建型设计模式，它的核心思想是：根据输入的参数或条件，返回一个特定类的实例。这些类通常继承自同一个基类或接口，具有相同的方法签名，但方法的具体实现可能不同。

简单工厂模式通过一个“工厂”类来封装对象的创建逻辑，使得客户端无需关心具体的对象创建过程，只需要调用工厂提供的接口即可获取所需对象。

二、简单工厂模式的结构解析

我们通过一个类图来理解简单工厂模式的核心组成部分：

基类（Base Class）：定义了所有子类共有的接口。
具体类（Concrete Classes）：继承自基类，实现具体的业务逻辑。
工厂类（Factory Class）：根据传入的参数决定返回哪一个具体类的实例。

以一个名字解析器为例，假设我们有如下类结构：

Namer：基类，提供基础属性和方法。
FirstFirst：表示“firstname lastname”格式。
LastFirst：表示“lastname, firstname”格式。
NamerFactory：简单工厂类，根据输入判断使用哪个具体类解析名字。

三、一个C#示例：名字解析器

1. 定义基类 `Namer`

public class Namer
{
    protected string frName, lName;
 
    public string GetFrname()
    {
        return frName;
    }
 
    public string GetLname()
    {
        return lName;
    }
}

该类定义了两个受保护的字段 frName 和 lName，并提供公共方法来获取它们。

2. 实现具体类 `FirstFirst` 和 `LastFirst`

FirstFirst 类处理“firstname lastname”格式：

public class FirstFirst : Namer
{
    public FirstFirst(string name)
    {
        int i = name.Trim().IndexOf(" ");
        if (i > 0)
        {
            frName = name.Substring(0, i).Trim();
            lName = name.Substring(i + 1).Trim();
        }
        else
        {
            lName = name;
            frName = "";
        }
    }
}

LastFirst 类处理“lastname, firstname”格式：

public class LastFirst : Namer
{
    public LastFirst(string name)
    {
        int i = name.IndexOf(",");
        if (i > 0)
        {
            lName = name.Substring(0, i);
            frName = name.Substring(i + 1).Trim();
        }
        else
        {
            lName = name;
            frName = "";
        }
    }
}

这两个派生类都通过构造函数对传入的字符串进行解析，并将结果保存在基类字段中。

3. 构建简单工厂类 `NamerFactory`

public class NamerFactory
{
    public Namer CreateNamer(string name)
    {
        if (name.Contains(","))
            return new LastFirst(name);
        else
            return new FirstFirst(name);
    }
}

工厂类根据输入是否包含逗号来决定返回哪一个具体类的实例。

4. 客户端调用示例

class Program
{
    static void Main(string[] args)
    {
        NamerFactory factory = new NamerFactory();
        Namer namer1 = factory.CreateNamer("John Doe");
        Console.WriteLine($"First Name: {namer1.GetFrname()}, Last Name: {namer1.GetLname()}");
 
        Namer namer2 = factory.CreateNamer("Doe, John");
        Console.WriteLine($"First Name: {namer2.GetFrname()}, Last Name: {namer2.GetLname()}");
    }
}

输出结果：

First Name: John, Last Name: Doe
First Name: John, Last Name: Doe

四、简单工厂模式的优点与局限

✅ 优点：

封装对象创建逻辑：客户端不需要关心具体类的创建过程，只需调用工厂接口。
提高可扩展性：新增一个具体类只需修改工厂逻辑，而不影响已有代码。
统一接口：所有返回对象都继承自同一个基类或接口，便于统一调用。

⚠️ 局限：

违反开放封闭原则：每次新增一个具体类，都需要修改工厂类的判断逻辑。
不适合大规模扩展：当具体类数量激增时，判断逻辑会变得复杂且难以维护。
不属于GoF模式：不被广泛认为是“标准”的设计模式，需谨慎使用。

五、简单工厂模式的适用场景

产品种类有限：适用于需要创建的对象类型不多的场景。
简化客户端调用：当客户端不希望处理复杂的对象创建逻辑时。
作为工厂方法模式的前奏：为后续引入更高级的工厂方法模式打下基础。

六、从简单工厂到工厂方法模式的演进

简单工厂模式虽然实用，但其“集中决策”的特性限制了它的扩展性。在工厂方法模式中，每个具体类都有自己的工厂类，客户端通过调用不同的工厂来获取实例，从而实现对扩展开放、对修改关闭的设计原则。

例如：

public interface INamerFactory
{
    Namer CreateNamer(string name);
}
 
public class FirstFirstFactory : INamerFactory 
{
    public Namer CreateNamer(string name)
    {
        return new FirstFirst(name);
    }
}