implicit 关键字

用于声明隐式的用户定义类型转换运算符。它可以实现2个不同类的隐式转换 ，提高代码的可读性。但是需要注意使用隐式转换操作符之后，在编译时会跳过异常检查，所以隐式转换运算符应当从不引发异常并且从不丢失信息，否则在运行时会出现一些意想不到的问题。
案例1如下:

class Program
    {
        static void Main(string[] args)
        {
            MyBool myBool = new MyBool();
            myBool.Init();
            if (myBool)
            {
                Console.WriteLine("true");
            }
            else
            {
                Console.WriteLine("false");
            }

            Console.ReadKey();   
        }
        
        public class MyBool 
        {
            public bool isExist = false;
            public void Init()
            {
                isExist = true;
            }

            public void Dispose()
            {
                isExist = false;
            }

            public static implicit operator bool(MyBool myBool)
            {
                if (myBool == null)
                    return false;
                return myBool.isExist;
            }

        }
    }    

图中定义一个类MyBool
并在类中使用了implicit关键字讲将MyBool转换成bool
这样在判断类是否为空的时候可以使用if(MyBool)的方式
并且可以在隐式转换函数中添加自己的条件
比如图中加入了isExist的布尔变量,Init的时候设置true,Dispose设置为false
这样在if(MyBool)的时候 就可以知道该对象有没有调用过Init的函数了
既减少了代码量也可以保证对象能够使用

案例2如下:

class Program
{
    static void Main(string[] args)
    {
        OtherClass otherClass = new OtherClass();
        otherClass.value = 1.5f;
        MyClass myClass = otherClass;
        Console.WriteLine(myClass.value);

        Console.ReadKey();
    }

    public class MyClass
    {
        public int value;

        public static implicit operator MyClass(OtherClass otherClass)
        {
            MyClass myClass = new MyClass();
            myClass.value = (int)Math.Round(otherClass.value);
            return myClass;
        }

        public static implicit operator OtherClass(MyClass myClass)
        {
            OtherClass otherClass = new OtherClass();
            otherClass.value = myClass.value;
            return otherClass;
        }

    }

    public class OtherClass
    {
        public float value;
    }
}

图中定义了MyClass和OtherClass 并且使用了关键字讲两个类互相进行了隐式转换,这样 假如我们把OtherClass 看成别人的类库里面的类 那样假如 我们要封装别人的类的话 除了继承外 还可以使用这种方式 ，这样优化代码量 并且继承的方式 可能会造成你这个类中有很多函数用不到而浪费 而这样写 可以自己封装一下你要用到的函数等