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

正題

operator 關鍵字用於在類或結構聲明中聲明運算符。運算符聲明能夠採用下列四種形式之一：

public static result-type operator unary-operator (type1 param)
public static result-type operator binary-operator (type1 param1, type2 param)
public static implicit operator result-type (type param )
public static explicit operator result-type (type param )

參數說明：
result-type：結果類型
type，type1，type2:參數類型
unary-operator： + - ! ~ ++ — true false
binary-operator： + - * / % & | ^ << >> == != > < >= <=

介紹了這麼多，開始步入正題，講解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，方便操做。