C＃中两个对象的等式比较

Question

This is a Fundamental type question, forgive me for being so amateurish.

Case 1:

Employee _emp1 = new Employee();
Employee _emp2 = _emp1;
_emp1.Equals(_emp2) ==> RETURNS a True !!

Case2:

Employee _emp1 = new Employee();
Employee _emp2 = new Employee();
_emp1.Equals(_emp2) ==> RETURNS a False !!

Could you explain me the above Comparison method and reason interms of Memory-Mapping and allocation perspective ?

Answer 1

Simply speaking, the default comparator compares object instances.

• In your first example, both _emp1 and _emp2 are pointing to the same instance of Employee and therefore Equals returns true.

• In your second example, you create two Employee objects, _emp1 and _emp2 being two distinctly different objects. Therefore, Equals returns false.

---

Note that copy constructors are not implicitly called for reference types. Were you to do:

Employee _emp1 = new Employee();
Employee _emp2 = new Employee(_emp1); //or _emp1.Clone() if that is implemented

then Equals using a the default comparator will return false since they are two unique objects.

Also note that this behavior is not the same for value types.

---

Furthermore, if you (as you should) override the default behavior of Equals and CompareTo , all the above becomes moot. A standard technique might be (assuming a little bit):

public bool Equals(object rhs)
{
    var rhsEmployee = rhs as Employee;
    if(rhsEmployee == null) return false;

    return this.Equals(rhsEmployee);
}

public bool Equals(Employee rhs)
{
     return this.EmployeeId == rhs.EmployeeId;
}

---

Further reading:

• Object.Equals
• Object.ReferenceEquals
• Value Types and Reference Types

Answer 2

Employee _emp1 = new Employee();

Everytime you have new Employee() you have new memory allocated in heap and stack.

means _emp1 is value in memory pointing to heap say 1212.

Now you have second statement

Employee _emp2 = new Employee();

So again new value _emp2 say 1414 in heap.

That's why _emp1.Equals(_emp2) returns false here.

when you say

_emp1 = _emp2

You are assigning the same values in both.

Answer 3

"This apple belongs to Joe. This pear belongs to the same man. Is this apple's owner the same person as this pear's owner? Yes."

"This apple belongs to Susan. This pear belongs to Susan. Is this apple's owner the same person as this pear's owner? No, they just happen to both be called Susan."

Answer 4

You should create your own Equals method. By default Equals is called from Object class, which is basically check if these two references points to one object (ie Object.ReferenceEqual(object, object) is called)

Answer 5

Employee , does not implement it's own .Equals() method, then it is using Object.Equals() , which is only comparing the references. In case 1, your two references are made equal when assigning.

If you want to compare the Employee objects by their internal properties, you should implement your own .Equals() method that returns true if all those properties values match, and false otherwise.

Answer 6

There is no way of equating the two seperate instances of employee, you need a way of equating whether they are equal because they are seperate instances. In case one, the instances are the same and _emp2 is _emp1 You can do this by implementing the IEquatable<T> interface.

public class Employee : IEquatable<Employee>
{
  public int Id { get; set; }

  public bool Equals(Employee other)
  {
    return other.Id == Id;
  } 
}

You can then do this

Employee e = new Employee() { Id = 1 };
Employee e2 = new Employee() { Id = 1 };
//Returns true
bool b = e.Equals(e2);

Answer 7

When you write Employee _emp1 you are allocating the memory which is needed to store a pointer to another piece of memory that will contain an instance of Employee.

new Employee(); allocates a new piece of memory filling it with an instance of Employee and return you the address of this memory (the pointer). Something like, let's say, 1234567. So after Executing Employee _emp1 = new Employee(); , you have _emp1 equal to 1234567, and the memory pointed by 1234567 containing your Employee.

Then you execute Employee _emp2 = _emp1; , and the result is having another piece of memory able to contain an address to a piece of memory containing an instance of Employee ( _emp2 ) which is equal to 1234567, too. This meand that when you execute _emp1.Equals(_emp2) the result is true, since both of your vars point to the same piece of memory.

In the second case, another instance of Employee is created and put in a different piece of memory (eg something like 7654321) and this address is assigned to _emp2 that hence is different from _emp1 .