ahjesus自定义隐式转换和体现转换,隐式转换关键字

implicit 关键字用于注解隐式的用户定义类型转换运算符。
若是能够保险转换进度不会造成数据丢失,则可选用该重大字在用户定义类型和其余项目之间开始展览隐式转换。

implicit   
关键字用于评释隐式的用户定义类型转换运算符。            

用户自定义的显示转换和隐式转换

回到目录

引用摘自:implicit(C#
参考)

如果能够保障转换进度不会造成数据丢失,则可使用该重大字在用户定义类型和别的连串之间展开隐式转换。

显式转换implicit关键字告诉编写翻译器,在源代码中不要做展示的转型就足以生出调用转换操作符方法的代码.

ahjesus自定义隐式转换和体现转换,隐式转换关键字。某个内容来自MSDN

仍以Student求和举例

参考戳此

隐式转换implicit关键字告诉编写翻译器唯有当源代码中钦定了体现的转型时,才发生调用转换操作符方法的代码.

implicit
关键字用于表明隐式的用户定义类型转换运算符。假设转换进程能够保险不会促成数据丢失,则可选取该重大字在用户定义类型和别的类型之间开始展览隐式转换。

    class Student
    {
        /// <summary>
        /// 语文成绩
        /// </summary>
        public double Chinese { get; set; }

        /// <summary>
        /// 数学成绩
        /// </summary>
        public double Math { get; set; }
    }

 

例如:

 

 1     class Digit
 2 
 3     {
 4 
 5         public Digit(double d) { val = d; }
 6 
 7         public double val;
 8 
 9  
10 
11  
12 
13         // User-defined conversion from Digit to double
14 
15         public static implicit operator double(Digit d)
16 
17         {
18 
19             return d.val;
20 
21         }
22 
23         //  User-defined conversion from double to Digit
24 
25         public static implicit operator Digit(double d)
26 
27         {
28 
29             return new Digit(d);
30 
31         }
32 
33     }
34 
35     class Program
36 
37     {
38 
39         static void Main(string[] args)
40 
41         {
42 
43             Digit dig = new Digit(7);
44 
45             //This call invokes the implicit "double" operator
46 
47             double num = dig;
48 
49             //This call invokes the implicit "Digit" operator
50 
51             Digit dig2 = 12;
52 
53             Console.WriteLine("num = {0} dig2 = {1}", num, dig2.val);
54 
55             Console.ReadLine();
56 
57         }
58 
59     }

不使用implicit 求和

explicit   
关键字用于注解必须接纳强制转换到调用的用户定义的类型转换运算符。       

//implicit 关键字用于申明隐式的用户定义类型转换运算符。

 

    class Program
    {
        static void Main(string[] args)
        {
            var a = new Student
            {
                Chinese = 90.5d,
                Math = 88.5d
            };

            //a的总成绩 语文和数据的总分数
            Console.WriteLine(a.Chinese + a.Math);          
        }
    }

参考戳此

public static implicit operator string(aaa table)

explicit
关键字用于注明必须使用强制转换来调用的用户定义的类型转换运算符

使用implicit

 

{

 1 // cs_keyword_explicit_temp.cs
 2 using System;
 3 class Celsius
 4 {
 5     public Celsius(float temp)
 6     {
 7         degrees = temp;
 8     }
 9     public static explicit operator Fahrenheit(Celsius c)
10     {
11         return new Fahrenheit((9.0f / 5.0f) * c.degrees + 32);
12     }
13     public float Degrees
14     {
15         get { return degrees; }
16     }
17     private float degrees;
18 }
19 
20 class Fahrenheit
21 {
22     public Fahrenheit(float temp)
23     {
24         degrees = temp;
25     }
26     public static explicit operator Celsius(Fahrenheit f)
27     {
28         return new Celsius((5.0f / 9.0f) * (f.degrees - 32));
29     }
30     public float Degrees
31     {
32         get { return degrees; }
33     }
34     private float degrees;
35 }
36 
37 class MainClass
38 {
39     static void Main()
40     {
41         Fahrenheit f = new Fahrenheit(100.0f);
42         Console.Write("{0} fahrenheit", f.Degrees);
43         Celsius c = (Celsius)f;
44         Console.Write(" = {0} celsius", c.Degrees);
45         Fahrenheit f2 = (Fahrenheit)c;
46         Console.WriteLine(" = {0} fahrenheit", f2.Degrees);
47     }
48 }
    class Student
    {
        /// <summary>
        /// 语文成绩
        /// </summary>
        public double Chinese { get; set; }

        /// <summary>
        /// 数学成绩
        /// </summary>
        public double Math { get; set; }

        /// <summary>
        /// 隐式求和
        /// </summary>
        /// <param name="a"></param>
        public static implicit operator double(Student a)
        {
            return a.Chinese + a.Math;
        }
    }

美高梅开户网址 ,有好几要小心的是,二个类中不可能而且写显式和隐式表明,只好是内部四个。

return table;

 

求和:

不过假使表明了隐式的转换,那么其相应的展示转换也会自动提供。

}  

重返目录

    class Program
    {
        static void Main(string[] args)
        {
            var a = new Student
            {
                Chinese = 90.5d,
                Math = 88.5d
            };

            double total = a;

            //a的总成绩 语文和数据的总分数
            Console.WriteLine(total);
        }
    }

假设证明了显式转换,其对应的隐式转换不会提供的。     

// 像上面包车型大巴代码正是科学的:

aaa var1;

string var2;  

var2=var一;//正确,能够隐式转换。

 

//explicit
关键字用于表明必须利用强制转换成调用的用户定义的类型转换运算符。

public static explicit operator aaa(string table)

{

return Convert(table);

}  

aaa var1;  

string var2;  

var一=var2; //错误,不可以隐式转换。

var一=(aaa)var2//正确,能够强制转换。

 

将三个类别的目的转换为另叁个类别的靶子。

隐式转换恐怕在各类场合下发出,包罗功用成员调用,表明式执行和赋值。

显式转换可以在勒迫类型转换表明式中爆发。  

用户定义的隐式转换应该被设计成不会抛出非凡而且不会放任消息。

如若3个用户定义的更换将发生一个老大(例如因为源变量超出了限定)或废弃消息(例如丢掉高位),那么这一个转换应该被定义为贰个显式转换。

 

 

 

=====================================

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图