Hello there,

Why is it that I sometimes see this construct

//case 1
if ( null == myVariable)
{
//...etc
}


//case 2
if ( myVariable == null)
{
//...etc
}

Basically, what is the difference between the two?

To my knowledge, there is no difference.

I was taught to use the if(null == myVariable) method because a mistake
like using a = instead of == will be caught at compile time instead of
runtime.

--
Message posted via http://www.dotnetmonster.com

It makes no difference, they are the same. The syntax is common for people
that have been programing in C/C++ for many years.

In C/C++ it is legal to write (single '=');

if(myVariable = null)
{
}

If you switch them around, it causes a compilation error because you cannot
assign a value to null.

if(null = myVariable)
{
}

Chris

<(E-Mail Removed)> wrote in message
news:(E-Mail Removed)...
> Hello there,
>
> Why is it that I sometimes see this construct
>
> //case 1
> if ( null == myVariable)
> {
> //...etc
> }
>
>
> //case 2
> if ( myVariable == null)
> {
> //...etc
> }
>
> Basically, what is the difference between the two?
>

Scott Klueppel via DotNetMonster.com <(E-Mail Removed)> wrote:
> To my knowledge, there is no difference.
>
> I was taught to use the if(null == myVariable) method because a mistake
> like using a = instead of == will be caught at compile time instead of
> runtime.

Both of them will be caught at compile-time with C# though. There's no
reason to use this unnatural ordering in C#.

--
Jon Skeet - <(E-Mail Removed)>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

I swear I saw a code doing like that ( case 1 and case 2) in one method
and throwing difference exception for each. That's why I wanted to
know.

Juanph31

I swear I saw a code doing like that ( case 1 and case 2) in one method
and throwing difference exception for each. That's why I wanted to
know.

Juanph31

I don't think that

if(null == MyValue)
{
....
}

is a good habit to get into. I personally have not seen code like that in
any real world projects, but feel it would not be a proper coding standard
even if it makes no difference with comparison operators. And that would go
for any language IMHO.

Bob Calvanese
<(E-Mail Removed)> wrote in message
news:(E-Mail Removed)...
> Hello there,
>
> Why is it that I sometimes see this construct
>
> //case 1
> if ( null == myVariable)
> {
> //...etc
> }
>
>
> //case 2
> if ( myVariable == null)
> {
> //...etc
> }
>
> Basically, what is the difference between the two?
>

juanph31 <(E-Mail Removed)> wrote:
> I swear I saw a code doing like that ( case 1 and case 2) in one method
> and throwing difference exception for each. That's why I wanted to
> know.

Well, if you could show that code, I'd be interested to see it.
Admittedly there could be a difference if someone had overloaded the ==
operator and done it badly, but that's a bug in their operator
overloading rather than a feature of the language.

--
Jon Skeet - <(E-Mail Removed)>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

Hi All,

I think that a "key" is operator overloading.
Like a Jon post it before.

MyClass myVar;

if( null==myVar ) {
}
Doesn't have a chance to fire MyClass "==" operator function.

Marcin

> juanph31 <(E-Mail Removed)> wrote:
>
>>I swear I saw a code doing like that ( case 1 and case 2) in one method
>>and throwing difference exception for each. That's why I wanted to
>>know.
>
>
> Well, if you could show that code, I'd be interested to see it.
> Admittedly there could be a difference if someone had overloaded the ==
> operator and done it badly, but that's a bug in their operator
> overloading rather than a feature of the language.
>

Marcin Grz?bski <(E-Mail Removed)> wrote:
> I think that a "key" is operator overloading.
> Like a Jon post it before.
>
> MyClass myVar;
>
> if( null==myVar ) {
> }
> Doesn't have a chance to fire MyClass "==" operator function.

Yes it does. Compile and run the following, ignoring the warnings:

using System;
using System.Data;

class Test
{
static void Main()
{
Test t = new Test();
Console.WriteLine (t==null);
Console.WriteLine (null==t);
}

public static bool operator == (Test t1, Test t2)
{
Console.WriteLine ("Operator== called");
Console.WriteLine ("t1={0}", t1);
Console.WriteLine ("t2={0}", t2);
return true;
}

public static bool operator!= (Test t1, Test t2)
{
return false;
}
}

The output is:
Operator== called
t1=Test
t2=
True
Operator== called
t1=
t2=Test
True

In other words, the overloaded operator is called both times.

--
Jon Skeet - <(E-Mail Removed)>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too