C#基础（1）：类型转换

1. 装箱与拆箱　　

　　C#的数据类型分为基本类型和引用类型两种，将基本类型转成引用类型的过程，称之为“装箱”；将引用类型转成基本类型的过程，称之为“拆箱”，“装箱”的过程，会在内存的堆中建立一个基本类型的副本，请看以下代码（代码来自MSDN）：

class TestBoxing
{
    static void Main()
    {
        int i = 123;
        object o = i;  // Implicit boxing

        i = 456;  // Change the contents of i

        System.Console.WriteLine("The value-type value = {0}", i);
        System.Console.WriteLine("The object-type value = {0}", o);
    }
}
/* Output:
    The value-type value = 456
    The object-type value = 123
*/

　　这个例子很好的说明了“装箱”后的变量的地址和原有变量的地址是不一样的，即“装箱”的过程中建立了一个原有变量的副本。

 

2. 隐式转换与显示转换

　　关于类型之间需要进行转换的主要原因，在于面向对象的两个主要特性：继承和多态。以父类类型声明的变量，其实现可以指向子类，这个过程是不需要显示表示的，称之为隐式转换；反过来的话，是需要在代码中显示的，称之为“显示转换”。

 

3. AS和IS的使用

　　由于在类型转换的过程中如果使用a = (int)x;这种形式时，很可能会触发InvalidCastException，为了避免这种情况，产生了AS和IS。如果只是需要判断变量是否是某一类型，而不需要真正转换时，我们可以使用IS操作符；如果我们需要将变量转换成某一种类型，我们可以使用AS。IS返回bool值，代表变量是否是某一类型的；AS使用时，如果转换成功，返回转换后的结果，如果转换失败，返回NULL。请看以下代码（代码来自MSDN）：

class SafeCasting
{
    class Animal
    {
        public void Eat() { Console.WriteLine("Eating."); }
        public override string ToString()
        {
            return "I am an animal.";
        }
    }
    class Mammal : Animal { }
    class Giraffe : Mammal { }

    class SuperNova { }

    static void Main()
    {
        SafeCasting app = new SafeCasting();

        // Use the is operator to verify the type.
        // before performing a cast.
        Giraffe g = new Giraffe();
        app.UseIsOperator(g);

        // Use the as operator and test for null
        // before referencing the variable.
        app.UseAsOperator(g);

        // Use the as operator to test
        // an incompatible type.
        SuperNova sn = new SuperNova();
        app.UseAsOperator(sn);

        // Use the as operator with a value type.
        // Note the implicit conversion to int? in 
        // the method body.
        int i = 5;
        app.UseAsWithNullable(i);


        double d = 9.78654;
        app.UseAsWithNullable(d);

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }

    void UseIsOperator(Animal a)
    {
        if (a is Mammal)
        {
            Mammal m = (Mammal)a;
            m.Eat();
        }
    }

    void UseAsOperator(object o)
    {
        Mammal m = o as Mammal;
        if (m != null)
        {
            Console.WriteLine(m.ToString());
        }
        else
        {
            Console.WriteLine("{0} is not a Mammal", o.GetType().Name);
        }
    }

    void UseAsWithNullable(System.ValueType val)
    {
        int? j = val as int?;
        if (j != null)
        {
            Console.WriteLine(j);
        }
        else
        {
            Console.WriteLine("Could not convert " + val.ToString());
        }
    }
}

上述代码的执行结果如下：

Eating.
I am an animal.
SuperNova is not a Mammal
5
Could not convert 9.78654
Press any key to exit.

 

4. Convert类与类型转换

　　如果我们面临一个问题：将一个字符串转换为int类型，你能想到几种实现方式呢？请看以下代码：

//将一个字符串转换为int
string str = "29";

//方法一：使用Convert类
int numVal = Convert.ToInt32(str);
numVal++;

//方法二：使用Int32.Parse方法
int numVal = Int32.Parse(str);
Console.WriteLine(numVal);

//方法三：使用Int32.TryParse方法
int j;
Int32.TryParse("-105", out j);
Console.WriteLine(j);

　　关于Parse方法和TryParse方法，以下代码说明了两者的不同：

//使用Parse方法
try
{
    int m = Int32.Parse("abc");
}
catch (FormatException e)
{
    Console.WriteLine(e.Message);
}
// Output: Input string was not in a correct format.

//使用TryParse方法
string inputString = "abc";
int numValue;
bool parsed = Int32.TryParse(inputString, out numValue);

if (!parsed)
    Console.WriteLine("Int32.TryParse could not parse '{0}' to an int.\n", inputString);

// Output: Int32.TryParse could not parse 'abc' to an int.

 

5. BitConverter类的使用

BitConverter类主要用来将基础数据类型与字节数组相互转换。例如，当我们在网络上接收到的数据一般都是字节数组，在实际的应用程序中，我们可能需要将其转换成其他类型，请看以下代码：

byte[] bytes = { 0, 0, 0, 25 };

// If the system architecture is little-endian (that is, little end first),
// reverse the byte array.
if (BitConverter.IsLittleEndian)
    Array.Reverse(bytes);

int i = BitConverter.ToInt32(bytes, 0);
Console.WriteLine("int: {0}", i);
// Output: int: 25

　　还有以下代码：

string hexString = "43480170";
uint num = uint.Parse(hexString, System.Globalization.NumberStyles.AllowHexSpecifier);

byte[] floatVals = BitConverter.GetBytes(num);
float f = BitConverter.ToSingle(floatVals, 0);
Console.WriteLine("float convert = {0}", f);

// Output: 200.0056   

 

6. 总结

（1） 类型转换是程序语言中一个基本的知识，转换的方式也是灵活多变的，我们需要很好的掌握，基础很重要。

（2） 善用MSDN。
string hexString = "43480170";
uint num = uint.Parse(hexString, System.Globalization.NumberStyles.AllowHexSpecifier);

byte[] floatVals = BitConverter.GetBytes(num);
float f = BitConverter.ToSingle(floatVals, 0);
Console.WriteLine("float convert = {0}", f);

// Output: 200.0056