[翻譯]C# BAD PRACTICES: Learn how to make a good code by bad example---C#：如何將壞的代碼重新編譯為好的代碼

本文轉載自查看原文 2018-07-13 10:23 647 C#學習筆記/ 翻譯/ Translate/ 設計模式

自己的前言說明：

本文原作者：Radoslaw Sadowski，原文鏈接為：C# BAD PRACTICES: Learn how to make a good code by bad example。

本系列還有其他文章，后續將慢慢翻譯。

引言：

我的名字叫Radoslaw Sadowski，我現在是一個微軟技術開發人員。我從開始工作時就一直接觸的微軟技術.

在工作一年后，我看到的質量很差的代碼的數量基本上都可以寫成一整本書了。

這些經歷讓我變成了一個想要清潔代碼的強迫症患者。

寫這篇文章的目的是為了通過展示質量很差的類的例子來說明如何書寫出干凈的、可延伸的和可維護的代碼。我會通過好的書寫方式和設計模式來解釋壞的代碼帶來的問題，以及替換他的好的解決方法。

第一部分是針對那些擁有C#基礎知識的開發人員——我會展示一些常見的錯誤，然后再展示一些讓代碼變得可讀性的方法與技巧。高級部分主要針對那些至少擁有設計模式概念的開發人員——我將會展示完全干凈的、單元可測試的代碼。

為了能夠理解這篇文章你需要至少掌握以下兩個部分的基本知識：

C#語言
依賴注入、工廠設計模式、策略設計模式

本文中所涉及的例子都將會是現實中實實在在的具體的特性，而不是用裝飾模式來做披薩或者用策略模式來做計算器這樣的示例。

（ps解釋：看過設計模式相關的書籍的人應該會知道很多這方面的書籍都是用這種例子，只是為了幫助讀者理解設計模式）

因為我發現這種類型的產品不好用來解釋，相反這些理論性的例子卻是非常適合用來在本文中做解釋的。

我們常常會聽到說不要用這個，要用那個，但是卻不知道這種替換的理由。今天我將會努力解釋和證明那些好的書寫習慣以及設計模式是真的是在拯救我們的開發生活！

提示：

在本文中我不會花時間來講解C#的特性和涉及模式之類（我也解釋不完），網上有很多關於這方面的好的理論的例子。我將集中講述如何在我們日常工作中使用這些東西。
例子是一種比較容易的突出我們要說明的問題的方法，但是僅限於描述的問題——因為我發現當我在學習哪些包含着主要代碼的例子時，我發現在理解文章的總體思想方面會有困難。
我不是說我文中說的方法是惟一的解決方式，我只是能保證這些方法將會是讓你的代碼變得更高質量的途徑。
我並不關心下面這些代碼的什么錯誤處理，日志記錄等等。我要表述的只是用來解決日常編碼一些問題的方法。

那就開始吧….

那些糟糕透了的類...

下面的例子是我們現實中的類：

 1 public class Class1
 2 {
 3   public decimal Calculate(decimal amount, int type, int years)
 4   {
 5     decimal result = 0;
 6     decimal disc = (years > 5) ? (decimal)5/100 : (decimal)years/100; 
 7     if (type == 1)
 8     {
 9       result = amount;
10     }
11     else if (type == 2)
12     {
13       result = (amount - (0.1m * amount)) - disc * (amount - (0.1m * amount));
14     }
15     else if (type == 3)
16     {
17       result = (0.7m * amount) - disc * (0.7m * amount);
18     }
19     else if (type == 4)
20     {
21       result = (amount - (0.5m * amount)) - disc * (amount - (0.5m * amount));
22     }
23     return result;
24   }
25 }

上面這個例子真的是一種非常差的書寫方式。你能知道這個類是用來干嘛的么？這個東西是用來做一些奇怪的運算的么？我們文章就從他開始入手來講解吧…

現在我來告訴你，剛剛那個類是用來當顧客在網上買東西的時候為他們計算對應折扣的折扣計算和管理的類。

-難以置信吧！

-可是這是真的！

這種寫法真的是將難以閱讀、難以維護和難以擴展這三種集合在一起了，而且擁有着太差的書寫習慣和錯誤的模式。

除此之外還有其他什么問題么？

1.命名方式-從源代碼中我們可以連蒙帶猜估計出來這個計算方法和輸出結果是什么。而且我們想要從這個類中提取計算算法將會是一件非常困難的事情。

這樣帶來的危害是：

最嚴重的問題是：浪費時間，

如果我們需要滿足客戶的商業咨詢，要像他們展示算法細節，或者我們需要修改這段代碼，這將花費我們很長的時間去理解我們的計算方法的邏輯。即使我們不記錄他或重構代碼，下次我們/其他開發人員再看這段代碼的時候，還是需要花費同等的時間來研究這些代碼是干嘛的。而且在修改的同時還容易出錯，導致原來的計算全部出錯。

2.魔法數字

在這個例子中type是變量，你能猜到它代表着客戶賬戶的等級么？If-else if語句是用來實現如何選擇計算出產品價格折扣的方法。

現在我們不知道什么樣的賬戶是1，2，3或4。現在想象一下，當你不得不為了那些有價值的VIP客戶改變他們的折扣計算方式的時候，你試着從那些代碼中找出修改的方法---這個過程可能會花費你很長的時間不說，還很有可能犯錯以至於修改那些基礎的一般的客戶的賬戶，畢竟像2或者3這些詞語毫無描述性的。但是在我們犯錯以后，那些一般的客戶卻很高興，因為他們得到了VIP客戶的折扣。:)

3.沒有明顯的bug

因為我們的代碼質量很差，而且可讀性非常差，所以我們可能輕易就忽略掉很多非常重要的事情。想象一下，現在突然在系統中增加一種新的客戶類型-金卡用戶，而在我們的系統中任何一種新的賬戶類型最后獲得的價格將是0元。為什么呢？因為在我們的if-else if語句中沒有任何狀態是滿足新的狀態的，所以只要是未處理過的賬戶類型，最后返回值都將變成0。一旦我們的老板發現這件事，他將會大發雷霆-畢竟他已經免費賣給這樣用戶很多很多東西了！

4.沒有可讀性

我們必須承認上面這段代碼的可讀性是真的糟糕。

她讓我們花費了太多的時間去理解這段代碼，同時代碼隱藏錯誤的幾率太大了，而這就是沒有可讀性的最重要的定義。

5.魔法數字（再次）

你從代碼中能知道類似0.1,0.7,0.5這些數字的意思么？好的，我承認我不知道。只有我們自己編寫這些代碼我們才知道這是什么意思，別人是無法理解的。

你試試想想如果讓你修改下面這句代碼，你會怎么樣：

result = (amount - (0.5m * amount)) - disc * (amount - (0.5m * amount));

因為這個方法完全不可讀，所以你修改的過程中只能嘗試着把第一個0.5改成0.4而保持第二個0.5不懂。這可能會是一個bug，但是卻是最好的最合適的修改方式。因為這個0.5什么都沒有告訴我們。

同樣的事也存在將years變量轉換到disc變量的轉換過程中：

decimal disc = (years > 5) ? (decimal)5/100 : (decimal)years/100;

這是用來計算折扣率的，會通過賬戶在我們系統的時間的百分比來獲取。好的，那么現在問題來了，如果時間剛剛好就是5呢？

6.簡潔-不要反復做無用功

雖然第一眼看的時候不容易看出來，但是仔細研究一下就會發現：我們的代碼里有很多重復的地方。例如：disc * (amount - (0.1m * amount));

而與之有同樣效果的還有（只是變了一個參數而已）：disc * (amount - (0.5m * amount))

在這兩個算術中，唯一的區別就只是一個靜態參數，而我們完全可以用一個可變的參數來替代。

如果我們不試着在寫代碼的時候從一直ctri+c，ctrl+v中擺脫出來，那我們將遇到的問題就是我們只能修改代碼中的部分功能，因為我們不知道有多少地方需要修改。上面的邏輯是計算出在我們系統中每個客戶對應年限獲得的折扣，所以如果我們只是貿然修改兩到三處，很容易造成其他地方的前后不一致。

7.每個類有着太多的復雜的責任區域

我們寫的類至少背負了三個責任：

選擇計算的運算法則
為每個不同狀態的賬戶計算折扣率
根據每個客人的年限計算出對應的折扣率

這個違背了單一責任原則。那么這會帶來什么危害呢？如果我們想要改變上訴3個特性中的兩個，那就意味着可能會碰觸到一些其他的我們並不想修改的特性。所以在修改的時候我們不得不重新測試所有的類，那么這就造成了很重的時間的浪費。

那就開始重構吧…

在接下來的9個步驟中我將向你展示我們如何避免上訴問題來構建一個干凈的易維護，同時又方便單元測試的看起來一目了然的代碼。

I：命名，命名，命名

恕我直言，這是代碼中最重要的一步。我們只是修改方法/參數/變量這些的名字，而現在我們可以直觀的了解到下面這個類代表什么意思。

 1 public class DiscountManager
 2 {
 3   public decimal ApplyDiscount(decimal price, int accountStatus, int timeOfHavingAccountInYears)
 4   {
 5     decimal priceAfterDiscount = 0;
 6     decimal discountForLoyaltyInPercentage = (timeOfHavingAccountInYears > 5) ? (decimal)5/100 : (decimal)timeOfHavingAccountInYears/100; 
 7     if (accountStatus == 1)
 8     {
 9       priceAfterDiscount = price;
10     }
11     else if (accountStatus == 2)
12     {
13       priceAfterDiscount = (price - (0.1m * price)) - (discountForLoyaltyInPercentage * (price - (0.1m * price)));
14     }
15     else if (accountStatus == 3)
16     {
17       priceAfterDiscount = (0.7m * price) - (discountForLoyaltyInPercentage * (0.7m * price));
18     }
19     else if (accountStatus == 4)
20     {
21       priceAfterDiscount = (price - (0.5m * price)) - (discountForLoyaltyInPercentage * (price - (0.5m * price)));
22     }
23  
24     return priceAfterDiscount;
25   }
26 }

雖然如此，我們還是不理解1,2,3,4代表着什么，那就繼續往下吧！

II：魔法數

在C#中避免出現不理解的魔法數的方法是通過枚舉來替代。我通過枚舉方法來替代在if-else if 語句中出現的代替賬戶狀態的魔法數。

1 public enum AccountStatus
2 {
3   NotRegistered = 1,
4   SimpleCustomer = 2,
5   ValuableCustomer = 3,
6   MostValuableCustomer = 4
7 }

現在在看我們重構了的類，我們可以很容易的說出那個計算法則是用來根據不用狀態來計算折扣率的。將賬戶狀態弄混的幾率就大幅度減少了。

 1 public class DiscountManager
 2 {
 3   public decimal ApplyDiscount(decimal price, AccountStatus accountStatus, int timeOfHavingAccountInYears)
 4   {
 5     decimal priceAfterDiscount = 0;
 6     decimal discountForLoyaltyInPercentage = (timeOfHavingAccountInYears > 5) ? (decimal)5/100 : (decimal)timeOfHavingAccountInYears/100;
 7  
 8     if (accountStatus == AccountStatus.NotRegistered)
 9     {
10       priceAfterDiscount = price;
11     }
12     else if (accountStatus == AccountStatus.SimpleCustomer)
13     {
14       priceAfterDiscount = (price - (0.1m * price)) - (discountForLoyaltyInPercentage * (price - (0.1m * price)));
15     }
16     else if (accountStatus == AccountStatus.ValuableCustomer)
17     {
18       priceAfterDiscount = (0.7m * price) - (discountForLoyaltyInPercentage * (0.7m * price));
19     }
20     else if (accountStatus == AccountStatus.MostValuableCustomer)
21     {
22       priceAfterDiscount = (price - (0.5m * price)) - (discountForLoyaltyInPercentage * (price - (0.5m * price)));
23     }
24     return priceAfterDiscount;
25   }
26 }

III：更多的可讀性

在這一步中我們將通過將if-else if 語句改為switch-case 語句，來增加文章的可讀性。

同時，我也將一個很長的計算方法拆分為兩句話來寫。現在我們將“ 通過賬戶狀態來計算折扣率”與“通過賬戶年限來計算折扣率”這兩者分開來計算。

例如：priceAfterDiscount = (price - (0.5m * price)) - (discountForLoyaltyInPercentage * (price - (0.5m * price)));

我們將它重構為：priceAfterDiscount = (price - (0.5m * price));
priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);

這就是修改后的代碼：

 1 public class DiscountManager
 2 {
 3   public decimal ApplyDiscount(decimal price, AccountStatus accountStatus, int timeOfHavingAccountInYears)
 4   {
 5     decimal priceAfterDiscount = 0;
 6     decimal discountForLoyaltyInPercentage = (timeOfHavingAccountInYears > 5) ? (decimal)5/100 : (decimal)timeOfHavingAccountInYears/100;
 7     switch (accountStatus)
 8     {
 9       case AccountStatus.NotRegistered:
10         priceAfterDiscount = price;
11         break;
12       case AccountStatus.SimpleCustomer:
13         priceAfterDiscount = (price - (0.1m * price));
14         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
15         break;
16       case AccountStatus.ValuableCustomer:
17         priceAfterDiscount = (0.7m * price);
18         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
19         break;
20       case AccountStatus.MostValuableCustomer:
21         priceAfterDiscount = (price - (0.5m * price));
22         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
23         break;
24     }
25     return priceAfterDiscount;
26   }
27 }

IV：沒有明顯的bug

我們終於找到我們隱藏的bug了！

因為我剛剛提到的我們的方法中對於不適合的賬戶狀態會在造成對於所有商品最后都返回0。雖然很不幸，但卻是真的。

那我們該如何修復這個問題呢？那就只有通過沒有錯誤提示了。

你是不是會想，這個會不會是開發的例外，應該不會被提交到錯誤提示中去？不，他會的！

當我們的方法通過獲取賬戶狀態作為參數的時候，我們並不想程序讓我們不可預知的方向發展，造成不可預計的失誤。

這種情況是絕對不允許出現的，所以我們必須通過拋出異常來防止這種情況。

下面的代碼就是通過拋出異常后修改的以防止出現不滿足條件的情況-修改方式是將拋出異常防止 switch-case語句中的default 句中。

 1 public class DiscountManager
 2 {
 3   public decimal ApplyDiscount(decimal price, AccountStatus accountStatus, int timeOfHavingAccountInYears)
 4   {
 5     decimal priceAfterDiscount = 0;
 6     decimal discountForLoyaltyInPercentage = (timeOfHavingAccountInYears > 5) ? (decimal)5/100 : (decimal)timeOfHavingAccountInYears/100;
 7     switch (accountStatus)
 8     {
 9       case AccountStatus.NotRegistered:
10         priceAfterDiscount = price;
11         break;
12       case AccountStatus.SimpleCustomer:
13         priceAfterDiscount = (price - (0.1m * price));
14         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
15         break;
16       case AccountStatus.ValuableCustomer:
17         priceAfterDiscount = (0.7m * price);
18         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
19         break;
20       case AccountStatus.MostValuableCustomer:
21         priceAfterDiscount = (price - (0.5m * price));
22         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
23         break;
24       default:
25         throw new NotImplementedException();
26     }
27     return priceAfterDiscount;
28   }
29 }

V：分析計算方法

在我們的例子中我們有兩個定義給客戶的折扣率的標准：

賬戶狀態；
賬戶在我們系統中存在的年限

對於年限的計算折扣率的方法，所有的計算方法都有點類似：

(discountForLoyaltyInPercentage * priceAfterDiscount)

當然，也還是存在例外的：0.7m * price

所以我們把這個改成這樣：price - (0.3m * price)

 1 public class DiscountManager
 2 {
 3   public decimal ApplyDiscount(decimal price, AccountStatus accountStatus, int timeOfHavingAccountInYears)
 4   {
 5     decimal priceAfterDiscount = 0;
 6     decimal discountForLoyaltyInPercentage = (timeOfHavingAccountInYears > 5) ? (decimal)5/100 : (decimal)timeOfHavingAccountInYears/100;
 7     switch (accountStatus)
 8     {
 9       case AccountStatus.NotRegistered:
10         priceAfterDiscount = price;
11         break;
12       case AccountStatus.SimpleCustomer:
13         priceAfterDiscount = (price - (0.1m * price));
14         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
15         break;
16       case AccountStatus.ValuableCustomer:
17         priceAfterDiscount = (price - (0.3m * price));
18         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
19         break;
20       case AccountStatus.MostValuableCustomer:
21         priceAfterDiscount = (price - (0.5m * price));
22         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
23         break;
24       default:
25         throw new NotImplementedException();
26     }
27     return priceAfterDiscount;
28   }
29 }

現在我們將整理所有通過賬戶狀態的計算方法改為同一種格式：price - ((static_discount_in_percentages/100) * price)

VI：通過其他方式再擺脫魔法數

接下來讓我們的目光放在通過賬戶狀態計算折扣率的計算方法中的靜態變量：(static_discount_in_percentages/100)

然后帶入下面數字距離試試：0.1m,0.3m,0.5m

這些數字其實也是一種類型的魔法數-他們也沒有直接告訴我們他們代表着什么。

我們也有同樣的情況，比如將“有賬戶的時間”折價為“忠誠折扣”。

decimal discountForLoyaltyInPercentage = (timeOfHavingAccountInYears > 5) ? (decimal)5/100 : (decimal)timeOfHavingAccountInYears/100;

數字5讓我們的代碼變得神秘了起來。

我們必須做些什么讓這個變得更具表現性。

我會用另外一種方法來避免魔法數的表述的出現-也就是C#中的常量（關鍵詞是const），我強烈建議在我們的應用程序中專門定義一個靜態類來存儲這些常量。

在我們的例子中，我是創建了下面的類：

1 public static class Constants
2 {
3   public const int MAXIMUM_DISCOUNT_FOR_LOYALTY = 5;
4   public const decimal DISCOUNT_FOR_SIMPLE_CUSTOMERS = 0.1m;
5   public const decimal DISCOUNT_FOR_VALUABLE_CUSTOMERS = 0.3m;
6   public const decimal DISCOUNT_FOR_MOST_VALUABLE_CUSTOMERS = 0.5m;
7 }

經過一定的修改，我們的DiscountManager類就變成了這樣了：

 1 public class DiscountManager
 2 {
 3   public decimal ApplyDiscount(decimal price, AccountStatus accountStatus, int timeOfHavingAccountInYears)
 4   {
 5     decimal priceAfterDiscount = 0;
 6     decimal discountForLoyaltyInPercentage = (timeOfHavingAccountInYears > Constants.MAXIMUM_DISCOUNT_FOR_LOYALTY) ? (decimal)Constants.MAXIMUM_DISCOUNT_FOR_LOYALTY/100 : (decimal)timeOfHavingAccountInYears/100;
 7     switch (accountStatus)
 8     {
 9       case AccountStatus.NotRegistered:
10         priceAfterDiscount = price;
11         break;
12       case AccountStatus.SimpleCustomer:
13         priceAfterDiscount = (price - (Constants.DISCOUNT_FOR_SIMPLE_CUSTOMERS * price));
14         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
15         break;
16       case AccountStatus.ValuableCustomer:
17         priceAfterDiscount = (price - (Constants.DISCOUNT_FOR_VALUABLE_CUSTOMERS * price));
18         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
19         break;
20       case AccountStatus.MostValuableCustomer:
21         priceAfterDiscount = (price - (Constants.DISCOUNT_FOR_MOST_VALUABLE_CUSTOMERS * price));
22         priceAfterDiscount = priceAfterDiscount - (discountForLoyaltyInPercentage * priceAfterDiscount);
23         break;
24       default:
25         throw new NotImplementedException();
26     }
27     return priceAfterDiscount;
28   }
29 }

我希望你也認同我這個方法會更加使代碼自身變得更具有說明性:)

VII：不要再重復啦！

我們可以通過分拆算法的方式來移動我們的計算方法，而不是僅僅簡單的復制代碼。

我們會通過擴展方法。

首先我們會創建兩個擴展方法。

 1 public static class PriceExtensions
 2 {
 3   public static decimal ApplyDiscountForAccountStatus(this decimal price, decimal discountSize)
 4   {
 5     return price - (discountSize * price);
 6   }
 7  
 8   public static decimal ApplyDiscountForTimeOfHavingAccount(this decimal price, int timeOfHavingAccountInYears)
 9   {
10      decimal discountForLoyaltyInPercentage = (timeOfHavingAccountInYears > Constants.MAXIMUM_DISCOUNT_FOR_LOYALTY) ? (decimal)Constants.MAXIMUM_DISCOUNT_FOR_LOYALTY/100 : (decimal)timeOfHavingAccountInYears/100;
11     return price - (discountForLoyaltyInPercentage * price);
12   }
13 }

正如方法的名字一般，我不再需要單獨解釋一次他們的功能是什么。現在就開始在我們的例子中使用這些代碼吧：

 1 public class DiscountManager
 2 {
 3   public decimal ApplyDiscount(decimal price, AccountStatus accountStatus, int timeOfHavingAccountInYears)
 4   {
 5     decimal priceAfterDiscount = 0;
 6     switch (accountStatus)
 7     {
 8       case AccountStatus.NotRegistered:
 9         priceAfterDiscount = price;
10         break;
11       case AccountStatus.SimpleCustomer:
12         priceAfterDiscount = price.ApplyDiscountForAccountStatus(Constants.DISCOUNT_FOR_SIMPLE_CUSTOMERS)
13           .ApplyDiscountForTimeOfHavingAccount(timeOfHavingAccountInYears);
14         break;
15       case AccountStatus.ValuableCustomer:
16         priceAfterDiscount = price.ApplyDiscountForAccountStatus(Constants.DISCOUNT_FOR_VALUABLE_CUSTOMERS)
17           .ApplyDiscountForTimeOfHavingAccount(timeOfHavingAccountInYears);
18         break;
19       case AccountStatus.MostValuableCustomer:
20         priceAfterDiscount = price.ApplyDiscountForAccountStatus(Constants.DISCOUNT_FOR_MOST_VALUABLE_CUSTOMERS)
21           .ApplyDiscountForTimeOfHavingAccount(timeOfHavingAccountInYears);
22         break;
23       default:
24         throw new NotImplementedException();
25     }
26     return priceAfterDiscount;
27   }
28 }

擴展方法讓代碼看起來更加友善了，但是這個代碼還是靜態的類，所以會讓你單元測試的時候遇到困難，甚至不可能。那么出於擺脫這個問題的打算我們在最后一步來解決這個問題。我將展示這些是如何簡化我們的工作生活的。但是對於我個人而言，我喜歡，但是並不算是熱衷粉。

不管怎樣，你現在同意我們的代碼看起來友善多了這一點么？

那我們就繼續下去吧！

VIII：移除那些多余的代碼

在寫代碼的時候原則上是我們的代碼越是精簡越好。精簡的代碼的意味着，越少的錯誤的可能性，在閱讀理解代碼邏輯的時候花費的時間越少。

所以現在開始精簡我們的代碼吧。

我們可以輕易發現我們三種客戶賬戶下有着相同的方法：

.ApplyDiscountForTimeOfHavingAccount(timeOfHavingAccountInYears);

我們可不可以只寫一次呢？我們之前將未注冊的用戶放在了拋出異常中，因為我們的折扣率只會計算注冊用戶的年限，並沒有給未注冊用戶留有功能設定。所以，我們應該給未注冊用戶設定的時間為多少呢？ -0年

那么對應的折扣率也將變成0了，這樣我們就可以安全的將折扣率交付給未注冊用戶使用了，那就開始吧！

 1 public class DiscountManager
 2 {
 3   public decimal ApplyDiscount(decimal price, AccountStatus accountStatus, int timeOfHavingAccountInYears)
 4   {
 5     decimal priceAfterDiscount = 0;
 6     switch (accountStatus)
 7     {
 8       case AccountStatus.NotRegistered:
 9         priceAfterDiscount = price;
10         break;
11       case AccountStatus.SimpleCustomer:
12         priceAfterDiscount = price.ApplyDiscountForAccountStatus(Constants.DISCOUNT_FOR_SIMPLE_CUSTOMERS);
13         break;
14       case AccountStatus.ValuableCustomer:
15         priceAfterDiscount = price.ApplyDiscountForAccountStatus(Constants.DISCOUNT_FOR_VALUABLE_CUSTOMERS);
16         break;
17       case AccountStatus.MostValuableCustomer:
18         priceAfterDiscount = price.ApplyDiscountForAccountStatus(Constants.DISCOUNT_FOR_MOST_VALUABLE_CUSTOMERS);
19         break;
20       default:
21         throw new NotImplementedException();
22     }
23     priceAfterDiscount = priceAfterDiscount.ApplyDiscountForTimeOfHavingAccount(timeOfHavingAccountInYears);
24     return priceAfterDiscount;
25   }
26 }

我們還可以將這一行移除到switch-case語句外面。好處就是：更少的代碼量！

IX：提高-最后的得到干凈整潔的代碼

好了，現在我們可以像閱讀一本書一樣方便來審視我們的代碼了，但是這就夠了么？我們可以將代碼變得超級精簡的！

好的，那就開始做一些改變來實現這個目標吧。我們可以使用依賴注入和使用策略模式這兩種方式。

這就是我們今天最后整理出來的代碼了：

 1 public class DiscountManager
 2 {
 3   private readonly IAccountDiscountCalculatorFactory _factory;
 4   private readonly ILoyaltyDiscountCalculator _loyaltyDiscountCalculator;
 5  
 6   public DiscountManager(IAccountDiscountCalculatorFactory factory, ILoyaltyDiscountCalculator loyaltyDiscountCalculator)
 7   {
 8     _factory = factory;
 9     _loyaltyDiscountCalculator = loyaltyDiscountCalculator;
10   }
11  
12   public decimal ApplyDiscount(decimal price, AccountStatus accountStatus, int timeOfHavingAccountInYears)
13   {
14     decimal priceAfterDiscount = 0;
15     priceAfterDiscount = _factory.GetAccountDiscountCalculator(accountStatus).ApplyDiscount(price);
16     priceAfterDiscount = _loyaltyDiscountCalculator.ApplyDiscount(priceAfterDiscount, timeOfHavingAccountInYears);
17     return priceAfterDiscount;
18   }
19 }

 1 public interface ILoyaltyDiscountCalculator
 2 {
 3   decimal ApplyDiscount(decimal price, int timeOfHavingAccountInYears);
 4 }
 5  
 6 public class DefaultLoyaltyDiscountCalculator : ILoyaltyDiscountCalculator
 7 {
 8   public decimal ApplyDiscount(decimal price, int timeOfHavingAccountInYears)
 9   {
10     decimal discountForLoyaltyInPercentage = (timeOfHavingAccountInYears > Constants.MAXIMUM_DISCOUNT_FOR_LOYALTY) ? (decimal)Constants.MAXIMUM_DISCOUNT_FOR_LOYALTY/100 : (decimal)timeOfHavingAccountInYears/100;
11     return price - (discountForLoyaltyInPercentage * price);
12   }
13 }

 1 public interface IAccountDiscountCalculatorFactory
 2 {
 3   IAccountDiscountCalculator GetAccountDiscountCalculator(AccountStatus accountStatus);
 4 }
 5  
 6 public class DefaultAccountDiscountCalculatorFactory : IAccountDiscountCalculatorFactory
 7 {
 8   public IAccountDiscountCalculator GetAccountDiscountCalculator(AccountStatus accountStatus)
 9   {
10     IAccountDiscountCalculator calculator;
11     switch (accountStatus)
12     {
13       case AccountStatus.NotRegistered:
14         calculator = new NotRegisteredDiscountCalculator();
15         break;
16       case AccountStatus.SimpleCustomer:
17         calculator = new SimpleCustomerDiscountCalculator();
18         break;
19       case AccountStatus.ValuableCustomer:
20         calculator = new ValuableCustomerDiscountCalculator();
21         break;
22       case AccountStatus.MostValuableCustomer:
23         calculator = new MostValuableCustomerDiscountCalculator();
24         break;
25       default:
26         throw new NotImplementedException();
27     }
28  
29     return calculator;
30   }
31 }

 1 public interface IAccountDiscountCalculator
 2 {
 3   decimal ApplyDiscount(decimal price);
 4 }
 5  
 6 public class NotRegisteredDiscountCalculator : IAccountDiscountCalculator
 7 {
 8   public decimal ApplyDiscount(decimal price)
 9   {
10     return price;
11   }
12 }
13  
14 public class SimpleCustomerDiscountCalculator : IAccountDiscountCalculator
15 {
16   public decimal ApplyDiscount(decimal price)
17   {
18     return price - (Constants.DISCOUNT_FOR_SIMPLE_CUSTOMERS * price);
19   }
20 }
21  
22 public class ValuableCustomerDiscountCalculator : IAccountDiscountCalculator
23 {
24   public decimal ApplyDiscount(decimal price)
25   {
26     return price - (Constants.DISCOUNT_FOR_VALUABLE_CUSTOMERS * price);
27   }
28 }
29  
30 public class MostValuableCustomerDiscountCalculator : IAccountDiscountCalculator
31 {
32   public decimal ApplyDiscount(decimal price)
33   {
34     return price - (Constants.DISCOUNT_FOR_MOST_VALUABLE_CUSTOMERS * price);
35   }
36 }

首先我們擺脫了擴展方法（也就是靜態類），之所以要擺脫這種是因為擴展方法與折扣計算方法之間存在了緊耦合的關系。如果我們想要單元測試我們的方法ApplyDiscount的時候將變得不太容易，因為我們必須統一測試與之緊密關聯的類PriceExtensions。

為了避免這個，我創建了DefaultLoyaltyDiscountCalculator 類，這里面包含了ApplyDiscountForTimeOfHavingAccount擴展方法，同事我通過抽象接口ILoyaltyDiscountCalculator隱藏了她的具體實現。現在，當我想測試我們的類DiscountManager的時候，我就可以通過 ILoyaltyDiscountCalculator模擬注入虛構對象到DiscountManager類中通過構造函數顯示測試功能。這里我們運用的就叫依賴注入模式。

在做這個的同時，我們也將計算折扣率這個功能安全的移交到另一個不同的類中，如果我們想要修改這一段的邏輯，那我們就只需要修改DefaultLoyaltyDiscountCalculator 類就好了，而不需要改動其他的地方，這樣減少了在改動他的時候產生破壞其他地方的風險，同時也不需要再增加單獨測試的時間了。

下面是我們在DiscountManager類中使用分開的邏輯類：

priceAfterDiscount = _loyaltyDiscountCalculator.ApplyDiscount(priceAfterDiscount, timeOfHavingAccountInYears);

為了針對賬戶狀態的邏輯來計算折扣率，我創建了一些比較復雜的東西。我們在DiscountManager類中有兩個責任需要分解出去。

根據賬戶狀態如何選擇對應的計算方法。
特殊計算方法的細節

為了將第一個責任移交出去，我創建了工廠類（DefaultAccountDiscountCalculatorFactory），為了實現工廠模式，然后再把這個隱藏到抽象IAccountDiscountCalculatorFactory里面去。

我們的工廠會決定選擇哪種計算方法。最后我們通過依賴注冊模式構造函數將工廠模式注射到DiscountManager類中

下面就是運用了工廠的DiscountManager類：

priceAfterDiscount = _factory.GetAccountDiscountCalculator(accountStatus).ApplyDiscount(price);

以上會針對不同的賬戶狀態返回何時的策略，然后調用ApplyDiscount 方法。

第一個責任已經被交接出去了，接下來就是第二個了。

接下來我們就開始討論策略了…..

因為不同的賬戶狀態會有不用的折扣計算方法，所以我們需要不同的實現策略。座椅非常適用於策略模式。

在我們的例子中，我們有三種策略：

NotRegisteredDiscountCalculator
SimpleCustomerDiscountCalculator
MostValuableCustomerDiscountCalculator

他們包含了具體的折扣計算方法的實現並被藏在了抽象IAccountDiscountCalculator里。

這就允許我們的類DiscountManager使用合適的策略，而不需要知道具體的實現。我們的類只需要知道與ApplyDiscount方法相關的IAccountDiscountCalculator 接口返回的對象的類型。

NotRegisteredDiscountCalculator, SimpleCustomerDiscountCalculator, MostValuableCustomerDiscountCalculator這些類包含了具體的通過賬戶狀態選擇適合計算的計算方法的實現。因為我們的這三個策略看起來相似，我們唯一能做的基本上就只有針對這三種計算策略創建一個方法然后每個策略類通過一個不用的參數來調用她。因為這會讓我們的代碼變得越來越多，所以我現在決定不這么做了。

好了，到目前為止我們的代碼變得可讀了，而且每個類都只有一個責任了-這樣修改他的時候會單獨一一對應了：

DiscountManager-管理代碼流
DefaultLoyaltyDiscountCalculator-可靠的計算折扣率的方法
DefaultAccountDiscountCalculatorFactory-決定根據賬戶狀態選擇哪個策略來計算。
NotRegisteredDiscountCalculator, SimpleCustomerDiscountCalculator, MostValuableCustomerDiscountCalculator – 根據賬戶狀態計算折扣率

現在開始比較現在與之前的方法：

 1 public class Class1
 2 {
 3     public decimal Calculate(decimal amount, int type, int years)
 4     {
 5         decimal result = 0;
 6         decimal disc = (years > 5) ? (decimal)5 / 100 : (decimal)years / 100;
 7         if (type == 1)
 8         {
 9             result = amount;
10         }
11         else if (type == 2)
12         {
13             result = (amount - (0.1m * amount)) - disc * (amount - (0.1m * amount));
14         }
15         else if (type == 3)
16         {
17             result = (0.7m * amount) - disc * (0.7m * amount);
18         }
19         else if (type == 4)
20         {
21             result = (amount - (0.5m * amount)) - disc * (amount - (0.5m * amount));
22         }
23         return result;
24     }
25 }

這是我們的新的重構的代碼：

1 public decimal ApplyDiscount(decimal price, AccountStatus accountStatus, int timeOfHavingAccountInYears)
2 {
3   decimal priceAfterDiscount = 0;
4   priceAfterDiscount = _factory.GetAccountDiscountCalculator(accountStatus).ApplyDiscount(price);
5   priceAfterDiscount = _loyaltyDiscountCalculator.ApplyDiscount(priceAfterDiscount, timeOfHavingAccountInYears);
6   return priceAfterDiscount;
7 }

總結

在本文中，代碼被極其簡化了，使得所有的技術和模式的解釋更容易了。它展示了如何解決常見的編程問題，以及使用良好的實踐和設計模式以適當、干凈的方式解決這些問題的好處。

在我的工作經歷中，我多次在這篇文章中強調了不良的做法。它們顯然存在於許多應用場合，而不是在一個類中，如在我的例子中那樣，這使得發現它們更加困難，因為它們隱藏在適當的代碼之間。寫這種代碼的人總是爭辯說，他們遵循的是簡單愚蠢的規則。不幸的是，幾乎所有的系統都在成長，變得非常復雜。然后，這個簡單的、不可擴展的代碼中的每一個修改都是非常重要的，並且帶來了巨大的風險。

請記住，您的代碼將長期存在於生產環境中，並將在每個業務需求更改上進行修改。因此編寫過於簡單、不可擴展的代碼很快就會產生嚴重的后果。最后一點是對開發人員有利，尤其是那些在你自己之后維護你的代碼。

如果你有一些問題根據文章不要猶豫聯系我！

PS：

根據文章敲的源代碼：

鏈接：https://pan.baidu.com/s/1i7BH6Krl_vPnwtBCJjpQ8w 密碼：9spz

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Bad Smell (代碼的壞味道) C/C++程序如何翻譯為匯編代碼 C++中流的錯誤狀態 --eof、fail、bad、good、rdstate tomcat沒有編譯重新編寫的代碼好代碼是管出來的——C#的代碼規范 C#中修改Dll文件 (反編譯后重新編譯) 無需重新編譯代碼，在線修改表單如何寫 go 代碼 (How to Write Go Code 翻譯) [翻譯]:怎樣從C/C++代碼中對C#進行回調 C#代碼處理網頁關於登錄的code