Why is concept of equals and operator== implemented this way?

[cody]

Why can I overload operator== and operator!= separately having different
implementations and additionally I can override equals() also having a
different implementation.

Why not forbid overloading of == and != but instead translate each call
of objA==objB automatically in System.Object.E quals(objA, objB).

This would remove inconsistencies like

myString1==mySt ring2

and

(object)myStrin g1==(object)myS tring2

having different results.

also, should operator!= not always return the negated value of!=?
So why is it good for?

I would like to understand the technical reason for that, if there was any.

[cody]

Barry Kelly wrote:

cody <de********@gmx .de> wrote:

2. Even with reference types, you're overriding a method that takes
object parameters, so your own Equals override will have to perform
cumbersome type checking on the supplied objects.

Sure it will have to, but honestly how often do you use == for objects
that are *no* value types and *no* strings (which are sealed) both
require no type checks. In collection methods like IndexOf the non-type
safe version of Equals is used and type checks have to be performed anyway.

Referential equality for mutable types has completely different
semantics from value equality, which is used for strings. With the
greatest respect, I use referential equality far, far, far more often
than value equality.

Taking something out of thin air:

Foo f = new Foo();
Foo f2 = new Foo();
Console.WriteLi ne(f == f2);

How often, in your programs, do you require this to print "True" on the
console? Speaking for myself, almost *never*.

For most other cases you want reference equality anyway for which an
operator=== could be used.

Here, it seems to me, you are introducing a new operator in order to do
what most people already use '==' for.

Which IMO is bad style. You never know whether the given objects have an
overloaded operator or not, maybe one is added later which will change
semantics of your code. Currently you will have to use
Object.Referenc eEquals or (object)obj1==( object)obj2 to ensure reference
equality is done.

And as I said, nobody prevents you from implementing a strongly typed
version of Equals which will then be picked by the compiler and here
also is no type check necessary.

But: this is advocating making an expensive boxing operation the
default. That approach might be more reasonable in a more dynamic
language like Lisp or Python, but it isn't right in a language with a
C-based history.

Microsoft recommends in the newer guidelines to always add a strongly
typed Equals to classes anyway.

The current implementation of operator overloading doesn't allow generic
code making use of them since static methods like operators are, cannot
be specified in interfaces.

public T Add<T>(T a, T b)
where a,b : IAddable<T> // interface may implement + and -
{
return a+b; // internally calls a.Add(b)
}

This way, users can make interfaces which implements the operators they
need for specific operations. In languages like C++, D (Digital Mars),
Python and Ruby are also normal methods (C++ also allows static ones for
operators).

[Jon Skeet [C# MVP]]

Mark Wilden <Ma********@new sgroups.nospam> wrote:

Referential equality for mutable types has completely different
semantics from value equality, which is used for strings.

Hmmm...I thought all identical strings were folded to the same reference. Or
am I thinking of a completely different language?

That's interning you're thinking of, and while it automatically applies
to string *literals* it certainly doesn't apply to strings in general.
For instance:

using System;

class Test
{
static void Main()
{
string x = "hello".Substri ng (0, 1);
string y = "hi".Substr ing (0, 1);
Console.WriteLi ne (x==y);
Console.WriteLi ne (object.Referen ceEquals(x, y));
}
}

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Mark Wilden]

"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@msnews.micros oft.com...

That's interning you're thinking of, and while it automatically applies
to string *literals* it certainly doesn't apply to strings in general.

Thanks. I knew I was thinking of something...