设计模式精读

外观模式： 从原有系统中抽出一些接口（也可以自己扩展）形成一个新的接口（外观类）， 供客户使用 减少了客户与原系统内部的耦合，只需要与外观类接口发生耦合即可
适配器模式：创建一个拥有所需接口的新类，然后包装原来类的方法，达到适配的效果
桥接模式：抽象变化 实现也变化 找到变化点并进行封装 少用继承多用组合防止类爆炸 将实现部分封装在一个抽象类中 在被实现的抽象部分积累中包含一个实现部分基类的句柄

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

namespace BridgePattern
{
    interface Drawing
    {
         void DrawLine();
        void DrawCircle();
    }
    abstract class Shape
    {
        Drawing IDraw;
        abstract public void Draw();

        public void SetInterface(Drawing d)
        {
            IDraw = d;
        }
        public void DrawLine()
        {
            IDraw.DrawLine();
        }

        public void DrawCircle()
        {
            IDraw.DrawCircle();
        }

    }
    class Rectangle : Shape
    {
        public override void Draw() {
            DrawLine();
        }

    }

     class Circle:Shape
    {
        public override void Draw()
        {
            DrawCircle();
        }

    }

    class DrawingA:Drawing
    {
        public void DrawLine()
        {
            MethodA.DrawLineA();
        }

        public void DrawCircle()
        {
            MethodA.DrawCircleA();
        }
    }

    class DrawingB : Drawing
    {
        public void DrawLine()
        {
            MethodB.DrawLineB();
        }

        public void DrawCircle()
        {
            MethodB.DrawCircleB();
        }
    }

    static class MethodA
    {
        public static void DrawLineA()
        {
            Console.WriteLine("DrawLineA");
        }

        public static void DrawCircleA()
        {
            Console.WriteLine("DrawCircleA");
        }
    }

    static class MethodB
    {
        public static void DrawLineB()
        {
            Console.WriteLine("DrawLineB");
        }

        public static void DrawCircleB()
        {
            Console.WriteLine("DrawCircleB");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Shape s = new Rectangle();
            s.SetInterface(new DrawingA());
            s.Draw();
            Console.Read();
        }
    }
}

抽象工厂模式：是要提供一个创建一系列相关或相互依赖对象的接口，而不需要指定它们具体的类

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

namespace AbstractFactoryPattern
{
    abstract class AbstractProductA
    {
        public abstract void Show();
    }

    class ProductA1:AbstractProductA
    {
        public override void Show()
        {
            Console.WriteLine("ProductA1");
        }
    }
    class ProductA2 : AbstractProductA
    {
        public override void Show()
        {
            Console.WriteLine("ProductA2");
        }
    }
    abstract class AbstractProductB
    {
       public abstract  void Show();
    }

    class ProductB1 : AbstractProductB
    {
        public override void Show()
        {
            Console.WriteLine("ProductB1");
        }
    }
    class ProductB2 : AbstractProductB
    {
        public override void Show()
        {
            Console.WriteLine("ProductB2");
        }
    }
    abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProuctA();
        public abstract AbstractProductB CreateProuctB();
    }

    class ProductFactory1:AbstractFactory
    {
        public override AbstractProductA CreateProuctA()
        {
            return new ProductA1();
        }

        public override AbstractProductB CreateProuctB()
        {
            return new ProductB1();
        }

    }

    class ProductFactory2 : AbstractFactory
    {
        public override AbstractProductA CreateProuctA()
        {
            return new ProductA2();
        }

        public override  AbstractProductB CreateProuctB()
        {
            return new ProductB2();
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            AbstractFactory af = new ProductFactory1();
            AbstractProductA ap = af.CreateProuctA();
            ap.Show();
            Console.Read();
        }
    }
}

策略模式：使用不同的业务规则或者算法 讲算法的选择和实现分离 让客户可以基于场景做出选择

装饰模式 为一个对象现在有的功能动态添加附加功能的一个方法 被装饰和装饰类都继承同一个抽象类 装饰类存有被装饰类的引用，对功能进行重新包装

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

namespace NewDecoratorPattern
{
    abstract class Component
    {
        public abstract void Operation();
    }

    class ConcreteComponent : Component
    {
        public override void Operation()
        {
            Console.WriteLine("具体组件方法");
        }
    }

    abstract class Decorator:Component
    {
        private Component component;

        public void SetDecorator(Component com)
        {
            this.component = com;
        }

        public override void Operation()
        {
            component.Operation();
        }
    }

    class DecoratorA:Decorator
    {
        public override void Operation()
        {
            base.Operation();
            Console.WriteLine("Decorator A");
        }
    }
    class DecoratorB: Decorator
    {
        public override void Operation()
        {
            base.Operation();
            Console.WriteLine("Decorator B");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteComponent c = new ConcreteComponent();
            DecoratorA ad = new DecoratorA();
            ad.SetDecorator(c);
            ad.Operation();
            Console.Read();
        }
    }
}

单例模式：类只存在一个实例 多线程需要进行检测