编写高质量代码改善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接口暂时没接触过。第一次使用。

posted @ 2014-03-31 09:26 aehyok 阅读(...) 评论(...) 编辑 收藏