当前位置：首页 > article >正文

深入解析工厂模式及其C#实现

article 2025/3/17 19:54:06

工厂模式（Factory Pattern）是设计模式中的一种创建型模式，它通过工厂方法来创建对象，而不是让客户端代码直接实例化对象。这样可以避免客户端与具体类的紧密耦合，从而提高代码的灵活性、可维护性和扩展性。工厂模式能够将对象的创建过程封装起来，使得系统可以在不修改客户端代码的情况下增加新的产品。

工厂模式主要分为以下几种类型：

简单工厂模式（Simple Factory Pattern）
工厂方法模式（Factory Method Pattern）
抽象工厂模式（Abstract Factory Pattern）

本文将深入探讨这些模式，并通过C#示例代码进行说明。

1. 简单工厂模式（Simple Factory Pattern）

简单工厂模式是一种最简单的工厂模式，它通过一个工厂类来根据传入的条件创建不同的产品对象。客户端不需要直接创建对象，而是通过工厂类获取所需的产品对象。

优点：

客户端代码不需要关心产品的具体实现，只需要通过工厂类来创建对象。
集中管理产品的创建过程，便于修改和维护。

缺点：

工厂类随着产品种类的增多会变得庞大，不易维护。
每当新增产品时，需要修改工厂类，违反了开闭原则。

C# 示例代码：

// 产品接口
public interface IProduct
{
    void Use();
}

// 具体产品A
public class ProductA : IProduct
{
    public void Use()
    {
        Console.WriteLine("使用产品A");
    }
}

// 具体产品B
public class ProductB : IProduct
{
    public void Use()
    {
        Console.WriteLine("使用产品B");
    }
}

// 简单工厂类
public class ProductFactory
{
    public static IProduct CreateProduct(string type)
    {
        if (type == "A")
        {
            return new ProductA();
        }
        else if (type == "B")
        {
            return new ProductB();
        }
        else
        {
            throw new ArgumentException("未知的产品类型");
        }
    }
}

// 客户端代码
public class Client
{
    public static void Main(string[] args)
    {
        IProduct productA = ProductFactory.CreateProduct("A");
        productA.Use();

        IProduct productB = ProductFactory.CreateProduct("B");
        productB.Use();
    }
}

在这个示例中，ProductFactory 类根据传入的参数来创建不同的 IProduct 实例。客户端通过工厂类来获取产品对象，而不需要关心具体的实现类。

2. 工厂方法模式（Factory Method Pattern）

工厂方法模式是对简单工厂模式的改进，它通过定义一个工厂接口，让子类决定创建哪个具体产品。每个具体工厂负责创建一个特定的产品对象，避免了简单工厂中工厂类做大量条件判断的情况。

优点：

每个工厂类只负责创建一个产品，符合单一职责原则。
可以通过新增工厂类来扩展新的产品，符合开闭原则。

缺点：

每增加一种产品类型，都需要增加一个工厂类，导致类的数量增多，系统复杂度上升。

C# 示例代码：

// 产品接口
public interface IProduct
{
    void Use();
}

// 具体产品A
public class ProductA : IProduct
{
    public void Use()
    {
        Console.WriteLine("使用产品A");
    }
}

// 具体产品B
public class ProductB : IProduct
{
    public void Use()
    {
        Console.WriteLine("使用产品B");
    }
}

// 抽象工厂接口
public interface IFactory
{
    IProduct CreateProduct();
}

// 具体工厂A
public class FactoryA : IFactory
{
    public IProduct CreateProduct()
    {
        return new ProductA();
    }
}

// 具体工厂B
public class FactoryB : IFactory
{
    public IProduct CreateProduct()
    {
        return new ProductB();
    }
}

// 客户端代码
public class Client
{
    public static void Main(string[] args)
    {
        IFactory factoryA = new FactoryA();
        IProduct productA = factoryA.CreateProduct();
        productA.Use();

        IFactory factoryB = new FactoryB();
        IProduct productB = factoryB.CreateProduct();
        productB.Use();
    }
}

在上面的示例中，FactoryA 和 FactoryB 各自负责创建不同的产品，客户端通过不同的工厂类来获取所需的产品实例。

3. 抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式是工厂方法模式的扩展，它通过提供一个抽象工厂接口来创建一系列相关的产品，而不需要指定它们的具体类。每个工厂可以创建多个产品，通常这些产品是相关或有依赖关系的。

优点：

客户端通过抽象工厂创建一系列相关产品，而不需要了解产品的具体实现。
可以确保产品之间的兼容性，并且便于扩展新的产品系列。

缺点：

每增加一个产品系列，就需要增加一个工厂类，导致类的数量增多，系统复杂度上升。

C# 示例代码：

// 抽象产品A
public interface IProductA
{
    void Use();
}

// 具体产品A1
public class ProductA1 : IProductA
{
    public void Use()
    {
        Console.WriteLine("使用产品A1");
    }
}

// 具体产品A2
public class ProductA2 : IProductA
{
    public void Use()
    {
        Console.WriteLine("使用产品A2");
    }
}

// 抽象产品B
public interface IProductB
{
    void Use();
}

// 具体产品B1
public class ProductB1 : IProductB
{
    public void Use()
    {
        Console.WriteLine("使用产品B1");
    }
}

// 具体产品B2
public class ProductB2 : IProductB
{
    public void Use()
    {
        Console.WriteLine("使用产品B2");
    }
}

// 抽象工厂接口
public interface IAbstractFactory
{
    IProductA CreateProductA();
    IProductB CreateProductB();
}

// 具体工厂1
public class ConcreteFactory1 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ProductA1();
    }

    public IProductB CreateProductB()
    {
        return new ProductB1();
    }
}

// 具体工厂2
public class ConcreteFactory2 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ProductA2();
    }

    public IProductB CreateProductB()
    {
        return new ProductB2();
    }
}

// 客户端代码
public class Client
{
    public static void Main(string[] args)
    {
        IAbstractFactory factory1 = new ConcreteFactory1();
        IProductA productA1 = factory1.CreateProductA();
        IProductB productB1 = factory1.CreateProductB();
        productA1.Use();
        productB1.Use();

        IAbstractFactory factory2 = new ConcreteFactory2();
        IProductA productA2 = factory2.CreateProductA();
        IProductB productB2 = factory2.CreateProductB();
        productA2.Use();
        productB2.Use();
    }
}

在上述示例中，ConcreteFactory1 和 ConcreteFactory2 分别创建一系列相关的产品对象。客户端可以选择不同的工厂来获取产品系列，确保产品的兼容性。