C# 谈谈代码重构

代码重构

重构（Refactoring）就是在不改变软件现有功能的基础上，通过调整程序代码改善软件的质量、性能，使其程序的设计模式和架构更趋合理，提高 软件的扩展性和维护性。　

一、为什么要重构（Refactoring）

 1、·持续偏纠和改进软件设计。

2、·使代码更易为人所理解。

3、·帮助发现隐藏的代码缺陷。

4、·从长远来看，有助于提高编程效率。

二、何时着手重构（Refactoring）

1、·代码中存在重复的代码。

2、·过大的类和过长的方法。

3、·牵一毛而需要动全身的修改。

4、·类之间需要过多的通讯。

5、·过度耦合的信息链。

6、·不完美的设计。

7、·缺少必要的注释。

三、如何来重构(Refactoring)

所谓重构也就是“保持软件的外在功能不变,重新调整其内部结构”。
Rename：   　　　　　改名了，类、函数、成员等名字都可以改。

改成大家容易理解其功能用途的名字：

 

1. ///

2. ///

3. ///

4. ///

5. ///

6. ///

7. protected int hename(string ID, Dictionary numlist)

8. {

9. int i = numlist.Count();

10. List onelist = (from entity in numlist where entity.Value == ID select entity.Value).ToList();

11. numlist.Add(i + 1, ID);

12. return onelist.Count();

13. }

14.  

15. //修改为

16. ///

17. ///

18. ///

19. ///

20. ///

21. ///

22. protected int GetSameNameCount(string ID, Dictionary numlist)

23. {

24. int i = numlist.Count();

25. List samelist = (from entity in numlist where entity.Value == ID select entity.Value).ToList();

26. numlist.Add(i + 1, ID);

27. return samelist.Count();

28. }

Extract Method：   　　将某段代码封到一个新函数里。

如果在某个方法里有一段代码是可以重新用一个方法来封装的，如下：

 

1. ///

2. ///

3. ///

4. ///

5. ///

6. ///

7. private DataTable ReplaceCloumnString(DataTable dtFormatedData, List ReplaceColumn)

8. {

9. Dictionary newfirstReplaces = new Dictionary();

10. newfirstReplaces = needfirstReplaces;

11. foreach (KeyValuePair newitem in firstReplaces)

12. {

13. if (!newfirstReplaces.ContainsKey(newitem.Key))

14. {

15. newfirstReplaces.Add(newitem.Key, newitem.Value);

16. }

17. }

18. DataTable dtFormatedDataCopy = dtFormatedData.Clone();

19. foreach (DataRow dr in dtFormatedData.Rows)

20. {

21. foreach (KeyValuePair item in newfirstReplaces)

22. {

23. foreach (string needColumn in ReplaceColumn)

24. {

25. if (dr[needColumn].ToString().Contains(item.Key))

26. {

27. string ContentStr = dr[needColumn].ToString();

28. dr[needColumn] = ReplaceStr(ContentStr, item.Key, item.Value);

29. }

30. }

31. }

32. DataRow drNewRow = dtFormatedDataCopy.NewRow();

33. drNewRow.ItemArray = dr.ItemArray;

34. dtFormatedDataCopy.Rows.Add(drNewRow);

35. }

36. return dtFormatedDataCopy;

37. }

38. ///修改为

39. ///

40. ///

41. ///

42. ///

43. ///

44. ///

45. private DataTable ReplaceCloumnString(DataTable dtFormatedData, List ReplaceColumn)

46. {

47. Dictionary newfirstReplaces = GetReplaceDictionary();

48. DataTable dtFormatedDataCopy = dtFormatedData.Clone();

49. foreach (DataRow dr in dtFormatedData.Rows)

50. {

51. foreach (KeyValuePair item in newfirstReplaces)

52. {

53. foreach (string needColumn in ReplaceColumn)

54. {

55. if (dr[needColumn].ToString().Contains(item.Key))

56. {

57. string ContentStr = dr[needColumn].ToString();

58. dr[needColumn] = ReplaceStr(ContentStr, item.Key, item.Value);

59. }

60. }

61. }

62. DataRow drNewRow = dtFormatedDataCopy.NewRow();

63. drNewRow.ItemArray = dr.ItemArray;

64. dtFormatedDataCopy.Rows.Add(drNewRow);

65. }

66. return dtFormatedDataCopy;

67. }

68. private Dictionary GetReplaceDictionary()

69. {

70. Dictionary newfirstReplaces = new Dictionary();

71. newfirstReplaces = needfirstReplaces;

72. foreach (KeyValuePair newitem in firstReplaces)

73. {

74. if (!newfirstReplaces.ContainsKey(newitem.Key))

75. {

76. newfirstReplaces.Add(newitem.Key, newitem.Value);

77. }

78. }

79. return newfirstReplaces;

80. }

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
Encapsulate Field：   　将某个字段转成属性

如下：

 

1. public string =null;

2. ///转换为

3. public string FieldName { get; set; }

Extract Interface：   　将某个属性或函数转成一个接口，从而是当前的这个属性或函数成为接口实现。

 

1. public class FolderBE

2. {

3. public string FolderOne

4. { get; set; }

5. public DateTime? CreateFolderOne

6. { get; set; }

7. public string FolderTwo

8. { get; set; }

9. public DateTime? CreateFolderTwo

10. { get; set; }

11. public string FolderThree

12. { get; set; }

13. public DateTime? CreateFolderThree

14. { get; set; }

15. public string FolderFour

16. { get; set; }

17. public DateTime? CreateFolderFour

18. { get; set; }

19. public string FolderFive

20. { get; set; }

21. public DateTime? CreateFolderFive

22. { get; set; }

23. }

24.  

25. public List HavelistResult = new List();

26.  

27. private bool CheckFolderExist(FolderBE folder, int item)

28. {

29. List HavelistFolder = new List();

30. if (item == 1)

31. {

32. HavelistFolder = (from entity in listFolder

33. where entity.FolderOne == folder.FolderOne &&

34. string.IsNullOrEmpty(entity.FolderTwo)

35. select entity).ToList();

36. }

37. else if (item == 2)

38. {

39. HavelistFolder = (from entity in listFolder

40. where entity.FolderOne == folder.FolderOne &&

41. entity.FolderTwo == folder.FolderTwo && string.IsNullOrEmpty(entity.FolderThree)

42. select entity).ToList();

43. }

44. else if (item == 3)

45. {

46. HavelistFolder = (from entity in listFolder

47. where entity.FolderOne == folder.FolderOne &&

48. entity.FolderTwo == folder.FolderTwo && entity.FolderThree == folder.FolderThree

49. select entity).ToList();

50. }

51. else if (item == 4)

52. {

53. HavelistFolder = (from entity in listFolder

54. where entity.FolderOne == folder.FolderOne &&

55. entity.FolderTwo == folder.FolderTwo && entity.FolderThree == folder.FolderThree &&

56. entity.FolderFour == folder.FolderFour

57. select entity).ToList();

58. }

59. else if (item == 5)

60. {

61. HavelistFolder = (from entity in listFolder

62. where entity.FolderOne == folder.FolderOne &&

63. entity.FolderTwo == folder.FolderTwo && entity.FolderThree == folder.FolderThree &&

64. entity.FolderFour == folder.FolderFour && entity.FolderFive == folder.FolderFive

65. select entity).ToList();

66. }

67. return HavelistFolder.Count == 0;

68. }

Promote Local Variable to Parameter： 将某个局部变量提升为函数参数

如上
Reorder Parameters：   对函数参数排序

略
Remove Parameters：   删除某个函数参数，但函数内对这个参数的使用不会删除。
如上，作为全局变量来用
重构函数（CHAPTER6）

Extract Method
前提：已经通过其他重构方法处理了间接变量。
目的：缩小函数的粒度以增加复用；强化代码的清晰度。
目标：函数的名称能够很好的表达函数要实现的“功能”。而不是要怎样做。

Inline Method

是Extract Method 的逆过程。正是因为有了这些逆过程，你才可以放心大胆的进行重构。

前提：被Inline的函数不能是多态的。Inline后无法表达多态的情况。
目的：去掉非必要的间接性。或者用于重组的一组组织不合理的函数的前提。
目标：去掉不必要的函数或者过多的委托。

提取方法是最常用的重构之一。当一个方法看起来太长或者方法中一些代码需要注释才能明白它的目的时，可以考虑把它们提取出来作为一个独立的方法。