zero-length string == nothing ??

Much as I love your ad-hom attacks and referring to my good-intentioned posts as something that people either learn in .NET day 1 or referring to it as a twitch, it would help if you checked you were right before attacking my posts.

You arn't:

        class ComplexNumber
        {
            public int RealPart {get; set;}
            public int ImaginaryPart {get; set;}

            public static bool operator ==(ComplexNumber a, ComplexNumber b)
            {
                Console.WriteLine("A method call happened. Note that this takes much longer than a reference check");

                return (a.RealPart == b.RealPart) && (a.ImaginaryPart == b.ImaginaryPart);
            }
            public static bool operator !=(ComplexNumber a, ComplexNumber b)
            {
                return !(a == b);
            }
        }

        static void Main(string[] args)
        {
            ComplexNumber cmplx = null;

            Console.WriteLine("Let's check shall we?");
            try
            {
                Console.WriteLine("Console.WriteLine( cmplx == null ) yields ...");
                Console.WriteLine(cmplx == null);
            }catch(Exception e){
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("Threw exception: " + e);
                Console.ForegroundColor = ConsoleColor.Gray;
            }

            Console.WriteLine();
            try
            {
                Console.WriteLine("Console.WriteLine( (object)cmplx == null ) yields ...");
                Console.WriteLine((object)cmplx == null);
            }
            catch (Exception e)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("Threw exception: " + e);
                Console.ForegroundColor = ConsoleColor.Gray;
            }

            Console.WriteLine("Press [ENTER] to exit");
            Console.ReadLine();

        }


Prints:

Let's check shall we?
Console.WriteLine( cmplx == null ) yields ...
A method call just happened. Note that this takes much longer than a reference check
Threw exception: System.NullReferenceException: Object reference not set to an instance of an object.

Console.WriteLine( (object)cmplx == null ) yields ...
True
Press [ENTER] to exit



That's the whole point of my past post is that Microsoft do cast to object before the == in order to produce il of the form:

ldarg.0
brfalse (dst)

rather than

ldarg.0
call System.String.op_eq
brfalse (dst)



I'd prefer it if you made constructive critisism in future rather than attacking my style or motives. Thanks.

You are no doubt aware that strings overload == operator themselves, and thus my argument is not arbitrary as you suppose ....

You code can be simplied slightly to

public static bool operator ==(ComplexNumber a, ComplexNumber b)
{
  if( (object) a == null)
    // then they are equivilent only if both are null
    return (object) b == null;
  if( (object)b == null)
    // then since a is non-null, they are different
    return false;

    return (a.RealPart == b.RealPart) && (a.ImaginaryPart ==     b.ImaginaryPart);
}

And dropping the (object) downcasts as you mention causes a stack-overflow. Thanks for helping me clarify my point.

As a side-point (which is where this all started) if a class overloads the == operator, such as the System.String class, then == null diverts through that method, thus causing a method call. If you cast-down to an object the compiler just checks that the object reference isn't null in place, which speeds things up a bit.

That's interesting, and I concede that for string the Microsoft C# compiler appears to optimise away the superfluous call to the string equality, which is pretty clever.

That said, selecting pretty much any other class that overloads operator ==, my original contention holds

for example:

    class Program
    {
        static Version foo;

        static void Main(string[] args)
        {
            Console.WriteLine((object)foo == null);
        }
    }

compiles to

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       16 (0x10)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  ldsfld     class [mscorlib]System.Version ConsoleApplication1.Program::foo
  IL_0006:  ldnull
  IL_0007:  ceq
  IL_0009:  call       void [mscorlib]System.Console::WriteLine(bool)
  IL_000e:  nop
  IL_000f:  ret
} // end of method Program::Main

whereas

    class Program
    {
        static Version foo;

        static void Main(string[] args)
        {
            Console.WriteLine(foo == null);
        }
    }

compiles to

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       19 (0x13)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  ldsfld     class [mscorlib]System.Version ConsoleApplication1.Program::foo
  IL_0006:  ldnull
  IL_0007:  call       bool [mscorlib]System.Version::op_Equality(class [mscorlib]System.Version,
                                                                  class [mscorlib]System.Version)
  IL_000c:  call       void [mscorlib]System.Console::WriteLine(bool)
  IL_0011:  nop
  IL_0012:  ret
} // end of method Program::Main



But with strings, comparison to null does not require down-casting to object to get any speedup., so yes, you're right in this instance.