c#设计模式-创建性模式-1.简单工厂工厂方法抽象工厂模式

Posted mr.chenyuelin

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了c#设计模式-创建性模式-1.简单工厂工厂方法抽象工厂模式相关的知识,希望对你有一定的参考价值。

简单工厂模式

现实中的工厂负责生产产品,顾名思义,编程中的简单工厂就是一个生产对象的类,它的主要作用是创建具体的产品类实例。我们以一个生产鼠标为例来分析简单工厂的作用,鼠标有两种:戴尔鼠标和惠普鼠标,代码如下:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 简单工厂模式
{
    public abstract class Mouse
    {
        public abstract void Print();
    }

    public class DellMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个Dell鼠标!");
        }
    }

    public class HpMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个惠普鼠标!");
        }
    }
    public class MouseFactory
    {
        //这里应该从配置文件从读取
        private static readonly string brand = "dell";
        private Mouse mouse = null;
        public Mouse CreateMouse()
        {
            switch (brand)
            {
                case "dell":
                    mouse = new DellMouse();
                    break;
                case "hp":
                    mouse = new HpMouse();
                    break;
                default:
                    break;
            }
            return mouse;
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            //实例化一个工厂类
            MouseFactory mouseFactory = new MouseFactory();
            //通过工厂类创建鼠标
            Mouse mouse1 = mouseFactory.CreateMouse();
            Mouse mouse2 = mouseFactory.CreateMouse();
            Mouse mouse3 = mouseFactory.CreateMouse();
            Mouse mouse4 = mouseFactory.CreateMouse();
            Mouse mouse5 = mouseFactory.CreateMouse();
            mouse1.Print();
            Console.ReadKey();
        }
    }
}

很明显简单工厂模式只有一个具体工厂,当厂家有很多时,就办法用了,下面的工厂方法模式可以解决这个问题

工厂方法模式

就是在简单工厂模式上,抽象一个工厂类,把具体生产产品的方法放在子类中实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 工厂模式
{
    //抽象产品类
    public abstract class Mouse
    {
        public abstract void Print();
    }

    public class DellMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个Dell鼠标!");
        }
    }

    public class HpMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个惠普鼠标!");
        }
    }
    //抽象工厂类
    public abstract class MouseFactory
    {
        public abstract Mouse CreateMouse();
    }
    public class DellMouseFactory : MouseFactory
    {
        public override Mouse CreateMouse()
        {
            return new DellMouse();
        }
    }
    public class HpMouseFactory : MouseFactory
    {
        public override Mouse CreateMouse()
        {
            return new HpMouse();
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            //实例化一个戴尔工厂类
            MouseFactory dellMouseFactory = new DellMouseFactory();
            Mouse dellMouse = dellMouseFactory.CreateMouse();
            dellMouse.Print();

            //实例化一个惠普工厂类
            MouseFactory HpMouseFactory = new HpMouseFactory();
            Mouse hpMouse = HpMouseFactory.CreateMouse();
            hpMouse.Print();
            Console.ReadKey();
        }
    }
}

如果增加一个苹果厂家生产的鼠标也是比较方便的,如下:

public class AppleMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个苹果鼠标!");
        }
    }
    public class AppleFactory : MouseFactory
    {
        public override Mouse CreateMouse()
        {
            return new AppleMouse();
        }
    }
    static void Main(string[] args)
        {        
            MouseFactory appleFactory = new AppleFactory();
            Mouse appleMouse = appleFactory.CreateMouse();
            appleMouse.Print();

            Console.ReadKey();
        }

当然工厂方法模式解决了简单模式的问题,但每个工厂不可能只生产一个产品吧,抽象工厂模式可以解决这个问题

抽象工厂模式

抽象工厂模式是为了解决系列产品的问题

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 简单工厂模式
{
    //抽象产品类
    public abstract class Mouse
    {
        public abstract void Print();
    }

    public class DellMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个戴尔鼠标!");
        }
    }

    public class HpMouse : Mouse
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个惠普鼠标!");
        }
    }
    //键盘抽象类
    public abstract class Keybo
    {
        public abstract void Print();
    }

    //戴尔键盘类
    public class DellKeybo : Keybo
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个戴尔键盘!");
        }
    }

    //惠普键盘
    public class HpKeybo : Keybo
    {
        public override void Print()
        {
            Console.WriteLine("生产了一个惠普键盘!");
        }
    }
    //抽象工厂类
    public abstract class AbstractFactory
    {
        public abstract Mouse CreateMouse();
        public abstract Keybo CreateKeybo();
    }
    public class DellFactory : AbstractFactory
    {
        public override Keybo CreateKeybo()
        {
            return new DellKeybo();
        }

        public override Mouse CreateMouse()
        {
            return new DellMouse();
        }
    }
    public class HpFactory : AbstractFactory
    {
        public override Keybo CreateKeybo()
        {
            return new HpKeybo();
        }

        public override Mouse CreateMouse()
        {
            return new HpMouse();
        }
    }   

    class Program
    {
        static void Main(string[] args)
        {
            //实例化一个戴尔工厂类
            AbstractFactory dellFactory = new DellFactory();
            Mouse dellMouse = dellFactory.CreateMouse();
            Keybo dellKeybo = dellFactory.CreateKeybo();
            dellMouse.Print();
            dellKeybo.Print();
            //实例化一个惠普工厂类
            AbstractFactory HpFactory = new HpFactory();
            Mouse hpMouse = HpFactory.CreateMouse();
            Keybo hpKeybo = HpFactory.CreateKeybo();
            hpMouse.Print();
            hpKeybo.Print();

            Console.ReadKey();
        }
    }
}

生产了一个戴尔鼠标!
生产了一个戴尔键盘!
生产了一个惠普鼠标!
生产了一个惠普键盘!

我们可以看出抽象工厂和工厂模式的区别在于:抽象工厂可以生产多种产品(两种:鼠标和键盘),而工厂模式只生产一种产品(键盘),抽象工厂主要时解决生产系列产品的问题。思考一下:如果抽象工厂中只有一种产品是什么情况呢?只有一种产品的抽象工厂其实就是工厂模式,我们可以把工厂模式看作是抽象工厂的一个特例。

抽象工厂模式缺点:在增加新产品时,是不满足开闭原则的。因为我们需要在父类AbstractFactory增加新方法而它的子类也要重写该方法

总结:
简单工厂模式:1个抽象产品类,1个具体工厂类.,1个产品
工厂方法模式:1个抽象产品类,1个抽象工厂类,1个产品
抽象工厂模式:1个抽象产品类,1个抽象工厂类,多个产品

转载:https://www.cnblogs.com/wyy1234/p/9986575.html

以上是关于c#设计模式-创建性模式-1.简单工厂工厂方法抽象工厂模式的主要内容,如果未能解决你的问题,请参考以下文章

C#设计模式——抽象工厂模式(原文转自:http://blog.jobbole.com/78059/)

C#工厂模式的原理

c#设计模式-工厂方法

C#——工厂模式

C#设计模式之三抽象工厂模式(AbstractFactory)创建型

工厂模式,简单工厂模式,抽象工厂模式三者有啥区别