通过implicit 和运算符重载想到一种坑爹的写法，专门对付强制==ture，或者强制不能带==true的。

我在这个帖子System.Convert 的一些事 的一个关于代码风格留言，发现还是有些争论的，我就想有没有办法让if (obj) 和 if (obj == ture)的行为不一样呢？我实验了一下，果然可以。

比如下面的代码

   
   

    
     1 
    
     
    
    static
    
     
    
    void
    
     Main(
    
    string
    
    [] args)

    
     2 
    
     {

    
     3 
    
     var confusedValue 
    
    =
    
     GetValue();

    
     4 
    
    

    
     5 
    
     
    
    if
    
     (confusedValue 
    
    ==
    
     
    
    true
    
    )

    
     6 
    
     {

    
     7 
    
     Console.WriteLine(
    
    "
    
    confusedObj == true
    
    "
    
    );

    
     8 
    
     }

    
     9 
    
    

    
    10 
    
     
    
    if
    
     (confusedValue)

    
    11 
    
     {

    
    12 
    
     Console.WriteLine(
    
    "
    
    隐式转换 confusedObj == true
    
    "
    
    );

    
    13 
    
     }

    
    14 
    
    

    
    15 
    
     
    
    if
    
     (
    
    !
    
    confusedValue)

    
    16 
    
     {

    
    17 
    
     Console.WriteLine(
    
    "
    
    隐式转换 confusedObj == false
    
    "
    
    );

    
    18 
    
     }

    
    19 
    
     }
   
   

直觉上，一定认为 if (confusedValue == true) 和 if (confusedValue) 是一样的，其实不然，实际运行的结果是：

 

这种效果是这样实现滴

    
    

     
      1 
     
      
     
     public
     
      
     
     class
     
      ConfusedClass

     
      2 
     
      {

     
      3 
     
      
     
     public
     
      
     
     static
     
      
     
     bool
     
      
     
     operator
     
      
     
     ==
     
      (ConfusedClass left, 
     
     bool
     
      right)

     
      4 
     
      {

     
      5 
     
      
     
     return
     
      right;

     
      6 
     
      }

     
      7 
     
     

     
      8 
     
      
     
     public
     
      
     
     static
     
      
     
     bool
     
      
     
     operator
     
      
     
     !=
     
     (ConfusedClass left, 
     
     bool
     
      right)

     
      9 
     
      {

     
     10 
     
      
     
     return
     
      
     
     !
     
     right;

     
     11 
     
      }

     
     12 
     
     

     
     13 
     
      
     
     public
     
      
     
     static
     
      
     
     implicit
     
      
     
     operator
     
      
     
     bool
     
     (ConfusedClass obj) 

     
     14 
     
      {

     
     15 
     
      
     
     return
     
      
     
     false
     
     ;

     
     16 
     
      }

     
     17 
     
     

     
     18 
     
      
     
     public
     
      
     
     override
     
      
     
     bool
     
      Equals(
     
     object
     
      obj)

     
     19 
     
      {

     
     20 
     
      
     
     return
     
      
     
     base
     
     .Equals(obj);

     
     21 
     
      }

     
     22 
     
      }
    
    

 

我简单的解释一下这个类，首先我重载了运算符==和!=，这样在confusedValue == true的时候，其实是执行了第四3行~6行的函数。

然后，我又用了implicit关键字，implicit关键字用于声明隐式的用户定义类型转换运算符，这样，当ConfusedClass的实例隐身转换为bool的时候，无论如何都返回false了。

如果想要捣乱的话，这样倒是一种方法。比如原来if (confusedValue)是正常的，但是你的项目经理规定了代码风格必须是if (confusedValue ==  true)的，你就可以设置一个陷阱，如果别人把你的代码或用你的类的时候用了if (confusedValue ==  true)的写法，就是相反的。反之亦然。

最后，我不鼓励捣乱的哈，如果然让我rewiew代码，碰到坑爹类型隐式转换，肯定要求删掉，不过implicit关键字的确是很少见啦。