設計模式（"大話設計模式"讀書筆記 C#實現）

前言：毫無疑問 ，學習一些設計模式，對我們的編程水平的提高幫助很大。寫這個博客的時候自己剛開始學習設計模式，難免有錯，歡迎評論指正。

        我學設計模式的第一本書是“大話設計模式”。

1.為什么要學設計模式？

設計模式的存在就是為了抵御需求變更。學會了這些思想，開始一個項目的時候考慮的更多，當用戶提出變更的時候項目改動更少。

2.怎么才能學會設計模式？

我不知道，不過輪子哥（vczh）文章中的一句話，我覺得對，就是：“設計模式就是因為情況復雜了所以才會出現的，所以我們只能通過復雜的程序來學習設計模式。你不管看別人的程序也好，自己寫程序練習也好，那必須要復雜，復雜到你不用設計模式就做不下去，這才能起到學習設計模式的作用”。所以，我准備選擇一些自己用到的設計模式，通過寫代碼的方式去熟悉它們。

一.簡單工廠模式（Simple Factory Pattern）

場景描述：制作一個計算器。

1.實現加減乘除。

2.以后有其它算法的時候，容易維護。

工廠類

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//Author：cuishiyu
//2016.08.13
namespace OperationByFactory.Class
{
    //運算工廠類
    class OperationFactory
    {
        public static Operation createOperation(string operate)
        {
            Operation oper = null;
            switch (operate)
            {
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
            }
            return oper;
        }
    }
}

運算類

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//Author：cuishiyu
//2016.08.13
namespace OperationByFactory.Class
{
    //運算類
    class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;

        public double NumberA
        {
            get
            {
                return _numberA;
            }

            set
            {
                _numberA = value;
            }
        }

        public double NumberB
        {
            get
            {
                return _numberB;
            }

            set
            {
                _numberB = value;
            }
        }

        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }
}

加減乘除類

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//Author：cuishiyu
//2016.08.13
namespace OperationByFactory.Class
{
    //加法類
    class OperationAdd:Operation
    {
        public override double GetResult()
        {
            return NumberA + NumberB;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//Author：cuishiyu
//2016.08.13
namespace OperationByFactory.Class
{
    //減法類
    class OperationSub:Operation
    {
        public override double GetResult()
        {
            return  NumberA - NumberB;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//Author：cuishiyu
//2016.08.13
namespace OperationByFactory.Class
{
    //乘法類
    class OperationMul:Operation
    {
        public override double GetResult()
        {
            return NumberA * NumberB;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//Author：cuishiyu
//2016.08.13
namespace OperationByFactory.Class
{
    //除法類
    class OperationDiv:Operation
    {
        public override double GetResult()
        {
            if(NumberB== 0)
                throw new Exception("除數不能為0");
            return NumberA / NumberB;
        }
    }
}

 總結：簡單工廠模式很簡單，重要的是。這個設計模式是怎么一步步形成的、和這樣做的好處有哪些。

1.可移植性號，無論是控制台程序，Windows程序，Web程序，都可以用這段代碼。

2.擴展性好，更安全，以后增加平方，立方，開根號等運算的時候，增加一個相應的類，然后再Switch里增加分支就好了。同時也不用擔心程序員修改原先寫好的加減乘除類，使得原先的代碼不會被有意或者無意的修改，所以更安全。

3.（1）編程盡可能避免重復的代碼。（2）對業務進行封裝，盡可能的讓業務邏輯和頁面邏輯分開，讓它們的耦合度下降，這樣更容易維護和擴展。

4.大家可以熟悉一下UML類圖，畫出來之后理解更直觀。

二.策略模式（strategy Pattern）

場景描述：商場的收銀軟件，收銀員根據客戶所購買的商品單價和數量進行收費。

1.要考慮到打折的情況（比如過節打8折）。

2.要考慮滿A返B的情況（比如滿300返100）。

3.考慮以后發生其它情況是，盡量做到代碼容易更改，安全的更改。

注：部分代碼是偽代碼

抽象策略類

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

namespace PromotionByStrategy
{
    //抽象策略類
    abstract class CashSuper
    {
        public abstract double acceptCatch(double money);
    }
}

返利收費子類

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

namespace PromotionByStrategy
{
    //返利收費子類
    class CashReturn : CashSuper
    {
        private double moneyCondition = 0.0d;
        private double moneyReturn = 0.0d;
        public CashReturn(string moneyCondition, string moneyReturn)
        {
            this.moneyCondition = double.Parse(moneyCondition);
            this.moneyReturn = double.Parse(moneyReturn);
        }
        public override double acceptCatch(double money)
        {
            double result = money;
            if (money >= moneyCondition)
            {
                result = money - Math.Floor(money / moneyCondition) * moneyReturn;
            }
            return result;
        }
    }
}

打折收費子類

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

namespace PromotionByStrategy
{
    //打折收費子類
    class CashRebate : CashSuper
    {
        private double moneyRebate = 1d;

        //構造函數傳入打折信息
        public CashRebate(string moneyRebate)
        {
            this.moneyRebate = double.Parse(moneyRebate);
        }

        public override double acceptCatch(double money)
        {
            return money * moneyRebate;
        }
    }
}

正常收費子類

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

namespace PromotionByStrategy
{
    //正常收費子類
    class CashNormal : CashSuper
    {
        public override double acceptCatch(double money)
        {
            return money;
        }
    }
}

策略和簡單工廠的結合

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

namespace PromotionByStrategy
{
    //策略和簡單工廠的結合
    class CashContext
    {
        //收錢的父類
        CashSuper cs = null;
        
        /// <summary>
        /// 構造函數初始化收費類型對象
        /// </summary>
        /// <param name="type"></param>
        public CashContext(string type)//傳入一個收費的類型
        {
            switch (type)//根據不同的類型實例化不同的收款算法對象
            {
                case"正常收費":
                     cs = new CashNormal();
                    break;
                case "滿A減B":
                    cs = new CashReturn("A", "B");
                    break;
                case "打X折":
                    cs = new CashRebate("0.X");
                    break;    
            }
        }
        
        public double GetResult(double money)
        {
            return cs.acceptCatch(money);
        }
    }
}

客戶端的主要程序

 double tatal = 0.0d;
        //客戶端的主要程序
        //傳入算法，和價格*數量，得到應收的錢
        public void btnOK_Click()
        {
            CashContext csuper = new CashContext("傳入收款的算法");
            double totalPrices = 0.0d;
            totalPrices = csuper.GetResult(Convert.ToDouble("價格*數量"));
        }

總結：在分析一個項目中，遇到不同的時間應用不同的業務規則，就可以考慮使用策略模式處理這種變化的可能性。這個代碼還可以優化，后面會用反射進行優化

三.單一職責原則（SRP）

注：三、四、五主要分享設計模式中用到的一些原則

就一個類而言，因該僅有一個引起它變化的原因。一個類只行使一個功能，后面維護的時候會方便許多。

四.開放-封閉原則(The Open-Closeed Principle)

對軟件實體來說（類、模塊。函數）都要求滿足：

兩大特征：對擴張是開放的（Open for extension）,對更改是封閉的（Closed for modification）。

在具體的實現過程中，可按照下面做：

1.我們在最初編碼的時候，假設變化不會發生。當發生變化的時候，我們就創建抽象來隔離以后發生的同類變化。

2.當面對需求的時候，對程序的改動，是通過增加代碼而不是修改現有的代碼實現。

3.拒絕不成熟的抽象，和抽象本身同樣重要。

五.依賴倒轉原則

1.依賴倒轉原則：抽象不應該依賴細節，細節應該依賴抽象。

簡單解釋就是，針對接口編程而不是針對實現編程。

A.高模塊不應該依賴低層模塊。兩個都應該依賴抽象。

B.抽象不應該依賴細節，細節應該依賴抽象。

2.里氏代換原則：子類型必須能夠替換掉他們的父類型。

簡單解釋就是，一個軟件實體如果使用的是一個父類的話，那么一定使用於其子類，而且它察覺不出父類對象和子類對象的區別。

也就是說，在軟件里面，把父類都替換成它的子類，程序行為沒有變化。

 六.裝飾模式

場景描述：寫一個給人搭配不同服飾的系統，類似QQ秀，或者游戲皮膚之類的。

Person類

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

namespace DressByDecorator
{
    //Person類
    class Person
    {
        public Person()
        { }

        private string name;

        public Person(string name)
        {
            this.name = name;
        }

        public virtual void Show()
        {
            Console.WriteLine("裝扮的{0}",name);
        }
    }
}

服飾類，繼承Person類

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

namespace DressByDecorator
{
    //服飾類
    class Finery : Person
    {
        protected Person componnet;

        //打扮
        public void Decorate(Person component)
        {
            this.componnet = component;
        }

        public override void Show()
        {
            if (componnet != null)
            {
                componnet.Show();
            }
        }
    }
}

具體的服飾類，下面舉兩個例子。

鞋子類，繼承服飾類。

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

namespace DressByDecorator
{
    //鞋子類
    class Shose:Finery
    {
        public override void Show()
        {
            Console.WriteLine("鞋子");
            base.Show();
        }
    }
}

T恤類，繼承服飾類。

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

namespace DressByDecorator
{
    //T恤類
    class TShirts:Finery
    {
        public override void Show()
        {
            Console.WriteLine("T恤");
            base.Show();
        }
    }
}

下面是main函數里的實現

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

namespace DressByDecorator
{
    //Person類
    class Person
    {
        public Person()
        { }

        private string name;

        public Person(string name)
        {
            this.name = name;
        }

        public virtual void Show()
        {
            Console.WriteLine("裝扮的{0}",name);
        }
    }
}

裝飾模式（Decorator），動態地給一個對象添加一些額外的職責，就增加功能來說，裝飾模式比生成子類更加靈活。

總結：這個例子中，每一個類都形式自己的功能。他們公有的功能都寫在了父類。可以實現動態的添加更多的衣服。