## 一、整型之间的类型转换
详细介绍C#中整数类型之间的数据类型转换。
C#中的整数类型主要包括byte, sbyte, short, ushort, int, uint, long, ulong。
## 整数类型范围对比
首先了解各整数类型的取值范围：
| 类型 | 大小 | 范围 | 说明 |
|------|------|------|------|
| sbyte | 8位 | -128 到 127 | 有符号字节 |
| byte | 8位 | 0 到 255 | 无符号字节 |
| short | 16位 | -32,768 到 32,767 | 有符号短整型 |
| ushort | 16位 | 0 到 65,535 | 无符号短整型 |
| int | 32位 | -2,147,483,648 到 2,147,483,647 | 有符号整型 |
| uint | 32位 | 0 到 4,294,967,295 | 无符号整型 |
| long | 64位 | -9.2×10¹⁸ 到 9.2×10¹⁸ | 有符号长整型 |
| ulong | 64位 | 0 到 1.8×10¹⁹ | 无符号长整型 |
#### 1. 1隐式转换（Implicit Conversion）
规则： 从小范围类型向大范围类型转换，且不会丢失数据时，可以隐式转换。
示例：安全的隐式转换
```csharp
// byte → short → int → long (无符号到有符号的扩大)
byte b = 200;
short s = b; // 隐式转换：byte → short
int i = s; // 隐式转换：short → int
long l = i; // 隐式转换：int → long
Console.WriteLine($"byte {b} → short {s} → int {i} → long {l}");
// sbyte → short → int → long (有符号到有符号的扩大)
sbyte sb = -100;
short s2 = sb; // 隐式转换
int i2 = s2; // 隐式转换
long l2 = i2; // 隐式转换
// ushort → uint → ulong (无符号到无符号的扩大)
ushort us = 40000;
uint ui = us; // 隐式转换
ulong ul = ui; // 隐式转换
// 相同大小但有符号→无符号？不可以隐式！
// int x = 100;
// uint y = x; // 编译错误：不能隐式转换
```
#### 1.2. 显式转换（Explicit Conversion）
规则： 从大范围类型向小范围类型转换，或在不同符号类型之间转换时，需要显式转换。
示例：需要显式转换的情况
```csharp
// int → short → byte (缩小转换 - 可能数据丢失)
int largeInt = 1000;
short smallShort = (short)largeInt; // 显式转换：1000
byte smallByte = (byte)largeInt; // 显式转换：232 (1000 % 256)
Console.WriteLine($"int {largeInt} → short {(short)largeInt} → byte {(byte)largeInt}");
// 有符号 ↔ 无符号转换
int signed = -50;
uint unsigned = (uint)signed; // 显式转换：4294967246
Console.WriteLine($"int {signed} → uint {(uint)signed}");
uint positive = 300;
int signed2 = (int)positive; // 显式转换：300
Console.WriteLine($"uint {positive} → int {(int)positive}");
// long → int (大范围到小范围)
long bigLong = 2_000_000_000;
int normalInt = (int)bigLong; // 2000000000 (在int范围内)
long tooBig = 3_000_000_000;
int overflow = (int)tooBig; // -1294967296 (溢出)
Console.WriteLine($"long {tooBig} → int {(int)tooBig} (溢出)");
```
#### 1.3. 使用 Convert 类进行转换
Convert类提供更安全的转换方式，会进行范围检查并在溢出时抛出异常。
```csharp
// 使用Convert类进行整数转换
int number = 255;
// 成功转换
byte b1 = Convert.ToByte(number); // 255
short s1 = Convert.ToInt16(number); // 255
// 溢出时会抛出异常
try
{
int tooBig = 1000;
byte b2 = Convert.ToByte(tooBig); // 抛出 OverflowException
}
catch (OverflowException ex)
{
Console.WriteLine($"转换溢出: {ex.Message}");
}
// 处理null值
int? nullableInt = null;
int result = Convert.ToInt32(nullableInt); // 返回 0
```
### 2.浮点数之间
```c#
// float ↔ double ↔ decimal
float floatValue = 3.14f;
double doubleValue = 2.71828;
decimal decimalValue = 123.456m;
// 需要显式转换（可能精度丢失）
double fromFloat = floatValue; // 隐式：3.14
float fromDouble = (float)doubleValue; // 显式：2.71828（可能精度损失）
decimal fromDouble2 = (decimal)doubleValue; // 显式：2.71828
// decimal 与其他浮点数的转换都需要显式
double fromDecimal = (double)decimalValue; // 123.456
float fromDecimal2 = (float)decimalValue; // 123.456f
```
### 3.整数和浮点数之间
## 二、数值和字符串
```c#
// string → double
string doubleStr = "3.14159";
double d1 = double.Parse(doubleStr); // 3.14159
double d2 = Convert.ToDouble("123.45"); // 123.45
double.TryParse("invalid", out double d3); // d3 = 0, 返回false
// string → float
string floatStr = "2.718f";
float f1 = float.Parse(floatStr); // 2.718
float f2 = Convert.ToSingle("99.99"); // 99.99f
// string → decimal (适合金融计算)
string moneyStr = "2999.99";
decimal m1 = decimal.Parse(moneyStr); // 2999.99m
decimal m2 = Convert.ToDecimal("0.1"); // 0.1m
// 数值 → string (所有数值类型都适用)
int number = 42;
double price = 19.95m;
string str1 = number.ToString(); // "42"
string str2 = price.ToString("C2"); // "$19.95" (货币格式)
string str3 = $"{123.456:F1}"; // "123.5" (插值字符串)
```
## 三、数值 和 字符
```c#
// char → int (获取ASCII码)
char letter = 'A';
int ascii = (int)letter; // 65
int unicode = letter; // 65 (隐式转换)
// int → char (根据ASCII码获取字符)
int code = 66;
char character = (char)code; // 'B'
// char → string
char ch = 'X';
string charStr = ch.ToString(); // "X"
string charStr2 = $"{ch}"; // "X"
```
## 四、数值 和 布尔值
## 五、字符串 和 布尔值
```c#
// string → bool
string trueStr = "True";
string falseStr = "False";
bool b1 = bool.Parse(trueStr); // true
bool b2 = Convert.ToBoolean("true"); // true (不区分大小写)
bool b3 = Convert.ToBoolean("1"); // true (将"1"视为true)
bool b4 = Convert.ToBoolean("0"); // false (将"0"视为false)
// bool → string
bool isValid = true;
string boolStr1 = isValid.ToString(); // "True"
string boolStr2 = $"{false}"; // "False"
```
## 六、字符串 和 日期
```c#
// string → DateTime
string dateStr = "2024-01-15";
string dateTimeStr = "2024-01-15 14:30:00";
DateTime dt1 = DateTime.Parse(dateStr); // 2024/1/15 0:00:00
DateTime dt2 = Convert.ToDateTime("2023/12/25"); // 2023/12/25
DateTime dt3 = DateTime.ParseExact("15-01-2024", "dd-MM-yyyy", null);
// DateTime → string
DateTime now = DateTime.Now;
string dateStr1 = now.ToString(); // "2024/1/15 14:30:45"
string dateStr2 = now.ToString("yyyy-MM-dd"); // "2024-01-15"
string dateStr3 = $"{now:yyyy年MM月dd日}"; // "2024年01月15日"
```
## 七、整数 和 枚举
```c#
public enum Status { Active = 1, Inactive = 0, Pending = 2 }
// enum → int
Status status = Status.Active;
int statusValue = (int)status; // 1
// int → enum
int value = 2;
Status fromInt = (Status)value; // Status.Pending
// string → enum
string statusStr = "Active";
Status fromStr = (Status)Enum.Parse(typeof(Status), statusStr); // Status.Active
// enum → string
string statusText = Status.Inactive.ToString(); // "Inactive"
```
## 练习
好的，这里有20道关于C#数据类型转换的单选题，涵盖了隐式转换、显式转换、Convert类、Parse/TryParse方法以及装箱拆箱等核心概念。
---
1. 以下哪种转换在C#中属于隐式转换？
A. int 转换为 long
B. double 转换为 int
C. decimal 转换为 float
D. long 转换为 int
2. 执行代码 int num = (int)3.14; 后，变量 num 的值是多少？
A. 3.14
B. 3
C. 4
D. 编译错误
3. 以下哪个方法最适合安全地将一个字符串（如用户输入）转换为整数？
A. (int)
B. Convert.ToInt()
C. int.Parse()
D. int.TryParse()
4. 代码 object obj = 10; int num = (int)obj; 演示了哪种概念？
A. 装箱
B. 拆箱
C. 隐式转换
D. 接口转换
5. 表达式 (double)10 / 4 的结果是什么？
A. 2
B. 2.0
C. 2.5
D. 2.50
6. Convert.ToInt32(5.6) 的返回值是？
A. 5
B. 6
C. 5.6
D. 运行时异常
7. 对于字符串 str = "123"，以下哪种转换方式会抛出异常？
A. int.Parse(str)
B. Convert.ToInt32(str)
C. (int)str
D. int.TryParse(str, out int result)
8. 代码 byte b = 200; int i = b; 执行时会发生什么？
A. 编译错误
B. 运行时错误
C. 隐式转换成功i 的值为200
D. 需要显式转换int i = (int)b
9. 以下关于 as 运算符的说法，哪一个是正确的？
A. 它可以用于任何值类型之间的转换。
B. 如果转换失败，它会返null。
C. 如果转换失败，它会抛InvalidCastException异常。
D. 它用于执行隐式转换。
10. 执行 bool success = int.TryParse("Hello", out int number); 后success 和 number 的值分别是？
A. true, 0
B. false, 0
C. true, null
D. false, null
11. 代码 var result = 5 + 2.5; 中，变量 result 的数据类型是？
A. int
B. double
C. decimal
D. string
12. 要将一个可空整数 int? nullableInt 安全地转换为 int，如果它为 null 则提供默认值0，应使用？
A. (int)nullableInt
B. nullableInt.Value
C. nullableInt.GetValueOrDefault()
D. Convert.ToInt32(nullableInt)
13. ToString() 方法实现了什么类型的转换？
A. 隐式转换
B. 显式转换
C. 装箱
D. 都不是，它是方法调用
14. 表达式 "5" + 1 在C#中的结果是？
A. 6
B. "51"
C. "6"
D. 编译错误
15. 以下哪种转换需要显式地进行（即可能导致精度丢失或运行时检查）？
A. short 转换为 int
B. int 转换为 short
C. float 转换为 double
D. char 转换为 int
16. decimal 和 double 之间？
A. 可以双向隐式转换
B. 可以双向显式转换
C. 只能从 double 显式转换为 decimal
D. 只能从 decimal 显式转换为 double
17. 代码 dynamic dyn = 100; int num = dyn; 会发生什么？
A. 编译错误
B. 运行时解析，转换成功
C. 运行时抛出异常
D. 需要显式转换int num = (int)dyn
18. 对于自定义结构体 MyStruct，如何定义一个到 int 的显式转换？
A. public static int explicit operator(MyStruct m) { ... }
B. public static explicit operator int(MyStruct m) { ... }
C. public int ToInt() { ... }
D. 结构体不能定义自定义转换
19. System.BitConverter 类的主要用途是？
A. 将基础数据类型与字节数组相互转换
B. 进行高性能的数学计算
C. 转换数字的进制（如十进制转二进制）
D. 处理字符串编码转换
20. 代码 IEnumerable<int> numbers = new List<int>(); var list = (List<int>)numbers; 可能会抛出异常，更安全的做法是使用？
A. var list = numbers as List<int>;
B. var list = numbers.ToList();
C. var list = Convert.ChangeType(numbers, typeof(List<int>));
D. var list = (List<int>)(object)numbers;
---
参考答案：
A
B
D
B
C
B (四舍六入五取偶，5.6入为6)
C
C
B
B
B
C
D
B (字符串连接)
B
B
B (动态类型在运行时解析)
B
A
A
as运算符在转换失败时返回null而不是抛出异常)