C# 程序设计基础之 - “类型转换”详解

原创于 2025-08-15 05:58:47 发布 · 406 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#c# #类型转换 #Convert #Parse #TryParse #隐式转换 #显式转换

C# 技术使用笔记同时被 3 个专栏收录

131 篇文章

订阅专栏

C# 探险之旅：编程入门到精通

131 篇文章

订阅专栏

WinForms编程技术与控件使用

41 篇文章

订阅专栏

1. 类型转换概述

1.1 类型转换的定义

类型转换是指将一种数据类型的值转换为另一种数据类型的值的过程。在C#中，类型转换可以分为隐式类型转换和显式类型转换。

隐式类型转换：由编译器自动完成，无需程序员显式指定。它通常发生在目标类型比源类型更宽泛，且转换不会导致数据丢失的情况下。例如，将int类型转换为long类型，因为long类型可以容纳int类型的所有值，所以这种转换是安全的。
显式类型转换：需要程序员显式指定，通常使用强制类型转换运算符。它用于将一种数据类型转换为另一种数据类型，但可能会导致数据丢失或引发异常。例如，将double类型转换为int类型时，可能会丢失小数部分。

1.2 类型转换的必要性

类型转换在编程中是必不可少的，原因如下：

数据处理需求：在实际开发中，经常需要将一种数据类型转换为另一种数据类型以满足特定的处理需求。例如，从用户输入的字符串中提取数字，或者将浮点数转换为整数进行计算。
函数参数适配：某些函数可能需要特定类型的数据作为参数。如果提供的数据类型不匹配，就需要进行类型转换。例如，一个函数需要double类型的参数，但提供的却是int类型，就需要将int类型转换为double类型。
数据存储与传输：在数据存储和传输过程中，可能需要将数据转换为特定的格式。例如，将对象序列化为字符串以便存储或传输，或者将字符串反序列化为对象以便使用。
性能优化：在某些情况下，类型转换可以用于优化性能。例如，将浮点数转换为整数进行计算，可以提高计算速度。
代码复用：通过类型转换，可以复用已有的代码逻辑，避免重复编写代码。例如，一个函数处理的是int类型的数据，但需要处理long类型的数据时，可以通过类型转换将long类型的数据转换为int类型，然后复用已有的函数逻辑。

2. 隐式类型转换

2.1 基本数据类型之间的隐式转换

在C#中，基本数据类型之间的隐式类型转换遵循一定的规则，这些规则确保了转换的安全性和合理性。以下是一些常见的基本数据类型之间的隐式转换情况：

整数类型之间的转换：较小范围的整数类型可以隐式转换为较大范围的整数类型。例如，byte（8位无符号整数）可以隐式转换为short（16位有符号整数）、int（32位有符号整数）、long（64位有符号整数）等。这是因为较大范围的整数类型能够容纳较小范围整数类型的所有值，不会导致数据丢失。例如，byte b = 10; int i = b; 这里的b可以隐式转换为i，因为int类型有足够的空间来存储byte类型的所有值。
浮点类型与整数类型之间的转换：整数类型可以隐式转换为浮点类型。例如，int可以隐式转换为float、double或decimal。这是因为浮点类型具有更高的精度和更大的范围，能够表示整数类型的所有值。例如，int i = 10; double d = i; 这里的i可以隐式转换为d，因为double类型可以准确地表示int类型的值。
字符类型与整数类型之间的转换：char类型可以隐式转换为ushort、int、uint、long、ulong、float、double或decimal。这是因为char类型在内存中以16位的Unicode编码存储，其值可以被视为一个无符号的16位整数，因此可以安全地转换为范围更大的整数类型或浮点类型。例如，char c = 'A'; int i = c; 这里的c的ASCII值为65，可以隐式转换为i。
布尔类型与其他类型的转换：bool类型不能隐式转换为其他任何类型，反之亦然。这是因为布尔值只有true和false两个状态，它不能直接表示为数值或其他类型的值。例如，bool b = true; int i = b; 这样是不合法的，需要通过显式转换或其他逻辑来实现相关的操作。

2.2 引用类型之间的隐式转换

引用类型之间的隐式转换主要发生在类的继承关系和接口实现关系中。以下是一些具体的规则和示例：

类的继承关系中的隐式转换：如果一个类Derived继承自另一个类Base，那么Derived类型的对象可以隐式转换为Base类型的对象。这是因为Derived类继承了Base类的所有成员，所以它本质上是一个Base类的对象，只是可能包含更多的成员。例如：

class Base { }
class Derived : Base { }
Derived d = new Derived();
Base b = d; // 隐式转换，Derived可以隐式转换为Base

这里，d是一个Derived类型的对象，它可以隐式转换为Base类型的对象b，因为Derived类继承自Base类。

接口实现关系中的隐式转换：如果一个类实现了某个接口，那么该类的对象可以隐式转换为该接口的类型。这是因为类实现了接口的所有方法和属性，所以它满足接口的契约，可以被视为该接口类型的一个实例。例如：

interface IMyInterface { void MyMethod(); }
class MyClass : IMyInterface {
    public void MyMethod() { }
}
MyClass c = new MyClass();
IMyInterface i = c; // 隐式转换，MyClass可以隐式转换为IMyInterface

这里，c是一个MyClass类型的对象，它可以隐式转换为IMyInterface类型的对象i，因为MyClass实现了IMyInterface接口。

数组协变：在C#中，数组类型之间也存在隐式转换的情况，这被称为数组协变。如果类型T可以隐式转换为类型U，那么T[]类型的数组可以隐式转换为U[]类型的数组。例如，string类型可以隐式转换为object类型，因此string[]类型的数组可以隐式转换为object[]类型的数组。例如：
```
string[] strArray = new string[] { "Hello", "World" };
object[] objArray = strArray; // 隐式转换，string[]可以隐式转换为object[]
```
这里，strArray是一个string[]类型的数组，它可以隐式转换为object[]类型的数组objArray，因为string类型可以隐式转换为object类型。
委托协变：委托类型之间也存在隐式转换的情况，这被称为委托协变。如果委托Delegate1的返回类型可以隐式转换为委托Delegate2的返回类型，并且它们的参数类型相同或兼容，那么Delegate1类型的委托可以隐式转换为Delegate2类型的委托。例如：

delegate int MyDelegate1();
delegate double MyDelegate2();
MyDelegate1 d1 = () => 10;
MyDelegate2 d2 = d1; // 隐式转换，MyDelegate1可以隐式转换为MyDelegate2

这里，d1是一个MyDelegate1类型的委托，它可以隐式转换为MyDelegate2类型的委托d2，因为int类型可以隐式转换为double类型。

3. 显式类型转换

3.1 基本数据类型之间的显式转换

在C#中，当需要将一种基本数据类型转换为另一种基本数据类型，但这种转换可能会导致数据丢失或不符合隐式转换规则时，就需要使用显式类型转换。显式类型转换通常使用强制类型转换运算符来完成。

整数类型之间的显式转换：当需要将较大范围的整数类型转换为较小范围的整数类型时，必须使用显式转换。例如，将long类型转换为int类型时，可能会导致数据丢失，因此需要显式转换。例如：

```
long l = 100L;
int i = (int)l; // 显式转换
```
这里，l是一个long类型的值，将其转换为int类型时，需要使用强制类型转换运算符(int)，因为long类型的范围比int类型大，可能会导致数据丢失。
浮点类型与整数类型之间的显式转换：将浮点类型转换为整数类型时，会丢失小数部分，因此需要显式转换。例如：
```
double d = 10.5;
int i = (int)d; // 显式转换，结果为10
```
这里，d是一个double类型的值，将其转换为int类型时，需要使用强制类型转换运算符(int)，并且会丢失小数部分。
字符类型与整数类型之间的显式转换：虽然char类型可以隐式转换为较大的整数类型，但将整数类型转换为char类型时需要显式转换。例如：
```
int i = 65;
char c = (char)i; // 显式转换，结果为'A'
```
这里，i是一个int类型的值，将其转换为char类型时，需要使用强制类型转换运算符(char)，并且会根据Unicode编码将整数值转换为对应的字符。
布尔类型与其他类型的显式转换：bool类型不能直接转换为其他类型，反之亦然。如果需要将布尔值转换为整数或其他类型，通常需要通过逻辑运算或其他方式来实现。例如：

bool b = true;
int i = b ? 1 : 0; // 通过三元运算符实现布尔值到整数的转换

3.2 引用类型之间的显式转换

引用类型之间的显式转换主要发生在类的继承关系和接口实现关系中，当需要将一个引用类型转换为另一个引用类型时，如果这种转换不是隐式允许的，则需要显式转换。

类的继承关系中的显式转换：如果一个类Derived继承自另一个类Base，那么Base类型的对象可以显式转换为Derived类型的对象，但这种转换需要确保对象的实际类型是Derived类型或其子类类型，否则会抛出InvalidCastException异常。例如：

```
class Base { }
class Derived : Base { }
Base b = new Derived();
Derived d = (Derived)b; // 显式转换
```
这里，b是一个Base类型的对象，但它的实际类型是Derived类型，因此可以显式转换为Derived类型的对象d。如果b的实际类型不是Derived类型或其子类类型，这种转换会抛出异常。
接口实现关系中的显式转换：如果一个类实现了多个接口，那么该类的对象可以显式转换为这些接口的类型。例如：

interface IMyInterface1 { void Method1(); }
interface IMyInterface2 { void Method2(); }
class MyClass : IMyInterface1, IMyInterface2 {
    public void Method1() { }
    public void Method2() { }
}
MyClass c = new MyClass();
IMyInterface1 i1 = (IMyInterface1)c; // 显式转换
IMyInterface2 i2 = (IMyInterface2)c; // 显式转换

这里，c是一个MyClass类型的对象，它可以显式转换为IMyInterface1和IMyInterface2类型的对象i1和i2，因为MyClass实现了这两个接口。

数组逆变：与数组协变相对，数组逆变是指将U[]类型的数组显式转换为T[]类型的数组，其中U可以隐式转换为T。例如：
```
object[] objArray = new object[] { "Hello", 10, 3.14 };
string[] strArray = (string[])objArray; // 显式转换，但会抛出InvalidCastException异常
```
这里，objArray是一个object[]类型的数组，尝试将其显式转换为string[]类型的数组strArray会抛出异常，因为objArray中包含的元素类型不仅仅是string。
委托逆变：委托类型之间的显式转换也存在类似的情况。如果委托Delegate2的返回类型可以隐式转换为委托Delegate1的返回类型，并且它们的参数类型相同或兼容，那么Delegate2类型的委托可以显式转换为Delegate1类型的委托。例如：

```
delegate double MyDelegate2();
delegate int MyDelegate1();
MyDelegate2 d2 = () => 10.5;
MyDelegate1 d1 = (MyDelegate1)d2; // 显式转换，但可能会抛出InvalidCastException异常
```
这里，d2是一个MyDelegate2类型的委托，尝试将其显式转换为MyDelegate1类型的委托d1可能会抛出异常，因为d2的返回类型是double，而d1的返回类型是int。

4. 装箱与拆箱

4.1 装箱操作

装箱是将值类型转换为引用类型的过程。在C#中，值类型（如int、double、char等）存储在栈内存中，而引用类型（如类、接口等）存储在堆内存中。装箱操作会将值类型的数据复制到堆内存中，并返回一个引用类型。

装箱的必要性：装箱操作的主要目的是将值类型的数据转换为引用类型，以便可以将其存储在引用类型的集合中（如ArrayList）或作为引用类型参数传递给方法。例如，ArrayList是一个可以存储任何类型对象的集合，但它的元素类型必须是引用类型。因此，当需要将值类型（如int）存储到ArrayList中时，就需要进行装箱操作。

ArrayList list = new ArrayList();
int i = 10;
list.Add(i); // 装箱操作，将int类型的i转换为引用类型并存储到ArrayList中

装箱的性能影响：装箱操作会创建一个新的对象，并将值类型的数据复制到堆内存中，这会增加内存的使用量和程序的运行时间。因此，在需要频繁进行装箱操作的场景中，可能会对程序的性能产生负面影响。例如，如果在一个循环中频繁地将值类型装箱并存储到集合中，可能会导致程序运行缓慢。
装箱的应用场景：尽管装箱操作可能会对性能产生影响，但在某些情况下仍然是必要的。例如，当需要将值类型的数据存储到引用类型的集合中，或者需要将值类型作为引用类型参数传递给方法时，就需要进行装箱操作。此外，在使用某些框架或库时，也可能需要进行装箱操作。例如，在使用System.Collections命名空间中的集合类时，就需要将值类型装箱后才能存储到集合中。

4.2 拆箱操作

拆箱是将引用类型转换回值类型的过程。在C#中，拆箱操作通常用于从引用类型的集合中获取值类型的数据，或者将引用类型的数据转换回值类型。

拆箱的必要性：拆箱操作的主要目的是将引用类型的数据转换回值类型，以便可以使用值类型的数据进行计算或其他操作。例如，从ArrayList中获取一个值类型的数据时，就需要进行拆箱操作。

ArrayList list = new ArrayList();
int i = 10;
list.Add(i); // 装箱操作
int j = (int)list[0]; // 拆箱操作，将引用类型的数据转换回值类型

拆箱的性能影响：拆箱操作需要将引用类型的数据复制回值类型，这同样会增加程序的运行时间。因此，在需要频繁进行拆箱操作的场景中，也可能会对程序的性能产生负面影响。例如，如果在一个循环中频繁地从集合中获取值类型的数据并进行拆箱操作，可能会导致程序运行缓慢。
拆箱的应用场景：尽管拆箱操作可能会对性能产生影响，但在某些情况下仍然是必要的。例如，当需要从引用类型的集合中获取值类型的数据，或者需要将引用类型的数据转换回值类型进行计算时，就需要进行拆箱操作。此外，在使用某些框架或库时，也可能需要进行拆箱操作。例如，在使用System.Collections命名空间中的集合类时，从集合中获取值类型的数据时就需要进行拆箱操作。
装箱与拆箱的优化：为了避免装箱和拆箱操作对程序性能的影响，可以采取一些优化措施。例如，尽量使用泛型集合（如List<T>）来存储值类型的数据，因为泛型集合可以避免装箱和拆箱操作。此外，也可以通过使用结构体（struct）来代替类（class），因为结构体是值类型，不会发生装箱和拆箱操作。

5. 类型转换方法

5.1 Convert 类的使用

Convert 类是 C# 中用于类型转换的一个非常重要的工具类，它提供了一系列静态方法，用于在不同的数据类型之间进行安全的转换。这些方法能够处理各种常见的数据类型转换场景，并且在转换失败时会抛出异常或返回默认值，从而保证程序的健壮性。

转换为布尔类型：Convert.ToBoolean 方法可以将多种数据类型转换为布尔类型。例如，将字符串 "true" 或 "false" 转换为布尔值，或者将非零数值转换为 true，零值转换为 false。

string str = "true";
bool result = Convert.ToBoolean(str); // result 为 true
int num = 0;
bool result2 = Convert.ToBoolean(num); // result2 为 false

转换为数值类型：Convert 类提供了多种方法来将字符串或其他类型转换为数值类型，如 Convert.ToInt32、Convert.ToDouble 等。这些方法会尝试将输入值解析为相应的数值类型，并在转换失败时抛出 FormatException 或 InvalidCastException 异常。

string str = "123";
int num = Convert.ToInt32(str); // num 为 123
double d = Convert.ToDouble(str); // d 为 123.0

转换为日期时间类型：Convert.ToDateTime 方法可以将字符串或其他类型转换为 DateTime 类型。它会根据当前文化区域设置的格式规则来解析字符串，因此在使用时需要注意字符串的格式是否符合预期。

string dateStr = "2023-10-01";
DateTime date = Convert.ToDateTime(dateStr); // date 为 2023 年 10 月 1 日

转换为字符串类型：Convert.ToString 方法可以将各种数据类型转换为字符串。它会调用对象的 ToString 方法来获取字符串表示形式，因此对于自定义类型，可以通过重写 ToString 方法来控制转换结果。

int num = 123;
string str = Convert.ToString(num); // str 为 "123"

处理空值和默认值：Convert 类在处理空值时会返回目标类型的默认值。例如，将 null 转换为数值类型时会返回 0，转换为布尔类型时会返回 false，转换为字符串时会返回空字符串。

object obj = null;
int num = Convert.ToInt32(obj); // num 为 0
bool result = Convert.ToBoolean(obj); // result 为 false
string str = Convert.ToString(obj); // str 为 ""

5.2 Parse 和 TryParse 方法

Parse 和 TryParse 方法是 C# 中用于将字符串转换为特定数据类型的方法，它们在处理字符串到数值类型或日期时间类型的转换时非常常用。

Parse 方法：Parse 方法用于将字符串解析为目标类型。如果字符串格式不正确，Parse 方法会抛出 FormatException 异常。因此，在使用 Parse 方法时，需要确保输入字符串的格式是正确的，或者在调用时使用 try-catch 块来捕获可能的异常。

string str = "123";
int num = int.Parse(str); // num 为 123
string dateStr = "2023-10-01";
DateTime date = DateTime.Parse(dateStr); // date 为 2023 年 10 月 1 日

TryParse 方法：TryParse 方法与 Parse 方法类似，但它不会抛出异常，而是返回一个布尔值来指示转换是否成功。如果转换成功，目标类型的值会通过 out 参数返回。TryParse 方法在处理用户输入或不确定格式的字符串时非常有用，因为它可以避免程序因异常而中断。

string str = "123";
int num;
bool success = int.TryParse(str, out num); // success 为 true，num 为 123

性能比较：TryParse 方法通常比 Parse 方法更高效，因为它避免了异常处理的开销。在需要频繁进行字符串解析的场景中，建议优先使用 TryParse 方法。

string[] inputs = { "123", "abc", "456" };
foreach (string input in inputs)
{
    int result;
    if (int.TryParse(input, out result))
    {
        Console.WriteLine($"转换成功：{result}");
    }
    else
    {
        Console.WriteLine($"转换失败：{input}");
    }
}

自定义类型解析：对于自定义类型，可以通过实现 IConvertible 接口或重写 Parse 和 TryParse 方法来支持字符串解析。这使得自定义类型可以像内置类型一样方便地进行类型转换。

public class MyCustomType
{
    public static MyCustomType Parse(string str)
    {
        // 实现字符串解析逻辑
        return new MyCustomType();
    }

    public static bool TryParse(string str, out MyCustomType result)
    {
        try
        {
            result = Parse(str);
            return true;
        }
        catch
        {
            result = null;
            return false;
        }
    }
}

6. 自定义类型转换

6.1 定义隐式转换运算符

在C#中，可以通过定义隐式转换运算符来自定义类型的隐式转换行为。这使得程序员能够方便地将一种类型隐式地转换为另一种类型，而无需显式调用转换方法。隐式转换通常用于当转换是安全的且不会丢失数据时。

定义隐式转换运算符的语法：隐式转换运算符的定义需要使用implicit关键字，并且必须是静态方法。其语法如下：

public static implicit operator 目标类型(源类型变量)
{
    // 转换逻辑
}

示例：假设有一个Money类，用于表示金额，我们希望可以隐式地将int类型转换为Money类型。

public class Money
{
    public decimal Amount { get; }

    public Money(decimal amount)
    {
        Amount = amount;
    }

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

在上述代码中，定义了一个从int到Money的隐式转换运算符。这意味着可以将int类型的值直接赋值给Money类型的变量，而无需显式调用构造函数或其他转换方法。

int amount = 100;
Money money = amount; // 隐式转换

注意事项：
- 隐式转换运算符必须是安全的，即不会丢失数据。如果转换可能导致数据丢失或异常，应使用显式转换运算符。
- 一个类型可以定义多个隐式转换运算符，但不能定义两个相同源类型和目标类型的隐式转换运算符。
- 隐式转换运算符不能与显式转换运算符重载相同的源类型和目标类型。

6.2 定义显式转换运算符

显式转换运算符用于定义可能不安全或可能导致数据丢失的类型转换。与隐式转换运算符类似，显式转换运算符也需要使用explicit关键字定义，并且必须是静态方法。

定义显式转换运算符的语法：显式转换运算符的定义语法如下：

public static explicit operator 目标类型(源类型变量)
{
    // 转换逻辑
}

示例：继续使用Money类，假设我们希望可以将Money类型显式地转换为int类型。

public class Money
{
    public decimal Amount { get; }

    public Money(decimal amount)
    {
        Amount = amount;
    }

    public static explicit operator int(Money money)
    {
        return (int)money.Amount; // 显式转换，可能丢失小数部分
    }
}

在上述代码中，定义了一个从Money到int的显式转换运算符。这意味着可以使用强制类型转换将Money类型的值转换为int类型，但需要显式地指定转换。

Money money = new Money(100.5m);
int amount = (int)money; // 显式转换

注意事项：
- 显式转换运算符通常用于可能不安全或可能导致数据丢失的转换。因此，在定义显式转换运算符时，需要明确告知调用者这种转换可能存在风险。
- 与隐式转换运算符类似，显式转换运算符也不能与另一个相同源类型和目标类型的显式或隐式转换运算符重载。
- 显式转换运算符的使用需要程序员显式地调用，这可以避免意外的类型转换，从而提高代码的安全性。

7. 类型转换中的常见问题与注意事项

7.1 类型转换异常处理

在C#中进行类型转换时，可能会遇到各种异常情况，正确处理这些异常对于程序的健壮性至关重要。

InvalidCastException：当尝试将一个引用类型显式转换为不兼容的类型时，会抛出此异常。例如，将一个Base类型的对象显式转换为Derived类型，但实际对象并非Derived类型或其派生类型时，就会抛出InvalidCastException。

Base b = new Base();
Derived d = (Derived)b; // 抛出InvalidCastException

为了避免此类异常，可以在转换前使用is关键字或as运算符进行类型检查。is关键字用于检查对象是否兼容于指定类型，而as运算符用于执行引用类型的安全转换，如果转换失败，as会返回null而不是抛出异常。

if (b is Derived)
{
    Derived d = (Derived)b;
}
else
{
    Console.WriteLine("类型转换失败");
}

OverflowException：当数值类型转换导致溢出时，会抛出此异常。例如，将一个超出目标类型范围的值转换为目标类型时，就会发生溢出。

int i = int.MaxValue;
byte b = (byte)i; // 抛出OverflowException

为了避免数值溢出，可以在转换前进行范围检查，或者使用checked和unchecked关键字来控制溢出检查的行为。checked关键字会启用溢出检查，而unchecked关键字会禁用溢出检查。

checked
{
    byte b = (byte)i; // 如果溢出，会抛出OverflowException
}
unchecked
{
    byte b = (byte)i; // 如果溢出，不会抛出异常，但结果可能不正确
}

FormatException：当使用Parse方法或Convert类进行字符串转换时，如果输入字符串的格式不正确，会抛出此异常。

string str = "abc";
int num = int.Parse(str); // 抛出FormatException

为了避免此类异常，可以使用TryParse方法代替Parse方法，TryParse方法不会抛出异常，而是返回一个布尔值来指示转换是否成功。

int num;
if (int.TryParse(str, out num))
{
    Console.WriteLine("转换成功");
}
else
{
    Console.WriteLine("转换失败");
}

7.2 性能优化建议

类型转换操作可能会对程序的性能产生影响，特别是在涉及装箱、拆箱或频繁的类型转换时。以下是一些性能优化建议：

避免不必要的装箱和拆箱操作：装箱和拆箱操作会增加内存分配和数据复制的开销，从而降低程序性能。尽量使用值类型集合（如List<T>）来存储值类型数据，避免将值类型存储到引用类型集合（如ArrayList）中。

List<int> list = new List<int>();
list.Add(10); // 不会发生装箱操作

使用泛型方法和泛型类：泛型可以避免装箱和拆箱操作，同时提高代码的类型安全性。在设计类库或工具类时，优先使用泛型来处理不同类型的数据。

public class MyGenericClass<T>
{
    public T Value { get; set; }
}

减少显式类型转换的使用：显式类型转换可能会导致性能开销，特别是在涉及复杂类型转换时。如果可能，尽量使用隐式类型转换或通过设计合理的类型层次结构来避免显式转换。

public class Base { }
public class Derived : Base { }

Derived d = new Derived();
Base b = d; // 隐式转换，无需显式转换

优化数值类型转换：在进行数值类型转换时，尽量避免不必要的范围检查和溢出检查。如果确定转换不会导致溢出，可以使用unchecked关键字来禁用溢出检查。

unchecked
{
    int i = int.MaxValue;
    byte b = (byte)i; // 不会抛出OverflowException
}

缓存转换结果：如果某些类型转换操作是重复执行的，可以考虑将转换结果缓存起来，避免重复计算。例如，可以使用字典来缓存字符串到枚举类型的转换结果。

Dictionary<string, MyEnum> cache = new Dictionary<string, MyEnum>();

public MyEnum ConvertStringToEnum(string str)
{
    if (cache.TryGetValue(str, out MyEnum result))
    {
        return result;
    }
    else
    {
        result = (MyEnum)Enum.Parse(typeof(MyEnum), str);
        cache[str] = result;
        return result;
    }
}

使用Convert类的优化方法：Convert类提供了许多类型转换方法，这些方法在处理空值和默认值时非常方便。在使用Convert类时，尽量选择合适的重载方法，以减少不必要的性能开销。

object obj = null;
int num = Convert.ToInt32(obj); // 返回0，不会抛出异常

8. 总结

在本教程中，我们深入探讨了 C# 程序设计中的类型转换，从类型转换的基本概念、隐式与显式转换，到装箱与拆箱、数值类型转换、引用类型转换，以及类型转换中的异常处理和性能优化，全面剖析了类型转换的各个方面。

8.1、类型转换概述

类型转换是编程中常见的操作，用于将一种数据类型转换为另一种数据类型。在 C# 中，类型转换分为隐式转换和显式转换。隐式转换由编译器自动完成，无需程序员干预；而显式转换需要程序员使用强制类型转换语法来完成。理解这两种转换的规则和使用场景是掌握类型转换的基础。

8.2、装箱与拆箱

装箱和拆箱是 C# 中值类型与引用类型相互转换的机制。装箱将值类型转换为引用类型，而拆箱则将引用类型转换回值类型。虽然装箱和拆箱提供了类型转换的灵活性，但它们会带来性能开销，尤其是在频繁转换时。因此，合理使用装箱和拆箱，避免不必要的转换，是提高程序性能的关键。

8.3、数值类型转换

数值类型转换涉及不同数值类型之间的相互转换，如从 int 转换为 double 或从 double 转换为 int。C# 提供了多种数值类型转换方法，包括隐式转换、显式转换以及使用 Convert 类进行转换。在进行数值类型转换时，需要注意转换规则和可能的溢出问题，以确保转换结果的正确性。

8.4、引用类型转换

引用类型转换主要用于对象类型的转换，如从基类到派生类的转换或从派生类到基类的转换。C# 提供了多种引用类型转换方式，包括隐式转换、显式转换、as 运算符以及 is 关键字。引用类型转换需要特别注意类型兼容性，以避免运行时异常。

8.5、类型转换中的异常处理

类型转换可能会引发各种异常，如 InvalidCastException、OverflowException 和 FormatException。正确处理这些异常对于程序的健壮性至关重要。通过使用异常处理机制（如 try-catch 块）和进行类型检查（如使用 is 关键字或 as 运算符），可以有效避免类型转换异常，提高程序的稳定性。

8.6、性能优化建议

类型转换操作可能会对程序性能产生影响，特别是在涉及装箱、拆箱或频繁的类型转换时。为了提高程序性能，建议避免不必要的装箱和拆箱操作，使用泛型方法和泛型类来减少类型转换的开销，优化数值类型转换，以及缓存转换结果。通过这些优化措施，可以显著提升程序的运行效率。

类型转换是 C# 程序设计中的重要概念，掌握类型转换的规则和使用方法对于编写高效、健壮的程序至关重要。在实际开发中，合理使用隐式和显式转换，注意装箱与拆箱的性能开销，正确处理数值类型和引用类型的转换，以及妥善处理类型转换中的异常，是每个 C# 开发者需要具备的技能。通过本教程的学习，希望读者能够全面理解 C# 中的类型转换机制，并在实际开发中灵活运用，提升编程水平和代码质量。