C#比较

初学C#，此文章意在记录学习心得

C#是如何比较的，首先看如下程序，p1和p2是两个不同的引用，所以第一次比较输出no same。

p1和p3引用同一段内存空间，所以第二次比较输出same。

    class Program
    {
        static void Main(string[] args)
        {
            person p1 = new person { name = "SLH" };
            person p2 = new person { name = "SLH" };
            person p3 = p1;
            if (p1 == p2)
                Console.WriteLine("same");
            else
                Console.WriteLine("no same");
            Console.WriteLine("!-********************-!");
            if (p1 == p3)
                Console.WriteLine("same");
            else
                Console.WriteLine("no same");
            Console.ReadLine();
        }
    }
    class person
    {
        public string name;
    }

第二段程序使用Equals进行比较，结果相同

class Program
    {
        static void Main(string[] args)
        {
            person p1 = new person { name = "SLH" };
            person p2 = new person { name = "SLH" };
            if (p1 .Equals (p2 ))
                Console.WriteLine("same");
            else
                Console.WriteLine("no same");
            Console.ReadLine();
        }
    }
    class person
    {
        public string name;
    }

第三段程序我们在person类中重写了Equals()方法，通过person类型的name属性来比较两个person对象是否相同，结果输出same

class Program
    {
        static void Main(string[] args)
        {
            person p1 = new person { name = "SLH" };
            person p2 = new person { name = "SLH" };
            if (p1 .Equals (p2 ))
                Console.WriteLine("same");
            else
                Console.WriteLine("no same");
            Console.ReadLine();
        }
    }
    class person
    {
        public string name;
        public override bool Equals(object obj)
        {
            return this.name .Equals(((person )obj).name );
        }
    }

那么我们如何比较person类型的数组呢，看下面程序，执行结果no same

class Program
    {
        static void Main(string[] args)
        {
            person[] persons1 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"}
                               };
            person[] persons2 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"}
                               };
            if (persons1 != persons2)
                Console.WriteLine("no same");
            else
                Console.WriteLine("same");

            Console.ReadLine();
        }
    }
    class person
    {
        public string name;
        public override bool Equals(object obj)
        {
            return this.name.Equals(((person)obj).name);
        }
    }

c#数组显式实现了IStructuralEquatable接口，使用时需要把数组强制转换为该接口，这个接口用于比较两个数组是否内容相同，例程如下。

IStructuralEquatable接口定义了Equals()方法，方法需传入两个参数，第一个参数为另一个数组，object类型，

第二个参数为IEqualityComparer类型，可以通过EqualityComparer<T>类型的Default属性返回IEqualityComparer接口的一个默认实现，就可以定义如何进行比较了

当然person类中还需重写Equals()方法，程序执行结果为same

使用IStructuralEquatable接口需引用System.Collections命名空间

 

class Program
    {
        static void Main(string[] args)
        {
            person[] persons1 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"}
                               };
            person[] persons2 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"}
                               };
            if (((IStructuralEquatable)persons1).Equals(persons2, EqualityComparer<person>.Default))
                Console.WriteLine("same");
            else
                Console.WriteLine("no same");

            Console.ReadLine();
        }
    }
    class person
    {
        public string name;
        public override bool Equals(object obj)
        {
            return this.name.Equals(((person)obj).name);
        }
    }

此时修改persons2数组，程序运行结果为no same

            person[] persons1 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"}                              
                               };
            person[] persons2 ={
                                   new person (){name ="Tom"},
                                   new person (){name ="Jackson"}
                               };

修改persons2数组，程序运行结果no same

            person[] persons1 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"}
                                   
                               };
            person[] persons2 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"},
                                   new person (){name ="SLH"}
                               };

修改persons2数组，程序运行结果no same

            person[] persons1 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"}
                                   
                               };
            person[] persons2 ={
                                   new person (){name ="Jackson"},
                                   new person (){name ="SLH"}
                                   
                               };

由Default属性返回的IEqualityComparer接口的默认实现，首先检查person类型是否实现了IEquatable <T>接口，如果实现了，就调用IEquatable.Equals()方法，

如果没有实现，就调用Object.Equals()方法，看下面程序A与程序B

程序A，运行结果

IEquatable
no same

class Program
    {
        static void Main(string[] args)
        {
            person[] persons1 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"}          
                               };
            person[] persons2 ={
                                   new person (){name ="Jackson"},
                                   new person (){name ="SLH"}                                 
                               };
            if (((IStructuralEquatable)persons1).Equals(persons2, EqualityComparer<person>.Default))
                Console.WriteLine("same");
            else
                Console.WriteLine("no same");

            Console.ReadLine();
        }
    }
    class person:IEquatable <person >
    {
        public string name;
        public override bool Equals(object obj)
        {
            Console.WriteLine("Equals");
            return this.name.Equals(((person)obj).name);
        }

        public bool Equals(person other)
        {
            Console.WriteLine("IEquatable");
            return this.name.Equals(other.name);
        }
    }

程序B运行结果

Equals
no same

 

 class Program
    {
        static void Main(string[] args)
        {
            person[] persons1 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"}
                                   
                               };
            person[] persons2 ={
                                   new person (){name ="Jackson"},
                                   new person (){name ="SLH"}
                                   
                               };
            if (((IStructuralEquatable)persons1).Equals(persons2, EqualityComparer<person>.Default))
                Console.WriteLine("same");
            else
                Console.WriteLine("no same");

            Console.ReadLine();
        }
    }
    class person
    {
        public string name;
        public override bool Equals(object obj)
        {
            Console.WriteLine("Equals");
            return this.name.Equals(((person)obj).name);
        }
    }

当然我们也可以不使用EqualityComparer<T>类型的Default属性返回的默认实现，如下程序定义了equalityComparer类，实现了IEqualityComparer接口

class Program
    {
        static void Main(string[] args)
        {
            person[] persons1 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"}
                                   
                               };
            person[] persons2 ={
                                   new person (){name ="SLH"},
                                   new person (){name ="Jackson"}
                                   
                               };
            if (((IStructuralEquatable)persons1).Equals(persons2,new equalityComparer () ))     //此处第二个参数传入equalityComparer类的匿名对象
                Console.WriteLine("same");
            else
                Console.WriteLine("no same");

            Console.ReadLine();
        }
    }
    class person
    {
        public string name;
        public override bool Equals(object obj)
        {
            Console.WriteLine("Equals-person");
            return this.name.Equals(((person)obj).name);
        }
    }
    class equalityComparer :IEqualityComparer
    {

        public new bool Equals(object x, object y)     //执行if判断时，调用equalityComparer类的Equals()方法，此时传入的两个参数为person类型对象，调用person类型的Equals()方法

                                                                               //因为数组包含两个元素，所以会调用两次
        {
            Console.WriteLine("Equals-equalityComparer");
            return x.Equals(y);
        }

        public int GetHashCode(object obj)
        {
            return obj.GetHashCode();
        }
    }

程序运行结果：

Equals-equalityComparer
Equals-person
Equals-equalityComparer
Equals-person
same