C# 中的类型转换

 

1. 装箱、拆箱还是别名

许多 C#.NET 的书上都有介绍 int -> Int32 是一个装箱的过程，反之则是拆箱的过程。许多其它变量类型也是如此，如：short <-> Int16，long <-> Int64 等。对于一般的程序员来说，大可不必去了解这一过程，因为这些装箱和拆箱的动作都是可以自动完成的，不需要写代码进行干预。但是我们需要记住这些类型之间的关系，所以，我们使用“别名”来记忆它们之间的关系。

C# 是全面向对象的语言，比 Java 的面向对象都还彻底——它把简单数据类型通过默认的装箱动作封装成了类。Int32、Int16、Int64 等就是相应的类名，而那些我们熟悉的、简单易记的名称，如 int、short、long 等，我们就可以把它称作是 Int32、Int16、Int64 等类型的别名。那么除了这三种类型之外，还有哪些类有“别名”呢？常用的有如下一些：

bool -> System.Boolean (布尔型，其值为 true 或者 false)

char -> System.Char (字符型，占有两个字节，表示 1 个 Unicode 字符)

byte -> System.Byte (字节型，占 1 字节，表示 8 位正整数，范围 0 ~ 255)

sbyte -> System.SByte (带符号字节型，占 1 字节，表示 8 位整数，范围 -128 ~ 127)

ushort -> System.UInt16 (无符号短整型，占 2 字节，表示 16 位正整数，范围 0 ~ 65,535)

uint -> System.UInt32 (无符号整型，占 4 字节，表示 32 位正整数，范围 0 ~ 4,294,967,295)

ulong -> System.UInt64 (无符号长整型，占 8 字节，表示 64 位正整数，范围 0 ~ 大约 10 的 20 次方)

short -> System.Int16 (短整型，占 2 字节，表示 16 位整数，范围 -32,768 ~ 32,767)

int -> System.Int32 (整型，占 4 字节，表示 32 位整数，范围 -2,147,483,648 到 2,147,483,647)

long -> System.Int64 (长整型，占 8 字节，表示 64 位整数，范围大约 -(10 的 19) 次方 到 10 的 19 次方)

float -> System.Single (单精度浮点型，占 4 个字节)

double -> System.Double (双精度浮点型，占 8 个字节)

我们可以用下列代码做一个实验：

private void TestAlias() {
    // this.textBox1 是一个文本框，类型为 System.Windows.Forms.TextBox
    // 设计中已经将其 Multiline 属性设置为 true
    byte a = 1; char b = 'a'; short c = 1;
    int d = 2; long e = 3; uint f = 4; bool g = true;
    this.textBox1.Text = "";
    this.textBox1.AppendText("byte -> " + a.GetType().FullName + "/n");
    this.textBox1.AppendText("char -> " + b.GetType().FullName + "/n");
    this.textBox1.AppendText("short -> " + c.GetType().FullName + "/n");
    this.textBox1.AppendText("int -> " + d.GetType().FullName + "/n");
    this.textBox1.AppendText("long -> " + e.GetType().FullName + "/n");
    this.textBox1.AppendText("uint -> " + f.GetType().FullName + "/n");
    this.textBox1.AppendText("bool -> " + g.GetType().FullName + "/n");
}在窗体中新建一个按钮，并在它的单击事件中调用该 TestAlias() 函数，我们将看到运行结果如下：

byte -> System.Byte

char -> System.Char

short -> System.Int16

int -> System.Int32

long -> System.Int64

uint -> System.UInt32

bool -> System.Boolean

这足以说明各别名对应的类！

2. 数值类型之间的相互转换

这里所说的数值类型包括 byte, short, int, long, fload, double 等，根据这个排列顺序，各种类型的值依次可以向后自动进行转换。举个例来说，把一个 short 型的数据赋值给一个 int 型的变量，short 值会自动行转换成 int 型值，再赋给 int 型变量。如下例：

private void TestBasic() {
    byte a = 1; short b = a; int c = b;
    long d = c; float e = d; double f = e;
    this.textBox1.Text = "";
    this.textBox1.AppendText("byte a = " + a.ToString() + "/n");
    this.textBox1.AppendText("short b = " + b.ToString() + "/n");
    this.textBox1.AppendText("int c = " + c.ToString() + "/n");
    this.textBox1.AppendText("long d = " + d.ToString() + "/n");
    this.textBox1.AppendText("float e = " + e.ToString() + "/n");
    this.textBox1.AppendText("double f = " + f.ToString() + "/n");
}译顺利通过，运行结果是各变量的值均为 1；当然，它们的类型分别还是 System.Byte 型……System.Double 型。现在我们来试试，如果把赋值的顺序反过来会怎么样呢？在 TestBasic() 函数中追加如下语句：

int g = 1;

short h = g;

this.textBox1.AppendText("h = " + h.ToString() + "/n");

结果编译报错：

G:/Projects/Visual C#/Convert/Form1.cs(118): 无法将类型“int”隐式转换为“short”

其中，Form1.cs 的 118 行即 short h = g 所在行。

这个时候，如果我们坚持要进行转换，就应该使用强制类型转换，这在 C 语言中常有提及，就是使用“(类型名) 变量名”形式的语句来对数据进行强制转换。如上例修改如下：

short g = 1;

byte h = (byte) g; // 将 short 型的 g 的值强制转换成 short 型后再赋给变量 h

this.textBox1.AppendText("h = " + h.ToString() + "/n");

编译通过，运行结果输出了 h = 1，转换成功。

但是，如果我们使用强制转换，就不得不再考虑一个问题：short 型的范围是 -32768 ~ 23767，而 byte 型的范围是 0 ~ 255，那么，如果变量 g 的大小超过了 byte 型的范围又会出现什么样的情况呢？我们不妨再一次改写代码，将值改为 265，比 255 大 10

short g = 265; //265 = 255 + 10

byte h = (byte) g;

this.textBox1.AppendText("h = " + h.ToString() + "/n");

编译没有出错，运行结果却不是 h = 265，而是 h = 9。

因此，我们在进行转换的时候，应当注意被转换的数据不能超出目标类型的范围。这不仅体现在多字节数据类型(相对，如上例的 short) 转换为少字节类型(相对，如上例的 byte) 时，也体现在字节数相同的有符号类型和无符号类型之间，如将 byte 的 129 转换为 sbyte 就会溢出。这方面的例子大同小异，就不详细说明了。

3. 字符的 ASCII 码和 Unicode 码

很多时候我们需要得到一个英文字符的 ASCII 码，或者一个汉字字符的 Unicode 码，或者从相关的编码查询它是哪一个字符的编码。很多人，尤其是从 VB 程序序转过来学 C# 的人，会报怨 C# 里为什么没有提供现成的函数来做这个事情——因为在 VB 中有 Asc() 函数和 Chr() 函数用于这类转换。

但是如果你学过 C，你就会清楚，我们只需要将英文字符型数据强制转换成合适的数值型数据，就可以得到相应的 ASCII 码；反之，如果将一个合适的数值型数据强制转换成字符型数据，就可以得到相应的字符。

C# 中字符的范围扩大了，不仅包含了单字节字符，也可以包含双字节字符，如中文字符等。而在字符和编码之间的转换，则仍延用了 C 语言的做法——强制转换。不妨看看下面的例子

private void TestChar() {
    char ch = 'a'; short ii = 65;
    this.textBox1.Text = "";
    this.textBox1.AppendText("The ASCII code of /'" + ch + "/' is: " + (short) ch + "/n");
    this.textBox1.AppendText("ASCII is " + ii.ToString() + ", the char is: " + (char) ii + "/n");
    char cn = '中'; short uc = 22478;
    this.textBox1.AppendText("The Unicode of /'" + cn + "/' is: " + (short) cn + "/n");
    this.textBox1.AppendText("Unicode is " + uc.ToString() + ", the char is: " + (char) uc + "/n");
}它的运行结果是

The ASCII code of 'a' is: 97

ASCII is 65, the char is: A

The Unicode of '中' is: 20013

Unicode is 22478, the char is: 城

从这个例子中，我们便能非常清楚的了解——通过强制转换，可以得以字符的编码，或者得到编码表示的字符。如果你需要的不是 short 型的编码，请参考第 1 条进行转换，即可得到 int 等类型的编码值。

4. 数值字符串和数值之间的转换

首先，我们得搞明白，什么是数值字符串。我们知道，在 C# 中，字符串是用一对双引号包含的若干字符来表示的，如 "123"。而 "123" 又相对特殊，因为组成该字符串的字符都是数字，这样的字符串，就是数值字符串。在我们的眼中，这即是一串字符，也是一个数，但计算机却只认为它是一个字符串，不是数。因此，我们在某些时候，比如输入数值的时候，把字符串转换成数值；而在另一些时候，我们需要相反的转换。

将数值转换成字符串非常简单，因为每一个类都有一个 void ToString() 方法。所有数值型的 void ToString() 方法都能将数据转换为数值字符串。如 123.ToSting() 就将得到字符串 "123"。

那么反过来，将数值型字符串转换成数值又该怎么办呢？我们仔细查找一下，会发现 short, int, float 等数值类型均有一个 static Parse() 函数。这个函数就是用来将字符串转换为相应数值的。我们以一个 float 类型的转换为例： float f = float.Parse("543.21"); 其结果 f 的值为 543.21F。当然，其它的数值类型也可以使用同样的方法进行转换，下面的例子可以更明确的说明转换的方法：

private void TestStringValue() {
    float f = 54.321F;
    string str = "123";
    this.textBox1.Text = "";
    this.textBox1.AppendText("f = " + f.ToString() + "/n");
    if (int.Parse(str) == 123) {
        this.textBox1.AppendText("str convert to int successfully.");
    } else {
        this.textBox1.AppendText("str convert to int failed.");
    }
}运行结果：

f = 54.321

str convert to int successfully.

5. 字符串和字符数组之间的转换

字符串类 System.String 提供了一个 void ToCharArray() 方法，该方法可以实现字符串到字符数组的转换。如下例：

private void TestStringChars() {
    string str = "mytest";
    char[] chars = str.ToCharArray();
    this.textBox1.Text = "";
    this.textBox1.AppendText("Length of /"mytest/" is " + str.Length + "/n");
    this.textBox1.AppendText("Length of char array is " + chars.Length + "/n");
    this.textBox1.AppendText("char[2] = " + chars[2] + "/n");
}例中以对转换转换到的字符数组长度和它的一个元素进行了测试，结果如下：

Length of "mytest" is 6

Length of char array is 6

char[2] = t

可以看出，结果完全正确，这说明转换成功。那么反过来，要把字符数组转换成字符串又该如何呢？

我们可以使用 System.String 类的构造函数来解决这个问题。System.String 类有两个构造函数是通过字符数组来构造的，即 String(char[]) 和 String[char[], int, int)。后者之所以多两个参数，是因为可以指定用字符数组中的哪一部分来构造字符串。而前者则是用字符数组的全部元素来构造字符串。我们以前者为例，在 TestStringChars() 函数中输入如下语句：

char[] tcs = {'t', 'e', 's', 't', ' ', 'm', 'e'};

string tstr = new String(tcs);

this.textBox1.AppendText("tstr = /"" + tstr + "/"/n");

运行结果输入 tstr = "test me"，测试说明转换成功。

实际上，我们在很多时候需要把字符串转换成字符数组只是为了得到该字符串中的某个字符。如果只是为了这个目的，那大可不必兴师动众的去进行转换，我们只需要使用 System.String 的 [] 运算符就可以达到目的。请看下例，再在 TestStringChars() 函数中加入如如下语名：

char ch = tstr[3];

this.textBox1.AppendText("/"" + tstr + "/"[3] = " + ch.ToString());

正确的输出是 "test me"[3] = t，经测试，输出正确。

6. 字符串和字节数组之间的转换

如果还想从 System.String 类中找到方法进行字符串和字节数组之间的转换，恐怕你会失望了。为了进行这样的转换，我们不得不借助另一个类：System.Text.Encoding。该类提供了 bye[] GetBytes(string) 方法将字符串转换成字节数组，还提供了 string GetString(byte[]) 方法将字节数组转换成字符串。

System.Text.Encoding 类似乎没有可用的构造函数，但我们可以找到几个默认的 Encoding，即 Encoding.Default(获取系统的当前 ANSI 代码页的编码)、Encoding.ASCII(获取 7 位 ASCII 字符集的编码)、Encoding.Unicode(获取采用 Little-Endian 字节顺序的 Unicode 格式的编码)、Encoding.UTF7(获取 UTF-7 格式的编码)、Encoding.UTF8(获取 UTF-8 格式的编码) 等。这里主要说说 Encoding.Default 和 Encoding.Unicode 用于转换的区别。

在字符串转换到字节数组的过程中，Encoding.Default 会将每个单字节字符，如半角英文，转换成 1 个字节，而把每个双字节字符，如汉字，转换成 2 个字节。而 Encoding.Unicode 则会将它们都转换成两个字节。我们可以通过下列简单的了解一下转换的方法，以及使用 Encoding.Default 和 Encodeing.Unicode 的区别：

private void TestStringBytes() {
    string s = "C#语言";
    byte[] b1 = System.Text.Encoding.Default.GetBytes(s);
    byte[] b2 = System.Text.Encoding.Unicode.GetBytes(s);
    string t1 = "", t2 = "";
    foreach (byte b in b1) {
        t1 += b.ToString("") + " ";
    }
    foreach (byte b in b2) {
        t2 += b.ToString("") + " ";
    }
    this.textBox1.Text = "";
    this.textBox1.AppendText("b1.Length = " + b1.Length + "/n");
    this.textBox1.AppendText(t1 + "/n");
    this.textBox1.AppendText("b2.Length = " + b2.Length + "/n");
    this.textBox1.AppendText(t2 + "/n");
}
运行结果如下，不说详述，相信大家已经明白了。

b1.Length = 6

67 35 211 239 209 212

b2.Length = 8

67 0 35 0 237 139 0 138

将字节数组转换成字符串，使用 Encoding 类的 string GetString(byte[]) 或 string GetString(byte[], int, int) 方法，具体使用何种 Encoding 还是由编码决定。在 TestStringBytes() 函数中添加如下语句作为实例：

byte[] bs = {97, 98, 99, 100, 101, 102};

string ss = System.Text.Encoding.ASCII.GetString(bs);

this.textBox1.AppendText("The string is: " + ss + "/n");

运行结果为：The string is: abcdef

7. 各种数值类型和字节数组之间的转换

在第 1 条中我们可以查到各种数值型需要使用多少字节的空间来保存数据。将某种数值类型的数据转换成字节数组的时候，得到的一定是相应大小的字节数组；同样，需要把字节数组转换成数值类型，也需要这个字节数组大于相应数值类型的字节数。现在介绍此类转换的主角：System.BitConverter。该类提供了 byte[] GetBytes(...) 方法将各种数值类型转换成字节数组，也提供了 ToInt32、ToInt16、ToInt64、ToUInt32、ToSignle、ToBoolean 等方法将字节数组转换成相应的数值类型。

由于这类转换通常只是在需要进行较细微的编码/解码操作时才会用到，所以这里就不详细叙述了，仅把 System.BitConverter 类介绍给大家。

8. 转换成十六进制

任何数据在计算机内部都是以二进制保存的，所以进制与数据的存储无关，只与输入输出有关。所以，对于进制转换，我们只关心字符串中的结果。

在上面的第 4 条中提到了 ToString() 方法可以将数值转换成字符串，不过在字符串中，结果是以十进制显示的。现在我们带给它加一些参数，就可以将其转换成十六进制——使用 ToString(string) 方法。这里需要一个 string 类型的参数，这就是格式说明符。十六进制的格式说明符是 "x" 或者 "X"，使用这两种格式说明符的区别主要在于 A-F 六个数字："x" 代表 a-f 使用小写字母表示，而 "X" 而表示 A-F 使用大字字母表示。如下例：

private void TestHex() {
    int a = 188;
    this.textBox1.Text = "";
    this.textBox1.AppendText("a(10) = " + a.ToString() + "/n");
    this.textBox1.AppendText("a(16) = " + a.ToString("x") + "/n");
    this.textBox1.AppendText("a(16) = " + a.ToString("X") + "/n");
}运行结果如下：

a(10) = 188

a(16) = bc

a(16) = BC

这时候，我们可能有另一种需求，即为了显示结果的整齐，我们需要控制十六进制表示的长度，如果长度不够，用前导的 0 填补。解决这个问题，我们只需要在格式说明符“x”或者“X”后写上表示长度的数字就行了。比如，要限制在 4 个字符的长度，可以写成“X4”。在上例中追加一句：

this.textBox1.AppendText("a(16) = " + a.ToString("X4") + "/n");

其结果将输出 a(16) = 00BC。

现在，我们还要说一说如何将一个表示十六进制数的字符串转换成整型。这一转换，同样需要借助于 Parse() 方法。这里，我需要 Parse(string, System.Globalization.NumberStyles) 方法。第一个参数是表示十六进制数的字符串，如“AB”、“20”(表示十进制的 32) 等。第二个参数 System.Globalization.NumberStyles 是一个枚举类型，用来表示十六进制的枚举值是 HexNumber。因此，如果我们要将“AB”转换成整型，就应该这样写：int b = int.Parse("AB", System.Globalization.NumberStyles.HexNumber)，最后得到的 b 的值是 171。

 9. 日期型数据和长整型数据之间的转换

为什么要将日期型数据转换为长整型数据呢？原因很多，但就我个人来说，经常将它用于数据库的日期存储。由于各种数据库对日期型的定义和处理是不一样的，各种语言对日期型数据的定义的处理也各不相同，因为，我宁愿将日期型数据转换成长整型再保存到数据库中。虽然也可以使用字符串来保存，但使用字符串也会涉及到许多问题，如区域等问题，而且，它需要比保存长整型数据更多的空间。

日期型数据，在 C# 中的参与运算的时候，应该也是转换为长整型数据来运算的。它的长整型值是自 0001 年 1 月 1 日午夜 12:00 以来所经过时间以 100 毫微秒为间隔表示时的数字。这个数在 C# 的 DateTime 中被称为 Ticks(刻度)。DateTime 类型有一个名为 Ticks 的长整型只读属性，就保存着这个值。如此，要从一个 DataTime 型数据得到 long 型值就非常简单了，只需要读出 DataTime 对象的 Ticks 值即可，如：

long longDate = DateTime.Now.Ticks;

DateTime 的构造函数中也提供了相应的，从长整型数据构造 DateTime 型数据的函数：DateTime(long)。如：

DateTime theDate = new DateTime(longDate);

但这样对于很多 VB6 程序员来说，是给他们出了一道难题，因为 VB6 中的日期型数据内部是以 Double 型表示的，将其转换为长整型后得到的仅仅是日期，而没有时间。如何协调这两种日期类型呢？

System.DateTime 提供了 double ToOADate() 和 static DateTime FromOADate(double) 两个函数来解决这个问题。前者将当前对象按原来的 double 值输出，后者则从一个 double 值获得一个 System.DateTime 对象。举例如下：

private void TestDateTimeLong() {
    double doubleDate = DateTime.Now.ToOADate();
    DateTime theDate = DateTime.FromOADate(doubleDate);
    this.textBox1.Text = "";
    this.textBox1.AppendText("Double value of now: " + doubleDate.ToString() + "/n");
    this.textBox1.AppendText("DateTime from double value: " + theDate.ToString() + "/n");
}运行结果：

Double value of now: 37494.661541713

DateTime from double value: 2002-8-26 15:52:37

10. 格式化日期型数据

编程的过程中，通常需要将日期型数据按照一定的格式输出，当然，输出结果肯定是字符串。为此，我们需要使用 System.DateTime 类的 ToString() 方法，并为其指定格式字符串。MSDN 中，System.Globalization.DateTimeFormatInfo 类的概述里对模式字符串有非常详细的说明，因此，这里我只对常用的一些格式进行说明，首先请看下表：

d
 月中的某一天
 一位数的日期没有前导零
 
dd
 月中的某一天
 一位数的日期有一个前导零
 
ddd
 周中某天的缩写名称
 在 AbbreviatedDayNames 中定义
 
dddd
 周中某天的完整名称
 在 DayNames 中定义
 
M
 月份数字
 一位数的月份没有前导零
 
MM
 月份数字
 一位数的月份有一个前导零
 
MMM
 月份的缩写名称
 在 AbbreviatedMonthNames 中定义
 
MMMM
 月份的完整名称
 在 MonthNames 中定义
 
y
 不包含纪元的年份
 如果不包含纪元的年份小于 10，则显示不具有前导零的年份
 
yy
 不包含纪元的年份
 如果不包含纪元的年份小于 10，则显示具有前导零的年份
 
yyyy
 包括纪元的四位数的年份
 
 
h
 12 小时制的小时
 一位数的小时数没有前导零
 
hh
 12 小时制的小时
 一位数的小时数有前导零
 
H
 24 小时制的小时
 一位数的小时数没有前导零
 
HH
 24 小时制的小时
 一位数的小时数有前导零
 
m
 分钟
 一位数的分钟数没有前导零
 
mm
 分钟
 一位数的分钟数有一个前导零
 
s
 秒
 一位数的秒数没有前导零
 
ss
 秒
 一位数的秒数有一个前导零
 

为了便于大家的理解，不妨试试下面的程序：

private void TestDateTimeToString() {
    DateTime now = DateTime.Now;
    string format;
    this.textBox1.Text = "";
    format = "yyyy-MM-dd HH:mm:ss";
    this.textBox1.AppendText(format + ": " + now.ToString(format) + "/n");
    format = "yy年M日d日";
    this.textBox1.AppendText(format + ": " + now.ToString(format) + "/n");
}这段程序将输出结果：

yyyy-MM-dd HH:mm:ss: 2002-08-26 17:03:04

yy年M日d日: 02年8日26日

这时候，又出现一个问题，如果要输出的文本信息中包含格式字符怎么办？如

format = "year: yyyy, month: MM, day: dd";

this.textBox1.AppendText(now.ToString(format) + "/n");

将输出：

2ear: 2002, 4on下5: 08, 26a2: 26

这并不是我想要的结果，怎么办呢？有办法——

format = "/"year/": yyyy, /'month/': MM, /'day/': dd";

this.textBox1.AppendText(now.ToString(format) + "/n");

看，这次运行结果对了：

year: 2002, month: 08, day: 26

可以看出，只需要使用单引号或者双引号将文本信息括起来就好。

11.String 转换为 Int

Q：如何把string解析为int？

A：简单的方法有三种：

 

Q：这三种方法有什么不同？

A：一个简单的回答是：

如果解析失败，Int32.Parse(source)总会抛出异常；Convert.ToInt32(source)在source为null的情况下不会抛出异常而是简单的返回0给调用方；而Int32.TryParse(source, result)则无论如何都不抛出异常，只会返回true或false来说明解析是否成功，如果解析失败，调用方将会得到0值。

Q：如果我要解析的字符串的字面数值不是十进制的话，那么从这些方法中得到的返回值是有问题的。有什么方法解决？

A：那么你就需要这些方法的对应重载版本了，一个简单的方法是使用Convert类的

 

其中fromBase的值只能为2、8、10或者16，用于指定进制方式。如果fromBase不是指定的数值或者value不为十进制而又带有前缀正负号，就会抛出ArgumentException。

 

当然，你还可以通过为Int32类的

 

指定NumberStyles.AllowHexSpecifier或者NumberStyles.HexNumber为第二个参数来解析十六进制字面值的字符串，此时，你需要引用System.Globalization命名空间。

或者使用Int32类的

 

并指定NumberStyles.AllowHexSpecifier或者NumberStyles.HexNumber为第二个参数，null为第三个参数来解析十六进制字面值的字符串。你当然也应该引用System.Globalization命名空间。

这里有一点要提醒的是，无论使用Parse或者TryParse方法来解析十六进制，字符串都不能出现0x或0X前缀，否则将会抛出异常。

Q：如果我要把使用科学记数法表示的string转换为int又该如何呢？

A：你可以通过把NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent（把两个NunberStyles枚举进行位运算，其中前者说明可能存在小数点，而后者则说明可能存在科学记数法的指数符号）作为第二个参数传递给Int32类的

 

或者

 

如果解析出来的结果与int不兼容的，就要考虑把结果储存在别的类型了。例如"1.412e2"就应该把解析结果存放到float或者double或者decimal类型的变量里，当然，你也应该使用与储存变量相对应的类型的方法来解析：

 

整个字符串表达式应该没有任何任何空格，否则将有可能抛出异常。

科学记数法的格式为[{+|-}]m.dddddd{e|E}[{+|-}]xx，可以分解为以下几种形式：

• [-]m.dddddde+xx
• [-]m.dddddde-xx
• [-]m.ddddddE+xx
• [-]m.ddddddE-xx

下面列举一些不能正常解析的：

• "1.412 e3"
• "1.412E 3"
• "1.412e +3"
• "141200E- 2"

Q：如何处理待解析string里所包含的空格？

A：对于字符串的前缀或后缀空格，你同样有多种选择，一般情况下，你可以直接使用String类的

 

来取掉头尾可能包含的空格：

 

又或者，你使用NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite来告诉Parse或TryParse待解析字符串的头尾可能包含着空格。

 

如果待解析的字符串使用科学记数法来表示，那么你可以

 

其中NumberStyles.Float告诉Parse方法待解析的字符串可能前缀或后缀的空格、前缀正负号、（十进制）小数点、科学记数法指数表示等。

Q：如何处理货币字符串的解析？

A：你可以通过指定NumberStyles.Currency来告诉Parse或TryParse待解析的字符串是货币样式的。NumberStyles.Currency说明待解析字符串可能包含前缀或后缀空格、前缀正负号、十进制小数点、千分位符号、字面数值可能为整数或小数等：

 

但货币样式字符串不能带有任何十六进制符号。另外，货币样式字符串格式的相关设定以Region and Languages Options（区域与语言选项）里面的设定为基准。

Q：如果我更改系统的Region and Languages Options（区域与语言选项）里面的设置，但又希望不按照里面的设置来解析字符串呢？

A：这个时候就轮到NumberFormatInfo类出场了，这个类能够让你无需对系统的设置作任何修改而直接告诉相关的方法如何处理字符串里的相关符号。

对应上图，我们通过NumberFormatInfo的相关属性来设定Customerize Regional Options（自定义区域选项）中Currency（货币）选项卡里的相关设定：

NumberFormatInfo	Currency（货币）
CurrencySymbol	Currency symbol（货币符号）
CurrencyPositivePattern	Positive currency format（货币正数格式）
CurrencyNegativePattern	Negative currency format（货币符号格式）
CurrencyDecimalSeparator	Decimal symbol（小数点）
CurrencyDecimalDigits	No. of digits after decimal（小数数位）
CurrencyGroupSeparator	Digit grouping symbol（数字分组符号）

其中，Customerize Regional Options（自定义区域选项）中Currency（货币）选项卡里的Digit grouping（数字分组）需要结合NumberFormatInfo的CurrencyGroupSeparator和CurrencyGroupSizes两个属性来设定。而NumberFormatInfo的CurrencyPositivePattern和CurrencyNegativePattern属性的设值是有限制的：

CurrencyPositivePattern
Value	Associated Pattern
0	$n
1	n$
2	$ n
3	n $

CurrencyNegativePattern
Value	Associated Pattern
0	($n)
1	-$n
2	$-n
3	$n-
4	(n$)
5	-n$
6	n-$
7	n$-
8	-n $
9	-$ n
10	n $-
11	$ n-
12	$ -n
13	n- $
14	($ n)
15	(n $)

Q：设置好的NumberFormatInfo的实例应该怎么使用？

A：NumberFormatInfo是IFormatProvider接口的一个实现，你可以把NumberFormatInfo的实例作为参数传递给对应的重载方法。

Q：那么，Customerize Regional Options（自定义区域选项）中Numbers（数字）选项卡里的设定是否也能通过NumberFormatInfo的对应属性来设置？

A：不全是，其中Display leading zeros（零起始显示）、List separator（列表分隔符）、Measurement system（度量衡系统）这三项没有；Negative number format（负数格式）需要同时结合使用NumberFormatInfo的NegativeSign、NumberDecimalDigits、NumberDecimalSeparator等来设置；其他的都能在NumberFormatInfo中找到与之对应的属性。

Q：那么，Display leading zeros（零起始显示）、List separator（列表分隔符）、Measurement system（度量衡系统）这三项在哪里有对应的设置呢？

A：很抱歉，到目前为止我也找不到对应的地方来设置，如果你或者其他人找到了，请务必告诉我。（不过，你可以通过RegionInfo.IsMetric这个只读属性来检测当前系统是否使用Metric（公制）度量系统。）

Q：如果我无法推断待解析的字符串应该使用哪一个或多个NumberStyles枚举呢？

A：这种情况一般不会发生，待解析的字符串肯定是有一定的目的或用途的，这些目的或用途就是字符串字面样式的约束，而NumberStyles枚举的作用就是说明这种约束的。当然，如果你目前确实无法推断，那么你可以使用NumberStyles.Any枚举。

Q：在具体的编码过程中，我如何知道应该选择哪一种方法来解析字符串呢？

A：就我个人来说，我会：

• 首先，你得清楚你所使用的CLR版本是否提供某种方法的支持，例如，TryParse是.NET 2.0或以上才支持的。
• 其次，你可以通过方法的重载签名来选择，如果你要解析非十进制的字符串，Convert.ToInt32可能是你唯一的选择，除了十进制和十六进制，你可以用它来解析二进制、八进制，但你不能用Int32.Parse或Int32.TryParse来解释这些进制的字符串。当然如果是十进制或者十六进制就哪种方法都可以。
• 另外，如果你需要使用NumberStyles枚举来告知相关方法待解析的字符串的样式，那么Convert.ToInt32就帮不了你了，此时你应该选择Int32.Parse或者Int32.TryParse相应的重载。
• 再次，如果你不希望在你的代码里处理异常，那么Int32.TryParse可能是你唯一的选择，你可能根据它的返回至来判断解析是否成功，进而决定是否使用解析结果。但如果你希望透过异常机制通知调用方解析失败，那么Int32.Parse或者Convert.ToInt32都是不错的选择。
• 最后，选择准则不可能唯一或者通用的的，你可能会在实践总结出适合你自己的选择准则，如果你有更好的选择方法，请你也告诉我一声。

Q：在.NET里面，如果要将string解析为其它的基元类型（Primitive Type）是否也有类似的方法？

A：是的，在.NET里面，我们为这些基元类型提供了Convert.ToPrimitiveType、PrimitiveType.Parse、PrimitiveType.TryParse（.NET 2.0或以上）方法，用于把string解析成对应的基元类型，当然，你得首先保证待解析的string字面值与对应的基元类型兼容。这些基元类型是（括号中是对应的C#关键字）：SByte (sbyte), Byte (byte), Int16 (short), UInt16 (ushort), Int32 (int), UInt32 (uint), Int64 (long) , UInt64 (ulong), Char (char), Single (float), Double (double) , Boolean (bool), Decimal (decimal)。另外，.NET也提供了把string解析为DateTime结构的方法，除了有上面提到的三种形式（Convert.ToDateTime、DateTime.Parse、DateTime.TryParse）之外，我们还可以使用DateTime.TryParseExact。所有的这些方法都是大同小异，差别在于对字符串字面值格式（包括其所包含符号）的规定，有兴趣的话，你可以参考以下MSDN的文档或者其他专题资料。

int  result  =  Int32.Parse( "  $1,412  " , NumberStyles.Currency);

int  result  =  Int32.Parse( "  1.412e3  " , NumberStyles.Float);

int  result  =  Int32.Parse(textBox1.Text, NumberStyles.AllowLeadingWhite  |  NumberStyles.AllowTrailingWhite);

int  result  =  Int32.Parse(textBox1.Text.Trim());

public   string  Trim();

double  result  =  Double.Parse( " 1.412e2 " , NumberStyles.AllowDecimalPoint  |  NumberStyles.AllowExponent);

public   static   bool  TryParse( string  s, NumberStyles style, IFormatProvider provider,  out   int  result);

public   static   int  Parse( string  s, NumberStyles style);

public   static   bool  TryParse( string  s, NumberStyles style, IFormatProvider provider,  out   int  result);

public   static   int  Parse( string  s, NumberStyles style);

string  source  =   " 0x1412 " ;  //  这里的0x（或0X）前缀是可选的。
int  result  =  Convert.ToInt32(source,  16 );

public   static   int  ToInt32( string  value,  int  fromBase);

string  source  =   " 1412 " ;
int  result  =   0 ;

//  使用Convert.ToInt32(string value);
result  =  Convert.ToInt32(source);

//  使用Int32.Parse(string value);
result  =  Int32.Parse(source);

//  使用Int32.TryParse(string s, out int result);
Int32.TryParse(source,  out  result);