C#设计模式--工厂模式(创建型模式)

一.简单工厂模式（UML类图）：

核心类代码：

public class Calc
{
    public double NumberA { get; set; }
    public double NumberB { get; set; }
    public virtual double GetResult()
    {
        double result = ;
        return result;
    }
}

用于返回计算结果

public class Add : Calc
{
    public override double GetResult()
    {
        return NumberA + NumberB;
    }
}

四则运算类

public class CalcFactory
{
    public static Calc CalcValue(string operate)
    {
        Calc calc = null;
        switch (operate)
        {
            case "+":
                calc = new Add();
                break;
            case "-":
                calc = new Sub();
                break;
            case "*":
                calc = new Mul();
                break;
            case "/":
                calc = new Div();
                break;
        }
        return calc;
    }
}

用于判断计算的工厂

客户端进行调用：

static void Main(string[] args)
{
    Calc calc = CalcFactory.CalcValue("+");
    calc.NumberA = ;
    calc.NumberB = ;
    Console.WriteLine(calc.GetResult());
    Console.ReadKey();
}

二.工厂方法模式（UML类图）：

　　 工厂方法模式（Factory Method）是一种创建型的设计模式，在该模式中父类决定实例的生成方式。但是不决定它要生成的具体的类，具体的处理是交给子类完成的，这样将生成实例的框架和负责生成实例的类解耦。

核心类代码：

public interface IFactory
{
    Calc createCalc();
}

工厂接口，创建计算

public class AddFactory:IFactory
{
    public Calc createCalc()
    {
        return new Add();
    }
}

加法工厂

客户端进行进行调用：

static void Main(string[] args)
{
    IFactory fact = new AddFactory();
    Calc calc= fact.createCalc();
    calc.NumberA = ;
    calc.NumberB = ;
    Console.WriteLine(calc.GetResult());
    Console.ReadKey();
}

三.工厂方法模式（一个工厂一个产品）：　

　　从简单入手，下面通过制作身份证IDCard来了解工厂模式：

• 产品类（Product）：
  • 在该类中仅仅声明了一个抽象方法use(),定义了任意产品都可以use的方法，即定义了生成的实例所持有的接口方法。

public abstract class Product
{
    public abstract void Use();
}

产品类

• 工厂类（Factory）：
• 该工厂是生产Product类，负责生成产品Product，但是具体处理交由具体创建者。对于使用生成实例的专用方法createProduct创建实例，而不用new关键字来生成，这样做的好处是可以防止，父类与其他类耦合
  • create：创建产品
  • createProduct（抽象方法）：顶层负责调用，底层负责实现
  • registerProduct（抽象方法）：注册产品。

public abstract class Factory
{
    public Product create(string name)
    {
        Product product = createProduct(name);
        registerProduct(product);
        return product;
    }
    protected abstract Product createProduct(string name);
    protected abstract void registerProduct(Product product);
}

工厂类

• 具体产品类:
• 身份证IDCard属于一个具体的产品，继承自Product，是具体的产品，来实现产品抽象类的内容
  
• 具体的由谁制作“身份证IDCard”
• 具体的由谁使用“身份证IDCard”
• 提供一个获取这个具体的Name

public class IDCard:Product
{
    string name;
    public IDCard(string name)
    {
        Console.WriteLine("制作卡片："+name);
            this.name=name;
    }
    public override void Use()
    {
        Console.WriteLine(name+"使用卡片");
    }
    public string getName()
    {
        return name;
    }
}

具体产品类IDCard

• 具体的工厂类（什么工厂）：
  • 为了方便理解，所以这个工厂就生产单一的产品，“身份证IDCard”　
    • 在顶层直接调用生产的方法就可以了，具体生产由具体的底层实现就可以了。
    • 将创建的产品信息注册到ArrayList中，返回这个注册信息就知道谁创建的，谁在使用

public class IDCardFactory:Factory
{
    ArrayList list = new ArrayList();
    protected override Product createProduct(string name)
    {
        return new IDCard(name);
    }
    protected override void registerProduct(Product product)
    {
        IDCard card = (IDCard)product;
        list.Add(card.getName());
    }
    public ArrayList getName()
    {
        return list;
    }
}

具体工厂模式（单一产品）

四.工厂方法模式调用测试：

下面实际调用测试一下：

static void Main(string[] args)
{
    Factory factory = new IDCardFactory();
    Product card1 = factory.create("小明");
    Product card2 = factory.create("小红");
    Product card3 = factory.create("小刚");
    card1.use();
    card2.use();
    card3.use();
    Console.ReadKey();
}

　　输出信息：

• • 制作ID卡小明
  • 制作ID卡小红
  • 制作ID卡小刚
  • 使用ID卡小明
  • 使用ID卡小红
  • 使用ID卡小刚