C#中的工厂模式

简单工厂模式适合产品种类较少且变化不大的情况。工厂方法模式适用于需要解耦对象创建和客户端代码的情况，增加了灵活性和可扩展性。抽象工厂模式适合用于创建一系列相关的产品，尤其是在产品族的情况下，能够确保产品之间的一致性。

就是有点傻

1200人浏览 · 2024-11-30 11:10:19

就是有点傻 · 2024-11-30 11:10:19 发布

在C#中，工厂模式（Factory Pattern） 是一种常见的设计模式，它属于创建型模式，主要用于定义一个用于创建对象的接口，让子类决定实例化哪一个类。通过使用工厂模式，客户端代码不需要直接实例化具体的类对象，而是通过工厂类来创建对象，这样可以解耦客户端与具体产品的关系，增加系统的灵活性和可扩展性。

工厂模式的分类

工厂模式有几种不同的变种，其中常见的包括：

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

下面分别介绍它们的实现方式及应用场景。

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

简单工厂模式通过一个工厂类来决定实例化哪一个产品类。客户端通过调用工厂的一个方法来获取需要的产品对象。它的关键在于工厂类中包含了逻辑，用于创建不同类型的对象。

代码示例：

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

// 具体产品类
public class ProductA : IProduct
{
    public void Show()
    {
        Console.WriteLine("ProductA");
    }
}

public class ProductB : IProduct
{
    public void Show()
    {
        Console.WriteLine("ProductB");
    }
}

// 简单工厂类
public class ProductFactory
{
    public static IProduct CreateProduct(string type)
    {
        switch (type)
        {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            default:
                throw new ArgumentException("Invalid product type.");
        }
    }
}

// 客户端代码
class Program
{
    static void Main()
    {
        IProduct productA = ProductFactory.CreateProduct("A");
        productA.Show();

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

解析：

产品接口（IProduct）：定义了所有产品的公共接口。
具体产品类（ProductA, ProductB）：实现了产品接口的具体类。
简单工厂类（ProductFactory）：通过CreateProduct方法根据不同的输入参数创建不同类型的产品对象。

优缺点：

优点：简单易懂，适用于产品种类较少且变化不大的情况。
缺点：如果产品种类增多，工厂类的CreateProduct方法会越来越复杂，不利于扩展和维护。

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

工厂方法模式与简单工厂模式不同，它将对象的创建交给子类去实现，而不是由一个工厂类负责。这样每个工厂类只负责创建一种类型的对象，符合单一职责原则。工厂方法模式通过抽象工厂来声明创建对象的接口，由具体的子工厂去实现该接口。

代码示例：

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

// 具体产品类
public class ProductA : IProduct
{
    public void Show()
    {
        Console.WriteLine("ProductA");
    }
}

public class ProductB : IProduct
{
    public void Show()
    {
        Console.WriteLine("ProductB");
    }
}

// 工厂方法接口
public abstract class ProductFactory
{
    public abstract IProduct CreateProduct();
}

// 具体工厂类
public class ProductAFactory : ProductFactory
{
    public override IProduct CreateProduct()
    {
        return new ProductA();
    }
}

public class ProductBFactory : ProductFactory
{
    public override IProduct CreateProduct()
    {
        return new ProductB();
    }
}

// 客户端代码
class Program
{
    static void Main()
    {
        ProductFactory factoryA = new ProductAFactory();
        IProduct productA = factoryA.CreateProduct();
        productA.Show();

        ProductFactory factoryB = new ProductBFactory();
        IProduct productB = factoryB.CreateProduct();
        productB.Show();
    }
}

解析：

产品接口（IProduct）：定义产品的公共行为。
具体产品类（ProductA, ProductB）：实现产品接口的具体类。
工厂方法接口（ProductFactory）：声明一个创建产品的抽象方法CreateProduct。
具体工厂类（ProductAFactory, ProductBFactory）：实现了CreateProduct方法，创建具体的产品实例。

优缺点：

优点：符合开闭原则，新增产品时只需要添加新的工厂类，而不需要修改现有代码。
缺点：需要创建很多具体的工厂类，增加了系统的复杂性。

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

抽象工厂模式提供一个接口，用于创建一系列相关或依赖的对象，而不需要指定具体的类。它通常用于需要创建多个相关对象的场景，且这些对象具有一致的风格、产品族。

代码示例：

// 产品A接口
public interface IProductA
{
    void Show();
}

// 产品B接口
public interface IProductB
{
    void Show();
}

// 具体产品A
public class ProductA1 : IProductA
{
    public void Show()
    {
        Console.WriteLine("ProductA1");
    }
}

public class ProductA2 : IProductA
{
    public void Show()
    {
        Console.WriteLine("ProductA2");
    }
}

// 具体产品B
public class ProductB1 : IProductB
{
    public void Show()
    {
        Console.WriteLine("ProductB1");
    }
}

public class ProductB2 : IProductB
{
    public void Show()
    {
        Console.WriteLine("ProductB2");
    }
}

// 抽象工厂接口
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();
    }
}

// 客户端代码
class Program
{
    static void Main()
    {
        IAbstractFactory factory1 = new ConcreteFactory1();
        IProductA productA1 = factory1.CreateProductA();
        IProductB productB1 = factory1.CreateProductB();
        productA1.Show();
        productB1.Show();

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