欢迎来到 C# 设计模式 的第四章！在这一章中，我们将深入探讨 工厂模式（Factory Pattern）。工厂模式是一种创建型设计模式，它提供了一种创建对象的接口，但让子类决定实例化哪一个类。想象一下，如果你是一家汽车制造厂的老板，你不想亲自去组装每一辆车，而是希望有一个“工厂”来帮你生产不同类型的汽车。工厂模式正是这样一种模式，它让你可以轻松地创建不同类型的对象，而不需要关心具体的实现细节。
第一节：什么是工厂模式？
1. 概念：
工厂模式的核心思想是：提供一个创建对象的接口，但让子类决定实例化哪一个类。换句话说，工厂模式允许你通过一个统一的接口来创建对象，而不需要知道具体的实现类。这样可以将对象的创建逻辑与使用逻辑分离，使代码更加灵活和可扩展。
幽默小贴士：
工厂模式就像是编程世界里的“神奇工厂”，你可以通过一个按钮来生产不同的产品，而不需要亲自去组装每一个零件。就像《查理和巧克力工厂》中的威利·旺卡一样，他只需要按下一个按钮，就能生产出各种美味的巧克力！ 🍫
2. 为什么需要工厂模式？
- 隐藏复杂的创建逻辑：有时候，创建一个对象的过程非常复杂，涉及到多个步骤或条件判断。通过工厂模式，你可以将这些复杂的创建逻辑封装在一个工厂类中，从而使客户端代码更加简洁和易读。
- 支持多态性：工厂模式允许你在运行时动态地选择要创建的对象类型，而不需要修改现有的代码。你可以根据不同的条件创建不同类型的对象，而不需要硬编码具体的类名。
- 提高代码的可扩展性：如果你需要添加新的对象类型，只需创建一个新的工厂类或扩展现有的工厂类，而不需要修改客户端代码。这样可以大大提高代码的可扩展性和维护性。
第二节：真实案例
1. 汽车制造系统：
想象一下，你在开发一个汽车制造系统，用户可以选择不同的品牌和型号来定制他们的汽车。为了实现这个功能，你可以使用工厂模式来创建不同类型的汽车对象，而不需要在客户端代码中硬编码具体的汽车类名。
幽默小贴士：
在汽车制造系统中，工厂模式就像是“汽车生产线”，你可以通过一个按钮来生产不同品牌的汽车，而不需要亲自去组装每一个零件。就像《疯狂原始人》中的洞穴人一样，他们也是从最基础的工具开始，逐渐发明了轮子、马车，最后造出了汽车！ 🚗
2. 披萨订单系统：
假设你在开发一个披萨订单系统，用户可以选择不同的口味和配料来定制他们的披萨。为了实现这个功能，你可以使用工厂模式来创建不同类型的披萨对象，而不需要在客户端代码中硬编码具体的披萨类名。
幽默小贴士：
在披萨订单系统中，工厂模式就像是“披萨制作工厂”，你可以通过一个按钮来生产不同口味的披萨，而不需要亲自去准备每一种配料。就像《料理鼠王》中的小老鼠雷米一样，它也是通过一步步的努力，最终成为了一名顶级厨师！ 🍕
第三节：实施方法
在 C# 中实现工厂模式通常涉及以下几个类：
Product类：这是你要创建的对象。它可以是一个抽象类或接口，定义了所有具体产品的公共行为。ConcreteProduct类：这是实现了Product接口的具体类。每个具体产品类都代表一种特定的产品。Creator类：这是一个工厂类，负责创建Product对象。它提供了一个抽象的CreateProduct()方法，具体的实现由子类来完成。ConcreteCreator类：这是实现了Creator类的具体工厂类。它负责创建特定类型的Product对象。Client类（客户端代码）：这是使用工厂模式的客户端代码。它通过调用工厂类的CreateProduct()方法来获取所需的Product对象，而不需要知道具体的实现类。
第四节：类之间的关系
1. 所需的类
在实现工厂模式时，通常需要以下几个类：
-
IProduct接口：- 这是一个定义了所有具体产品公共行为的接口。所有的具体产品类都必须实现这个接口。
-
ConcreteProductA和ConcreteProductB类：- 这些是实现了
IProduct接口的具体产品类。每个具体产品类都代表一种特定的产品。
- 这些是实现了
-
ICreator接口：- 这是一个定义了创建产品方法的接口。所有的具体工厂类都必须实现这个接口。
-
ConcreteCreatorA和ConcreteCreatorB类：- 这些是实现了
ICreator接口的具体工厂类。每个具体工厂类负责创建特定类型的Product对象。
- 这些是实现了
-
Client类（客户端代码）：- 这是使用工厂模式的客户端代码。它通过调用工厂类的
CreateProduct()方法来获取所需的Product对象，而不需要知道具体的实现类。
- 这是使用工厂模式的客户端代码。它通过调用工厂类的
-
Pizza类（可选）：- 如果你需要创建不同类型的披萨，你可以为披萨定义一个单独的类。这样可以确保在创建过程中，对象的属性可以被逐步设置。
2. 类的详细说明
1. IProduct 接口
// 定义产品接口
public interface IProduct
{
void Show();
}
- 作用：
IProduct接口定义了所有具体产品类的公共行为。在这个例子中，我们定义了一个Show()方法，用于显示产品的信息。 - 优点：通过接口定义公共行为，可以支持多态性，允许客户端代码动态地选择不同的产品类型。
2. ConcreteProductA 和 ConcreteProductB 类
// 实现具体产品 A
public class ConcreteProductA : IProduct
{
public void Show()
{
Console.WriteLine("我是产品 A");
}
}
// 实现具体产品 B
public class ConcreteProductB : IProduct
{
public void Show()
{
Console.WriteLine("我是产品 B");
}
}
- 作用：
ConcreteProductA和ConcreteProductB是实现了IProduct接口的具体产品类。每个具体产品类都代表一种特定的产品，并提供了具体的实现逻辑。 - 优点：通过实现具体的
Show()方法，每个产品类都可以展示自己的独特信息，而不需要修改其他类的代码。
3. ICreator 接口
// 定义工厂接口
public interface ICreator
{
IProduct CreateProduct();
}
- 作用：
ICreator接口定义了创建产品的方法。所有的具体工厂类都必须实现这个接口，并提供具体的创建逻辑。 - 优点：通过接口定义创建方法，可以支持多态性，允许客户端代码动态地选择不同的工厂类。
4. ConcreteCreatorA 和 ConcreteCreatorB 类
// 实现具体工厂 A
public class ConcreteCreatorA : ICreator
{
public IProduct CreateProduct()
{
return new ConcreteProductA();
}
}
// 实现具体工厂 B
public class ConcreteCreatorB : ICreator
{
public IProduct CreateProduct()
{
return new ConcreteProductB();
}
}
- 作用：
ConcreteCreatorA和ConcreteCreatorB是实现了ICreator接口的具体工厂类。每个具体工厂类负责创建特定类型的Product对象，并提供了具体的创建逻辑。 - 优点：通过实现具体的
CreateProduct()方法，每个工厂类都可以创建不同类型的产品，而不需要修改其他类的代码。
5. Client 类（客户端代码）
class Program
{
static void Main(string[] args)
{
// 创建具体工厂 A
ICreator creatorA = new ConcreteCreatorA();
// 使用工厂 A 创建产品
IProduct productA = creatorA.CreateProduct();
productA.Show(); // 输出: 我是产品 A
// 创建具体工厂 B
ICreator creatorB = new ConcreteCreatorB();
// 使用工厂 B 创建产品
IProduct productB = creatorB.CreateProduct();
productB.Show(); // 输出: 我是产品 B
}
}
- 作用：
Client类是使用工厂模式的客户端代码。它通过调用工厂类的CreateProduct()方法来获取所需的Product对象，而不需要知道具体的实现类。 - 优点：通过使用工厂模式，客户端代码可以轻松地创建不同类型的产品，而不需要直接调用具体的构造函数。
6. Pizza 类（可选）
// 定义披萨类
public class Pizza
{
public string Dough { get; set; }
public string Sauce { get; set; }
public List<string> Toppings { get; set; } = new List<string>();
public void Show()
{
Console.WriteLine("披萨详情:");
Console.WriteLine($"- 面饼: {Dough}");
Console.WriteLine($"- 酱料: {Sauce}");
Console.WriteLine("配料:");
foreach (var topping in Toppings)
{
Console.WriteLine($"- {topping}");
}
}
}
- 作用：
Pizza类是一个具体的对象类，用于表示披萨。它包含了一些属性，如Dough（面饼）、Sauce（酱料）和Toppings（配料）。你可以通过工厂模式逐步设置这些属性，最终构建出一份完整的披萨。 - 优点：通过逐步设置属性，
Pizza类可以灵活地构建出不同的披萨，而不需要一次性传递所有的参数。
3. 类之间的关系
现在我们已经了解了所有需要的类，接下来让我们通过类图来展示这些类之间的关系。
类图示例：
+-------------------------------+
| IProduct |
+-------------------------------+
| + Show() |
+-------------------------------+
^
|
+-------------------------------+ +----------------------------+
| ConcreteProductA | | ConcreteProductB |
+-------------------------------+ +----------------------------+
| + Show() | | + Show() |
+-------------------------------+ +----------------------------+
+-------------------------------+
| ICreator |
+-------------------------------+
| + CreateProduct(): IProduct |
+-------------------------------+
^
|
+-------------------------------+ +----------------------------+
| ConcreteCreatorA | | ConcreteCreatorB |
+-------------------------------+ +----------------------------+
| + CreateProduct(): IProduct | + | CreateProduct(): IProduct |
+-------------------------------+ +----------------------------+
+-------------------------------+
| Client |
+-------------------------------+
| + Main(): void |
+-------------------------------+
+-------------------------------+
| Pizza |
+-------------------------------+
| - Dough: string |
| - Sauce: string |
| - Toppings: List<string> |
| + Show() |
+-------------------------------+
幽默小贴士：
类图就像是编程世界的“生产线图纸”，它展示了各个类之间的关系。
IProduct接口是“产品标准”，定义了所有产品必须遵守的规则。ConcreteProductA和ConcreteProductB是“具体产品”，它们按照标准生产不同的产品。ICreator接口是“工厂标准”，定义了如何创建产品。ConcreteCreatorA和ConcreteCreatorB是“具体工厂”，它们负责按照标准生产不同类型的产品。Client类则是“客户”，它只需要告诉工厂想要什么样的产品，而不需要亲自参与生产。 🏭
第五节：程序执行与输出
让我们通过几个实际的代码示例来演示工厂模式的使用。
示例 1：基本工厂模式
using System;
class Program
{
static void Main(string[] args)
{
// 创建具体工厂 A
ICreator creatorA = new ConcreteCreatorA();
// 使用工厂 A 创建产品
IProduct productA = creatorA.CreateProduct();
productA.Show(); // 输出: 我是产品 A
// 创建具体工厂 B
ICreator creatorB = new ConcreteCreatorB();
// 使用工厂 B 创建产品
IProduct productB = creatorB.CreateProduct();
productB.Show(); // 输出: 我是产品 B
}
}
输出结果：
我是产品 A
我是产品 B
代码分析：
- 我们首先创建了一个
ConcreteCreatorA对象，它是具体工厂类，负责创建ConcreteProductA对象。 - 然后，我们调用
CreateProduct()方法来创建ConcreteProductA对象，并通过Show()方法显示产品的信息。 - 接下来，我们创建了一个
ConcreteCreatorB对象，它是另一个具体工厂类，负责创建ConcreteProductB对象。 - 最后，我们再次调用
CreateProduct()方法来创建ConcreteProductB对象，并通过Show()方法显示产品的信息。
幽默小贴士：
基本工厂模式就像是“魔法工厂”，你可以通过一个按钮来生产不同的产品，而不需要亲自去组装每一个零件。就像《哈利·波特》中的魔法商店一样，你只需要说出你想要的东西，魔法就会为你创造出完美的产品！ 🧙♂️
示例 2：披萨工厂模式
using System;
// 定义披萨建造者接口
public interface IPizzaBuilder
{
void BuildDough();
void BuildSauce();
void BuildToppings();
Pizza GetPizza();
}
// 实现具体披萨建造者类
public class HawaiianPizzaBuilder : IPizzaBuilder
{
private Pizza pizza = new Pizza();
public void BuildDough()
{
pizza.Dough = "厚底";
}
public void BuildSauce()
{
pizza.Sauce = "番茄酱";
}
public void BuildToppings()
{
pizza.Toppings.Add("火腿");
pizza.Toppings.Add("菠萝");
}
public Pizza GetPizza()
{
return pizza;
}
}
// 定义披萨工厂接口
public interface IPizzaFactory
{
IPizzaBuilder CreatePizzaBuilder();
}
// 实现具体披萨工厂类
public class HawaiianPizzaFactory : IPizzaFactory
{
public IPizzaBuilder CreatePizzaBuilder()
{
return new HawaiianPizzaBuilder();
}
}
class Program
{
static void Main(string[] args)
{
// 创建具体披萨工厂
IPizzaFactory factory = new HawaiianPizzaFactory();
// 获取披萨建造者
IPizzaBuilder builder = factory.CreatePizzaBuilder();
// 构建披萨
builder.BuildDough();
builder.BuildSauce();
builder.BuildToppings();
// 获取构建好的披萨
Pizza pizza = builder.GetPizza();
// 显示披萨信息
pizza.Show();
}
}
输出结果：
披萨详情:
- 面饼: 厚底
- 酱料: 番茄酱
配料:
- 火腿
- 菠萝
代码分析：
- 我们定义了一个
IPizzaBuilder接口，它定义了构建披萨的步骤，包括BuildDough()（构建面饼）、BuildSauce()（构建酱料）和BuildToppings()（构建配料）。 - 然后，我们实现了一个
HawaiianPizzaBuilder类，它是具体的建造者类，负责逐步构建夏威夷披萨。 - 接下来，我们定义了一个
IPizzaFactory接口，它定义了创建披萨建造者的工厂方法。 - 然后，我们实现了一个
HawaiianPizzaFactory类，它是具体的工厂类，负责创建HawaiianPizzaBuilder对象。 - 最后，我们在
Main()方法中创建了一个HawaiianPizzaFactory对象，并通过CreatePizzaBuilder()方法获取HawaiianPizzaBuilder对象。然后，我们调用建造者的各个方法来构建披萨，并通过GetPizza()方法获取构建好的Pizza对象。 - 最终，我们调用
Show()方法来显示披萨的详细信息。
幽默小贴士：
披萨工厂模式就像是“披萨制作工厂”，你可以通过一个按钮来生产不同口味的披萨，而不需要亲自去准备每一种配料。就像《料理鼠王》中的小老鼠雷米一样，它也是通过一步步的努力，最终成为了一名顶级厨师！ 🍕
第六节：注意事项
虽然工厂模式非常有用，但在使用时也有一些需要注意的地方：
-
避免过度使用：
- 工厂模式适用于那些创建过程比较复杂，或者需要频繁创建相似对象的场景。如果你的对象创建过程比较简单，或者不需要分步骤构建，那么工厂模式可能并不是最佳选择。
-
保持工厂类的独立性：
- 工厂类应该尽量保持独立，避免与其他类产生过多的依赖关系。这样可以确保工厂类的灵活性和可复用性。
-
支持多态性：
- 工厂模式允许你在运行时动态地选择要创建的对象类型，而不需要修改现有的代码。你可以根据不同的条件创建不同类型的对象，而不需要硬编码具体的类名。
-
避免重复代码：
- 在实现工厂模式时，尽量避免在多个工厂类中重复相同的代码。可以通过提取公共逻辑或将重复的代码封装在基类中来减少冗余。
幽默小贴士：
工厂模式虽然强大，但也需要谨慎使用。毕竟，即使是“魔法工厂”也需要懂得适可而止，不能随便生产一切！ 🧙♂️
第七节：本章总结
在这章中，我们学习了 工厂模式 的基本概念、应用场景、实现方法以及注意事项。工厂模式提供了一种创建对象的接口，但让子类决定实例化哪一个类。它在隐藏复杂的创建逻辑、支持多态性和提高代码的可扩展性方面有着重要的作用。
我们通过两个实际的代码示例展示了如何在 C# 中实现工厂模式，包括基本工厂模式和披萨工厂模式。最后，我们还讨论了一些使用工厂模式时需要注意的地方，帮助你在实际开发中做出明智的选择。
幽默小贴士：
工厂模式就像是编程世界里的“魔法工厂”，你可以通过一个按钮来生产不同的产品，而不需要亲自去组装每一个零件。就像《哈利·波特》中的魔法商店一样，你只需要说出你想要的东西，魔法就会为你创造出完美的产品！ 🧙♂️
结束语
亲爱的学员们，恭喜你完成了 C# 设计模式 的第四章！通过学习工厂模式，你已经掌握了如何通过一个统一的接口来创建不同类型的对象，而不需要关心具体的实现细节。接下来，我们将继续探索更多的设计模式，帮助你编写更加优雅、灵活和可维护的代码。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
