比较两个对象

Question

使用 Object.Equals 会导致两个使用相同构造函数新创建的对象返回 false。这是为什么呢？我希望能够比较两个对象并查看它们是否相同，换句话说，我想做与上面相同的测试，但我希望能够在第一次测试中得到 true （因为这两个对象应该是相同的）。

如何在不为任何特定类构建自己的比较方法的情况下实现这一目标。

using System;
class Program
{
    static void Main(string[] args)
    {
        Object Obj1 = new Object();
        Object Obj2 = new Object();
        Console.WriteLine(Obj1.Equals(Obj2));
        Obj2 = Obj1;
        Console.WriteLine(Obj1.Equals(Obj2)); 
    }
}

/* This example produces the following output:
False
True
 */

附录：

Object o1 = new Object();
Object o2 = new Object();

o1.value1 = 1;
o2.value1 = 1;

//Now I want to compare o1 and o2 and see if they are equal
//Can I do this without building my own function?

Answer 1

Object.Equals() 正在使用引用比较的相等性，只有当它是相同的对象引用时才会结果为 true。您可以为自己的从 Object 派生的类型重写此行为。

来自 MSDN：

Equals 的默认实现
支持引用相等
引用类型和按位相等
对于值类型。引用相等
表示对象引用
比较指的是同一个对象。
按位相等意味着对象
被比较的具有相同的二进制
代表。

请注意，派生类型可能
重写 Equals 方法以
落实价值平等。价值
相等是指比较对象
即使它们具有相同的值
有不同的二进制表示。
例如，考虑两个十进制
代表数字的对象
1.10 和 1.1000。 Decimal 对象不具有按位相等性，因为
他们有不同的二进制
陈述以解释
不同数量的尾随零。
但物品还是有其价值的
相等，因为数字 1.10 和
出于比较目的，1.1000 被认为是相等的，因为尾随
零是微不足道的。

Answer 2

当我做出这个答案时我很着急，这就是我重写我的答案的原因。

当您使用相同的数据创建同一个类两次时，equals 方法会检查两个对象的引用是否相等，它们仍然存储在内存中的不同位置，因此它们的引用不相等，并且 Equals 方法返回 false。

要检查类的值是否相等，您必须重写 Equals 方法，同时要使用 == 和 != 运算符，我们需要重载它们。

例如，字符串类会覆盖它，如果它不这样做，则会打印 false：

string test = "string";
string test2 = "string";
Console.WriteLine(test == test2);

示例：

// Example 1:
// Without overriding the Equals method:
Foo f1 = new Foo();
Foo f2 = new Foo();
f1.Name = "String";
f2.Name = "String";
bool fooEquals = f1 == f2; // False
f2.Name = "Test";
fooEquals f1 == f2; // False

// Example 2:
// With overriding the Equals method:
Foo f1 = new Foo();
Foo f2 = new Foo();
f1.Name = "String";
f2.Name = "String";
bool fooEquals = f1 == f2; // True
f2.Name = "Test";
fooEquals f1 == f2; // False

This is Foo in the first example:

public class Foo
{
    public string Name { get; set; }
}

This is Foo in the second example:

public class Foo
{
    public string Name { get; set; }

    public override bool Equals(object obj)
    {
        // If parameter is null return false.
        if (obj == null)
        {
            return false;
        }

        // If parameter cannot be cast to Point return false.
        Foo p = obj as Foo;
        if ((System.Object)p == null)
        {
            return false;
        }

        // Return true if the fields match:
        return (Name == p.Name);
    }

    public bool Equals(Foo p)
    {
        // If parameter is null return false:
        if ((object)p == null)
        {
            return false;
        }

        // Return true if the fields match:
        return (Name == p.Name);
    }

    public static bool operator ==(Foo f1, Foo f2)
    {
        return f1.Equals(f2);
    }

    public static bool operator !=(Foo f1, Foo f2)
    {
        return !f1.Equals(f2);
    }

    public override int GetHashCode()
    {
        return Name.GetHashCode();
    }
}

注意： 当覆盖 Equals 时或重载 ==/!=，Visual Studio 希望您重写 GetHashCode 函数。该函数对于 Foo 的每个实例都应该是唯一的，并且具有相同的值。

Answer 3

大多数答案都是正确的，我只会提供更多细节：

从 System.Object 派生的类的任何实例（除了 System.ValueType 类之外）都是“引用”类。 “参考”类有两部分：实例的“核心”被放置在程序的内存中，称为“堆”，然后指向该内存地址的“引用”或“指针”被放置在堆栈中。有关堆栈和堆是什么以及为什么需要它们的更多信息，请参阅 MSDN 文档或计算机编程基本入门书。

在.NET中，引用类型的两个变量的相等性默认比较是比较变量存储的内存地址。这就是“引用相等”；如果两个变量指向相同的内存地址，则它们相等。如果没有，他们就不是。

对于“语义”或“结构”平等，需要更深入地了解每个变量的内存空间中的内容。一般情况下不能这样做；开发人员必须为他想要比较的每个类定义什么使他的类的两个实例在语义上相等。这是通过重写从 Object 类继承的 Equals() 方法来实现的（因此对所有 .NET 类都是通用的）。 Equals 重写通常具有以下结构：

public override bool Equals (object other)
{
    //Reference equality is still a simple and necessary check
    if(Object.ReferenceEquals(this, other)) return true;

    //Another simple check; the two objects should be the same type
    if(this.GetType() != other.GetType()) return false;

    //Now, compare members of the object that you want to use to determine
    //"semantic" equality. These members, if also reference types, must also
    //be "semantically" equal.

    if(this.Property1 == other.Property1 && this.FieldA == other.FieldA && ... )
       return true;

    return false;
}

实现 IComparable、IEquatable 和 IStructuralEquatable 接口向使用者提供当前类的作者具有相等或其他比较的自定义定义的线索。它们在某些情况下是必要的，但并非在所有情况下都是必要的。

Answer 4

我相信你必须创建自己的比较方法，并实现 ICompare 接口

Answer 5

Object.Equals() 是引用相等。您必须构建自己的比较方法，无论是重写 equals，还是实现 IEqualityComparer，或任何其他比较接口。

Answer 6

与按值比较的基元不同，使用对象的引用来比较对象。这经常困扰字符串新手，在很多语言中字符串都是对象，他们只是尝试使用原始比较来检查它们的相等性。

如果您确实希望能够使用 == 运算符进行比较，那么您可以 重载运算符。

Answer 7

除了引用标识之外，object 类型绝对没有任何区别特征。如果您希望两个不同的 object 实例比较相等，只需实现您自己的比较器：

class ObjectComparer : IEqualityComparer<object>
{
    public bool Equals(object x, object y)
    {
        if (x == null || y == null)
        {
            return false;
        }

        return x.GetType == typeof(object) && y.GetType() == typeof(object);
    }

    public int GetHashCode(object obj)
    {
        if (obj == null)
        {
            return 0;
        }

        if (obj.GetType() == typeof(object))
        {
            return 1; // I don't know, whatever.
        }

        return obj.GetHashCode();
    }
}

哦等等，这就是您不想要做的。好吧，然后创建您自己的类型，使其按照您想要的方式运行：

sealed class SimpleObject()
{
    // No characteristics, all instances equal.
    public override bool Equals(object obj)
    {
        return obj is SimpleObject;
    }

    public override int GetHashCode()
    {
        return 0;
    }
}

您不能只更改 object 类型本身。

Answer 8

对象类的 equals 方法比较两个引用。由于您正在创建一个新对象，因此它们永远不会相等。