设计模式 工厂

三种工厂模式：

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

namespace 简单工厂练习
{
    class Program
    {
        static void Main(string[] args)
        {
            food a = gongchang.selectfood("cai1");
            a.print();
        }
       
    }
    public interface food
    {
          void print();
    }
    public class  cai1:food
    {
        public  void print()
        {
            Console.WriteLine("hongshaoyu");
        }
    }
    public class cai2 : food
    {
        public  void print()
        {
            Console.WriteLine("qiezi");
        }
    }
    public class gongchang
    {
        public static food selectfood(string type)
        {
            if (type.Equals("cai1"))
            {
                return new cai1();
            }
            else
            {
                return new cai2();
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//简单工厂总结：
//               1.创建具体事物的抽象类，创建不同的具体事物继承
//               2.创建抽象工厂类，创建不同的具体工厂继承
//               3.选择工厂的新实例。工厂选择具体事物的新实例
//               4.执行具体事物的方法。
//如果要扩展产品，要添加一个具体事物类和具体工厂类，缺点：单个工厂只创建单个产品
namespace 工厂方法模式
{
    class Program
    {

        static void Main(string[] args)
        {
            Factory a = new CreFactoryAodi();//大众工厂赋值给抽象工厂
            Factory d = new CreFactoryDazhong();//奥迪工厂赋值给抽象工厂
            car q = a.CreFactory();//执行奥迪工厂的方法，这个方法会选择new奥迪的对象，方法返回是奥迪具体事物类
            q.outcar();//执行奥迪具体事物类
            car w = d.CreFactory();//执行大众工厂的方法，这个方法会选择new大众的对象，方法返回是大众具体事物类
            w.outcar();//执行大众具体事物类
        }
    }
    public abstract class car//抽象汽车类
    {
        public abstract void outcar();
    }
    public class dazhong : car//具体大众子类
    {
        public override void outcar()
        {
            Console.WriteLine("生产一辆大众汽车");
        }
    }
    public class aodi : car//具体奥迪子类
    {
        public override void outcar()
        {
            Console.WriteLine("生产一辆奥迪汽车");
        }
    }
    public abstract class Factory//抽象工厂类
    {
        public abstract car CreFactory();
    }
    public class CreFactoryAodi: Factory//具体工厂类，选择aodi工厂
    {
        public override  car CreFactory()
        {
            return new aodi();
        }
    }
    public class CreFactoryDazhong : Factory//具体工厂类，选择dazhong工厂
    {
        public override car CreFactory()
        {
            return new dazhong();
        }
    }
}

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

namespace 抽象工厂
{
    //工厂总结：
    //               1.这里有抽象工厂，抽象产品1，抽象产品2
    //               2.选择产地工厂，选择品牌，生产
    //如果要扩展产地，要添加一个具体产地和产品1，产品2
    class Program
    {
        static void Main(string[] args)
        {
            FA S = new shangqiFA();//得到具体工厂，选择工厂
            dazhong ss= S.dazhongCar();//选择品牌
            ss.outCar();//生产
            aodi ss1 = S.aodiCar();
            ss1.outCar();
            FA Q = new yiqiFA();
            dazhong QQ = Q.dazhongCar();
            QQ.outCar();
            aodi QQ1 = Q.aodiCar();
            QQ1.outCar();

        }
    }
    public abstract class FA//抽象工厂
    {
        public abstract dazhong dazhongCar();
        public abstract aodi aodiCar();
    }
    public abstract class dazhong//抽象大众
    {
        public abstract void outCar();
    }
    public abstract class aodi//抽象奥迪
    {
        public abstract void outCar();
    }
    public class shangqiDazhong : dazhong
    {
        public override void outCar()
        {
            Console.WriteLine("生产上海大众汽车");
        }
    }
    public class yiqidazhong : dazhong
    {
        public override void outCar()
        {
            Console.WriteLine("生产一汽大众汽车");
        }
    }
    public class yiqiaodi : aodi
    {
        public override void outCar()
        {
            Console.WriteLine("生产一汽奥迪汽车");
        }
    }
    public class shangqiaodi : aodi
    {
        public override void outCar()
        {
            Console.WriteLine("生产上海奥迪汽车");
        }
    }

    public class shangqiFA : FA
    {
        public override dazhong dazhongCar()
        {
            return new shangqiDazhong();
        }
        public override aodi aodiCar()
        {
            return new shangqiaodi();
        }

    }
    public class yiqiFA : FA
    {
        public override dazhong dazhongCar()
        {
            return new yiqidazhong();
        }
        public override aodi aodiCar()
        {
            return new yiqiaodi();
        }

    }
}

 工业硬 件实例

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

namespace 工厂方法
{
    /// <summary>
    /// 抽象硬件类
    /// </summary>
    public abstract class Dev
    {
        public  bool IsConnect { get; set; }
      //  public abstract bool ABC;//不能定义抽象属性,可以定义抽象方法
        public abstract void open();
        public abstract void operate();
        public abstract void close();
    }
    /// <summary>
    /// 扫码枪硬件类
    /// </summary>
    public class BarCodeGun:Dev
    {
      
       
        public override void  open()
        {
            Console.WriteLine("打开了扫码枪的驱动");
            IsConnect = true;
        }
        public override void operate()
        {
            Console.WriteLine("扫码枪执行命令");
            
        }
        public override void close()
        {
            Console.WriteLine("关闭了扫码枪的驱动");
            IsConnect = false;
        }

    }
    /// <summary>
    /// 感应器硬件类
    /// </summary>
    public class Sensor : Dev
    {
       
        public override void open()
        {
            Console.WriteLine("打开了感应器的驱动");
            IsConnect = true;
        }
        public override void operate()
        {
            Console.WriteLine("感应器执行命令");
            
        }
        public override void close()
        {
            Console.WriteLine("关闭了感应器的驱动");
            IsConnect = false;
        }

    }
    /// <summary>
    /// 抽象创建类
    /// </summary>
    public abstract class FACreator
    {
        public abstract Dev Creator();
    }
    /// <summary>
    /// 扫码枪创建类
    /// </summary>
    public class CreatorBarCodeGun:FACreator
    {
        public override Dev Creator()
        {
            return new BarCodeGun();
        }
    }
    /// <summary>
    /// 感应器创建类
    /// </summary>
    public class CreatorSensor : FACreator
    {
        public override Dev Creator()
        {
            return new Sensor();
        }
    }
    //客户端调用
    internal class Program
    {
        static void Main(string[] args)
        {
            //1.实例化扫码枪创建类
            FACreator CB = new CreatorBarCodeGun();
            //2.创建 扫码枪实例返回
            Dev saoma =   CB.Creator();
            //执行扫码枪方法
            saoma.open();
            bool b = saoma.IsConnect;
            saoma.close();

            //同上的操作
          //  CreatorSensor CS = new CreatorSensor();//这个也是可以的，不过一般不这样用
           FACreator CS=new CreatorSensor();
            Dev ganying = CS.Creator();
            ganying.operate();
            bool BE = ganying.IsConnect;
            Console.ReadKey();

        }
    }
}