工厂设计模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需暴露对象的创建逻辑。在工厂模式中，我们定义一个接口或抽象类，该接口或抽象类用于创建对象，但让子类决定要实例化的类。工厂方法模式使类的实例化延迟到其子类。
下面是一个完整的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 接收一个工厂对象，并使用工厂对象创建产品并使用。这样，客户端代码就可以通过更换工厂对象来创建不同的产品。
