C#的关键字Explicit 和 Implicit

一、explicit和implicit

explicit 关键字用于声明必须使用强制转换来调用的用户定义的类型转换运算符；implicit 关键字用于声明隐式的用户自定义的类型转换运算符。

总结来说:explicit和implicit都是用于用户自定义的类型转换运算符，explicit是显示转换，implicit是隐式转换。

二、explicit和Implicit的使用

我们建立一个时间段类，里面包含了时间段的开始时间和结束时间，而实际使用中，往往需要去获取这个时间段类的小时数。代码如下：

 1  /// <summary>
 2     /// 时间类
 3     /// </summary>
 4     public class DateTimeRange
 5     {
 6         //开始时间
 7         public DateTime StartTime { get; set; }
 8 
 9         //结果时间
10         public DateTime EndTime { get; set; }
11 
12 
13         public DateTimeRange(DateTime startTime, DateTime endTime)
14         {
15             StartTime = startTime;
16             EndTime = endTime;
17         }
18 
19 
20         //计算时间差(小时)
21         public static  double GetHourRang(DateTimeRange timeRange)
22         {
23             return (timeRange.EndTime - timeRange.StartTime).TotalHours;
24         }
25     }

而使用的时候都要调用GetRangeHours方法把DateTimeRange类转换成时间差的类型double，代码如下：

1   static void Main(string[] args)
2   {
3      DateTimeRange timeRange = new DateTimeRange(new DateTime(2020, 1, 1, 1, 1, 1), DateTime.Now);
4      double hours = DateTimeRange.GetHourRang(timeRange);
5      Console.WriteLine($"时间差:{hours}");
6 
7      Console.ReadKey();
8    }

为了省略每次都调用GetRangeHours方法，我们使用关键字explicit和implicit，而explicit和implicit往往搭配operation使用。

1:使用implicit关键字代码如下：

 1  /// <summary>
 2     /// 时间类
 3     /// </summary>
 4     public class DateTimeRange
 5     {
 6         //开始时间
 7         public DateTime StartTime { get; set; }
 8 
 9         //结果时间
10         public DateTime EndTime { get; set; }
11 
12 
13         public DateTimeRange(DateTime startTime, DateTime endTime)
14         {
15             StartTime = startTime;
16             EndTime = endTime;
17         }
18 
19 
20         //计算时间差(小时)
21         public static implicit operator double(DateTimeRange timeRange)
22         {
23             return (timeRange.EndTime - timeRange.StartTime).TotalHours;
24         }
25     }
26 
27 
28     class Program
29     {
30         static void Main(string[] args)
31         {
32             //隐式转换(DateTimeRange=>double)
33             double hours = new DateTimeRange(new DateTime(2020, 1, 1, 1, 1, 1), DateTime.Now);
34             Console.WriteLine($"时间差:{hours}");
35 
36             Console.ReadKey();
37         }
38     }

2：使用explicit关键字代码如下:

 1  /// <summary>
 2     /// 时间类
 3     /// </summary>
 4     public class DateTimeRange
 5     {
 6         //开始时间
 7         public DateTime StartTime { get; set; }
 8 
 9         //结果时间
10         public DateTime EndTime { get; set; }
11 
12 
13         public DateTimeRange(DateTime startTime, DateTime endTime)
14         {
15             StartTime = startTime;
16             EndTime = endTime;
17         }
18 
19 
20         //计算时间差(小时)
21         public static explicit operator double(DateTimeRange timeRange)
22         {
23             return (timeRange.EndTime - timeRange.StartTime).TotalHours;
24         }
25     }
26 
27 
28     class Program
29     {
30         static void Main(string[] args)
31         {
32             //显示式转换(DateTimeRange=>double)，必须显示转换，否则，会编译报错
33             double hours = (double)new DateTimeRange(new DateTime(2020, 1, 1, 1, 1, 1), DateTime.Now);
34             Console.WriteLine($"时间差:{hours}");
35 
36             Console.ReadKey();
37         }
38     }

三、explicit和Implicit的总结

explicit和implicit都是应用于用户自定义类型转换运算符，两者的区别如下：

(1) 使用explicit关键字，则进行类型转换时必须显示声明，如果转换操作会导致异常或丢失信息，则应将其标记为 explicit。这可阻止编译器静默调用可能产生意外后果的转换操作；

(2) 使用impilit关键字，则进行类型转换时可以隐式声明，如果可以确保转换过程不会造成数据丢失，则可使用该关键字在用户定义类型和其他类型之间进行隐式转换。这可以通过消除不必要的强制转换来提高源代码的可读性。

引用文章:https://www.cnblogs.com/uoyo/p/12157709.html