Using的用法

1.using指令。using + 命名空间名字，这样可以在程序中直接用命令空间中的类型，而不必指定类型的详细命名空间，类似于Java的import，这个功能也是最常用的，几乎每个cs的程序都会用到。
例如：using System; 一般都会出现在*.cs中。

2.using别名。using + 别名 = 包括详细命名空间信息的具体的类型。
这种做法有个好处就是当同一个cs引用了两个不同的命名空间，但两个命名空间都包括了一个相同名字的类型的时候。当需要用到这个类型的时候，就每个地方都要用详细命名空间的办法来区分这些相同名字的类型。而用别名的方法会更简洁，用到哪个类就给哪个类做别名声明就可以了。注意：在.net3.5中并不需要给用到的重名的每个类都起别名，当然重名了用到的时候都起别名更好。

例如：

1. namespace NameSpace1
2. {
3.     public class MyClass
4.     {
5.         public override string ToString()
6.         {
7.             return "You are in NameSpace1.MyClass";
8.         }
9.     }
10. }
11. 
    
12. namespace NameSpace2
13. {
14.     class MyClass
15.     {
16.         public override string ToString()
17.         {
18.             return "You are in NameSpace2.MyClass";
19.         }
20.     }
21. }
22. 
    
23. namespace testUsing
24. {
25.     using System;
26.     //这里重名的两个类都起了别名，实际上3.5中不需要都起别名
27.     using aClass = NameSpace1.MyClass;
28.     using bClass = NameSpace2.MyClass;
29.     
30.     class Class1
31.     {
32.         static void Main(string[] args)
33.         {
34.             aClass my1 = new aClass();
35.             Console.WriteLine(my1);
36.             bClass my2 = new bClass();
37.             Console.WriteLine(my2);
38.             Console.WriteLine("Press any key");
39.             Console.Read();
40.         }
41.     }
42. }

实际上，我们反编译上面的代码后，就会发现，IL语言中还是使用全路径的。具体IL代码如下：

1. .class private auto ansi beforefieldinit Class1
2.     extends [mscorlib]System.Object
3. {
4.     .method public hidebysig specialname rtspecialname instance void .ctor() cil managed
5.     {
6.         .maxstack 8
7.         L_0000: ldarg.0 
8.         L_0001: call instance void [mscorlib]System.Object::.ctor()
9.         L_0006: ret 
10.     }
11. 
    
12.     .method private hidebysig static void Main(string[] args) cil managed
13.     {
14.         .entrypoint
15.         .maxstack 1
16.         .locals init (
17. 
    
18.             [0] class NameSpace1.MyClass my1,
19.             [1] class NameSpace2.MyClass my2
20.                      
    
21.                         )
22. 
    
23.         L_0000: nop 
24.         L_0001: newobj instance void NameSpace1.MyClass::.ctor()
25.         L_0006: stloc.0 
26.         L_0007: ldloc.0 
27.         L_0008: call void [mscorlib]System.Console::WriteLine(object)
28.         L_000d: nop 
29.         L_000e: newobj instance void NameSpace2.MyClass::.ctor()
30.         L_0013: stloc.1 
31.         L_0014: ldloc.1 
32.         L_0015: call void [mscorlib]System.Console::WriteLine(object)
33.         L_001a: nop 
34.         L_001b: ldstr "Press any key"
35.         L_0020: call void [mscorlib]System.Console::WriteLine(string)
36.         L_0025: nop 
37.         L_0026: call int32 [mscorlib]System.Console::Read()
38.         L_002b: pop 
39.         L_002c: ret 
40.     }
41. 
    
42. }
43. 
    
44. 
    

从上面粗体的部分可以看出来，c#中做没做别名，到了IL这里，根本就不知道。别名只是提供给我们方便而已。

3.using语句，定义一个范围，在范围结束时处理对象。
场景：
当在某个代码段中使用了类的实例，而希望无论因为什么原因，只要离开了这个代码段就自动调用这个类实例的Dispose方法。
要达到这样的目的，用try...catch来捕捉异常也是可以的，但用using更方便。
这里需要注意的就是using()里声明的对象所属的类必须是实现了IDispose()接口的类型，如果该类没有实现IDisposable接口，编译器就会很生气，抛出一个错：Error type used in a using statement must be implicitly convertible to 'System.IDisposable'！！！
另外提醒大家，using()里并不是只可以声明一个变量，是可以声明好多变量的！！！
例如：

2. using System;
3. namespace NameSpace1
4. {
5.     public class MyClass : IDisposable
6.     {
7.         public override string ToString()
8.         {
9.             return "You are in NameSpace1.MyClass";
10.         }
12.         public void Dispose()
13.         {
14.             Console.WriteLine("i am in dispose function!");
15.         }
16.     }
17. }
19. namespace testUsing
20. {
21.     using aClass = NameSpace1.MyClass;
22.     
23.     class Class1
24.     {
25.         static void Main(string[] args)
26.         {
27.             using(aClass oTest = new aClass())
28.             {
29.                 oTest.ToString();
30.             }
31.             Console.WriteLine("Press any key");
32.             Console.Read();
33.         }
34.     }
35. }

为了证实using结束时，会调用using()中定义的对象的dispose()，我们把上面的代码反编译为IL语言，仔细的来看一下，IL代码如下：
MyClass类的反编译代码，平淡无奇，构造器、Dispose方法、 ToString方法：

1. .class public auto ansi beforefieldinit MyClass
2.     extends [mscorlib]System.Object
3.     implements [mscorlib]System.IDisposable
4. {
5.     .method public hidebysig specialname rtspecialname instance void .ctor() cil managed
6.     {
7.         .maxstack 8
8.         L_0000: ldarg.0 
9.         L_0001: call instance void [mscorlib]System.Object::.ctor()
10.         L_0006: ret 
11.     }
13.     .method public hidebysig newslot virtual final instance void Dispose() cil managed
14.     {
15.         .maxstack 8
16.         L_0000: nop 
17.         L_0001: ldstr "i am in dispose function!"
18.         L_0006: call void [mscorlib]System.Console::WriteLine(string)
19.         L_000b: nop 
20.         L_000c: ret 
21.     }
23.     .method public hidebysig virtual instance string ToString() cil managed
24.     {
25.         .maxstack 1
26.         .locals init (
27.             [0] string CS$1$0000)
28.         L_0000: nop 
29.         L_0001: ldstr "You are in NameSpace1.MyClass"
30.         L_0006: stloc.0 
31.         L_0007: br.s L_0009
32.         L_0009: ldloc.0 
33.         L_000a: ret 
34.     }
36. }

关键是看Class1的反编译代码：

1. .class private auto ansi beforefieldinit Class1
2.     extends [mscorlib]System.Object
3. {
4.     .method public hidebysig specialname rtspecialname instance void .ctor() cil managed
5.     {
6.         .maxstack 8
7.         L_0000: ldarg.0 
8.         L_0001: call instance void [mscorlib]System.Object::.ctor()
9.         L_0006: ret 
10.     }
12.     .method private hidebysig static void Main(string[] args) cil managed
13.     {
14.         .entrypoint
15.         .maxstack 2
16.         .locals init (
17.             [0] class NameSpace1.MyClass oTest,
18.             [1] bool CS$4$0000)
19.         L_0000: nop 
20.         L_0001: newobj instance void NameSpace1.MyClass::.ctor()
21.         L_0006: stloc.0 
22.         L_0007: nop 
23.         L_0008: ldloc.0 
24.         L_0009: callvirt instance string [mscorlib]System.Object::ToString()
25.         L_000e: pop 
26.         L_000f: nop 
27.         L_0010: leave.s L_0022
28.         L_0012: ldloc.0 
29.         L_0013: ldnull 
30.         L_0014: ceq 
31.         L_0016: stloc.1 
32.         L_0017: ldloc.1 
33.         L_0018: brtrue.s L_0021
34.         L_001a: ldloc.0 
35.         L_001b: callvirt instance void [mscorlib]System.IDisposable::Dispose()
36.         L_0020: nop 
37.         L_0021: endfinally 
38.         L_0022: nop 
39.         L_0023: ldstr "Press any key"
40.         L_0028: call void [mscorlib]System.Console::WriteLine(string)
41.         L_002d: nop 
42.         L_002e: call int32 [mscorlib]System.Console::Read()
43.         L_0033: pop 
44.         L_0034: ret 
45.         .try L_0007 to L_0012 finally handler L_0012 to L_0022
46.     }
48. }

注意在上面的代码中，在Main函数中声明了两个变量，一个就是Class1的对象oTest,声明的另一个变量是个bool值，用来判断比较的结果。
L_0000到 L_0006中即创建一个Class1的对象，并赋给变量 oTest。
L_0008到 L_000e中即执行 oTest的 ToString()。
L_0012到 L_0021即判断 oTest这个时候是不是null，如果时null，则啥都不做了，到 endfinally那去了。
如果不为null，则执行 oTest. Dispose()。
不太懂IL语言的朋友，也可以从最后一句 . try  L_0007 to L_0012  finally  handler L_0012 to L_0022中看出来确实using在这里是相当于try{...}finally{调用对象的dispose方法}的。