學習之路二十九：泛型和委托在重構中的運用

最近在對項目中的代碼進行重構，在重構的過程中發現了一些很有趣的東西，就是泛型和委托！

泛型和委托給我的重構帶來了很大的便利，我也對它們在重構的技術上有了一些新的認識！

如果小菜說的不對，還請園友們幫我指出，我會虛心接受的，謝謝~！

下面我只是說泛型和委托在重構時的一些觀點，不包含泛型和委托的所有知識點！

一丶泛型

重構前代碼：

    public class Test
    {
        public object TestOne(int number)
        {
            switch (number) //根據傳過來的number來選擇對象
            {
                case 1:
                    return Test1();
                case 2:
                    return Test2();
                default:
                    return null;
            }
        }

        public Person1 Test1() //很簡單，返回一個對象實例
        {
            Person1 person1 = new Person1();
            return person1;
        }

        public Person2 Test2() //這個也是返回一個對象實例
        {
            Person2 person2 = new Person2();
            return person2;
        }
    }

    public class Person1
    { }

    public class Person2
    { }

分析：

　　①首先看到有兩個方法的操作行為都是返回對象實例！

　　②也就是操作行為是相似的，但是返回的類型是不一樣的!

　　③找到了相同點之后，我們就要對經常變化的點進行封裝了，也就是我們要封裝類型的變化點！

　　③最后我們很容易想到用泛型實現這樣的需求！

重構后代碼：

    public class Test
    {
        public object TestOne(int number)
        {
            switch (number)
            {
                case 1:
                    return TestTwo<Person1>();
                case 2:
                    return TestTwo<Person2>();
                default:
                    return null;
            }
        }

        public T TestTwo<T>() where T : class,new() //通過泛型來封裝類型變化點
        {
            T t = new T();
            return t;
        }
    }

    public class Person1
    { }

    public class Person2
    { }

結論：泛型封裝類型變化點

通過泛型來傳遞類型，規定現在我們應該使用哪一種類型，這樣就可以做到類型封裝，從而做到以不變應萬變！

 

二丶委托

重構前代碼：

    public class Test
    {
        public void Test1()
        {
            DataTable table = new DataTable(); //獲取數據源
            //生成Entity
            foreach (DataRow item in table.Rows)
            {
                GenerateEntity1(item);
            }
        }

        public void Test2()
        {
            DataTable table = new DataTable(); //獲取數據源
            //生成Entity
            foreach (DataRow item in table.Rows)
            {
                GenerateEntity2(item);
            }
        }

        public void GenerateEntity1(DataRow dataRow)
        {
            //生成Entity1
        }

        public void GenerateEntity2(DataRow dataRow)
        {
            //生成Entity2
        }
    }

分析：

　　①首先會看到Test1和Test2方法中在生成Entity時會有foreach循環的重復代碼！

　　②要想提取出兩邊的通用代碼，需要分析兩邊哪些代碼是一樣的，哪些是變化的，這樣我們就能提取出不變的代碼，而用一些技術來封裝變化點，最終做到通用！

　　③我們很容易發現foreach循環的代碼是一樣的，生成entity是不一樣的，但是在仔細看一下生成entity方法的參數和返回值是一樣的！

　　④那么怎么來封裝那個經常變化的點呢？

　　⑤我們想到委托，通過委托來傳遞操作行為來做到變化！

重構后代碼：

    public class Test2
    {
        public void Test1()
        {
            DataTable table = new DataTable(); //數據源
            GenerateEntity(table, GenerateEntity1);
        }

        public void Test2()
        {
            DataTable table = new DataTable();  //數據源，跟上面不同的數據源
            GenerateEntity(table, GenerateEntity2);
        }

        public void GenerateEntity1(DataRow dataRow)
        {
            //生成Entity1
        }

        public void GenerateEntity2(DataRow dataRow)
        {
            //生成Entity2
        }

        private void GenerateEntity(DataTable table, Action<DataRow> action)  //通過委托來實現操作行為的傳遞
        {
            foreach (DataRow item in table.Rows)
            {
                action(item);
            }
        }
    }

結論：委托封裝行為操作變化點

通過傳遞委托實例來指定我需要使用那種操作行為，如果發現返回值不一樣，那么再加上泛型來封裝類型的變化點，最后就構成了委托和泛型的綜合利用！

 

三丶總結

　　其實就是想說在實踐中進行思考，進行總結，最終一定會有不一樣的收獲！ 

 

已同步至：個人文章目錄索引