設計模式精讀

外觀模式： 從原有系統中抽出一些接口（也可以自己擴展）形成一個新的接口（外觀類）， 供客戶使用 減少了客戶與原系統內部的耦合，只需要與外觀類接口發生耦合即可
適配器模式：創建一個擁有所需接口的新類，然後包裝原來類的方法，達到適配的效果
橋接模式：抽象變化 實現也變化 找到變化點並進行封裝 少用繼承多用組合防止類爆炸 將實現部分封裝在一個抽象類中 在被實現的抽象部分積累中包含一個實現部分基類的句柄

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();
        }
    }
}

單例模式：類只存在一個實例 多線程需要進行檢測