FactoryPattern-工厂模式
在C#中，工厂模式（Factory Pattern）是一种创建型模式，用于创建对象，而不需要直接使用构造函数来实例化对象。它通过一个工厂类来封装对象的创建逻辑，使得客户端只需要与工厂类交互，而无需关心具体的对象创建过程。
1.简单工厂
简单工厂模式（Simple Factory Pattern）是工厂模式的一种简化形式，通常包含以下几个核心角色：
产品接口（Product Interface）：定义了产品对象的接口，即产品所具有的方法和属性。
具体产品（Concrete Product）：实现产品接口的具体产品类，它是工厂模式所创建的对象。
简单工厂（Simple Factory）：负责创建具体产品对象的工厂类，根据不同的参数或条件来创建不同的具体产品对象。
//产品接口(汽车)
interface ICar
{
void Produce();
}
//具体产品(A型轿车)
public class CarA : ICar
{
public void Produce()
{
Console.WriteLine("produce CarA");
}
}
//具体产品(B型轿车)
public class CarB : ICar
{
public void Produce()
{
Console.WriteLine("produce CarB");
}
}
//简单工厂(汽车制造工厂)
class SimpleFactory
{
public static ICar CreateProduct(string type)
{
switch (type)
{
case "A":
return new CarA();
case "B":
return new CarB();
default:
throw new ArgumentException("Invalid product type");
}
}
}
//客户端代码
static void Main(string[] args)
{
//需要A型号汽车
ICar productA = SimpleFactory.CreateProduct("A");
productA.Produce();
//需要B型号汽车
ICar productB = SimpleFactory.CreateProduct("B");
productB.Produce();
}简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。当需要增加产品CraC(C型轿车)时，需要增加工厂的Swith分支。不修改代码的话，是无法扩展的，不符合开闭原则。
2.工厂方法
工厂方法模式（Factory Method Pattern）的核心思想是将对象的创建过程交给子类来完成，从而提供了一种扩展的方式，使得新的子类可以根据需要创建不同的产品对象，而不影响客户端代码。通常包含以下几个核心角色：
产品接口（Product Interface）：定义了产品对象的接口，即产品所具有的方法和属性。
具体产品（Concrete Product）：实现产品接口的具体产品类，它是工厂方法模式所创建的对象。
抽象工厂（Abstract Factory）：定义了一个创建产品对象的抽象方法，让具体工厂子类来实现。
具体工厂（Concrete Factory）：继承抽象工厂类，实现抽象工厂中的抽象方法，负责创建具体的产品对象。
//具体产品(C型轿车)
public class Carc : ICar
{
public void Produce()
{
Console.WriteLine("produce CarC");
}
}
// 抽象工厂
abstract class Factory
{
public abstract ICar CreateProduct();
}
// 具体工厂A
class ConcreteFactoryA : Factory
{
public override ICar CreateProduct()
{
return new CarA();
}
}
// 具体工厂B
class ConcreteFactoryB : Factory
{
public override ICar CreateProduct()
{
return new CarB();
}
}
// 具体工厂C
class ConcreteFactoryC : Factory
{
public override ICar CreateProduct()
{
return new CarC();
}
}
//客户端代码
static void Main(string[] args)
{
Factory factoryA = new ConcreteFactoryA();
ICar productA = factoryA.CreateProduct();
productA.Produce();
Factory factoryB = new ConcreteFactoryB();
ICar productB = factoryB.CreateProduct();
productB.Produce();
Factory factoryC = new ConcreteFactoryC();
ICar productC = factoryC.CreateProduct();
productC.Produce();
}工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。在同一等级结构中，支持增加任意产品。符合开闭原则，但随着产品类的增加，对应的工厂也会随之增多。
3.工厂模式
工厂模式（Factory Pattern）用于创建对象，而不需要直接使用构造函数来实例化对象。它通过一个工厂类来封装对象的创建逻辑，使得客户端只需要与工厂类交互，而无需关心具体的对象创建过程。
工厂模式和工厂方法模式的主要区别在于角色的不同以及使用的场景。
角色的不同：
工厂模式中，通常包含一个抽象工厂类和多个具体工厂类，抽象工厂类定义了一个或多个创建产品对象的抽象方法，而具体工厂类继承抽象工厂类并实现这些抽象方法，负责具体的产品对象的创建。
工厂方法中，通常包含一个抽象工厂类和多个具体工厂类，抽象工厂类定义了创建产品对象的抽象方法，而具体工厂类继承抽象工厂类并实现这个抽象方法，负责具体产品对象的创建。每个具体工厂类对应一个具体的产品类。
使用的场景：
工厂模式适用于需要创建一族相关或相互依赖的对象的场景。它提供一个抽象的工厂类，通过子类化这个工厂类来创建不同的产品族，具体的产品族由不同的具体工厂类来创建。
工厂方法适用于需要创建单一对象的场景。它将对象的创建延迟到子类中进行实现，使得每个具体工厂类负责创建特定的产品对象。
创建两个产品系列类，Car和Bus
public class Car
{
public abstract class AbstractCar
{
public abstract void Produce();
}
public class CarA : AbstractCar
{
public override void Produce()
{
Console.WriteLine("produce CarA");
}
}
public class CarB : AbstractCar
{
public override void Produce()
{
Console.WriteLine("produce CarB");
}
}
} public class Bus
{
public abstract class AbstractBus
{
public abstract void Produce();
}
public class BusA : AbstractBus
{
public override void Produce()
{
Console.WriteLine("produce BusA");
}
}
public class BusB : AbstractBus
{
public override void Produce()
{
Console.WriteLine("produce BusB");
}
}
}定义产品线，具体工厂宝马和比亚迪分别生产不同系列的Car与Bus
public interface IAbstractFactoryA
{
AbstractCar CreateCar();
AbstractBus CreateBus();
}
public class BMFactory : IAbstractFactoryA
{
public AbstractCar CreateCar()
{
return new CarA();
}
public AbstractBus CreateBus()
{
return new BusA();
}
}
public class BYDFactory : IAbstractFactoryA
{
public AbstractCar CreateCar()
{
return new CarB();
}
public AbstractBus CreateBus()
{
return new BusB();
}
}客户端代码
static void Main(string[] args)
{
BMFactory bMFactory = new BMFactory();
bMFactory.CreateCar();
bMFactory.CreateBus();
BYDFactory bYDFactory = new BYDFactory();
bYDFactory.CreateCar();
bYDFactory.CreateBus();
}
工厂模式（Factory Pattern）是一种创建型设计模式，它通过一个工厂类来创建对象，将对象的创建和使用分离。工厂模式具有以下优点和缺点：
优点：
-
封装对象的创建逻辑：工厂模式将对象的创建逻辑封装在一个工厂类中，客户端只需要通过工厂类来获取对象，无需知道具体的创建细节。这样可以将对象的创建过程和使用过程分离，提高代码的可读性和可维护性。
-
提供灵活性和可扩展性：工厂模式可以轻松地实现对象的切换和替换。通过更改工厂类中的具体创建逻辑，可以在运行时创建不同类型的对象。这样可以在不修改客户端代码的情况下，灵活地扩展和修改对象的创建方式。
-
隐藏具体实现细节：工厂模式将对象的创建过程封装在工厂类中，客户端不需要了解具体的实现细节。这样可以隐藏具体实现细节，保护对象的创建逻辑，提高系统的安全性。
-
代码解耦：工厂模式通过将对象的创建过程解耦，将对象的使用和创建分开。这样可以降低类之间的依赖关系，提高代码的灵活性和可维护性。
缺点：
-
增加代码复杂性：引入工厂模式会增加额外的类和接口，增加了代码的复杂性。如果对象的创建逻辑较为简单，使用工厂模式可能会显得过于繁琐。
-
不适用于简单对象的创建：如果对象的创建过程非常简单，没有复杂的依赖关系或变化，使用工厂模式可能会显得过于繁重，不值得额外引入工厂类。
-
难以创建需要大量参数的对象：如果对象的创建过程需要提供大量参数，那么在工厂类中传递和管理这些参数可能会变得困难。
需要根据具体的应用场景和需求来评估使用工厂模式的利弊。工厂模式适用于需要将对象的创建和使用分离，并且需要提供灵活性和可扩展性的情况。通过权衡其优点和缺点，可以选择是否使用工厂模式。
