Implicit conversion and operator overloading

[charlee strong]

I'm seeing some strange behaviour:
i have a managed wrapper class that wraps around unmanaged object, i want to
convert back and forth between managed and unmanaged object, so i have
overloaded conversion operators.

namespace ManagedWorld{
ref class ManagedFoo{
private:
Unmanaged::Foo* pFoo;
public:
ManagedFoo(Unma naged::Foo * p) : pFoo(p) {};
Unmanaged::Foo* GetInternalObje ct() { return pFoo; }
static operator Unmanaged::Foo* (ManagedFoo^ rfoo){
return rfoo->GetInternalObj ect();
}
static operator ManagedFoo^(Unm anaged::Foo *p){
return gcnew ManagedFoo( p );
}
}
}// managed world namespace.

Using this unmanaged class from C#.

ManagedFoo^ myfoo = nullptr;
if( myfoo == nullptr ) // Line 2
Console.WriteLi ne("it is nullptr");
if( nullptr == myfoo)
Console.WriteLi ne("this works fine");

In Line 2, it does implicit conversion, then it calls this function
static operator Unmanaged::Foo* (ManagedFoo^ rfoo){
return rfoo->GetInternalObj ect();
}

I want to know why it does implicit conversion on handles before comparing?

Thanks
Charles