C#设计模式之工厂模式

什么是工厂模式？

工厂模式是指为创建对象定义一个接口，让子类决定实例化哪一个类。工厂模式让一个类的实例化延迟到其子类。使用工厂模式我们可以让对象的创建和实现分离，当我们需要增加一种新的对象时，我们只需要添加一个新的具体的类和它相应的工厂类就可以了，不会对原来的代码产生太多的影响。

工厂模式的三种形式

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

简单工厂模式

简单工厂模式又叫静态工厂方法模式，在这种模式下，工厂类提供一个静态的工厂方法，用于创建所有的产品对象。这种模式优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。

以下是一个简单工厂模式的示例：

public interface IPrinter
{
    void Print(string text);
}

public class A4Printer : IPrinter
{
    public void Print(string text)
    {
        Console.WriteLine($"Printing on A4... {text}");
    }
}

public class A3Printer : IPrinter
{
    public void Print(string text)
    {
        Console.WriteLine($"Printing on A3... {text}");
    }
}

public class PrinterFactory
{
    public enum PrinterType
    {
        A3,
        A4
    }

    public static IPrinter CreatePrinter(PrinterType type)
    {
        switch (type)
        {
            case PrinterType.A3:
                return new A3Printer();
            case PrinterType.A4:
                return new A4Printer();
            default:
                throw new ArgumentException("Invalid printer type", nameof(type));
        }
    }
}

在这个示例中，我们定义了一个IPrinter接口，和两个具体实现A3Printer和A4Printer。我们又定义了一个PrinterFactory，并在其中实现了一个静态方法CreatePrinter，用来创建IPrinter实例。客户端代码只需要通过调用CreatePrinter方法，传递相应的参数，而不用去关心如何创建IPrinter对象。

var printer = PrinterFactory.CreatePrinter(PrinterFactory.PrinterType.A4);
printer.Print("Hello, world!");

工厂方法模式

工厂方法模式又称为工厂模式，它把简单工厂模式中的具体工厂类变成了抽象工厂类和具体工厂子类，降低了工厂类的复杂度，同时，工厂方法模式也提供了扩展的可能。在工厂方法模式中，创建对象的是具体的工厂子类，如有新的对象增加，只需要增加一个具体的类和其对应的工厂子类即可。

以下是一个工厂方法模式的示例：

public interface IAnimal
{
    void Speak();
}

public class Cat : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("Meow~");
    }
}

public class Dog : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("Woof!");
    }
}

public abstract class AnimalFactory
{
    public abstract IAnimal Create();
}

public class CatFactory : AnimalFactory
{
    public override IAnimal Create()
    {
        return new Cat();
    }
}

public class DogFactory : AnimalFactory
{
    public override IAnimal Create()
    {
        return new Dog();
    }
}

在这个示例中，我们定义了IAnimal接口和两个具体实现：Cat和Dog。与简单工厂的区别在于，我们在AnimalFactory中只定义了一个抽象工厂方法Create()，这个方法由具体工厂子类实现。客户端代码只需要通过调用具体的工厂子类的Create()方法就可以创建相应的对象了。

var catFactory = new CatFactory();
var cat = catFactory.Create();
cat.Speak();

var dogFactory = new DogFactory();
var dog = dogFactory.Create();
dog.Speak();

抽象工厂模式

抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式可以提供一个产品类的库，让工厂子类负责选择并生成一组合适的产品。这样一来，客户端就可以从具体的产品实现中解耦。

以下是一个抽象工厂模式的示例：

public interface IUIFactory
{
    IButton CreateButton();
    ITextBox CreateTextBox();
}

public interface IButton
{
    void Click();
}

public interface ITextBox
{
    void Input(string text);
}

public class WinUIFactory : IUIFactory
{
    public IButton CreateButton()
    {
        return new WinButton();
    }

    public ITextBox CreateTextBox()
    {
        return new WinTextBox();
    }
}

public class MacUIFactory : IUIFactory
{
    public IButton CreateButton()
    {
        return new MacButton();
    }

    public ITextBox CreateTextBox()
    {
        return new MacTextBox();
    }
}

public class WinButton : IButton
{
    public void Click()
    {
        Console.WriteLine("Win Button Clicked");
    }
}

public class MacButton : IButton
{
    public void Click()
    {
        Console.WriteLine("Mac Button Clicked");
    }
}

public class WinTextBox : ITextBox
{
    public void Input(string text)
    {
        Console.WriteLine($"Win Textbox Input: {text}");
    }
}

public class MacTextBox : ITextBox
{
    public void Input(string text)
    {
        Console.WriteLine($"Mac Textbox Input: {text}");
    }
}

在这个示例中，我们定义了抽象工厂IUIFactory，以及两个具体实现WinUIFactory和MacUIFactory，每个工厂都实现了两个方法CreateButton()和CreateTextBox()。客户端代码只需要通过具体的工厂实例调用CreateButton()和CreateTextBox()方法，就可以得到相应的对象，而不用关心具体是哪一个实现类。

var uiFactory = new MacUIFactory();
var button = uiFactory.CreateButton();
var textBox = uiFactory.CreateTextBox();
button.Click();
textBox.Input("Hello, World!");

总结

通过这篇文章，我们了解了工厂模式的三种形式和实现方式，并通过不同的示例来说明了各自的应用场景和使用方法。工厂模式具有代码扩展性和简化客户端代码的优点，能够更好地支持开闭原则，为软件设计和开发提供了更多的灵活性。