c# implicit - CSDN
  • C# implicit关键字的用法

    千次阅读 2016-09-02 14:37:06
    implicit 关键字用于声明隐式的用户定义类型转换运算符。如果可以确保转换过程不会造成数据丢失,则可使用该关键字在用户定义类型和其他类型之间进行隐式转换。隐式转换可以通过消除不必要的类型转换来提高源代码的...

    implicit 关键字用于声明隐式的用户定义类型转换运算符。如果可以确保转换过程不会造成数据丢失,则可使用该关键字在用户定义类型和其他类型之间进行隐式转换。隐式转换可以通过消除不必要的类型转换来提高源代码的可读性。 但是,因为隐式转换不需要程序员将一种类型显式强制转换为另一种类型,所以使用隐式转换时必须格外小心,以免出现意外结果。 一般情况下,隐式转换运算符应当从不引发异常并且从不丢失信息,以便可以在程序员不知晓的情况下安全使用它们。 如果转换运算符不能满足那些条件,则应将其标记为 explicit。

    举个例子

            class A
            {
                public A(float f)
                {
                    p = f;
                }
                public float p { get; }
    
                public static implicit operator A(float f)
                {
                    return new A(f);
                }
    
                public static implicit operator float(A a)
                {
                    return a.p;
                }
            }

                //初始化构造函数
                A a = new A(100.12345f);
                //把a对象赋值给f,其实这个时候float已经被重载运算了所以不会报错
                float f = a;
                //把30赋值给a2对象的时候,A类已被重载了
                A a2 = 30;
                richTextBox1.Text += "f是:" + f + "\n";
                richTextBox1.Text += "a2.p是:" + a2.p + "\n";


    得到的结果是

    f是:100.1235
    a2.p是:30

    总结:连续介绍了三个关键字operator搭配implicit和explicit,重载运算,类型转换的过程当中都离不开static,explicit需要强制转换而implicit隐试转换类型。

    展开全文
  • C#之自定义的implicit和explicit转换

    千次阅读 2014-07-23 10:03:48
    在类型转换时常会遇到隐式转换和显式转换。那我们自定义的类型要如何去定义隐式转换和显式转换?我们来看一段代码 public class Rational { private Int32 _inner_int = 0; public Rational() ...

    在类型转换时常会遇到隐式转换和显式转换。那我们自定义的类型要如何去定义隐式转换和显式转换?我们来看一段代码

    public class Rational
        {
            private Int32 _inner_int = 0;
    
            public Rational()
            {
    
            }
    
            public Rational(Int32 num)
            {
                this._inner_int = num;
            }
    
    
            public Int32 ToInt32() { return this._inner_int; }
    
            // Implicitly constructs and returns a Rational from an Int32 
            public static implicit operator Rational(Int32 num)
            {
                return new Rational(num);
            }
    
            // Explicitly returns an Int32 from a Rational 
            public static explicit operator Int32(Rational r)
            {
                return r.ToInt32();
            }
    
            public override string ToString()
            {
                //return base.ToString();
                String s = String.Format("{0}", this._inner_int);
                return s;
            }
        }

    测试代码

      class Program
        {
            static void Main(string[] args)
            {
                Rational r1 = 10;          
                Console.WriteLine(r1);       
    
                Int32 i = r1;     
                Console.WriteLine(i);       
                Console.ReadLine();
            }
        }
    这时编辑会报错,见下图

    从提示可以看到,是因为Int32 i=r1时缺少了显式转换。现在我们添加显示转换,修改后的代码及输出结果如下:

    结果正常输出为10.

    那为什么会这样呢?究其原因是在Rational转换成 Int32时,指定了explicit(显式的),所以必须要指定转换类型Int32。如果将explicit换成implicit(隐式),原来的代码将可以正常运行。

    修改后的Rational

     public class Rational
        {
            private Int32 _inner_int = 0;
    
            public Rational()
            {
    
            }
    
            public Rational(Int32 num)
            {
                this._inner_int = num;
            }
    
    
            public Int32 ToInt32() { return this._inner_int; }
    
            // Implicitly constructs and returns a Rational from an Int32 
            public static implicit operator Rational(Int32 num)
            {
                return new Rational(num);
            }
    
            // Explicitly returns an Int32 from a Rational 
            public static <span style="color:#ff0000;">implicit</span> operator Int32(Rational r)
            {
                return r.ToInt32();
            }
    
            public override string ToString()
            {
                //return base.ToString();
                String s = String.Format("{0}", this._inner_int);
                return s;
            }
        }
    测试代码及输出结果


    可见explicit和implicit影响着类型的显式转换和隐式转换。

    其实在Rational r1=10已经执行了隐式转换,对应的转换代码如下:

     // Implicitly constructs and returns a Rational from an Int32 
            public static implicit operator Rational(Int32 num)
            {
                return new Rational(num);
            }
    
    如果将implicit换成explicit,Rational r1=10也将会报错(可以自行测试)。


    转载请注明出处:http://blog.csdn.net/xxdddail/article/details/38057563

    展开全文
  • C# 关键字explicit和implicit 1. 关键字的含义 implicit:代表用来声明隐式自定义类型的转换 explicit:代表用来声明显示自定义类型的转换 2.实例 此文章所有代码通过LINQPad编写 explicit 用法 定义A、B俩个类,为B...

    C# 关键字explicit和implicit

    1. 关键字的含义

    implicit:代表用来声明隐式自定义类型的转换
    explicit:代表用来声明显示自定义类型的转换

    2.实例

    此文章所有代码通过LINQPad编写

    explicit 用法

    定义A、B俩个类,为B声明一个显示转换。

    class A
    {
        public int age;
    }
    class B
    {
    	public string age;
    	public B(string age){
    		this.age = age;
    	}
    	public static explicit operator B(A a)
    	{
    	    return new B(a.age.ToString());
    	}
    }
    

    main函数-使用方法

    void Main()
    {
    	A a = new A();
    	a.age = 10;
    	B b = (B)a;
    	b.Dump(); 
    }
    
    

    implicit 用法

    同样先定义A、B俩个类,为B声明一个隐式转换

    class A
    {
        public int age;
    	public A(int age)
    	{
    		this.age = age;
    	}
    }
    class B
    {
    	public string age;
    	public B(string age)
        {
    		this.age = age;
    	}
    	
    	public static implicit operator A(B b)
    	{
    		return new A(int.Parse(b.age));
    	}
    }
    

    main方法-将B隐式转换为A

    void Main()
    {
    	B b2 = new B("100");
    	A a2 = b2;
    	a2.Dump();
    }
    
    展开全文
  • C#中的explicit和implicit了解一下吧 今天在研究公司项目框架的时候看到了下面的用法,public static implicit operator JsonData(int data);。貌似很久没用过这种隐式转换的写法了,因此重新温习...

    C#中的explicit和implicit了解一下吧

    今天在研究公司项目框架的时候看到了下面的用法,public static implicit operator JsonData(int data);。貌似很久没用过这种隐式转换的写法了,因此重新温习一下C#中转换相关的知识。

    作者:依乐祝
    原文地址:https://www.cnblogs.com/yilezhu/p/10898582.html

    implicit

    implicit 关键字用于声明隐式的用户自定义的类型转换运算符。 如果可以确保转换过程不会造成数据丢失,则可使用该关键字在用户定义类型和其他类型之间进行隐式转换。

    使用隐式转换操作符之后,在编译时会跳过异常检查,所以隐式转换运算符应当从不引发异常并且从不丢失信息,否则在运行时会出现一些意想不到的问题。

    示例

    class Digit
    {
        public Digit(double d) { val = d; }
        public double val;
        // ...other members
    
        // User-defined conversion from Digit to double
        public static implicit operator double(Digit d)
        {
            return d.val;
        }
        //  User-defined conversion from double to Digit
        public static implicit operator Digit(double d)
        {
            return new Digit(d);
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            Digit dig = new Digit(7);
            //This call invokes the implicit "double" operator
            double num = dig;
            //This call invokes the implicit "Digit" operator
            Digit dig2 = 12;
            Console.WriteLine("num = {0} dig2 = {1}", num, dig2.val);
            Console.ReadLine();
        }
    }

    隐式转换可以通过消除不必要的强制转换来提高源代码的可读性。 但是,因为隐式转换不需要程序员将一种类型显式强制转换为另一种类型,所以使用隐式转换时必须格外小心,以免出现意外结果。 一般情况下,隐式转换运算符应当从不引发异常并且从不丢失信息,以便可以在程序员不知晓的情况下安全使用它们。 如果转换运算符不能满足那些条件,则应将其标记为 explicit。 有关详细信息,请参阅使用转换运算符

    explicit显示转换

    explicit 关键字声明必须通过显示的调用用户定义的类型转换运算符来进行转换。

    以下示例定义从 Fahrenheit 类转换为 Celsius 类的运算符。 必须在 Fahrenheit 类或 Celsius 类中定义运算符:

    public static explicit operator Celsius(Fahrenheit fahr)
    {
        return new Celsius((5.0f / 9.0f) * (fahr.Degrees - 32));
    }

    如下所示,调用用户定义的转换运算符来强制转换:

    Fahrenheit fahr = new Fahrenheit(100.0f);
    Console.Write($"{fahr.Degrees} Fahrenheit");
    Celsius c = (Celsius)fahr;

    此转换运算符从源类型转换为目标类型。 源类型提供转换运算符。 不同于隐式转换,显式转换运算符必须通过转换的方式来调用。 如果转换操作会导致异常或丢失信息,则应将其标记为 explicit。 这可阻止编译器静默调用可能产生意外后果的转换操作。

    省略转换将导致编译时错误 CS0266。

    有关详细信息,请参阅使用转换运算符

    示例

    下面的示例提供了 FahrenheitCelsius 类,其中每个类均提供转换为其他类的显式转换运算符。

    class Celsius
    {
        public Celsius(float temp)
        {
            Degrees = temp;
        }
        
        public float Degrees { get; }
        
        public static explicit operator Fahrenheit(Celsius c)
        {
            return new Fahrenheit((9.0f / 5.0f) * c.Degrees + 32);
        }
    }
    
    class Fahrenheit
    {
        public Fahrenheit(float temp)
        {
            Degrees = temp;
        }
        
        public float Degrees { get; }
        
        public static explicit operator Celsius(Fahrenheit fahr)
        {
            return new Celsius((5.0f / 9.0f) * (fahr.Degrees - 32));
        }
    }
    
    class MainClass
    {
        static void Main()
        {
            Fahrenheit fahr = new Fahrenheit(100.0f);
            Console.Write($"{fahr.Degrees} Fahrenheit");
            Celsius c = (Celsius)fahr;
    
            Console.Write($" = {c.Degrees} Celsius");
            Fahrenheit fahr2 = (Fahrenheit)c;
            Console.WriteLine($" = {fahr2.Degrees} Fahrenheit");
        }
    }
    // 输出:
    // 100 Fahrenheit = 37.77778 Celsius = 100 Fahrenheit

    示例

    下面的示例定义结构 Digit,它表示单个的十进制数字。 将运算符定义为从 byteDigit 的转换,但由于并非所有字节都可转换为 Digit,因此该转换应该应用显式转换。

    struct Digit
    {
        byte value;
        public Digit(byte value)
        {
            if (value > 9)
            {
                throw new ArgumentException();
            }
            this.value = value;
        }
    
        // 定义从byte到Digit的显示转换 explicit operator:
        public static explicit operator Digit(byte b)
        {
            Digit d = new Digit(b);
            Console.WriteLine("转换已完成");
            return d;
        }
    }
    
    class ExplicitTest
    {
        static void Main()
        {
            try
            {
                byte b = 3;
                Digit d = (Digit)b; // 显示转换
            }
            catch (Exception e)
            {
                Console.WriteLine("{0} 捕获到一成.", e);
            }
        }
    }
    /*
    输出:
    转换已完成
    */

    参考资料

    posted @ 2019-05-21 12:11 依乐祝 阅读(...) 评论(...) 编辑 收藏
    展开全文
  • c# implicit explicit关键字(隐式和显式数据类型转换) implicit关键字用于声明隐式的用户定义类型转换运算符。(explicit反之)explicit则用于显示转换用户自定义类型。 static implicit operator target_type( ...
  • 今天在研究公司项目框架的时候看到了下面的用法,public static implicit operator JsonData(int data);。貌似很久没用过这种隐...
  • 1. 什么是“implicit”和“explicit”呢? implicit:关键字是用来声明隐式的用户定义类型转换运算符。当然隐式转换可以通过不必要的类型转换来提高源代码的可读性。 explicit:关键字反之则用于显示转换用户自定义...
  • explicit 和 implicit 属于转换运算符,如用这两者可以让我们自定义的类型支持相互交换explicti 表示显式转换,如从 A -> B 必须进行强制类型转换(B = (B)A)implicit 表示隐式转换,如从 B -> A 只需直接赋值(A =...
  • explicit 和 implicit 属于转换运算符,如用这两者可以让我们自定义的类型支持相互交换explicti 表示显式转换,如从 A -> B 必须进行强制类型转换(B = (B)A)implicit 表示隐式转换,如从 B -> A 只需直接...
  • msdn参考:http://msdn.microsoft.com/zh-cn/library/s53ehcz3.aspx  http://msdn.microsoft.com/zh-cn/library/z5z9kes2.aspx  http://msdn.microsoft.com/zh-cn/library/xhbhezf4.as
  • 先上代码 using System; namespace Object { public class Pet { public string name; public Pet(string name) { this.name = name; } virtual public void...
  • 一、这两个关键字有什么用? (1)考虑下面的需求,Person类有个字段age。我想使用Person p = (Person) 18 来创建一个age为18的Person对象,怎么办? 更进一步,我想使用Person p = 18 来创建一个age为18的Person...
  • http://blog.csdn.net/w200221626/article/details/52413700 原文地址 主要是implicit 关键词,能够提升强制类型转换带来的不便和速度
  • 在C++中,我们有时可以将构造函数用作自动类型转换函数。但这种自动特性并非总是合乎要求的,有时会导致意外的类型转换,因此,C++新增了关键字explicit,用于关闭这种自动特性。即被explicit关键字修饰的类构造函数...
  • class Person { public int Age { get; set; } public string Name { get; set; } public static int operator -(Person p1, Person p2)//int为想减结果类型,-表示对-进行运算符重载 //参数为待计算的两个值 ...
1 2 3 4 5 ... 20
收藏数 5,610
精华内容 2,244
热门标签
关键字:

c# implicit