每次使用它安全注销..都会使代码复杂化..
比如在using(new 对象){方法体}..
那为什么不写个方法类似using的委托直接处理它呢...

我觉得using的这种用法，使代码结构很清晰。
比如声明多个对象的时候，或者有多个链接和内存需要释放时。

1. namespace statement  
   
2. {  
   
3.     //指定Font类的别名为F  
   
4.     using F = System.Drawing.Font;  
   
5.   
   
6.     class Program  
   
7.     {  
   
8.         static void Main(string[] args)  
   
9.         {  
   
10.             //using 强制资源清理  
    
11.             using (TextWriter writer = File.CreateText(@"E:\test.txt"))  
    
12.             {  
    
13.                 //使用别名来实例化对象  
    
14.                 F font = new F("宋体", 12);  
    
15.                 writer.WriteLine(font.Name.ToString() + font.Size.ToString());  
    
16.             }  
    
17.   
    
18.   
    
19.             //上面的using语句等价于  
    
20.             TextWriter w = File.CreateText(@"E:\test.txt");  
    
21.             try  
    
22.             {  
    
23.                 F font = new F("宋体", 12);  
    
24.                 w.WriteLine(font.Name.ToString() + font.Size.ToString());  
    
25.             }  
    
26.             finally  
    
27.             {  
    
28.                 if (w != null) w.Dispose();  
    
29.             }  
    
30.   
    
31.   
    
32.             //也可以在using之前声明对象  
    
33.             TextReader r = File.OpenText("E://test.txt");  
    
34.             using (r)  
    
35.             {  
    
36.                 Console.WriteLine(r.ReadToEnd());  
    
37.             }  
    
38.   
    
39.   
    
40.             //对象类型相同时，可以使用多个：  
    
41.             using (StreamReader reader = new StreamReader("1.txt"), reader2 = new StreamReader("2.txt"))  
    
42.             {  
    
43.                 //do something  
    
44.             }  
    
45.   
    
46.   
    
47.             //嵌套using  
    
48.             using (SqlConnection conn = new SqlConnection())  
    
49.             {  
    
50.                 using (SqlCommand cmd = new SqlCommand())  
    
51.                 {  
    
52.                     //嵌套using 缩进太多，从而不便于观察代码，可以用，但适可而止，如果有多层嵌套请使用 多重using  
    
53.                     //这一层如果出错，不会影响上一层conn的释放，也就是说可以这么用  
    
54.                 }  
    
55.             }  
    
56.   
    
57.   
    
58.             //多重using  
    
59.             using (StreamReader reader = new StreamReader("1.txt"))  
    
60.             using (StreamWriter writer = new StreamWriter("1.txt"))  
    
61.             using (SqlConnection conn = new SqlConnection())  
    
62.             using (SqlCommand cmd = new SqlCommand())  
    
63.             {  
    
64.                 //这样操作也可以最后释放所有资源，并且不会因嵌套using而产生太多缩进  
    
65.                 //通过reflector观察发现系统最后会生成跟嵌套using相同的代码  
    
66.             }  
    
67.   
    
68.   
    
69.         }  
    
70.     }  
    
71. }  

复制代码

{:soso_e143:}其实是我不喜欢NEW......的原因....一般都内部自NEW了....
如果用USING ....下次就找不到这个对象了...