C# 自定义隐式和显式转换运算符

[TOC]

## 1. 用户定义的显式和隐式转换运算符

用户定义类型可以自己定义使用隐式或显式的方式转换成另一个类型，也可以从另一个其他类类型转成用户定义的类型，这样做可以提高代码的可读性和易用性，使得你的类型能够像内建类型一样自然地融入到其他代码中

### 1.1. 隐式转换运算符

隐式转换运算符允许无需使用任何特殊语法就能将一个类型转换为另一个类型。通常，这意味着转换是安全的，不会导致数据丢失或精度下降，隐式转换运算符会用到两个关键字 `implicit`, `operator` ,下面是一个语法定义方式

```csharp
public static implicit operator TargetType(SourceType value)
{
    // 实现转换逻辑
    return /* 转换后的TargetType值 */;
}
```

#### 1.1.1. 隐式转换运算符示例

自定义的类型转换可以在赋值和方法调用中，隐式转换运算符需要使用 `implicit`, `operator` 两个关键字

```csharp
public static void test()
{
    try
    {
        int num = 8;
        MyInteger myInteger = new MyInteger(num);
        // 赋值隐式转换
        int reqnum = myInteger;
        Console.WriteLine(reqnum);
        IntTest(myInteger);
    }
    catch (ArgumentOutOfRangeException e)
    {
        Console.WriteLine(e.Message);
    }
}

/// <summary>
/// 函数调用隐式转换
/// </summary>
/// <param name="val"></param>
public static void IntTest(int val)
{
    Console.WriteLine(val);
}

public struct MyInteger
{
    private int _value;

public MyInteger(int value)
    {
        if (value > 9)
        {
            throw new ArgumentOutOfRangeException("超出范围！只能转换10以内的数字");
        }
        _value = value;
    }

public static implicit operator int(MyInteger myInt)
    {
        return myInt._value;
    }
}
```

> 备注：使用自定义隐式转换时注意最好是不会出错和出现精度的写法，不然会出现一些奇怪的错误，例如死循环，下面的示例就是一个死循环的写法，如果 `MyInteger myInteger = new MyInteger(num);` num 传入的是大于9的数字则会陷入死循环
> ```csharp
public static implicit operator int(MyInteger myInt)
{
    if(myInt > 9){  // 不停的陷入到隐私转换中，改成 myInt._value 即可
        throw new ArgumentOutOfRangeException("超出范围！只能转换10以内的数字");
    }
    return myInt._value;
}
```

### 1.2. 显式转换运算符

显式转换运算符要求在转换时必须使用特定的语法（通常是 (TargetType)），这表明可能存在数据丢失或转换不总是安全的

#### 1.2.1. 显式转换运算符示例

隐式转换运算符需要使用 `explicit`, `operator` 两个关键字

```csharp
public static void test()
{
    try
    {
        int num2 = 9;
        Custom((MyInteger)num2);  // 使用(TargetType) 显示的将int转成了 MyInteger 类型
    }
    catch (ArgumentOutOfRangeException e)
    {
        Console.WriteLine(e.Message);
    }
}
/// <summary>
/// 显示转换
/// </summary>
/// <param name="val"></param>
public static void Custom(MyInteger val)
{
    Console.WriteLine(val);
}

public struct MyInteger
{
    private int _value;

public static explicit operator MyInteger(int myInt)
    {
        return new MyInteger(myInt);
    }
}
```

### 1.3. 完整示例

下面自定义一个对象与string类型之间进行转换运算

```csharp
public static void TestString()
{
    try
    {
        string info = "Hello China！";
        MyString myInteger = new MyString(info);
        // 赋值隐式转换
        string overloadInfo = myInteger;
        Console.WriteLine(overloadInfo);
        MyString val = (MyString)"你好中国！";
        Console.WriteLine(val);
        Console.WriteLine(val.ToString());
    }
    catch (ArgumentNullException e)
    {
        Console.WriteLine(e.Message);
    }
}

public struct MyString
{
    public string _value;
    public MyString(string val)
    {
        if (string.IsNullOrEmpty(val))
        {
            throw new ArgumentNullException("初始化值不能为空");
        }
        _value = val;
    }

public static implicit operator string(MyString myString)
    {
        return myString._value;
    }

public static explicit operator MyString(string myString)
    {
        return new MyString(myString);
    }

public override string ToString() {
        return $"{_value}你真的很美丽";
    }
}
```

[========]

## 使用隐式显示转换运算说明

+ **关于拆箱和装箱：**这里建议需要隐式显示转换运算的自定义类型使用 `struct` ，因为 `struct` 声明的类型是存放在栈上的，这样可以避免拆箱和装箱

+ **运算符重载：**定义转换运算符是运算符重载的一种形式，即重新定义已存在的运算符行为。C#允许重载多种运算符，如+、-、\*等，以适应自定义类型的特殊需求

+ **类型安全：**设计转换运算符时，确保转换是类型安全的，避免在运行时出现错误或数据损坏

+ **使用场景：**通常，当你设计一个类型作为现有类型更具体的实现或者包装器时，定义合适的转换运算符可以使该类型更加灵活和易于使用

通过定义这些转换运算符，你可以极大地提升自定义类型在代码中的兼容性和灵活性。

## 参考资料

> **微软中国官网：**
[用户定义的显式和隐式转换运算符](https://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/operators/user-defined-conversion-operators?devlangs=csharp)
[用户定义的显式和隐式转换运算符（英文）](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/user-defined-conversion-operators?devlangs=csharp)
[运算符重载](https://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/operators/operator-overloading?devlangs=csharp#overloadable-operators)