AlbertZhao 2021.7.15-

五大设计原则SOLID

1 单例模式

代码实例讲解

//单例模式：
public sealed class DeviceDGManager {
        /// 仪器管理，单例模式，内存唯一
        /// </summary>
        private static readonly Lazy<DeviceDGManager> lazy = new Lazy<DeviceDGManager>(() => new DeviceDGManager());
        public static DeviceDGManager Instance {
            get {
                return lazy.Value;
            }
        }
        //Fluke仪器清单列表
        public List<DeviceDG> flukeDevices = new List<DeviceDG>();
        /// <summary>
        /// 根据SN来查询Fluke设备
        /// </summary>
        /// <param name="SN"></param>
        /// <returns></returns>
        public DeviceDG GetFlukeDeviceBySN(string SN) {
            var temp = flukeDevices.Where(item => item.SN == SN);
            if (temp.Count() != 0) {
                return temp.FirstOrDefault();
            }
            return null;
        }
    }
}
//多例模式：
public class Multiton
     {
         private static Multiton instance1=null;
         private static Multiton instance2=null;
         private Multiton()
         {
          }
         public static Multiton getInstance(int whichOne)
         {
              if(whichOne==1)
              {
                   if(instance1==null)
                   {
                       instance1=new Multiton ();
                   }
                   return instance1;
              }
              else
              {
                   if(instance2==null)
                   {
                       instance2=new Multiton ();
                   }
               return instance2;
              }
         }
     }

通用代码模板

//单例模式：
public sealed class A {
        /// 仪器管理，单例模式，内存唯一
        /// </summary>
        private static readonly Lazy<A> lazy = new Lazy<A>(() => new A());
        public static A Instance {
            get {
                return lazy.Value;
            }
        }
        //Fluke仪器清单列表
        public List<B> listB = new List<B>();
        /// <summary>
        /// 根据SN来查询Fluke设备
        /// </summary>
        /// <param name="SN"></param>
        /// <returns></returns>
        public B GetProductBySN(string SN) {
            var temp = listB.Where(item => item.SN == SN);
            if (temp.Count() != 0) {
                return temp.FirstOrDefault();
            }
            return null;
        }
    }
}
//多例模式：
public class Multiton
     {
         private static Multiton instance1=null;
         private static Multiton instance2=null;
         private Multiton()
         {
          }
         public static Multiton getInstance(int whichOne)
         {
              if(whichOne==1)
              {
                   if(instance1==null)
                   {
                       instance1=new Multiton ();
                   }
                   return instance1;
              }
              else
              {
                   if(instance2==null)
                   {
                       instance2=new Multiton ();
                   }
               return instance2;
              }
         }
     }

2 工厂方法模式

代码实例讲解

using System;
using System.Collections.Generic;
namespace FactoryModern
{
    class Program
    {
        static void Main(string[] args)
        {
            //声明加人类工厂
            AbstractHumanFactory factory = new HumanFactory();
            //第一次造白种人
            IHuman human = factory.CreateHuman<WhiteHuman>();
            human.GetColor();
            human.Talk();
            //第二次造黑人
            human = factory.CreateHuman<BlackHuman>();
            human.GetColor();
            human.Talk();
        }
    }
    public interface IHuman
    {
        void GetColor();
        void Talk();
    }
    class BlackHuman : IHuman
    {
        public void GetColor()
        {
            Console.WriteLine("My Color is black.");
        }
        public void Talk()
        {
            Console.WriteLine("My language is xxxx");
        }
    }
    class WhiteHuman : IHuman
    {
        public void GetColor()
        {
            Console.WriteLine("My Color is white.");
        }
        public void Talk()
        {
            Console.WriteLine("My language is english");
        }
    }
    class YellowHuman : IHuman
    {
        public void GetColor()
        {
            Console.WriteLine("My Color is yellow.");
        }
        public void Talk()
        {
            Console.WriteLine("My language is chinese");
        }
    }
   public abstract class AbstractHumanFactory
    {
        //where约束T为class类型，必须是来自IHuman或者是实现IHuman接口,可创建实例
        public abstract T CreateHuman<T>() where T : class,IHuman,new();      
    }
    public class HumanFactory : AbstractHumanFactory
    {
        public override T CreateHuman<T>()
        {
            IHuman human = null;
            try
            {
                human = new T();
            }
            catch
            {
                Console.WriteLine("人种生成错误");
            }
            return (T)human;
        }
    }
}

通用类图及代码模板

抽象产品类Product负责定义产品的共性，实现对事物最抽象的定义；Creator为抽象创建类，也就是抽象工厂，具体如何创建产品类是由具体的实现工厂ConcreteCreator完成的。

//抽象产品类
public abstract class AbsProduct{
    //产品类的公共方法
    public void method1(){
        //业务逻辑处理
    }
    //抽象方法
    public abstract void method2();
}

//具体的产品类可有多个
public class ConcreteProduct1:AbsProduct{
    public override void method2(){
        //业务逻辑处理
    }
}
public class ConcreteProduct2:Product{
    public override void method2(){
        //业务逻辑处理
    }
}

//抽象工厂
public abstract class AbsFactory{
    //返回一个T类型的产品，T限定为Product或派生自它的，限定为class
    public abstract T CreateMethod<T>() where T:class,Product,new();
}

//具体工厂类
public class Factory:AbsFactory{
    public override T CreateMethod<T>(){
        Product product = null;
        try{
            product = new T();
            //或者传参进来 product = (T)Activator.CreateInstance(t.GetType());
        }
        catch(Exception e){
            //异常处理
        }
        return (T)product;
    }
}


//具体工厂类结合依赖注入框架
 public class HumanFactoryDelay : AbstractHumanFactory
    {
    //依赖注入框架Microsoft.Extensions.DependencyInjection
        public static ServiceCollection sc = new ServiceCollection();
        public override T CreateHuman<T>()
        {
            IHuman human = null;
            try
            {
                sc.AddScoped(typeof(IHuman), typeof(T));//将T类型放入到容器中
                var sp = sc.BuildServiceProvider();
                human = sp.GetService<T>();
            }
            catch
            {
                Console.WriteLine("人种生成错误");
            }
            return (T)human;
        }
    }

//场景类Client调用场景
public class Client{
    public static void main(Stirng[] args){
        AbsFactory absFactory = new Factory();
        AbsProduct absProduct = absFactory.CreateMethod<ConcreteProduct1>();
        absProduct.method1();
        absProduct.method2();
    }
}

3 抽象工厂模式

工厂方法模式

抽象工厂模式 将产品抽象化，将工厂抽象化
其本质还是一样的，将产品抽象化，再进行产品线的扩充。在抽象工厂中分别暴露三个A B C产品的方法，然后延时到具体工厂中实现。

通用类图及代码模板

//抽象产品A类
public abstract class AbstractProductA{
    public void ShareMethod(){}
    //每个产品的相同方法不同实现
    public abstract void DoSomething();
}

//A类产品不同型号1
public class ProductA1:AbstractProductA{
    public void DoSomething(){
        //
    }
}

//A类产品不同型号2
public class ProductA2:AbstractProductA{
    public void DoSomething(){
        //
    }
}

//抽象工厂:有几类产品就有几类方法
public abstract class AbstractFactory{
    //创建A类产品
    public abstract AbstractProductA createProductA();
    //创建B类产品
    public abstract AbstractProductB createProductB();
}

//只生产型号1的产品
public class Factory1:AbstractFactory{
    //创建A类产品
    public AbstractProductA createProductA(){
        return new ProductA1;
    }
    //创建B类产品
    public AbstractProductB createProductB(){
        return new ProductB1;
    }
}

//只生产型号2的产品
public class Factory2:AbstractFactory{
    //创建A类产品
    public AbstractProductA createProductA(){
        return new ProductA2;
    }
    //创建B类产品
    public AbstractProductB createProductB(){
        return new ProductB2;
    }
}