編寫高質量代碼改善C#程序的157個建議[10-12]

前言

　　本文已更新至http://www.cnblogs.com/aehyok/p/3624579.html 。本文主要學習記錄以下內容：

　　建議10、創建對象時需要考慮是否實現比較器

　　建議11、區別對待==和Equals

　　建議12、重寫Equals時也要重寫GetHashCode

建議10、創建對象時需要考慮是否實現比較器

　　有對象的地方就會存在比較，就像小時候每次拿着考卷回家，媽媽都會問你隔壁的那誰誰誰考了多少分呀。下面我們也來舉個簡單的例子，就是有幾個人的Salary列表。我們根據基本工資來進行羅列：

    class Program
    {
        static void Main(string[] args)
        {
            ArrayList array = new ArrayList();
            array.Add(1100);
            array.Add(1200);
            array.Add(1160);
            array.Sort();
            foreach (var obj in array)
            {
                Console.WriteLine(obj.ToString());
            }
            Console.ReadLine();
        }
    }

 可以發現通過ArrayList.Sort()方法即可完成排序的任務。不過ArrayList這里只能是一個字段的。假如有姓名、工資兩個字段，然后根據工資進行排序那么按照現在的情況來看，ArrayList是無法實現的。所以接口IComparable現在可以派上用場了。現在先定義一個實體，並且實現接口IComparable。

public class Salary:IComparable
    {
        /// <summary>
        /// 姓名
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 基本工資
        /// </summary>
        public int BaseSalary { get; set; }

        /// <summary>
        /// 實現IComparable接口
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public int CompareTo(object obj)
        {
            Salary staff = obj as Salary;
            if (BaseSalary > staff.BaseSalary)
            {
                return 1;
            }
            else if (BaseSalary == staff.BaseSalary)
            {
                return 0;
            }
            else
            {
                return -1;
            }
        }
    }

進行排序

                ArrayList array = new ArrayList();
                array.Add(new Salary() { Name = "aehyok", BaseSalary = 12000 });
                array.Add(new Salary() { Name = "Kris", BaseSalary = 11200 });
                array.Add(new Salary() { Name = "Leo", BaseSalary = 18000 });
                array.Add(new Salary() { Name = "Niki", BaseSalary = 20000 });
                array.Sort();
                foreach (Salary obj in array)
                {
                    Console.WriteLine(string.Format("{0} BaseSalary:{1}", obj.Name, obj.BaseSalary));
                }
                Console.ReadLine();

如果未繼承Icomparable接口。那么會出現如下錯誤。

正確的進行排序，結果如下所示

假如現在在Salary類中添加了一個獎金的字段如下

public class Salary:IComparable
    {
        /// <summary>
        /// 姓名
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 基本工資
        /// </summary>
        public int BaseSalary { get; set; }

        /// <summary>
        /// 獎金
        /// </summary>
        public int Bouns { get; set; }

        /// <summary>
        /// 實現IComparable接口
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public int CompareTo(object obj)
        {
            Salary staff = obj as Salary;
            if (BaseSalary > staff.BaseSalary)
            {
                return 1;
            }
            else if (BaseSalary == staff.BaseSalary)
            {
                return 0;
            }
            else
            {
                return -1;
            }
        }
    }

再繼續假如，現在又要以Bouns獎金字段進行排序，那應該怎么處理呢？當然修改Salary實體類中繼承的接口方法進行處理肯定是沒問題了，但是比較麻煩。我們可以采用自定義比較接口IComparer來實現。

    public class BounsComparer:IComparer
    {
        public int Compare(object x, object y)
        {
            Salary s1 = x as Salary;
            Salary s2 = y as Salary;
            return s1.Bouns.CompareTo(s2.Bouns);
        }
    }

然后重新進行排序

                ArrayList array = new ArrayList();
                array.Add(new Salary() { Name = "aehyok", BaseSalary = 12000,Bouns=500 });
                array.Add(new Salary() { Name = "Kris", BaseSalary = 11200,Bouns=400 });
                array.Add(new Salary() { Name = "Leo", BaseSalary = 18000,Bouns=300 });
                array.Add(new Salary() { Name = "Niki", BaseSalary = 20000,Bouns=700 });
                array.Sort(new BounsComparer());
                foreach (Salary obj in array)
                {
                    Console.WriteLine(string.Format("{0} \tBaseSalary:{1}\tBouns{2}", obj.Name, obj.BaseSalary,obj.Bouns));
                }
                Console.ReadLine();

結果如下所示

注意，剛才實現接口名字叫IComparable,而自定義的比較器接口是IComparer

如果我們稍有經驗，會發現如下函數中的問題

        public int Compare(object x, object y)
        {
            Salary s1 = x as Salary;
            Salary s2 = y as Salary;
            return s1.Bouns.CompareTo(s2.Bouns);
        }

這個函數中進行了轉型處理，這是會影響性能的。如果集合中有成千上萬個復雜的實體對象，那么進行排序時耗費的時間是巨大的。所以泛型登場，很好的解決了這個問題。

因此以上代碼中的ArrayList，可以替換為List<T>,對應的我們就應該實現IComparable<T>和IComparer<T>。

實現的代碼如下:  

1、實體類實現接口IComparable<T>  2、自定義比較器實現接口IComparer<T> 3、進行排序的調用

    public class Salary:IComparable<Salary>
    {
        /// <summary>
        /// 姓名
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 基本工資
        /// </summary>
        public int BaseSalary { get; set; }

        /// <summary>
        /// 獎金
        /// </summary>
        public int Bouns { get; set; }

        /// <summary>
        /// 實現IComparable接口
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>

        public int CompareTo(Salary other)
        {
            return BaseSalary.CompareTo(other.BaseSalary);
        }
    }

    public class BounsComparer : IComparer<Salary>
    {
        public int Compare(Salary x, Salary y)
        {
            return x.Bouns.CompareTo(y.Bouns);
        }
    }

                List<Salary> array =new List<Salary>();
                array.Add(new Salary() { Name = "aehyok", BaseSalary = 12000,Bouns=500 });
                array.Add(new Salary() { Name = "Kris", BaseSalary = 11200,Bouns=400 });
                array.Add(new Salary() { Name = "Leo", BaseSalary = 18000,Bouns=300 });
                array.Add(new Salary() { Name = "Niki", BaseSalary = 20000,Bouns=700 });
                array.Sort(new BounsComparer());
                foreach (Salary obj in array)
                {
                    Console.WriteLine(string.Format("{0} \tBaseSalary:{1}\tBouns{2}", obj.Name, obj.BaseSalary,obj.Bouns));
                }
                Console.ReadLine();

最終結果

建議11、區別對待==和Equals

 這里我之前有一篇博文針對==和Equals有過專門的介紹，在此就不再進行過多的闡述了http://www.cnblogs.com/aehyok/p/3505000.html

建議12、重寫Equals時也要重寫GetHashCode

 下面先來看一個簡單的小例子，定義如下實體類：

    public class Person
    {
        public string IDCode { get;private set; }

        public Person(string idCode)
        {
            this.IDCode = idCode;
        }

        public override bool Equals(object obj)
        {
            return IDCode == (obj as Person).IDCode;
        }
    }

針對上面實體類進行編譯

這里會有一個提示暫時先不管

    public class PersonMoreInfo
    {
        public string SomeThing { get; set; }
    }

通過這兩個實體類，我們來使用以下Dictionary類型，代碼如下：

    class Program
    {
        static Dictionary<Person, PersonMoreInfo> PersonValues = new Dictionary<Person, PersonMoreInfo>();
        static void Main(string[] args)
        {
            AddAPerson();
            Person mike = new Person("aehyok");
            Console.WriteLine(PersonValues.ContainsKey(mike));
            //Console.WriteLine(mike.GetHashCode());
            Console.ReadLine();
        }
        static void AddAPerson()
        {
            Person mike = new Person("aehyok");
            PersonMoreInfo mikeValue = new PersonMoreInfo() {  SomeThing="aehyok's Info"};
            PersonValues.Add(mike, mikeValue);
            //Console.WriteLine(mike.GetHashCode());
            Console.WriteLine(PersonValues.ContainsKey(mike));
        }
    }

結果為true,false。

理論上來說，我們重寫了Person類中的Equals方法，也就是說在AddAPerson方法中的mike和在Main函數中的mike屬於”值相等“。從上面的結果可以發現，針對同一個實例，這種結論是正確的，針對不同的實例，這種結果就是有問題的。

基於鍵值的集合（如上面的Dictionary）會根據Key值來查找Value值。CLR內部會優化這種查找，實際上，最終是根據Key值的HasCode來查找Value值。代碼運行的時候，CRL首先會調用Person類型的GetHashCode，由於發現Person沒有實現GetHashCode，所以CLR最終會調用Object的 GetHashCode方法。將上面代碼中的兩行注釋代碼去掉，運行程序得到輸出

 

可以發現，AddAPerson方法和Main方法中的兩個mike的HashCode是不同的。這是因為：Object為所有的CLR類型都提供了GetHashCode的默認實現。每new一個對象，CLR都會為該對象生成一個固定的整形值，該整形值在對象的生存周期內不會改變，而該對象默認的GetHashCode實現就是對該整型值求HashCode。所以，在上面的代碼中，兩個mike兌現雖然屬性值都一致，但是它們默認實現的HashCode不一致，這就導致Dictionary中出現異常的行為。

想要修正該問題，就必須重寫GetHashCode方法。Person類的一個簡單的重寫可以是如下的代碼：

        public override int GetHashCode()
        {
            return this.IDCode.GetHashCode();
        }

此時再運行上面的代碼，會發現

兩者的HashCode是一致的，而dictionary也會找到相應的鍵值。

GetHasCode方法存在另外一個問題，就是它永遠只返回一個整型，而整型類型的容量顯然無法滿足字符串的容量

            string str1 = "NB0903100006";
            string str2 = "NB0904140001";
            Console.WriteLine(str1.GetHashCode());
            Console.WriteLine(str2.GetHashCode());

這兩個字符串產生的HasCode是一樣的。為了減少這種情況，我們稍作修改：

        public override int GetHashCode()
        {
            return (System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName+"#"+this.IDCode).GetHashCode();
        }

重寫Equals方法的同時，也應該實現一個類型安全的接口IEquatable<T>,所以Person類型的最終代碼如下：

    public class Person:IEquatable<Person>
    {
        public string IDCode { get;private set; }

        public Person(string idCode)
        {
            this.IDCode = idCode;
        }

        public override bool Equals(object obj)
        {
            return IDCode == (obj as Person).IDCode;
        }

        public override int GetHashCode()
        {
            return (System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName+"#"+this.IDCode).GetHashCode();
        }

        public bool Equals(Person other)
        {
            return IDCode == other.IDCode;
        }
    }

對於IEquatable接口暫時沒接觸過。第一次使用。