C# 将一个类实例与另一个包含匹配值的类实例进行比较

我发现一个类的一个实例不等于同一个类的另一个实例，即使两个实例都包含属性，实例的字段也包含相同的值。例如，在下面的代码中，即使

TestClass

的两个实例对于

TestValue01

和

TestValue02

属性具有相同的值，但比较将等同于false，并且将打印

“Boooo！”

static void Main(string[] args)
{
    TestClass testClassInstance01 = new TestClass(1, 1);
    TestClass testClassInstance02 = new TestClass(1, 1);

    if (testClassInstance01 == testClassInstance02)
    {
        Console.WriteLine("Woohoo!");
    }
    else
    {
        Console.WriteLine("Boooo!");
    }
}

class TestClass
{
    public int TestValue01 { get; private set; }
    public int TestValue02 { get; private set; }

    public TestClass(int testValue01, int testValue02)
    {
        TestValue01 = testValue01;
        TestValue02 = testValue02;
    }
}

有可能强迫这种比较等同于真的吗

显而易见，要做的事情是比较属性值，如下所示，但我很好奇这是否可以避免

if (testClassInstance01.TestValue01 == testClassInstance02.TestValue01
    && testClassInstance01.TestValue02 == testClassInstance02.TestValue02)
{
    Console.WriteLine("Woohoo!");
}
else
{
    Console.WriteLine("Boooo!");
}

编辑 为了完整性，我要寻找的是

运算符重载

。以下是我要求此示例返回true的代码：

class TestClass
{
    public int TestValue01 { get; private set; }
    public int TestValue02 { get; private set; }

    public TestClass(int testValue01, int testValue02)
    {
        TestValue01 = testValue01;
        TestValue02 = testValue02;
    }

    public static bool operator==(TestClass tc01, TestClass tc02)
    {
        return tc01.TestValue01 == tc02.TestValue01 && tc01.TestValue02 == tc02.TestValue02;
    }

    public static bool operator!=(TestClass tc01, TestClass tc02)
    {
        return tc01.TestValue01 != tc02.TestValue01 || tc01.TestValue02 != tc02.TestValue02;
    }
}

---

重载==运算符。我已经有一段时间没有做c了，所以我有点生疏了，但是你可以看看操作符重载来定义这种类型的行为

重载==操作符。我已经有一段时间没有做c了，所以我有点生疏了，但是你可以看看操作符重载来定义这种行为类型

Marij Khans的答案基本上是正确的。在不重载的情况下，运算符ReferenceEquals（对象，对象）用于“==”和“！=”当应用于类实例时，由于在示例中比较了两个实例，因此结果为“false”。完整的解决方案如下所示：

public class TestClass : IEquatable<TestClass>
{
    public int TestValue01 { get; private set; }
    public int TestValue02 { get; private set; }

    public TestClass(int testValue01, int testValue02)
    {
        TestValue01 = testValue01;
        TestValue02 = testValue02;
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as TestClass);
    }

    public bool Equals(TestClass other)
    {
        return other != null &&
            TestValue01 == other.TestValue01 &&
            TestValue02 == other.TestValue02;
    }

    public static bool operator ==(TestClass test1, TestClass test2)
    {
        return EqualityComparer<TestClass>.Default.Equals(test1, test2);
    }

    public static bool operator !=(TestClass test1, TestClass test2)
    {
        return !(test1 == test2);
    }
}

public类TestClass:IEquatable
{
public int TestValue01{get；private set；}
public int TestValue02{get；private set；}
公共测试类（int-testValue01，int-testValue02）
{
TestValue01=TestValue01；
TestValue02=TestValue02；
}
公共覆盖布尔等于（对象对象对象）
{
返回等于（obj作为TestClass）；
}
公共布尔等于（TestClass其他）
{
返回其他！=null&&
TestValue01==其他。TestValue01&&
TestValue02==other.TestValue02；
}
公共静态布尔运算符==（TestClass test1，TestClass test2）
{
返回EqualityComparer.Default.Equals（test1、test2）；
}
公共静态布尔运算符！=（TestClass test1，TestClass test2）
{
返回！（test1==test2）；
}
}

---

除了运算符“==”和“！=”的重载之外IEquatable接口的实现确保了比较始终按预期工作，即使在用作字典中的键或使用模式a.Equals（b）时也是如此。为了在搜索以此类实例为键的大型集合时提高速度，您甚至可能希望实现GetHashCode（），但这要求生成哈希代码时使用的值必须是只读的（即删除属性的setter，因此只能从构造函数中设置）玛丽·坎斯的回答基本上是正确的。在不重载的情况下，运算符ReferenceEquals（对象，对象）用于“==”和“！=”当应用于类实例时，由于在示例中比较了两个实例，因此结果为“false”。完整的解决方案如下所示：

public class TestClass : IEquatable<TestClass>
{
    public int TestValue01 { get; private set; }
    public int TestValue02 { get; private set; }

    public TestClass(int testValue01, int testValue02)
    {
        TestValue01 = testValue01;
        TestValue02 = testValue02;
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as TestClass);
    }

    public bool Equals(TestClass other)
    {
        return other != null &&
            TestValue01 == other.TestValue01 &&
            TestValue02 == other.TestValue02;
    }

    public static bool operator ==(TestClass test1, TestClass test2)
    {
        return EqualityComparer<TestClass>.Default.Equals(test1, test2);
    }

    public static bool operator !=(TestClass test1, TestClass test2)
    {
        return !(test1 == test2);
    }
}

public类TestClass:IEquatable
{
public int TestValue01{get；private set；}
public int TestValue02{get；private set；}
公共测试类（int-testValue01，int-testValue02）
{
TestValue01=TestValue01；
TestValue02=TestValue02；
}
公共覆盖布尔等于（对象对象对象）
{
返回等于（obj作为TestClass）；
}
公共布尔等于（TestClass其他）
{
返回其他！=null&&
TestValue01==其他。TestValue01&&
TestValue02==other.TestValue02；
}
公共静态布尔运算符==（TestClass test1，TestClass test2）
{
返回EqualityComparer.Default.Equals（test1、test2）；
}
公共静态布尔运算符！=（TestClass test1，TestClass test2）
{
返回！（test1==test2）；
}
}

---

除了运算符“==”和“！=”的重载之外IEquatable接口的实现确保了比较始终按预期工作，即使在用作字典中的键或使用模式a.Equals（b）时也是如此。为了在搜索以此类实例为键的大型集合时提高速度，您甚至可能希望实现GetHashCode（），但这要求生成哈希代码时使用的值必须是只读的（即删除属性的setter，因此只能从构造函数中设置）.

可能是@MongZhu的复制品你的权利，这正是我想要的。但我目前无法将此问题标记为重复问题。不知道为什么（可能是等待编辑？）。可能是@MongZhu的复制品，你的权利，这正是我想要的。但我目前无法将此问题标记为重复问题。不知道为什么（可能是等待编辑？）。可能是我想要的复制品，谢谢！有人评论了一个类似的链接，这给了我一个可以效仿的例子。这正是我想要的，谢谢！有人评论了一个类似的链接，这给了我一个可以效仿的例子。