1.using指令。using + 命名空间名字，这样可以在程序中直接用命令空间中的类型，而不必指定类型的详细命名空间，类似于Java的import，这个功能也是最常用的，几乎每个cs的程序都会用到。 例如：using System; 一般都会出现在*.cs中。
2.using别名。using + 别名 = 包括详细命名空间信息的具体的类型。 这种做法有个好处就是当同一个cs引用了两个不同的命名空间，但两个命名空间都包括了一个相同名字的类型的时候。当需要用到这个类型的时候，就每个地方都要用详细命名空间的办法来区分这些相同名字的类型。而用别名的方法会更简洁，用到哪个类就给哪个类做别名声明就可以了。注意：并不是说两个名字重复，给其中一个用了别名，另外一个就不需要用别名了，如果两个都要使用，则两个都需要用using来定义别名的。
using System;
using aClass = NameSpace1.MyClass;
using bClass = NameSpace2.MyClass;
namespace NameSpace1
{
public class MyClass
{
public override string ToString()
{
return "You are in NameSpace1.MyClass";
}
}
}
namespace NameSpace2
{
class MyClass
{
public override string ToString()
{
return "You are in NameSpace2.MyClass";
}
}
}
namespace testUsing
{
using NameSpace1;
using NameSpace2;
/// <summary>
/// Class1 的摘要说明。
/// </summary>
class Class1
{
/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main(string[] args)
{
//
// TODO: 在此处添加代码以启动应用程序
//
aClass my1 = new aClass();
Console.WriteLine(my1);
bClass my2 = new bClass();
Console.WriteLine(my2);
Console.WriteLine("Press any key");
Console.Read();
}
}
}
3.using语句，定义一个范围，在范围结束时处理对象。
场景：
当在某个代码段中使用了类的实例，而希望无论因为什么原因，只要离开了这个代码段就自动调用这个类实例的Dispose。
要达到这样的目的，用try...catch来捕捉异常也是可以的，但用using也很方便。
using (Class1 cls1 = new Class1(), cls2 = new Class1())
{
// the code using cls1, cls2
} // call the Dispose on cls1 and cls2
在.net 编程环境中，系统的资源分为托管资源和非托管资源。
对于托管的资源的回收工作，是不需要人工干预回收的，而且你也无法干预他们的回收，所能够做的
只是了解.net CLR如何做这些操作。也就是说对于您的应用程序创建的大多数对象，可以依靠 .NET
Framework 的垃圾回收器隐式地执行所有必要的内存管理任务。
对于非托管资源，您在应用程序中使用完这些非托管资源之后，必须显示的释放他们，例如
System.IO.StreamReader的一个文件对象，必须显示的调用对象的Close()方法关闭它，否则会占用系统
的内存和资源，而且可能会出现意想不到的错误。
我想说到这里，一定要清楚什么是托管资源，什么是非托管资源了？
最常见的一类非托管资源就是包装操作系统资源的对象，例如文件，窗口或网络连接，对于这类资源
虽然垃圾回收器可以跟踪封装非托管资源的对象的生存期，但它不了解具体如何清理这些资源。还好.net
Framework提供了Finalize()方法，它允许在垃圾回收器回收该类资源时，适当的清理非托管资源。如果
在MSDN Library 中搜索Finalize将会发现很多类似的主题，这里列举几种常见的非托管资源：
ApplicationContext,Brush,Component,ComponentDesigner,Container,Context,Cursor,FileStream,Fon
t,Icon,Image,Matrix,Object,OdbcDataReader,OleDBDataReader,Pen,Regex,Socket,StreamWriter,Time
r,Tooltip 等等资源。可能在使用的时候很多都没有注意到！
关于托管资源，就不用说了撒，像简单的int,string,float,DateTime等等，.net中超过80%的资源都是托管资源。
非托管资源如何释放，.NET Framework 提供 Object.Finalize 方法，它允许对象在垃圾回收器回收该对象使用的内存时适当清理其非托管资源。默认情况下，
Finalize 方法不执行任何操作。如果您要让垃圾回收器在回收对象的内存之前对对象执行清理操作，您必须在类中重写 Finalize 方法。然而大家都可以发现在
实际的编程中根本无法override方法Finalize(),在C#中，可以通过析构函数自动生成 Finalize 方法和对基类的 Finalize 方法的调用。
例如：
~MyClass()
{
// Perform some cleanup operations here.
}
该代码隐式翻译为下面的代码。
protected override void Finalize()
{
try
{
// Perform some cleanup operations here.
}
finally
{
base.Finalize();
}
}
但是，在编程中，并不建议进行override方法Finalize()，因为，实现 Finalize 方法或析构函数对性能
可能会有负面影响。一个简单的理由如下：用 Finalize 方法回收对象使用的内存需要至少两次垃圾回收
，当垃圾回收器回收时，它只回收没有终结器(Finalize方法)的不可访问的内存，这时他不能回收具有终
结器(Finalize方法)的不可以访问的内存。它改为将这些对象的项从终止队列中移除并将他们放置在标记
为“准备终止”的对象列表中，该列表中的项指向托管堆中准备被调用其终止代码的对象，下次垃圾回收
器进行回收时，就回收并释放了这些内存。
c#托管资源和非托管资源区别
托管的概念是在.net框架诞生后出现的。用比较通俗的话解释就是运行在.net框架下，并受.net框架管理的应用或其他组件称为托管的，反之为非托管的。
也就是说用.net平台开发出来的程序应该就是托管的了，而在.net以前开发的程序都属于非托管的。但是非托管的程序完全可以通过在.net平台下重新生成
而变成托管的 ，你就把.net framework理解为一个Microsoft的Java Virtual Machine，这样，东西在上面跑，完全受控，这就是managed code。
在了解Finalize和Dispose之前，我们需要了解两个概念，一个是托管资源，一个非委托资源。
a.其中托管资源一般是指被CLR控制的内存资源，这些资源的管理可以由CLR来控制，例如程序中分配的对象，作用域内的变量等。
b.而非托管资源是CLR不能控制或者管理的部分，这些资源有很多，比如文件流，数据库的连接，系统的窗口句柄，打印机资源等等……
这些资源一般情况下不存在于Heap（内存中用于存储对象实例的地方）中。 .Net平台中，CLR为程序员提供了一种很好的内存管理机制，
使得程序员在编写代码时不需要显式的去释放自己使用的内存资源（这些在先前C和C++中是需要程序员自己去显式的释放的）。
这种管理机制称为GC(garbage collection)。GC的作用是很明显的，当系统内存资源匮乏时，它就会被激发，然后自动的去释放那些
没有被使用的托管资源（也就是程序员没有显式释放的对象）。 但正如上面说的，CLR的GC功能也只能释放托管资源，对于非托管资源
例如窗口，文件和网络连接等，它都只能跟踪非托管资源的生存期，而不知道如何去释放它。这样就会出现当资源用尽时就不能提供资源
能够提供的服务，windows的运行速度就会变慢。这样的情况会出现在数据库的连接当中，当你没有显式的释放一个数据库资源时，
如果还是不断的申请数据库资源，那么到一定时候程序就会抛出一个异常。 所以，当我们在类中封装了对非托管资源的操作时，我们就需
要显式，或者是隐式的释放这些资源。而上面提到的Finalize和Dispose方法分别就是隐式和显式操作中分别使用到的方法。
Finalize一般情况下用于基类不带close方法或者不带Dispose显式方法的类，也就是说，在Finalize过程中我们需要隐式的去实现非托管资
源的释放，然后系统会在Finalize过程完成后，自己的去释放托管资源。 如果要实现Dispose方法，可以通过实现IDisposable接口，
这样用户在使用这个类的同时就可以显示的执行Dispose方法，释放资源。
以下是MSDN上提出的Finalize和Dispose方法的使用指南，如果你的类遵循这个标准的话，你写出的类在.Net平台上就是一个“良民”。
Finalize 下面的规则概括了 Finalize 方法的使用指南。
1.仅在要求终结的对象上实现 Finalize。存在与 Finalize 方法相关的性能开销。 如果需要 Finalize 方法，应考虑实现 IDisposable，
以使类的用户可以避免调用 Finalize 方法带来的开销。(juky_huang注：在实现IDisposable的类中，可以通过GC.SuppressFinalize来
停止Finalize的运行，这样只要显式的调用了Dispose方法，就能给用户提供更小的开销。如果用户没有显式的调用Dispose方法，也就是
没有停止Finalize的运行，这样就可以隐式的实现非托管资源的释放)
2.不要使 Finalize 方法更可见。它应该是 protected，而不是 public。 (juky_huang注：这个很重要，Finalize方法一般是系统调用，用户不去显式的调用它)
3.对象的 Finalize 方法应该释放对象拥有的任何外部资源。此外，Finalize 方法应该仅释放由对象控制的资源。Finalize 方法不应该引用任何其他对象。
4.不要对不是对象的基类的对象直接调用 Finalize 方法。在 C# 编程语言中，这不是有效的操作。
5.从对象的 Finalize 方法调用 base.Finalize 方法。(juky_huang注：就是派生类调用基类的Finalize方法) 注意 基类的 Finalize 方法由 C# 和 C++ 的托管扩展的析构函数语法自动用。
Dispose 下面的规则概括了 Dispose 方法的使用指南：
1.在封装明确需要释放的资源的类型上实现处置设计方案。用户可以通过调用公共 Dispose 方法释放外部资源。
2.在通常包含控制资源的派生类型的基类型上实现处置设计方案，即使基类型并不需要。如果基类型有 close 方法，这通常指示需要实现 Dispose。在这类情况下，不要在基类型上实现 Finalize 方法。应该在任何引入需要清理的资源的派生类型中实现 Finalize。
3.使用类型的 Dispose 方法释放类型所拥有的任何可处置资源。
4.对实例调用了 Dispose 后，禁止 Finalize 方法通过调用 GC.SuppressFinalize 方法运行。此规则的例外情况是当必须用 Finalize 完成 Dispose 没有覆盖的工作时，但这种情况很少见。 5.如果基类实现 IDisposable，则调用基类的 Dispose 方法。
6.不要假定 Dispose 将被调用。如果 Dispose 未被调用，也应该使用 Finalize 方法释放类型所拥有的非托管资源。
7.处置了资源之后，在该类型（非 Dispose）上从实例方法引发一个 ObjectDisposedException。该规则不适用于 Dispose 方法，因为在不引发异常的情况下，该方法应该可以被多次调用。
8.通过基类型的层次结构将调用传播到 Dispose。Dispose 方法应释放此对象控制的所有资源和此对象所拥有的任何对象。例如，可以创建一个类似 TextReader 的对象来控制 Stream 和 Encoding，两者均在用户不知道的情况下由 TextReader 创建。另外，Stream 和 Encoding 都可以获取外部资源。当对 TextReader 调用Dispose方法时，它应该依次对 Stream 和 Encoding 调用 Dispose，使它们释放它们的外部资源。
9.应考虑在调用了对象的 Dispose 方法后不允许使用对象。重新创建已处置的对象是难以实现的方案。
10.允许 Dispose 方法被调用多次而不引发异常。此方法在首次调用后应该什么也不做。
有了以上的基础后，我们看一段代码，这段代码是Dispose的一个实现，这个代码如果仔细的去考虑的话，非常的有趣，在这里我们又会看到C#中一个非常常用的技术，多态性，如果你看过我在前面写的一篇关于虚拟方法的文章的话，你可以从中理解下面代码的精要之处。
本示例中有两个类一个是基类BaseResource,一个是派生类MyResourceWrapper,首先我们必须理解一下几点：
1.类型的 Dispose 方法应该释放它拥有的所有资源。它还应该通过调用其父类型的 Dispose 方法释放其基类型拥有的所有资源。该父类型的Dispose 方法应该释放它拥有的所有资源并同样也调用其父类型的 Dispose 方法，从而在整个基类型层次结构中传播该模式。
2.如果显式的调用了Dispose方法，我们就在Dispose方法中实现托管资源和非托管资源的释放，使用 GC.SuppressFinalize 方法来停止Finalize方法。因为如果用户调用了Dispose方法，那么我们就不必隐式的完成资源的释放，应为Finalizes会大大的减损性能。(Finalize一般只用于用户没有显式的调用Dispose方法，需要我们隐式完成时才使用) 3.要确保始终正确地清理资源，Dispose 方法应该可以被多次调用而不引发任何异常
示例中最主要的一个方法就是带参数的Dispose方法，本例中所有的具体操作都是放到这里来做的，它是一个受保护的虚函数，可以被派生类重写，并且如果派生类自己有对非托管资源的调用，那么派生类就要按照上面提到的要求，首先释放自己的资源，然后调用base.Dispose来实现基类的资源释放。（juky_huang注:这就是我们所谓的传播特性） 带参数的Dispose方法通过所带的参数disposing来判断，本次的Dispose操作是由Finalize发起还是由用户显式的调用公共Dispose方法发起的。如果为true则表示由公共的Dispose方法发起，如果为false表示是在GC调用Finalize方法时候发起。所以当为true时，我们就需要释放托管资源和非托管资源，并且禁止GC的Finalize操作，因为用户可以直接通过显示调用来减小性能开销。如果为false时，表示我们只需要释放非托管资源，因为本次调用是由GC的Finalize引起的，所以托管资源的释放可以让GC来完成。 示例中还有一个值得注意的地方，就是在多次显示调用Dispose时，如果资源已经处置，那么我们就要忽略本次操作，而不抛出异常。这个特性由disposed来决定。
好了，现在我们来看看这个程序的一个精要之处，那就是在派生类中，没有公共的Dispose方法，和Finalize方法（就是析构函数），那如果我们调用派生类对象时，是怎么实现资源释放的呢，刚开始我也不是很了解，后来仔细一看，突然发现其实很简单，它使用到了类的多态性来完成。 因为在派生类中使用了方法重写，所以在派生类中的Dispose(bool disposing)方法的派生度最大。由于基类中的Finalize和公共Dispose方法都是调用的是Dispose(bool disposing)方法，所以最终调用的是派生度最大的哪个函数，也就派生类中的Finalize和公共Dispose方法都是调用派生类自己的Dispose(bool disposing)方法。对于虚拟方法，可以参看我写的一篇文章地址是:
http://blog.csdn.net/juky_huang/archive/2005/10/26/517069.aspx
例如，现在我们有一个派生类实例A，如果我们显示调用A.Dispose()方法，它会去调用基础中的public Dispose方法这是由于继承的原因，在public Dispose方法中调用的又是Dispose(bool disposing)方法，由于这个方法已经被重写，所以它实际调用的不是基类中的Dispose(bool disposing)方法，而是A自己的Dispose(bool disposing)方法。这是根据运行时类型来定的。所以最终还是实现了，先调用A中的资源释放，然后才调用base.Dispose方法来完成基类的资源释放。 如果用户没有显示调用Dispose方法，那么Finalize方法就会有效，过程和上面是类似的。
从上面可以看出，对于非托管资源的释放，有一个很好的规则，只要我们按照这个规则来做，你写的代码就是.Net中的“良民”。