operator would be used, in an object sense, to see if the two objects were actually the same object. This operator looks at the actually memory address to see if it actually the same object.
The equals() method is used to compare the values of the object respectively. This is used in a higher level to see if the object values are equal. Of course the the equals() method would be overloaded in a meaningful way for whatever object that you were working with. char[] test = {'t','e','s','t'};
string x = "test";
string y = new string (test);
object ox=x;
object oy=y;
Console.WriteLine(x== y);
Console .WriteLine(ox==oy);
Console .WriteLine(x.Equals(y));
Cons ole.WriteLine(ox.Equals(oy));
When you run this application, you will notice that the first about is true, but the second one is false. but more confusing that third and the fourth statements are both true.

Answered by Raksha , an ibibo Master, at 9:10 AM on June 27, 2008

hello radhe Hi,

The difference between == and object.Equals are given below-

For value types, == and Equals() usually compare two objects by value. For example:

int x = 10;
int y = 10;
Console.WriteLine( x == y );
Console.WriteLine( x.Equals(y) );

will display:

True
True

Howe ver things are more complex for reference types.

Generally speaking, for reference types == is expected to perform an identity comparison, i.e. it will only return true if both references point to the same object. By contrast, Equals() is expected to perform a value comparison,

i.e. it will return true if the references point to objects that are equivalent. For example:

StringBuilder s1 = new StringBuilder("fred");
String Build er s2 = new StringBuilder("fred");
Consol e.Wri teLine( s1 == s2 );
Console.WriteLine( s1.Equals(s2) );

will display:

False
True

s1 and s2 are different objects (hence == returns false), but they are equivalent (hence Equals() returns true).

Unfortunately there are exceptions to these rules. The implementation of Equals() in System.

Object (the one you'll inherit by default if you write a class) compares identity, i.e. it's the same as operator==. So Equals() only tests for equivalence if the class author overrides the method (and implements it correctly).

Another exception is the string class - its operator== compares value rather than identity.

Bottom line: If you want to perform an identity comparison use the ReferenceEquals() method.

If you want to perform a value comparison, use Equals() but be aware that it will only work if the type has overridden the default implementation.

Avoid operator== with reference types (except perhaps strings), as it's simply too ambiguous.

Answered by raj u , an ibibo Master, at 1:06 PM on June 04, 2008

operator would be used, in an object sense, to see if the two objects were actually the same object. This operator looks at the actually memory address to see if it actually the same object.
The equals() method is used to compare the values of the object respectively. This is used in a higher level to see if the object values are equal. Of course the the equals() method would be overloaded in a meaningful way for whatever object that you were working with. char[] test = {'t','e','s','t'};
string x = "test";
string y = new string (test);
object ox=x;
object oy=y;
Console.WriteLine(x== y);
Console .WriteLine(ox==oy);
Console .WriteLine(x.Equals(y));
Cons ole.WriteLine(ox.Equals(oy));
When you run this application, you will notice that the first about is true, but the second one is false. but more confusing that third and the fourth statements are both true.

Answered by Romi , an ibibo Master, at 6:26 PM on June 03, 2008

Hi,

The difference between == and object.Equals are given below-

For value types, == and Equals() usually compare two objects by value. For example:

int x = 10;
int y = 10;
Console.WriteLine( x == y );
Console.WriteLine( x.Equals(y) );

will display:

True
True

However things are more complex for reference types.

Generally speaking, for reference types == is expected to perform an identity comparison, i.e. it will only return true if both references point to the same object. By contrast, Equals() is expected to perform a value comparison,

i.e. it will return true if the references point to objects that are equivalent. For example:

StringBuilder s1 = new StringBuilder("fred");
StringBuild er s2 = new StringBuilder("fred");
Console.Wri teLine( s1 == s2 );
Console.WriteLine( s1.Equals(s2) );

will display:

False
True

s1 and s2 are different objects (hence == returns false), but they are equivalent (hence Equals() returns true).

Unfortunately there are exceptions to these rules. The implementation of Equals() in System.

Object (the one you'll inherit by default if you write a class) compares identity, i.e. it's the same as operator==. So Equals() only tests for equivalence if the class author overrides the method (and implements it correctly).

Another exception is the string class - its operator== compares value rather than identity.

Bottom line: If you want to perform an identity comparison use the ReferenceEquals() method.

If you want to perform a value comparison, use Equals() but be aware that it will only work if the type has overridden the default implementation.

Avoid operator== with reference types (except perhaps strings), as it's simply too ambiguous.

Answered by Ajay Pal , an ibibo Master, at 2:51 PM on June 02, 2008

well, This is a common question, and I am sure that many of you confused about which one to use. Actually someday you can run into a big trouble by using them wrong.

Let’s take a simple example to demonstrate the behaviors of two comparisons.


char[] test = {'t','e','s','t'};
string x = "test";
string y = new string (test);

object ox=x;
object oy=y;

Console.WriteLine(x== y);
Console .WriteLine(ox==oy);

Console .WriteLine(x.Equals(y));
Cons ole.WriteLine(ox.Equals(oy));


When you run this application, you will notice that the first about is true, but the second one is false. but more confusing that third and the fourth statements are both true.

But what about third and the fourth, why == operator states false but Equals method states true. The answer is "Operators are not applied polymorphically, methods are." As ox and oy are objects holding strings, running Equals method on both, actually runs Equals method on strings.

Answered by Saurabh , an ibibo Master, at 8:54 AM on June 02, 2008

operator would be used, in an object sense, to see if the two objects were actually the same object. This operator looks at the actually memory address to see if it actually the same object.
The equals() method is used to compare the values of the object respectively. This is used in a higher level to see if the object values are equal. Of course the the equals() method would be overloaded in a meaningful way for whatever object that you were working with. char[] test = {'t','e','s','t'};
string x = "test";
string y = new string (test);
object ox=x;
object oy=y;
Console.WriteLine(x== y);
Console .WriteLine(ox==oy);
Console .WriteLine(x.Equals(y));
Cons ole.WriteLine(ox.Equals(oy));
When you run this application, you will notice that the first about is true, but the second one is false. but more confusing that third and the fourth statements are both true.

Answered by Ram Singh , an ibibo Master, at 6:58 AM on June 02, 2008

operator would be used, in an object sense, to see if the two objects were actually the same object. This operator looks at the actually memory address to see if it actually the same object.
The equals() method is used to compare the values of the object respectively. This is used in a higher level to see if the object values are equal. Of course the the equals() method would be overloaded in a meaningful way for whatever object that you were working with. char[] test = {'t','e','s','t'};
string x = "test";
string y = new string (test);
object ox=x;
object oy=y;
Console.WriteLine(x== y);
Console .WriteLine(ox==oy);
Console .WriteLine(x.Equals(y));
Cons ole.WriteLine(ox.Equals(oy));
When you run this application, you will notice that the first about is true, but the second one is false. but more confusing that third and the fourth statements are both true.

Answered by Anju Singh , an ibibo Master, at 6:09 AM on June 02, 2008

well Radhe, operator would be used, in an object sense, to see if the two objects were actually the same object. This operator looks at the actually memory address to see if it actually the same object.

The equals() method is used to compare the values of the object respectively. This is used in a higher level to see if the object values are equal. Of course the the equals() method would be overloaded in a meaningful way for whatever object that you were working with. char[] test = {'t','e','s','t'};
string x = "test";
string y = new string (test);

object ox=x;
object oy=y;

Console.WriteLine(x== y);
Console .WriteLine(ox==oy);

Console .WriteLine(x.Equals(y));
Cons ole.WriteLine(ox.Equals(oy));


When you run this application, you will notice that the first about is true, but the second one is false. but more confusing that third and the fourth statements are both true.

Answered by satyaiitk , an ibibo Master, at 7:38 PM on June 01, 2008

This is a common question, and I am sure that many of you confused about which one to use. Actually someday you can run into a big trouble by using them wrong.

Let’s take a simple example to demonstrate the behaviors of two comparisons.


char[] test = {'t','e','s','t'};
string x = "test";
string y = new string (test);

object ox=x;
object oy=y;

Console.WriteLine(x==y);
Console .WriteLine(ox==oy);

Console.WriteLine(x.Equals(y));
Console.WriteLine(ox.Equals(oy));


When you run this application, you will notice that the first about is true, but the second one is false. but more confusing that third and the fourth statements are both true.

Ok let's see the trick in this. == operator on strings, compares strings by content. But == operator on objects just checks if the objects are same. So the first statement is true because both strings contain "test" as content, and the second one is false, because they are not the same object at all.

But what about third and the fourth, why == operator states false but Equals method states true. The answer is "Operators are not applied polymorphically, methods are." As ox and oy are objects holding strings, running Equals method on both, actually runs Equals method on strings.
Let's see objects Equals definition from dotnet framework.


public static bool Equals(object objA, object objB)
{
if (objA == objB)
{
return true;
}
if ((objA != null) && (objB != null))
{
return objA.Equals(objB);
}
return false;
}


As we see if both objects are not reference equal, then objects are compared with their type in mind.
Hope this helps a little to clarify difference between == operator and Equals method.

Answered by Mohd Farooq , an ibibo Master, at 6:34 PM on June 01, 2008

The == operator returns true if the two handles on the left and right sides refer to the same location in memory.

The function Object.equals() is intended to return true if two handles refer to logically equivalent instances.

Answered by chandragiris , an ibibo Citizen, at 8:35 PM on May 31, 2008