C#中关键字：explicit、implicit与operator研究

c#中的这个几个关键字：explicit、implicit与operator，估计好多人的用不上，什么情况，这是什么？字面解释：explicit：清楚明白的;易于理解的;(说话)清晰的，明确的;直言的;坦率的;直截了当的;不隐晦的;不含糊的。implicit：含蓄的;不直接言明的;成为一部分的;内含的;完全的;无疑问的。operator：操作人员;技工;电话员;接线员;(某企业的)经营者，专业公司。说了这么多，其实explicit和implicit关键字分别表示显式的类型转换和隐式的类型转换。

显式转换

显式转换（强制转换）：必须使用强制运算符，才能执行的转换，在转换过程中可能会丢失信息或转换失败。
例如

public class baseab { }
public class a : baseab { }
public class b : baseab { }
//测试
double test = 1.234;
int testint = (int)test;
console.writeline(testint); //运算结果1，强制转换数据丢失

try {
    baseab ab = new a();
    b b = (b)ab;  //引用强制转换抛出异常 system.invalidcastexception: unable to cast object of type 'a' to type 'b'.
} catch (exception ex) {
    console.writeline(ex.tostring());
}

在值类型强制转换的时候，会数据丢失，在引用类型做强制转换的时候会有引发invalidcastexception风险，但是可以通过使用模式匹配安全的进行强制转换，通过is和as运算符来检测是否属于特定类型。
模式匹配：给定一个子串，要求在某个字符串中找出与该子串相同的所有子串。例如：a是字串，ba是待查找的字符串，要求从ba中查找出所有与a相同的字串，这个问题就是模式匹配问题。a是模式，ba是目标。
例如：

var test = 1.1234;
int testint = test is int ? (int)test : 0;
console.writeline(testint);
baseab ab = new a();
b b = ab as b;
if (b == null) console.writeline("ab 不是 b类型");
//结果：
//0
//ab 不是 b类型

隐式转换

隐式转换：这种转换是类型安全的，不需要特殊处理。
例如：

int i = 123;
double b = i;
console.writeline(b);

a a = new a();
baseab baseab = a;
//结果：
//123

简单来说就是：小类型转换成大类型的时候隐式转换，大类型转换成小类型用强制转换。int > float > double >deca

正题

介绍了这么多，开始步入正题，讲解explicit、implicit与operator。explicit、implicit都是与operator一起操作使用的，operator 关键字用于在类或结构声明中声明运算符。explicit用于强制转换，implicit用于隐式转换。
例如：

public struct medecimal
{
    private readonly int intv;
    private readonly double doublev;

    public medecimal(int value):this(value,0)
    {
    }

    public medecimal(double value):this(0,value)
    {
    }

    public medecimal(int intv, double doublev)
    {
        this.intv = intv;
        this.doublev = doublev;
    }

    public static implicit operator int(medecimal medecimal)
    {
        return medecimal.intv;
    }

    public static explicit operator double(medecimal medecimal)
    {
        return medecimal.doublev;
    }

    public static implicit operator medecimal(int medecimal)
    {
        return new medecimal(medecimal);
    }

    public static explicit operator medecimal(double medecimal)
    {
        return new medecimal(medecimal);
    }

    public static medecimal operator ++(medecimal medecimal)
    {
        var t = medecimal.intv + 1;
        var t2 = medecimal.doublev + 1;
        var temp = new medecimal(t, t2);
        return temp;
    }

    public override string tostring()
    {
        return $"intv:{intv},doublev:{doublev}";
    }
}

用法：

medecimal d = (medecimal)2.1;
console.writeline($"原始数据：{d}");
d++;
double c = (double)d;
int c2 = d;
console.writeline($"int的值：{c2},double的值：{c}");
console.writeline($"{d}");

//结果：
原始数据：intv:0,doublev:2.1
int的值：1,double的值：3.1
intv:1,doublev:3.1

像一些类型需要转换的地方或者特殊处理的地方，可以用explicit、implicit，方便操作。