小编点评

**工厂模式**是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需暴露对象的创建逻辑。 **工厂方法模式**使类的实例化延迟到其子类。 **C#工厂模式示例** ```csharp public interface IAnimal { void Speak(); } public class Dog : IAnimal { public void Speak() { Console.WriteLine("狗说:汪，汪"); } } public class Cat : IAnimal { public void Speak() { Console.WriteLine("猫说:喵。"); } } public class AnimalFactory { public IAnimal GetAnimal(string animalType) { switch (animalType.ToLower()) { case "dog": return new Dog(); case "cat": return new Cat(); default: throw new ArgumentException("无效动物型"); } } } public class Client { private IFactory factory; public Client(IFactory factory) { this.factory = factory; } public void UseProduct() { IAnimal product = factory.GetAnimal("dog"); product.Speak(); } } ``` **使用示例** ```csharp // 创建工厂 AnimalFactory animalFactory = new AnimalFactory(); // 创建产品 IAnimal dog = animalFactory.GetAnimal("dog"); // 使用产品 dog.Speak(); // 创建另一个产品 IAnimal cat = animalFactory.GetAnimal("cat"); // 使用另一个产品 cat.Speak(); ``` **输出** ``` 狗说:汪，汪 猫说:喵。 ```

正文

工厂设计模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需暴露对象的创建逻辑。在工厂模式中，我们定义一个接口或抽象类，该接口或抽象类用于创建对象，但让子类决定要实例化的类。工厂方法模式使类的实例化延迟到其子类。

下面是一个完整的C#实现案例：

首先，我们定义一个接口，用于创建对象：

public interface IAnimal
{
    void Speak();
}

然后，我们定义两个实现该接口的类：

public class Dog : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("狗说:汪，汪");
    }
}

public class Cat : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("猫说:喵。");
    }
}

接下来，我们定义一个工厂类，该类根据传入的参数创建相应的对象：

public class AnimalFactory
{
    public IAnimal GetAnimal(string animalType)
    {
        switch (animalType.ToLower())
        {
            case "dog":
                return new Dog();
            case "cat":
                return new Cat();
            default:
                throw new ArgumentException("无效动物型");
        }
    }
}

最后，我们可以使用工厂类来创建对象：

AnimalFactory animalFactory = new AnimalFactory();

IAnimal dog = animalFactory.GetAnimal("dog");
dog.Speak(); // 输出:狗说:汪汪

IAnimal cat = animalFactory.GetAnimal("cat");
cat.Speak(); // 输出:猫说:喵

在这个例子中，我们使用工厂类来创建不同类型的动物对象，而不需要暴露对象的创建逻辑。这使得我们可以轻松地添加新的动物类型，而不需要修改现有的代码。

以下是一个抽象工厂的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
{
    private IFactory factory;

    public Client(IFactory factory)
    {
        this.factory = factory;
    }

    public void UseProduct()
    {
        IProduct product = factory.CreateProduct();
        product.Use();
    }
}

// 使用示例
Client clientA = new Client(new FactoryA());
clientA.UseProduct(); // 输出：使用产品A

Client clientB = new Client(new FactoryB());
clientB.UseProduct(); // 输出：使用产品B

在这个示例中，抽象工厂接口 IFactory 定义了一个 CreateProduct 方法，用于创建产品。具体工厂 FactoryA 和 FactoryB 实现了 IFactory 接口，并分别创建了具体产品 ProductA 和 ProductB。客户端代码 Client 接收一个工厂对象，并使用工厂对象创建产品并使用。这样，客户端代码就可以通过更换工厂对象来创建不同的产品。