C# 命名空间 （Namespace）

C# 命名空间（Namespace）

命名空间的设计目的是提供一种让一组名称与其他名称分隔开的方式。在一个命名空间中声明的类的名称与另一个命名空间中声明的相同的类的名称不冲突。

定义命名空间

命名空间的定义是以关键字 namespace 开始，后跟命名空间的名称，如下所示：

[csharp]  view plain  copy

1. namespace namespace_name  
2. {  
3.    // 代码声明  
4. }  

为了调用支持命名空间版本的函数或变量，会把命名空间的名称置于前面，如下所示：

[csharp]  view plain  copy

1. namespace_name.item_name;  

下面的程序演示了命名空间的用法：

[csharp]  view plain  copy

1. using System;  
2. namespace first_space  
3. {  
4.    class namespace_cl  
5.    {  
6.       public void func()  
7.       {  
8.          Console.WriteLine("Inside first_space");  
9.       }  
10.    }  
11. }  
12. namespace second_space  
13. {  
14.    class namespace_cl  
15.    {  
16.       public void func()  
17.       {  
18.          Console.WriteLine("Inside second_space");  
19.       }  
20.    }  
21. }     
22. class TestClass  
23. {  
24.    static void Main(string[] args)  
25.    {  
26.       first_space.namespace_cl fc = new first_space.namespace_cl();  
27.       second_space.namespace_cl sc = new second_space.namespace_cl();  
28.       fc.func();  
29.       sc.func();  
30.       Console.ReadKey();  
31.    }  
32. }  

当上面的代码被编译和执行时，它会产生下列结果：

[csharp]  view plain  copy

1. Inside first_space  
2. Inside second_space  

using 关键字

using 关键字表明程序使用的是给定命名空间中的名称。例如，我们在程序中使用 System 命名空间，其中定义了类 Console。我们可以只写：

[csharp]  view plain  copy

1. Console.WriteLine ("Hello there");  

我们可以写完全限定名称，如下：

[csharp]  view plain  copy

1. System.Console.WriteLine("Hello there");  

您也可以使用 using 命名空间指令，这样在使用的时候就不用在前面加上命名空间名称。该指令告诉编译器随后的代码使用了指定命名空间中的名称。下面的代码演示了命名空间的应用。

让我们使用 using 指定重写上面的实例：

[csharp]  view plain  copy

1. using System;  
2. using first_space;  
3. using second_space;  
4.   
5. namespace first_space  
6. {  
7.    class abc  
8.    {  
9.       public void func()  
10.       {  
11.          Console.WriteLine("Inside first_space");  
12.       }  
13.    }  
14. }  
15. namespace second_space  
16. {  
17.    class efg  
18.    {  
19.       public void func()  
20.       {  
21.          Console.WriteLine("Inside second_space");  
22.       }  
23.    }  
24. }     
25. class TestClass  
26. {  
27.    static void Main(string[] args)  
28.    {  
29.       abc fc = new abc();  
30.       efg sc = new efg();  
31.       fc.func();  
32.       sc.func();  
33.       Console.ReadKey();  
34.    }  
35. }  

当上面的代码被编译和执行时，它会产生下列结果：

[csharp]  view plain  copy

1. Inside first_space  
2. Inside second_space  

using 其他用法

1. using指令：引入命名空间

这是最常见的用法，例如：

[csharp]  view plain  copy

1. using System;  
2. using Namespace1.SubNameSpace;  

2. using static 指令：指定无需指定类型名称即可访问其静态成员的类型

[csharp]  view plain  copy

1. using static System.Math;var = PI; // 直接使用System.Math.PI  

3. 起别名

[csharp]  view plain  copy

1. <span style="font-size:14px;">using Project = PC.MyCompany.Project;</span>  

4. 将实例与代码绑定

[csharp]  view plain  copy

1. using (Font font3 = new Font("Arial", 10.0f),  
2.             font4 = new Font("Arial", 10.0f))  
3. {  
4.     // Use font3 and font4.  
5. }  

代码段结束时，自动调用font3和font4的Dispose方法，释放实例。

嵌套命名空间

命名空间可以被嵌套，即您可以在一个命名空间内定义另一个命名空间，如下所示：

[csharp]  view plain  copy

1. namespace namespace_name1   
2. {  
3.    // 代码声明  
4.    namespace namespace_name2   
5.    {  
6.      // 代码声明  
7.    }  
8. }  

您可以使用点（.）运算符访问嵌套的命名空间的成员，如下所示：

[csharp]  view plain  copy

1. using System;  
2. using SomeNameSpace;  
3. using SomeNameSpace.Nested;  
4.   
5. namespace SomeNameSpace  
6. {  
7.     public class MyClass   
8.     {  
9.         static void Main()   
10.         {  
11.             Console.WriteLine("In SomeNameSpace");  
12.             Nested.NestedNameSpaceClass.SayHello();  
13.         }  
14.     }  
15.   
16.     // 内嵌命名空间  
17.     namespace Nested     
18.     {  
19.         public class NestedNameSpaceClass   
20.         {  
21.             public static void SayHello()   
22.             {  
23.                 Console.WriteLine("In Nested");  
24.             }  
25.         }  
26.     }  
27. }  

当上面的代码被编译和执行时，它会产生下列结果：

[csharp]  view plain  copy

1. In SomeNameSpace  
2. In Nested