Location>code7788 >text

"Equal Judgment" in C#

Popularity：60 ℃/2025-03-09 17:54:20

"Equal Judgment" in C#

There are many ways to judge equality in C#, such as:

  • Double equality==​
  • ExampleEquals()Method
  • ​()Static method
  • ​()Method
  • ​EqualityComparer<int>.()Method
  • ​isOperator

There are also some special types that implement equality judgments internally, such as:

  • Tuples
  • Anonymous Type

There are also some special equality judgments, such as:

  • Comparison of internal elements structured equality

What do these equality judgments do? When to use it? I will list the explanations below.

1. Double equal sign (==) Equal judgment

1.1 Primitive Type

For primitive types (int​、float​ etc.),==​ is to compare whether the values ​​of the two are equal. Looking at the source code of these primitive types, you will find that they are not correct.==Operators are overloaded, but they can be used==​ Make a comparison. This is because the compiler has made special optimizations to primitive types:

  • Compilation stage: Direct generationceq​ IL command (Compare Equal)
  • Runtime: The JIT compiler willceq​ Convert to the underlying CPU integer comparison instruction without calling any method

1.2 Some predefined value types

Some built-in value types (non-primitive types, such asdecimal, they can be used==​ Comparison is because==The operator is overloaded. The following two codes are comparedintanddecimal​ Make equal comparisons corresponding IL code:

int num = 1;
 int num2 = 2;
 bool flag = num == num2;

 // The corresponding IL code is as follows, with deleted
 IL_0000: nop
 // int num = 1;
 IL_0001: ldc.i4.1
 IL_0002: stloc.0
 // int num2 = 2;
 IL_0003: ldc.i4.2
 IL_0004: stloc.1
 // bool flag = num == num2;
 IL_0005: ldloc.0
 IL_0006: ldloc.1
 IL_0007: ceq
 IL_0009: stloc.2
decimal num = 1m;
 decimal num2 = 2m;
 bool flag = num == num2;

 // The corresponding IL code is as follows, with deleted
 IL_0000: nop
 // decimal num = 1m;
 IL_0001: ldsfld valuetype [] []::One
 IL_0006: stloc.0
 // decimal num2 = 2m;
 IL_0007: 1
 IL_0009: ldc.i4.2
 IL_000a: call instance void []::.ctor(int32)
 // bool flag = num == num2;
 IL_000f: ldloc.0
 IL_0010: ldloc.1
 IL_0011: call bool []::op_Equality(valuetype [], valuetype [])
 IL_0016: stloc.2

For value types, if no overload==Operators are unavailable==​ Comparison. The following code cannot be compiled:

Person person1 = new Person();
Person person2 = new Person();

bool flag = person1 == person2;

struct Person
{
    public int Age { get; set; }
}

1.3 Reference Type

For reference types,==​ Determine whether the references returned by both are the same (provided that they are not overloaded==operator). The most typical one isstringType, its==Method determines whether the contents of two strings are the same and force it toobjectType is carried out again==​ When comparing, it will be converted into a reference comparison. Taking the following code as an example, it will output True and False in turn:

string value = "123";
string content1 = value + value;
string content2 = value + value;
(content1 == content2);
((object)content1 == (object)content2);

The abovestring​ Variable values ​​are determined at runtime, so their references are different. Look at the following code, it will output True and True in turn:

string value = "123";
string content1 = value;
string content2 = value;
(content1 == content2);
((object)content1 == (object)content2);

This is because of compile timestringThe value of the variable has been determined. In order to save memory, both are the same instance.

2. Equals()Example method

2.1 Equals()Writing guidelines and usage scenarios of

​Equals()​ Instance methods are often used in hash tables and other set types that require equality judgments, so they have stricter requirements for equality judgments. It follows the following guidelines:

  • Reflexive

    ​(x)It should betrue​。

  • symmetry

    ​(y)The return value of ​ and(x)​ Same.

  • Transitive

    ​(y)​、(z)​ Fortrue​, then(z)It should also betrue​

  • consistency

    As long as x and y are not modified,(y)The return values ​​of ​ should all be the same.

  • Non-empty

    ​(null)Should returnfalse​。

If the above guidelines are not strictly followed, then the work in the hash table will go wrong! Suppose we have the followingPersonclass, it overridesEquals()method, and always returns false, which makes it in insertionHashSet<T>After that, it cannot be found correctly. The following code will output False:

Person person = new Person
{
    Name = "John",
    Age = 20
};
HashSet<Person> set = new();
(person);
((person));

struct Person
{
    public string Name { get; set; }
    public int Age { get; set; }

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

The above areEquals()The main purpose of the method (I rarely see calls in business codeEquals()​ method), let's explain it belowEuqals()​Differences in value types and reference types.

2.1 Primitive Type

Primitive typeEquals()The method is called directly==​ operator, so its call and use==There is no difference between operators.

2.1.1 NaN equality judgment

Before learning the equality judgment of NaN, we will first answer a question: What is NaN?

NaN is the abbreviation for "Not a Number", which represents an undefined or undenoted value. It often occurs when floating point calculations are divisored to 0. NaN will be obtained by calculating the following:

(0.0 / 0.0);

NaN is very special, used==​ operators for judgment and useEquals()​ The judgment result is exactly the opposite! Taking the following code as an example, it will output False and True respectively

double value = 0.0 / 0.0;
(value == value);
((value));

This is because==​ More of it means "equality in mathematics". In mathematics, two NaNs cannot be equal in any case, sovalue == valueThe result is False. andEquals()Reflexivity must be supported, therefore(value)The result is True. Collections and dictionaries requireEquals()Keep this behavior, otherwise you will not be able to find the previously stored items.

We usually use()​ or()Method determines whether a value is NaN:

 ( (0.0 / 0.0));

Info

Please refer toChapter 2 C# Language Basics - hihaojie - Blog Park2.4.7 Special floating point values,Chapter 6 Framework Basics - hihaojie - Blog Park 6.11.2.6 Equalsand==When isn't the same

2.2 Value Type

Here we specifically refer to custom structures,Equals()The method is not overwritten.

Value typeEquals()The method is very special, its underlying layer will compare all fields equally by reflection! Take the following code as an example, even ifp1andp2Definition separately,Equals()​ The method can still determine that the two are equal.

Person p1 = new Person
{
    Name = "John",
    Age = 18
};
Person p2 = new Person
{
    Name = "John",
    Age = 18
};
((p2));

struct Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Equal judgment is completed by reflection, its performance will inevitably be limited, and the value type is in use()​ The method comparison will be packed. For this C# providesIEquatable<T>​ Interface.

2.2.1 IEquatable<T>Interface

Info

This content can be referencedChapter 4 Type Design Guidelines - hihaojie - Blog Park4.7 struct design,Chapter 8 Guidelines for Use - hihaojie - Blog Parkof 8.6IComparable<T>​ withIEquatable<T>​、8.9 Object

Value type implementationIEquatable<T>​ 2 problems can be avoided:

  1. Value type()The method will cause packing,
  2. ​()​ Reflection is used, and its default implementation is not efficient.

The interface is defined as follows:Equals()The method requires us to complete the equality judgment of members by ourselves:

public interface IEquatable<T>
{
    bool Equals(T? other);
}

Previous articlePerson​ Structure as an example, its implementation is as follows:

Person p1 = new Person
{
    Name = "John",
    Age = 18
};
Person p2 = new Person
{
    Name = "John",
    Age = 18
};
((p2));

class Person : IEquatable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }

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

    public bool Equals(Person? other)
    {
        if (other is null)
        {
            return false;
        }

        if (!())
        {
            return false;
        }
        if (Age != )
        {
            return false;
        }
        return true;
    }
}

2.3 Reference Type

For reference type (inEquals()Method,==If the operator is not overwritten),Equals()Methods and==​ The operator has the same meaning, and compare whether the references are the same.

andEqualsand==​ There are many reference types in different meanings, which are customized by developers.Equals()​ Implement equal comparison of values, but still make==Perform (default) reference equality comparison.StringBuilderThe class adopts this method, and the following code will output "False, True":

var sb1 = new StringBuilder ("foo");
var sb2 = new StringBuilder ("foo");
 (sb1 == sb2);
 ( (sb2));

Notice

​StringBuilderNot overwritten()​ Instance method, it just adds a new overloaded method. Therefore, the following two code execution results are different:

((sb2));
(((object)sb1).Equals(sb2));

Under what circumstances should the reference type be overriddenEquals()​ What about the method? "Frame Design Guide"Chapter 8 Guidelines for useSuggestions are given:

  • ​CONSIDER​: If the reference type represents a value, consider overwritingEquals()Method to provide value equal semantics.

    For example: Reference type that represents numerical values ​​and mathematical entities.

Info

For more content, please refer toChapter 6 Framework Basics - hihaojie - Blog Park 6.11.2.6 Equalsand==When isn't equivalent,Chapter 8 Guidelines for use 8.9.1

3. ()Static method

​()​ Static methods are mainly used to avoid "empty reference exceptions caused by null instances (NullReferenceException​)”. Its internal operations are as follows:

public static bool Equals (object objA, object objB)
    => objA == null ? objB == null :  (objB);

and()​ The instance method is different, and this static method accepts two parameters. It is often used==and!=​ Unusable scenarios, such as comparison of generic instances:

class Test<T>
{
    T _value;
    public void SetValue(T newValue)
    {
        if (!(newValue, _value))
        {
            _value = newValue;
            OnValueChanged();
        }
    }

    protected virtual void OnValueChanged() {}
}

The above code cannot be used==and!=​(Because the type is uncertain, it cannot be bound during compilation); for()​ Instance method, ifnewValuenull, it will be thrownNullReferenceExceptionException, so a static method is used here()​。

4. ()Method

We mentioned in 2.3 reference type:

andEqualsand==​ There are many reference types in different meanings, which are customized by developers.Equals()​ Implement equal comparison of values, but still make==Perform (default) reference equality comparison.StringBuilderThe class adopts this method, and the following code will output "False, True":

if==andEquals()​ All have been overloaded, and we need to judge whether the references are the same. What should we do?

There are 2 solutions:

  • Explicitly convert an instance toobject​ Use again==Make a comparison
  • pass()Static method comparison

We actually see()The code will find that the above two solutions are actually the same: both convert the instance toobject​ Use again==​ Make a comparison, just convert the instance toobject​ This step is omitted by passing parameters:

public static bool ReferenceEquals (Object objA, Object objB)
{
        return objA == objB;
}

The following code compares various comparison methods, and only the last two output statements are correctly referenced and compared:

var p1 = new Person
{
    Name = "John",
    Age = 18
};
var p2 = new Person
{
    Name = "John",
    Age = 18
};
(p1 == p2);
((p2));
(((object)p1).Equals(p2));
((p1, p2));
((object)p1 == (object)p2);
((p1, p2));

class Person : IEquatable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }
  
    public static bool operator ==(Person left, Person right)
    {
        return (right);
    }
  
    public static bool operator !=(Person left, Person right)
    {
        return !(left == right);
    }

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

    public bool Equals(Person? other)
    {
        if (other is null)
        {
            return false;
        }

        if (!())
        {
            return false;
        }
        if (Age != )
        {
            return false;
        }
        return true;
    }
}

5. EqualityComparer<T>.()Method

We show whether the two generic instance comparisons are equal in the use case code of 3. () static method:

class Test<T>
{
    T _value;
    public void SetValue(T newValue)
    {
        if (!(newValue, _value))
        {
            _value = newValue;
            OnValueChanged();
        }
    }

    protected virtual void OnValueChanged() {}
}

Although it implements functionality, it still has some performance losses: if T is a value type, use()​ Packing will occur during the comparison process!EqualityComparer<T>.()​ Methods came into being.

​EqualityComparer<T>.DefaultThe property will return a common equality comparator instead of staticMethod. It will check firstT​ Is it implementedIEquatable<T>, if implemented, the implementation class is called directly to avoid packing overhead.

Change the following code to useEqualityComparer<T>.()​, avoiding packing:

class Test<T>
{
    T _value;
    public void SetValue(T newValue)
    {
        if (!EqualityComparer<T>.(newValue, _value))
        {
            _value = newValue;
            OnValueChanged();
        }
    }

    protected virtual void OnValueChanged() { }
}

Info

For more content, please refer toChapter 7 Collection - hihaojie - Blog Garden 7.7.1 IEqualityComparerandEqualityComparer​

6. isOperator

​is​ There are three types of modes available for operators: constant mode, type mode, and var mode. Here we explain the equality comparison involved in constant patterns.

6.1 Constant Mode

When using is to compare equality with constants, there are two situations:

  • Integer expression: Use==Make a comparison
  • Other types: Use()​ Static methods are compared.

6.1.1 Integer expressions

Integer expressions will be converted to use==​ operators for comparison. Taking the following code as an example, the decompiled program can be seen that it actually uses==Make a comparison:

long x = 10L;
if (x is 10)
{
    ("x is 10");
}

long x = 10L;
if (x == 10)
{
    ("x is 10");
}

6.1.2 Other types

We can use is to determine whether the variable is null. At this time, the equal comparison is()Method:

  • Check if it isnull​, as shown in the following example:
if (input is null)
{
    return;
}

Convert expression withnull​ When matching, the compiler guarantees that the user overloaded==​ or!=​ operator.

  • Non-null checks can be performed using negative mode, as shown in the following example:
if (result is not null)
{
    (());
}

Question

Please think about the following code, what will be output? Which of the above situations meets the above situations?

Match(10L);

 static void Match(object input)
 {
     if (input is 10)
         ("input is 10 of integer type");
     else
         ("Input is not an integer type 10");
 }

The answer is the second one. Input10L​ value occurs when boxing, soinput is 10Actually called() The methods are relatively equal, obviously,(10L, 10)The result is False

6.2 List Mode

  • Starting with C#11, you can use the list pattern to match elements of a list or array. The following code checks for integer values ​​in the array that are in the expected position:
int[] empty = [];
int[] one = [1];
int[] odd = [1, 3, 5];
int[] even = [2, 4, 6];
int[] fib = [1, 1, 2, 3, 5];

(odd is [1, _, 2, ..]);   // false
(fib is [1, _, 2, ..]);   // true
(fib is [_, 1, 2, 3, ..]);     // true
(fib is [.., 1, 2, 3, _ ]);     // true
(even is [2, _, 6]);     // true
(even is [2, .., 6]);    // true
(odd is [.., 3, 5]); // true
(even is [.., 3, 5]); // false
(fib is [.., 3, 5]); // true

Info

For more content, please refer tois operator - Match expressions to types or constant patterns - C# reference | Microsoft Learn, "In-depth Understanding C#" Edition 4 12.4.1 Constant Mode,C# cold knowledge you don't know (second)_Bilibili_bilibili

7. IEqualityComparer<T>andEqualityComparer<T>​

When it comes to equality comparison, there will inevitably be a hash table. We also mentioned it beforeEquals()​ The importance of methods to hash tables. If you have observed it carefullyHashSet<T>andDictionary<TKey, TValue>​ construction method, you will find that they all receiveIEqualityComparer<T>​ The constructor of the interface instance:

public HashSet([Nullable(IEqualityComparer<T>)
public Dictionary(IEqualityComparer<TKey>)

From the principle of the hash table, we can know that when storing elements, the hash table passesGetHashCode()​ method obtains the hash value and stores the element in the corresponding position; when searching for elements, the hash table passesGetHashCode()The method gets the hash value, gets the element, and then calls itEquals()​ Method confirms whether it is the element to be searched.

Sometimes we need to use it if we want to customize the storage and search rules of hash tables.IEqualityComparer<T>​ Interface. The interface is defined as follows:

public interface IEqualityComparer<in T>
{
    bool Equals(T x, T y);
    int GetHashCode(T obj);
}

Next, let’s demonstrate the use of this interface. We assume thatPersonClass:

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

We hope onlyPerson​ ExampleNameandAge​ If the same is true, it is considered to be the same "person". The following code obviously does not meet the requirements, and it will output False:

HashSet<Person> set = new HashSet<Person>();
Person person1 = new Person
{
    Name = "John",
    Age = 18
};
(person1);

Person person2 = new Person
{
    Name = "John",
    Age = 18
};
((person2));

ifPerson​ is provided by a third-party library, and we cannot override itEquals()Methods andGetHashCode()Method, at this time we can customize a class and implement itIEqualityComparer<T>​ Interface:

class PersonEqualityComParer : IEqualityComparer<Person>
{
    public bool Equals(Person? x, Person? y)
    {
        if (x is null || y is null)
        {
            return false;
        }
        if ( != )
        {
            return false;
        }
        if ( != )
        {
            return false;
        }
        return true;
    }

    public int GetHashCode([DisallowNull] Person obj)
    {
        int hash = 17;
        hash = hash * 31 + ();
        hash = hash * 31 + ();
        return hash;
    }
}

WillPersonEqualityComParer​ The instance passes the HashSet constructor, and we can customize the matching method of the hash table, and the following code will output True:

HashSet<Person> set = new HashSet<Person>(new PersonEqualityComParer());
Person person1 = new Person
{
    Name = "John",
    Age = 18
};
(person1);

Person person2 = new Person
{
    Name = "John",
    Age = 18
};
((person2));

‍

A lot of the previous ones are aboutIEqualityComparer<T>Interface, thatEqualityComparer<T>​ What are you doing? This has to mention the non-generic versionIEqualityComparer​ Interface. If you've observedHashTable​ The collection type (it is non-generic), you will find that its constructor will be acceptableIEqualityComparerInterface instance:

public Hashtable(IEqualityComparer)

​IEqualityComparerInterface definition andIEqualityComparer<T>Highly similar:

public interface IEqualityComparer
{
    new bool Equals(object x, object y);
    int GetHashCode(object obj);
}

If we want to implement it earlierPersonEqualityComParer​It can be used for generic and non-generic hash tables at the same time. Both interfaces need to be implemented, which is obviously very troublesome. For this C# providesEqualityComparer<T>Abstract class, comparator only needs to be implemented onceEquals()Method, onceGetHashCode()​ Methods can be used in both generic and non-generic:

// Can be used for generic and non-generic hash tables at the same time:
 HashSet<Person> set = new HashSet<Person>(new PersonEqualityComParer());
 Hashtable table = new Hashtable(new PersonEqualityComParer());

 class PersonEqualityComParer : EqualityComparer<Person>
 {
     public override bool Equals(Person? x, Person? y)
     {
         if (x is null || y is null)
         {
             return false;
         }
         if ( != )
         {
             return false;
         }
         if ( != )
         {
             return false;
         }
         return true;
     }

     public override int GetHashCode([DisallowNull] Person obj)
     {
         int hash = 17;
         hash = hash * 31 + ();
         hash = hash * 31 + ();
         return hash;
     }
 }

8. Equal comparison of some special predefined types

8.1 Tuple(ValueTuple​）

Tuple usageEquals()Methods and usage==Operator comparisons are not the same. byValueTuple<T1, T2>​ For example, check its source code and you can find that itsEquals()Methods are calledEqualityComparer<T>.()​ Implement equality comparison:

public bool Equals(ValueTuple<T1, T2> other)
{
    return EqualityComparer<T1>.(Item1, other.Item1)
        && EqualityComparer<T2>.(Item2, other.Item2);
}

If you can't find it in the source code==​ Overloading of operators! But since C# 7.3, it can be used again==​、!=Operators make equality judgments.

This is because the compiler provides tuples for tuple types==and!=​ implementation. The compiler will==Operators extend to element level==​ Operation. It will be executed on each pair of element values==Operation (!=The same applies to operators). The code example is as follows:

var t1 = (x: "x", y: "y", z: 1); // No consideration when comparing
 var t2 = ("x", "y", 1); // Different elements

 (t1 == t2);
 (t1.Item1 == t2.Item1 && //
                   t1.Item2 == t2.Item2 && // Generated by the compiler
                   t1.Item3 == t2.Item3); // Equivalent code

 (t1 != t2);
 (t1.Item1 != t2.Item1 || //
                   t1.Item2 != t2.Item2 || // Compiler generated
                   t1.Item3 != t2.Item3); // Equivalent code

This also requires that the types in the tuple must be able to pass==​、!=​ Make a comparison, take the following code as an example, because the Person structure is not overloaded==​、!=​ operator, the following code compiler reported an error CS0019:

var tuple1 = (1, p1);
var tuple2 = (1, p2);
(tuple1 == tuple2);

struct Person
{
    public int Age;
    public string Name;
}

8.2 Anonymous Type

Anonymous types are essentially reference types, so they can be used==​ operators compare, which compares whether the references are equal. ItsEquals()The method will compare whether all elements are the same (byEqualityComparer<T>.()​ method), considering that it is commonly used in LINQ,Equals()​ It is very reasonable to compare whether all elements behave the same.

The premise for the same two anonymous type instances is: the same type, the same attribute name, and the same attribute order. Take the following code as an example, it will output True, False, False, False

var value1 = new { Name = "John", Age = 18 };
var value2 = new { Name = "John", Age = 18 };
var value3 = new { Age = 18, Name = "John" };
var value4 = new { Title = "John", Level = 18 };
((value2));
((value3));
((value4));
(value1 == value2);

Tips

Why it is said that "considering that anonymous types are often used in LINQ,Equals()​ It would be very reasonable to compare whether all elements behave the same”?

Taking the following code as an example, we use anonymous type to conduct connection queries based on multiple keys in a query, which uses anonymous typeEquals()Method:

from s in stringProps
join b in builderProps on new { ,  }
                   equals new { ,  }

9. Comparison of internal elements structured equality

For some types of data, we need to compare internal elements equally, such as arrays and tuples. This is available throughIStructuralEquatableInterfaceEquals()The method performs this operation. Arrays and tuples implement this interface. Here are two simple use cases that demonstrate the equality comparison of elements inside arrays and tuples:

int[] nums1 = [1, 2, 3, 4, 5];
int[] nums2 = [1, 2, 3, 4, 5];

((nums2));

IStructuralEquatable se = (IStructuralEquatable)nums1;
((nums2, EqualityComparer<int>.Default));

var t1 = (1, "foo");
var t2 = (1, "FOO");

IStructuralEquatable se1 = t1;
((t2, ));

Info

See moreChapter 7 Collection - hihaojie - Blog Garden7.7.4 IStructuralEquatable and IStructualComparable

References:

  1. "Framework Design Guide: Conventions, Conventions and Patterns for Building Reusable .NET Library" Third Edition
  2. "C# 7.0 Core Technology Guide"
  3. "In-depth Analysis of C#" Fourth Edition

Info

Some of the contents of the first two books can be found in my reading notesSummary of reading notes - hihaojie - Blog Park

‍

‍

<Previous Next>