第一篇：C#各命名空间用途
C#各命名空间用途
.NET Framework 类库是一个由 Microsoft.NET Framework SDK 中包含的类、接口和值类型组成的库。该库提供对系统功能的访问，是建立.NET Framework 应用程序、组件和控件的基础。
DotNet FrameWork所有的类都包含在命名空间里面。
命名空间
.NET Framework 类库提供下列命名空间：
▲Microsoft.CSharp
包含支持用 C# 语言进行编译和代码生成的类。▲Microsoft.JScript 包含支持用 JScript 语言进行编译和代码生成的类。▲Microsoft.VisualBasic
包含支持用 Visual Basic.NET 语言进行编译和代码生成的类。▲Microsoft.Vsa
包含使您可以将.NET Framework 脚本引擎的脚本集成到应用程序中以及在运行时编译和执行代码的接口。▲Microsoft.Win32 提供两种类型的类：处理由操作系统引发的事件的类和对系统注册表进行操作的类。
▲System
包含用于定义常用值和引用数据类型、事件和事件处理程序、接口、属性和处理异常的基础类和基类。
其他类提供支持下列操作的服务：数据类型转换，方法参数操作，数学计算，远程和本地程序调用，应用程序环境管理以及对托管和非托管应用程序的监管。
▲System.CodeDom
包含可用于表示源代码文档的元素和结构的类。这些元素可用于建立源代码文档的结构。通过使用 ▲System.CodeDom.Compiler 命名空间所提供的功能，可以将源代码文档输出为用受支持的语言编写的源代码。▲System.CodeDom.Compiler 包含用于管理用受支持的编程语言生成和编译源代码的类型。每个代码生成器可根据“代码文档对象模型”(CodeDOM)源代码模型的结构（由
▲System.CodeDom 命名空间所提供的元素组成），用特定的某种编程语言生成源代码。
▲System.Collections
包含定义各种对象集合（如列表、队列、位数组、哈希表和字典）的接口和类。▲System.Collections.Specialized
包含专用的强类型集合；例如，链接表词典、位向量以及只包含字符串的集合。▲System.ComponentModel 提供用于实现组件和控件的运行时和设计时行为的类。此命名空间包括用于属性和类型转换器的实现、数据源绑定和组件授权的基类和接口。▲System.ComponentModel.Design
包含可由开发人员用来生成自定义设计时组件行为和在设计时配置组件的用户界面的类。设计时环境提供了使开发人员能够安排组件并配置它们的属性的系统。
▲System.ComponentModel.Design.Serialization 提供支持在设计时自定义和控制序列化的类型。▲System.Configuration 提供使您可以以编程方式访问.NET Framework 配置设置和处理配置文件（.config 文件）中的错误的类和接口。▲System.Configuration.Assemblies 包含用于配置程序集的类。
▲System.Configuration.Install
提供使您可以为自己的组件编写自定义安装程序的类。Installer 类是.NET Framework 中所有自定义安装程序的基类。▲System.Data
基本上由构成 ADO.NET 结构的类组成。ADO.NET 结构使您可以生成可用于有效管理多个数据源中的数据的组件。在断开连接的方案（如 Internet）中，ADO.NET 提供了一些可以在多层系统中请求、更新和协调数据的工具。ADO.NET 结构也可以在客户端应用程序（如 Windows 窗体）或 ASP.NET 创建的 HTML 页中实现。▲System.Data.Common
包含由.NET Framework 数据提供程序共享的类。.NET Framework 数据提供程序描述用于在托管空间中访问数据源（如数据库）的类的集合。▲System.Data.Odbc
封装 ODBC.NET Framework 数据提供程序。.NET Framework 数据提供程序描述用于在托管空间中访问数据源（如数据库）的类的集合。通过使用 OdbcDataAdapter 类，可以填充驻留在内存中的 DataSet，使用它可以查询和更新数据源。
有关如何使用此命名空间的其他信息，请参见 OdbcDataReader、OdbcCommand 和 OdbcConnection 类。
注意：该命名空间仅在.NET Framework 1.1 版中受支持。
▲System.Data.OleDb
封装 OLE DB.NET Framework 数据提供程序。OLE DB.NET Framework 数据提供程序描述了用于在托管空间中访问 OLE DB 数据源的类集合。▲System.Data.OracleClient
封装 Oracle.NET Framework 数据提供程序。Oracle.NET Framework 数据提供程序描述了用于在托管空间中访问 Oracle 数据源的类集合。注意：该命名空间仅在.NET Framework 1.1 版中受支持。
▲System.Data.SqlClient
封装 SQL Server.NET Framework 数据提供程序。SQL Server.NET Framework 数据提供程序描述了用于在托管空间中访问 SQL Server 数据库的类集合。▲System.Data.SqlServerCE
描述可用于在托管环境下从基于 Windows CE 的设备访问 SQL Server CE 中的数据库的类集合。通过此命名空间，可以在一个设备上创建 SQL Server CE 数据库，并且可以与另一个设备或远程服务器上的 SQL Server 数据库建立连接。注意：该命名空间仅在.NET Framework 1.1 版中受支持。
▲System.Data.SqlTypes 提供用于 SQL Server 中的本机数据类型的类。这些类提供了其他数据类型的更安全、更快速的替代物。使用此命名空间中的类有助于防止在可能发生精度损失的情况中出现的类型转换错误。由于其他数据类型与 SqlTypes 在后台相互转换，因此在此命名空间内显式创建和使用对象同样会产生较快的代码。▲System.Diagnostics 提供允许与系统进程、事件日志和性能计数器进行交互的类。此命名空间还提供了使您可以调试应用程序和跟踪代码执行的类。有关更多信息，请参见 Trace 和 Debug 类。
▲System.Diagnostics.SymbolStore
提供使您可以读取和写入调试符号信息（如 Microsoft 中间语言(MSIL)映射的源行）的类。面向.NET Framework 的编译器可以将调试符号信息存储到程序员的数据库(PDB)文件中。调试器和代码分析器工具可以在运行时读取调试符号信息。
▲System.DirectoryServices 提供从托管代码轻松访问 Active Directory 的方法。此命名空间包含两个组件类：DirectoryEntry 和 DirectorySearcher。这两个类使用 Active Directory 服务接口(ADSI)技术。ADSI 是由 Microsoft 提供的一组接口，是一种可灵活处理各种网络提供程序的工具。ADSI 使管理员能够相对轻松地查找和管理网络资源，不论网络规模有多大。▲System.Drawing
提供对 GDI+ 基本图形功能的访问。▲System.Drawing.Drawing2D、▲System.Drawing.Imaging 和 ▲System.Drawing.Text 命名空间提供了更高级的功能。
▲System.Drawing.Design
包含扩展设计时用户界面(UI)逻辑和绘制的类。可以进一步扩展此设计时功能来创建以下对象：自定义工具箱项，类型特定的值编辑器或类型转换器，其中类型特定的值编辑器用于编辑和以图形方式表示所支持的类型的值；类型转换器用于在特定的类型之间转换值。此命名空间提供了开发设计时用户界面扩展的基本框架。
▲System.Drawing.Drawing2D
提供高级的二维和向量图形功能。此命名空间包括渐变画笔、Matrix 类（用于定义几何转换）和 GraphicsPath 类。▲System.Drawing.Imaging 提供高级的 GDI+ 图像处理功能。基本图形功能由 ▲System.Drawing 命名空间提供。
▲System.Drawing.Printing 提供与打印相关的服务。通常情况下，您可以创建 PrintDocument 类的实例，设置描述打印内容的属性，然后调用 Print 方法实际打印文档。▲System.Drawing.Text
提供高级的 GDI+ 版式功能。基本图形功能由 ▲System.Drawing 命名空间提供。此命名空间中的类使用户可以创建和使用字体集合。▲System.EnterpriseServices
为企业级应用程序提供重要的基础结构。COM+ 为企业级环境中部署的组件编程模型提供服务结构。此命名空间为.NET Framework 对象提供了对 COM+ 服务的访问，从而使.NET Framework 对象更适用于企业级应用程序。▲System.EnterpriseServices.CompensatingResourceManager
提供使您可以在托管代码中使用补偿资源管理器(CRM)的类。CRM 是由 COM+ 提供的一项服务，它使您可以在 Microsoft 分布式事务处理协调器(DTC)事务中包括非事务性对象。虽然 CRM 不提供完整资源管理器的功能，但它们却通过恢复日志提供事务性原子性（全有或全无行为）和持久性。▲System.EnterpriseServices.Internal 提供 COM+ 服务的基础结构支持。此命名空间中的类和接口专门用于支持从非托管 COM+ 类调入 ▲System.EnterpriseServices。▲System.Globalization
包含定义区域性相关信息的类，这些信息包括语言、国家/地区、正在使用的日历、日期的格式模式、货币、数字以及字符串的排序顺序。这些类对于编写全球化（国际化）应用程序很有用。▲System.IO
包含允许对数据流和文件进行同步和异步读写的类型。▲System.IO.IsolatedStorage
包含允许创建和使用独立存储区的类型。通过使用这些存储区，可以读写入受信任程度较小的代码无法访问的数据，并且可以防止公开可保存在文件系统中其他位置的敏感信息。数据存储在独立于当前用户和代码所在的程序集的数据舱中。▲System.Management
提供对一组丰富的管理信息和管理事件（它们是关于符合 Windows Management Instrumentation(WMI)基础结构的系统、设备和应用程序的）的访问。▲System.Management.Instrumentation 提供在规范应用程序管理并通过 WMI 向潜在使用者公开管理信息和事件时必需的类。这样，Microsoft Application Center 或 Microsoft Operations Manager 等使用者就可以轻松地管理您的应用程序，而管理员脚本或其他应用程序（托管应用程序和非托管应用程序）也可以监视和配置您的应用程序。▲System.Messaging 提供使您可以连接、监视和管理网络上的消息队列以及发送、接收或查看消息的类。
▲System.Net 为当前网络采用的多种协议提供简单的编程接口。WebRequest 和 WebResponse 类构成了所谓的可插接式协议的基础，该协议是一种网络服务的实现，它使您可以开发使用 Internet 资源的应用程序，而不必考虑各个协议的具体细节。▲System.Net.Sockets
为需要严格控制网络访问的开发人员提供 Windows 套接字(Winsock)接口的托管实现。
▲System.Reflection 包含提供已加载类型、方法和字段的托管视图的类和接口，并具有动态创建和调用类型的能力。
▲System.Reflection.Emit
包含允许编译器或工具发出元数据和 Microsoft 中间语言(MSIL)并在磁盘上生成 PE 文件（可选）的类。这些类的主要客户端是脚本引擎和编译器。▲System.Resources 提供允许开发人员创建、存储和管理应用程序中使用的各种区域性特定资源的类和接口。
▲System.Runtime.CompilerServices 为使用托管代码的编译器编写器提供功能，以在影响公共语言运行库的运行时行为的元数据中指定属性。此命名空间中的类只用于编译器编写器。▲System.Runtime.InteropServices
提供各种支持 COM Interop 和平台调用服务的成员。如果对这些服务不熟悉，请参见与非托管代码交互操作。
▲System.Runtime.InteropServices.CustomMarshalers 支持.NET 基础结构，不在代码中直接使用。▲System.Runtime.InteropServices.Expando
包含 IExpando 接口，此接口允许通过添加或移除对象的成员来修改对象。▲System.Runtime.Remoting
提供允许开发人员创建和配置分布式应用程序的类和接口。▲System.Runtime.Remoting.Activation
提供支持服务器和客户端远程对象激活的类和对象。▲System.Runtime.Remoting.Channels 包含支持和处理信道和信道接收器的类，这些信道和信道接收器在客户端对远程对象调用方法时用作传输媒介。
▲System.Runtime.Remoting.Channels.Http
包含使用 HTTP 协议与远程位置之间相互传输消息和对象的信道。默认情况下，HTTP 信道以 SOAP 格式对对象和方法调用进行编码以便传输，但在信道的配置属性中也可以指定其他编码和解码格式化程序接收器。▲System.Runtime.Remoting.Channels.Tcp
包含使用 TCP 协议与远程位置之间相互传输消息和对象的信道。默认情况下，TCP 信道以二进制格式对对象和方法调用进行编码以便传输，但在信道的配置属性中也可以指定其他编码和解码格式化程序接收器。▲System.Runtime.Remoting.Contexts 包含定义所有对象所驻留的上下文的对象。上下文是一个有序的属性序列，用于定义其中的对象所处的环境。上下文是在对象的激活过程中创建的，这些对象被配置为要求某些自动服务，如同步、事务、实时(JIT)激活、安全性等。多个对象可以存留在一个上下文内。
▲System.Runtime.Remoting.Lifetime
包含管理远程对象生存期的类。传统上，分布式垃圾回收功能使用引用计数和 Ping 来控制对象的生存期。这种机制在每一项服务只有较少的客户端时可以正常工作，但是当每一项服务有几千个客户端时就不能正常工作了。远程处理生存期服务将每一项服务与一个租约关联，当租约到期时，就会删除该服务。生存期服务可以起到传统的分布式垃圾回收器的作用，并且当每一项服务的客户端数量增加时也能很好地调整。
▲System.Runtime.Remoting.Messaging 包含用于创建和远程处理消息的类。远程处理基础结构使用消息与远程对象进行通信。消息用于传输远程方法调用、激活远程对象和交流信息。消息对象携带一组命名属性，其中包括操作标识符、代表信息和参数。▲System.Runtime.Remoting.Metadata 包含可用于为对象和字段自定义 SOAP 的生成和处理的类和属性。此命名空间中的类可用于指示 SOAPAction、类型输出、XML 元素名和 XML 命名空间 URI 方法。
▲System.Runtime.Remoting.Metadata.W3cXsd2001
包含由万维网联合会(W3C)在 2001 年定义的 XML 架构定义(XSD)。W3C 中的“XML Schema Part2: Data types”（XML 架构第二部分：数据类型）规范确定了各种数据类型的格式和行为。此命名空间包含符合 W3C 规范的数据类型的包装类。所有日期和时间类型都符合 ISO 标准规范。▲System.Runtime.Remoting.MetadataServices
包含由 Soapsuds.exe 命令行工具和用户代码用来在元数据和远程处理基础结构的 XML 架构之间相互转换的类。▲System.Runtime.Remoting.Proxies 包含控制和提供代理功能的类。代理是作为远程对象映像的本地对象。代理使客户端可以跨远程处理边界访问对象。▲System.Runtime.Remoting.Services
包含为.NET Framework 提供功能的服务类。▲System.Runtime.Serialization 包含可用于序列化和反序列化对象的类。序列化是将对象或对象图转换为线性的字节序列以存储或传输到其他位置的过程。反序列化是接受存储的信息并用这些信息重新创建对象的过程。
▲System.Runtime.Serialization.Formatters
提供由序列化格式化程序使用的通用枚举、接口和类。▲System.Runtime.Serialization.Formatters.Binary 包含可用于以二进制格式序列化和反序列化对象的 BinaryFormatter 类。▲System.Runtime.Serialization.Formatters.Soap
包含可用于以 SOAP 格式序列化和反序列化对象的 SoapFormatter 类。▲System.Security
提供.NET Framework 安全系统的基础结构，包括权限的基类。▲System.Security.Cryptography 提供加密服务，包括数据的安全编码和解码，以及其他许多操作，如哈希处理、随机数生成和消息身份验证。
▲System.Security.Cryptography.X509Certificates 包含 Authenticode X.509 v.3 证书的公共语言运行库实现。此证书用唯一明确标识证书持有者的私钥签名。
▲System.Security.Cryptography.XML
包含支持创建和验证 XML 数字签名的类。此命名空间中的类贯彻了万维网联合会(W3C)建议“XML-Signature Syntax and Processing”（XML 签名语法和处理），详见 http:// 控件、Web 控件还是用户控件）提供一组通用功能。它还包括 Page 控件，每当对 Web 应用程序中的页发出请求时，都会自动生成此控件。另外还提供了一些类，这些类提供 Web 窗体服务器控件数据绑定功能、保存给定控件或页的视图状态的能力，以及对可编程控件和文本控件都适用的分析功能。▲System.Web.UI.Design 包含可用于扩展 Web 窗体设计时支持的类。▲System.Web.UI.Design.WebControls
包含可用于扩展 Web 服务器控件设计时支持的类。▲System.Web.UI.HtmlControls
包含使您可以在 Web 窗体页上创建 HTML 服务器控件的类集合。HTML 服务器控件运行在服务器上，并且直接映射到大多数浏览器所支持的标准 HTML 标记。这使您能够以编程方式控制 Web 窗体页上的 HTML 元素。▲System.Web.UI.MobileControls 包含一组 ASP.NET 服务器控件，这些控件可以针对不同的移动设备智能地呈现您的应用程序。
▲System.Web.UI.MobileControls.Adapters
包含由 ASP.NET 移动控件用来自定义设备和支持扩展设备的核心设备适配器类。
▲System.Web.UI.WebControls
包含使您可以在 Web 页上创建 Web 服务器控件的类。Web 服务器控件运行在服务器上，并且包括按钮和文本框等窗体控件。它们还包括类似于日历的特殊控件。由于 Web 服务器控件运行在服务器上，因此可以以编程方式来控制这些元素。Web 服务器控件比 HTML 服务器控件更抽象。它们的对象模型不一定反映 HTML 语法。
▲System.Windows.Forms
包含用于创建基于 Windows 的应用程序的类，这些应用程序可以充分利用 Microsoft Windows 操作系统中的丰富用户界面功能。▲System.Windows.Forms.Design
包含支持 Windows 窗体组件的设计时配置和行为的类。这些类包括：提供 Windows 窗体组件（即一组设计时服务）支持的设计器类、用于配置特定属性类型的 UITypeEditor 类，以及用于导入 ActiveX 控件的类。▲System.Xml
提供基于标准的 XML 处理支持。▲System.Xml.Schema
包含提供基于标准的 XML 架构定义语言(XSD)架构支持的 XML 类。▲System.Xml.Serialization
包含用于将对象序列化为 XML 格式的文档或流的类。▲System.Xml.XPath
包含 XPath 分析器和计算引擎。它支持 W3C XML 路径语言(XPath)1.0 版建议(www.teniu.cc/TR/xpath)。▲System.Xml.Xsl
提供可扩展样式表转换(XSLT)转换支持。它支持 W3C XSL 转换(XSLT)1.0 版建议(www.teniu.cc/TR/xslt)。用法
第二篇：C#命名空间详解
C＃命名空间详解
包含支持用C#语言进行编译的代码 ? Microsoft.Jscript
包含支持用Jscript语言进行编译和代码生成的Jscript运行库和类 ? Microsoft.VisualBasic 包含Visual Basic.NET运行库。此运行库于Visual Basic.NET语言一起使用。此命名空间包含支持Visual Basic.NET语言进行编译和代码生成类。? Microsoft.Win32
提供两种类型的类：处理由操作系统引发的事件的类和对系统注册表进行操作的类。? System
最重要的类，包含用于定义常用值和引用数据类型、事件和事件处理程序、接口、属性、和处理异常的基础类和基类。
? System.CodeDom
包含用于表示源代码文档的元素和结构的类 ? System.CodeDom.Compiler
包含源代码模型的结构，管理源代码所生成的编译的类。? System.Collections
包含定义各种对象集合（如列表、队列、位数组、散列表和词典）的接口和类。? System.Collections.Specialized
包含中用的强类型集合；例如，链接表词典、位向量以及值包含字符串的集合。? System.CommponentModel
提供用于实现组件和空间的运行时和设计时行为的类。此命名空间包括用于属性和类型转换器的事件、数据源绑定和组件授权的基类和接口。
? System.ComponentModel.Design
使开发人员可以生成自定义用户控件，并将这些控件包括在设计时环境中以便与供应商空间一起使用。? System.ComponentModel.Design.Serialization
提供设计器所进行的组件序列化支持。此命名空间中的类可用于提哦能够自定义序列化程序、管理特定类型的序列化、管理设计器加载和设计器序列化，以及优化设计器重新加载。? System.Configuration
提供以变成方式访问.NET空间配置和处理配置文件（.config文件）中的错误的类和接口。? System.Configuration.Assemblies 包含用于配置程序集的类。
? System.Configuration.Install
提供为组件编写自定义安装程序的类。Installer类是.NET框架中所有自定义安装程序的基类。? System.Data
基本上由构成ADO.NET结构的类组成。使用ADO.NET结构可以生成用于有效管理多个数据源中的数据组件。在断开连接的方案（如Internet）中，ADO.NET提供可以在多城系统中请求、更新和协调数据的工具。ADO.NET结构也可以在客户端应用程序或ASP.NET创建的HTML页中实现。? System.Data.Common
包含由.NET数据提供程序共享的类。.NET数据提供程序描述用于在托管空间中访问数据源的类的集合。? System.Data.OleDb
封装OLE DB.NET数据提供程序。.NET数据提供程序描述用于在托管空间中访问数据源的类的集合 ? System.Data.SqlClient
封装SQL Server.NET数据提供程序。.NET数据提供描述用于在托管空间中访问数据源的类的集合。? System.Data.SqlTypes
提供用于SQL Sserver中本机数据类型的类。这些类提供其他数据类型更安全、更快速的替代物。使用此命名空间中的类有助于防止在可能发生精度损失的情况中出现的类行转换错误。? System.Diagnostics
提供允许与系统进程、事件日志和性能计数器进行交互的类。此命名空间还提供可以调试应用程序和跟踪代码执行的类。
? System.Diagnostics.SymbolStore
提供允许读取和写入调适符号信息的类。面向.NET框架的编译器可以将调试符号信息存储到程序员的数据库（PDB）文件中。调试器和代码分析器工具可以在运行时读取调试符号信息。? System.DirectioyServices
提供从托管代码轻松访问Active Directory的方法。? System.Drawing 提供对GDI+基本形功能的访问。System.Drawing.Drawing2D,System.Drawing.Imaging和System.Drawing.Text命名空间提供了更高级的功能 ? System.Drawing.Design
包含扩展设计时用户界面（UI）逻辑和绘制的类。可以进一步扩展此设计时功能，以创建自定义工具箱项、类型特定的值编辑器（可编辑和以图形方式表示所支持的类型的值）或类型转换器（可在特定类型之间转换值）。? System.Drawing.Drawing2D
提供高级的二维和向量图形功能。此命名空间包括渐变笔、Matrix类（用于定义几何转换）和GraphicsPath类。? System.Drawing.Imaging 提供高级的GDI+图象处理功能 ? System.Drawing.Printing 提供与打印相关的服务。? System.Drawing.Text
提供高级的GDI+版式功能。此命名空间中的类使用户可以创建和使用字体集合。? System.EnterpriseServices
为企业级应用程序提供重要的基础结构。COM+为企业级环境中部署的组件编程模型提供服务结构。此命名空间为.NET框架对象提供对COM+服务的访问，使.NET框架对象更适用于企业级应用程序。? System.EnterpriseServices.CompensatingResourceManager
提供在托管代码中使用补偿资源管理器（CRM）的类。CRM是由COM+提供的一项服务，使用户可以在Microsoft分布式事务处理协调器（DTC）事务中包括非事务对象。虽然CRM不提供完整资源管理器的功能，但它们却通过恢复日志提供事务性和持久性。? System.Globalization
包含定义区域性相关信息的类，这些信息包括语言、国家/地区、正在使用的日历、日期的格式模式、货币、数字以及字符串的排序顺序。? System.IO
包含允许对数据流和文件进行同步和异步读写的类型。? System.IO.IsolatedStorage
包含允许船舰和使用独立存储区的类型。通过使用这些存储区，可以读写信任度较低的代码无法访问的数据，防止公开可保存在文件系统其他位置的敏感信息。数据存储在独立于当前用户和代码所在的程序集的数据仓中。? System.ManageMent
提供对一组丰富的管理信息和管理事件（有关符合Windows管理规范（WMI）基础机构的系统、设备和应用程序的）的访问。
? System.Management.Instrumentation
提供在规范应用程序管理并通过WMI向潜在用户公开管理信息和事件时必须的类。这样，Microsoft Application Center 或 Microsoft Operations Manager 等用户者就可以轻松地管理您的应用程序。而管理员脚本或其他应用程序（托管应用程序和非过关应用程序）也可以监视和配置您的应用程序。? System.Messaging
提供用户连接、监视和管理网络上的消息列队以及发送、和接受或查看消息的类。? System.Net
为当前网络采用的多种协议提供简单的编程接口。WebRequest和WebResponse类构成所谓的可插接式协议的基础，该协议式一种网络服务的实现，它使您可以开发使用Internet资源的应用程序，而不必考虑各个协议的具体细节。? System.Net.Sockets
为需要严格控制网络访问的开发人员提供Windows套接字（Winsock）接口的托管实现。? System.Refection
包含提供已加载类型、方法和字段的托管视图的类和接口，并具由动态创建和调用类型的能力。? System.Reflection.Emit
包含允许编译器或工具发出元数据和Micosoft中间语言（MSIL）并在磁盘上生成PE（可选）的类。这些类的主要客户端是脚本引擎和编译器。
? System.Runtime.CompilerServices
第三篇：C# 命名空间9
命名空间.................................................................................................................................................................2 9.1 编译单元......................................................................................................................................................2 9.2 命名空间声明..............................................................................................................................................2 9.3 using 指令.....................................................................................................................................................3 9.3.1 Using 别名指令.....................................................................................................................................4 9.3.2 Using 命名空间指令.............................................................................................................................6 9.4 命名空间成员..............................................................................................................................................8 9.5 类型声明......................................................................................................................................................9
1.命名空间
C# 程序是利用命名空间组织起来的。命名空间既用作程序的“内部”组织系统，也用作“外部”组织系统（一种向其他程序公开自己拥有的程序元素的方法）。using 指令（第 1.3 节）是用来使命名空间用起来更方便。
1.1 编译单元
compilation-unit 定义了源文件的总体结构。编译单元的组成方式如下：先是零个或多个 using-directive，后跟零个或多个 global-attributes，然后是零个或多个 namespace-member-declaration。
compilation-unit: using-directivesopt
global-attributesopt
namespace-member-declarationsopt
一个 C# 程序由一个或多个编译单元组成，每个编译单元都用一个单独的源文件来保存。编译 C# 程序时，所有这些编译单元一起进行处理。因此，这些编译单元间可以互相依赖，甚至以循环方式互相依赖。
一个编译单元中的 using-directives 影响该编译单元内的 global-attributes 和 namespace-member-declarations，但是不会影响其他编译单元。
编译单元的 global-attributes（第 错误！未找到引用源。章）允许指定目标程序集和模块的属性。程序集和模块充当类型的物理容器。程序集可以包含若干个在物理上分离的模块。一个程序中各编译单元中的 namespace-member-declarations 用于为一个称为“全局命名空间”的单个声明空间提供成员。例如：
文件 A.cs：
class A {} 文件 B.cs：
class B {} 这两个编译单元是为该全局命名空间提供成员的，在本例中它们分别声明了具有完全限定名 A 和 B 的两个类。由于这两个编译单元为同一声明空间提供成员，因此如果它们分别包含了一个同名成员的声明，将会是个错误。
1.2 命名空间声明
一个 namespace-declaration 的组成方式如下：先是关键字 namespace，后跟一个命名空间名称和体，然后加一个分号（可选）。
namespace-declaration: namespace
qualified-identifier
namespace-body
;opt
qualified-identifier: identifier qualified-identifier
.identifier namespace-body: {
using-directivesopt
namespace-member-declarationsopt
}
namespace-declaration 可以作为顶级声明出现在 compilation-unit 中，或是作为成员声明出现在另一个 namespace-declaration 内。当 namespace-declaration 作为顶级声明出现在 compilation-unit 中时，该命名空间成为全局命名空间的一个成员。当一个 namespace-declaration 出现在另一个 namespace-declaration 内时，该内部命名空间就成为包含着它的外部命名空间的一个成员。无论是何种情况，一个命名空间的名称在它所属的命名空间内必须是唯一的。
命名空间隐式地为 public，而且在命名空间的声明中不能包含任何访问修饰符。在 namespace-body 内，可选用 using-directives 来导入其他命名空间和类型的名称，这样，就可以直接地而不是通过限定名来引用它们。可选的 namespace-member-declarations 用于为命名空间的声明空间提供成员。请注意，所有的 using-directives 都必须出现在任何成员声明之前。
namespace-declaration 中的 qualified-identifier 可以是单个标识符或者是由“.”标记分隔的标识符序列。后一种形式允许一个程序直接定义一个嵌套命名空间，而不必按词法嵌套若干个命名空间声明。例如，namespace N1.N2 { class A {} class B {} } 在语义上等效于
namespace N1 { namespace N2 {
} } class A {} class B {} 命名空间是可扩充的，两个具有相同的完全限定名的命名空间声明是在为同一声明空间（第 错误！未找到引用源。节）提供成员。在下面的示例中
namespace N1.N2 { class A {} } namespace N1.N2 { class B {} } 上面的两个命名空间声明为同一声明空间提供了成员，在本例中它们分别声明了具有完全限定名 N1.N2.A 和 N1.N2.B 的两个类。由于两个声明为同一声明空间提供成员，因此如果它们分别包含一个同名成员的声明，就将出现错误。
1.3 using 指令
using 指令(using directives)方便了对在其他命名空间中定义的命名空间和类型的使用。using 指令影响 namespace-or-type-name（第 错误！未找到引用源。节）和 simple-name（第 7.5.2 节）的名称解析过程，与声明不同，using 指令不会向在其中使用它们的编译单元或命名空间的基础声明空间中提供新成员。
using-directives: using-directive using-directives
using-directive using-directive: using-alias-directive using-namespace-directive using-alias-directive（第 1.3.1 节）用于为一个命名空间或类型引入一个别名。using-namespace-directive（第 1.3.2 节）用于导入一个命名空间的类型成员。
using-directive 的范围扩展到直接包含它的编译单元或命名空间体内的所有 namespace-member-declarations。具体而言，using-directive 的范围不包括与它对等的 using-directive。因此，对等 using-directive 互不影响，而且按什么顺序编写它们也无关紧要。
1.3.1 Using 别名指令
using-alias-directive 为一个命名空间或类型（在直接包含该指令的编译单元或命名空间体内）引入用作别名的标识符。
using-alias-directive: using
identifier
=
namespace-or-type-name
;在包含 using-alias-directive 的编译单元或命名空间体内的成员声明中，由 using-alias-directive 引入的标识符可用于引用给定的命名空间或类型。例如：
namespace N1.N2 { class A {} } namespace N3 { using A = N1.N2.A;class B: A {} } 上面的示例中，在 N3 命名空间中的声明成员内，A 是 N1.N2.A 的别名，因此类 N3.B 从类 N1.N2.A 派生。通过为 N1.N2 创建别名 R 然后引用 R.A 可以得到同样的效果：
namespace N3 { using R = N1.N2;class B: R.A {} } using-alias-directive 中的 identifier 在直接包含该 using-alias-directive 的编译单元或命名空间的声明空间内必须是唯一的。例如： namespace N3 { class A {} } namespace N3 { using A = N1.N2.A;}
// Error, A already exists 上例中，N3 已包含了成员 A，因此 using-alias-directive 使用 A 作标识符会导致一个编译时错误。同样，如果同一个编译单元或命名空间体中的两个或更多 using-alias-directive 用相同名称声明别名，也会导致一个编译时错误。
using-alias-directive 使别名可用在特定编译单元或命名空间体内，但是它不会向基础声明空间提供任何新成员。换句话说，using-alias-directive 是不可传递的，它仅影响它在其中出现的编译单元或命名空间体。在下面的示例中
namespace N3 { using R = N1.N2;} namespace N3 { class B: R.A {} }
// Error, R unknown 引入 R 的 using-alias-directive 的范围只延伸到包含它的命名空间体中的成员声明，因此 R 在第二个命名空间声明中是未知的。但是，如果将 using-alias-directive 放置在包含它的编译单元中，则该别名在两个命名空间声明中都可用：
using R = N1.N2;namespace N3 { class B: R.A {} } namespace N3 { class C: R.A {} } 和常规成员一样，using-alias-directive 引入的别名在嵌套范围中也可被具有相似名称的成员所隐藏。在下面的示例中
using R = N1.N2;namespace N3 { class R {} class B: R.A {} }
// Error, R has no member A B 的声明中对 R.A 的引用将导致编译时错误，原因是这里的 R 所引用的是 N3.R 而不是 N1.N2。
编写 using-alias-directive 的顺序并不重要，对在 using-alias-directive 引用的 namespace-or-type-name 的解析过程既不受 using-alias-directive 本身影响，也不受直接包含着该指令的编译单元或命名空间体中的其他 using-directive 影响。换句话说，对 using-alias-directive 的 namespace-or-type-name 的解析，就如同在直接包含该指定的编译单元或命名空间体中根本没有 using-directive 一样来处理。在下面的示例中
namespace N1.N2 {} namespace N3 { using R1 = N1;
// OK using R2 = N1.N2;using R3 = R1.N2;}
// OK
// Error, R1 unknown 最后一个 using-alias-directive 导致编译时错误，原因是它不受第一个 using-alias-directive 的影响。
using-alias-directive 可以为任何命名空间或类型创建别名，包括它在其中出现的命名空间本身，以及嵌套在该命名空间中的其他任何命名空间或类型。
对一个命名空间或类型进行访问时，无论用它的别名，还是用它的所声明的名称，结果是完全相同的。例如，给定
namespace N1.N2 { class A {} } namespace N3 { using R1 = N1;using R2 = N1.N2;class B {
} } N1.N2.A a;R1.N2.A b;R2.A c;
// refers to N1.N2.A // refers to N1.N2.A
// refers to N1.N2.A 名称 N1.N2.A、R1.N2.A 和 R2.A 是等效的，它们都引用完全限定名为 N1.N2.A 的类。
1.3.2 Using 命名空间指令
using-namespace-directive 将一个命名空间中所包含的类型导入到直接包含该指定的编译单元或命名空间体中，从而可以直接使用每个被导入的类型的标识符而不必加上它们的限定名。
using-namespace-directive: using
namespace-name
;在包含 using-namespace-directive 的编译单元或命名空间体中的成员声明内，可以直接引用包含在给定命名空间中的那些类型。例如：
namespace N1.N2 { class A {} } namespace N3 { using N1.N2;class B: A {} } 上面的示例中，在 N3 命名空间中的成员声明内，N1.N2 的类型成员是直接可用的，所以类 N3.B 从类 N1.N2.A 派生。
using-namespace-directive 导入包含在给定命名空间中的类型，但要注意，它不导入嵌套的命名空间。在下面的示例中
namespace N1.N2 { class A {} } namespace N3 { using N1;class B: N2.A {} }
// Error, N2 unknown using-namespace-directive 导入包含在 N1 中的类型，但是不导入嵌套在 N1 中的命名空间。因此，在 B 的声明中引用 N2.A 导致编译时错误，原因是在涉及的范围内没有名为 N2 的成员。
与 using-alias-directive 不同，using-namespace-directive 可能导入一些类型，它们的标识符在包含该指令的编译单元或命名空间体内已被定义。事实上，using-namespace-directive 导入的名称会被包含该指令的编译单元或命名空间体中具有类似名称的成员所隐藏。例如：
namespace N1.N2 { class A {} class B {} } namespace N3 { using N1.N2;class A {} } 此处，在 N3 命名空间中的成员声明内，A 引用 N3.A 而不是 N1.N2.A。
当由同一编译单元或命名空间体中的 using-namespace-directive 导入多个命名空间时，如果它们所包含的类型中有重名的，则直接引用该名称就被认为是不明确的。在下面的示例中
namespace N1 { class A {} } namespace N2 { class A {} } namespace N3 { using N1;using N2;class B: A {} } N1 和 N2 都包含一个成员 A，而由于 N3 将两者都导入，所以在 N3 中引用 A 会导致一
// Error, A is ambiguous 个编译时错误。这种情况的冲突，有两种解决办法：使用限定名来引用 A，或者利用 using-alias-directive 为想要引用的某个特定的 A 引入一个别名。例如：
namespace N3 { using N1;using N2;using A = N1.A;class B: A {} }
// A means N1.A 同 using-alias-directive 一样，using-namespace-directive 不会向编译单元或命名空间的基础声明空间提供任何新成员，因而，它仅影响它出现在的编译单元或者命名空间体。
对 using-namespace-directive 所引用的 namespace-name 的解析方式，与对 using-alias-directive 所引用的 namespace-or-type-name 的解析方式相同。因此，同一编译单元或命名空间体中的 using-namespace-directive 互不影响，而且可以按照任何顺序编写。
1.4 命名空间成员
namespace-member-declaration 或是一个 namespace-declaration（第 1.2 节），或是一个 type-declaration（第 9.5 节）。
namespace-member-declarations: namespace-member-declaration namespace-member-declarations
namespace-member-declaration namespace-member-declaration: namespace-declaration type-declaration 编译单元或命名空间体可以包含 namespace-member-declarations，而此类声明则为与包含它们的编译单元或命名空间体的基础声明空间提供新成员。
1.5 类型声明
type-declaration 是 class-declaration（第 错误！未找到引用源。节）、struct-declaration（第 错误！未找到引用源。节）、interface-declaration（第 错误！未找到引用源。节）、enum-declaration（第 错误！未找到引用源。节）或 delegate-declaration（第 错误！未找到引用源。节）。
type-declaration: class-declaration struct-declaration interface-declaration enum-declaration delegate-declaration type-declaration 可以作为顶级声明出现在编译单元中，或者作为成员声明出现在命名空间、类或结构内部。
当类型 T 的类型声明作为编译单元中的顶级声明出现时，新声明的类型的完全限定名正好是 T。当类型 T 的类型声明出现在命名空间、类或结构内时，新声明的类型的完全限定名是 N.T，其中 N 是包含它的命名空间、类或结构的完全限定名。
在类或结构内声明的类型称为嵌套类型（第 错误！未找到引用源。节）。在一个类型声明中允许使用哪些访问修饰符以及具有何种默认访问属性，依赖于该声明发生处的上下文（第 错误！未找到引用源。节）：
在编译单元或命名空间中声明的类型可以具有 public 或 internal 访问属性。默认为 internal 访问属性。 在类中声明的类型可以具有 public、protected internal、protected、internal 或 private 访问属性。默认为 private 访问属性。 在结构中声明的类型可以具有 public、internal 或 private 访问属性。默认为
private 访问属性。
第四篇：C# System命名空间简介
System 命名空间 类
Activator 包含特定的方法，用以在本地或从远程创建对象类型，或获取对现有远程对象的引用。
AppDomain 表示应用程序域，它是一个应用程序在其中执行的独立环境。不能继承此类。AppDomainSetup 表示可以添加到 AppDomain 的实例的程序集绑定信息。
AppDomainUnloadedException 在尝试访问已卸载的应用程序域时引发的异常。ApplicationException 发生非致命应用程序错误时引发的异常。ArgumentException 在向方法提供的其中一个参数无效时引发的异常。
ArgumentNullException 当将空引用（在 Visual Basic 中为 Nothing）传递给不接受它作为有效参数的方法时引发的异常。
ArgumentOutOfRangeException 当参数值超出调用的方法所定义的允许取值范围时引发的异常。
ArithmeticException 因算术运算、类型转换或转换操作中的错误而引发的异常。
Array 提供创建、操作、搜索和排序数组的方法，因而在公共语言运行库中用作所有数组的基类。
ArrayTypeMismatchException 当试图在数组中存储类型不正确的元素时引发的异常。AssemblyLoadEventArgs 为 AssemblyLoad 事件提供数据。Attribute 自定义属性的基类。
AttributeUsageAttribute 指定另一特性类的用法。无法继承此类。
BadImageFormatException 当 DLL 或可执行程序的文件图像无效时引发的异常。BitConverter 将基础数据类型与字节数组相互转换。Buffer 操作基元类型的数组。
CannotUnloadAppDomainException 卸载应用程序域的尝试失败时引发的异常。CharEnumerator 支持循环访问 String 并读取它的各个字符。
CLSCompliantAttribute 指示程序元素是否符合公共语言规范(CLS)。无法继承此类。Console 表示控制台应用程序的标准输入流、输出流和错误流。无法继承此类。ContextBoundObject 定义所有上下文绑定类的基类。
ContextMarshalException 在尝试将对象封送过上下文边界失败时引发的异常。ContextStaticAttribute 指示静态字段的值是特定上下文的唯一值。Convert 将一个基本数据类型转换为另一个基本数据类型。DBNull 表示空值。Delegate 表示委托，委托是一种数据结构，它引用静态方法或引用类实例及该类的实例方法。DivideByZeroException 试图用零除整数值或十进制数值时引发的异常。
DllNotFoundException 当未找到在 DLL 导入中指定的 DLL 时所引发的异常。
DuplicateWaitObjectException 当对象在同步对象数组中不止一次出现时引发的异常。EntryPointNotFoundException 因不存在项方法而导致加载类的尝试失败时引发的异常。Enum 为枚举提供基类。
Environment 提供有关当前环境和平台的信息以及操作它们的方法。不能继承此类。EventArgs EventArgs 是包含事件数据的类的基类。Exception 表示在应用程序执行期间发生的错误。
ExecutionEngineException 当公共语言运行库的执行引擎中发生内部错误时引发的异常。无法继承此类。
FieldAccessException 当试图非法访问类中的私有字段或受保护字段时引发的异常。FlagsAttribute 指示可以将枚举作为位域（即一组标志）处理。
FormatException 当参数格式不符合调用的方法的参数规范时引发的异常。GC 控制系统垃圾回收器（一种自动回收未使用内存的服务）。
IndexOutOfRangeException 试图访问索引超出数组界限的数组元素时引发的异常。无法继承此类。
InvalidCastException 因无效类型转换或显式转换引发的异常。
InvalidOperationException 当方法调用对于对象的当前状态无效时引发的异常。
InvalidProgramException 当程序包含无效 Microsoft 中间语言(MSIL)或元数据时将引发的异常。通常这表示编译器中出现错误。
LoaderOptimizationAttribute 用于为可执行应用程序的主方法设置默认的加载程序优化策略。LocalDataStoreSlot 封装内存槽以存储本地数据。无法继承此类。
MarshalByRefObject 允许在支持远程处理的应用程序中跨应用程序域边界访问对象。Math 为三角函数、对数函数和其他通用数学函数提供常数和静态方法。MemberAccessException 访问类成员的尝试失败时引发的异常。
MethodAccessException非法尝试访问类中的私有方法或受保护的方法时引发的异常。MissingFieldException 试图动态访问不存在的字段时引发的异常。
MissingMemberException 试图动态访问不存在的类成员时引发的异常。MissingMethodException 试图动态访问不存在的方法时引发的异常。
MTAThreadAttribute 指示应用程序的 COM 线程模型为多线程单元(MTA)。
MulticastDelegate 表示多路广播委托；即，其调用列表中可以拥有多个元素的委托。
MulticastNotSupportedException 当试图合并不可合并的委托类型的两个实例时引发的异常，除非操作数中有一个是空引用（在 Visual Basic 中为 Nothing）。无法继承此类。NonSerializedAttribute 指示可序列化类的某个字段不应被序列化。无法继承此类。
NotFiniteNumberException 当浮点值为正无穷大、负无穷大或非数字(NaN)时引发的异常。
NotImplementedException 在无法实现请求的方法或操作时引发的异常。NotSupportedException 当调用的方法不受支持，或试图读取、查找或写入不支持调用功能的流时引发的异常。
NullReferenceException 尝试取消引用空对象引用时引发的异常。
Object 支持.NET Framework 类层次结构中的所有类，并为派生类提供低级别服务。这是.NET Framework 中所有类的最终基类；它是类型层次结构的根。ObjectDisposedException 对已处置的对象执行操作时所引发的异常。ObsoleteAttribute 标记不再使用的程序元素。无法继承此类。
OperatingSystem 表示有关操作系统的信息，如版本和平台标识符。OutOfMemoryException 没有足够的内存继续执行程序时引发的异常。OverflowException 在选中的上下文中所进行的算术运算、类型转换或转换操作导致溢出时引发的异常。
ParamArrayAttribute 指示方法在调用中将允许参数的数目可变。无法继承此类。PlatformNotSupportedException 当功能未在特定平台上运行时所引发的异常。
Random 表示伪随机数生成器，一种能够产生满足某些随机性统计要求的数字序列的设备。RankException 将维数错误的数组传递给方法时引发的异常。
ResolveEventArgs 为 TypeResolve、ResourceResolve 和 AssemblyResolve 事件提供数据。SerializableAttribute 指示一个类可以序列化。无法继承此类。StackOverflowException 挂起的方法调用过多而导致执行堆栈溢出时引发的异常。无法继承此类。
STAThreadAttribute 指示应用程序的 COM 线程模型是单线程单元(STA)。String 表示文本，即一连串 Unicode 字符。
SystemException 为 System 命名空间中的预定义异常定义基类。ThreadStaticAttribute 指示静态字段的值对于每个线程都是唯一的。TimeZone 表示时区。Type 表示类型声明：类类型、接口类型、数组类型、值类型和枚举类型。
TypeInitializationException 作为由类初始值设定项引发的异常周围的包装引发的异常。无法继承此类。
TypeLoadException 类型加载失败发生时引发的异常。TypeUnloadedException 试图访问已卸载的类时引发的异常。
UnauthorizedAccessException 当操作系统因 I/O 错误或指定类型的安全错误而拒绝访问时所引发的异常。
UnhandledExceptionEventArgs 为以下情况下引发的事件提供数据：存在一个不是由应用程序域处理的异常。
Uri 提供统一资源标识符(URI)的对象表示形式和对 URI 各部分的轻松访问。
UriBuilder 为统一资源标识符(URI)提供自定义构造函数，并修改 Uri 类的 URI。UriFormatException 当检测到无效的统一资源标识符(URI)时引发的异常。ValueType 提供值类型的基类。
Version 表示公共语言运行库程序集的版本号。无法继承此类。WeakReference 表示“弱引用”，即在引用对象的同时仍然允许对该对象进行垃圾回收。接口
IAppDomainSetup 表示可以添加到 AppDomain 的实例的程序集绑定信息。IAsyncResult 表示异步操作的状态。
ICloneable 支持克隆，即用与现有实例相同的值创建类的新实例。
IComparable 定义通用的比较方法，由值类型或类实现以创建类型特定的比较方法。IConvertible 定义特定的方法，这些方法将实现引用或值类型的值转换为具有等效值的公共语言运行库类型。
ICustomFormatter 定义一种方法，它支持对象值的自定义（用户定义）格式设置。IDisposable 定义一种释放分配的非托管资源的方法。IFormatProvider 提供用于检索控制格式化的对象的机制。IFormattable 提供将对象的值格式化为字符串表示形式的功能。IServiceProvider 定义一种检索服务对象的机制，服务对象是为其他对象提供自定义支持的对象。
_AppDomain 表示应用程序域，它是一个应用程序在其中执行的独立环境。结构
ArgIterator 表示变长参数列表；即采用可变数量的参数的函数的参数。Boolean 表示布尔值。
Byte 表示一个 8 位无符号整数。Char 表示一个 Unicode 字符。DateTime 表示时间上的一刻，通常以日期和当天的时间表示。Decimal 表示十进制数。
Double 表示一个双精度浮点数字。Guid 表示全局唯一标识符(GUID)。Int16 表示 16 位有符号的整数。Int32 表示 32 位有符号的整数。Int64 表示 64 位有符号的整数。
IntPtr 用于表示指针或句柄的平台特定类型。RuntimeArgumentHandle 引用变长参数列表。
RuntimeFieldHandle 使用内部元数据标记表示一个字段。
RuntimeMethodHandle RuntimeMethodHandle 是方法的内部元数据表示形式的句柄。RuntimeTypeHandle 表示使用内部元数据标记的类型。SByte 表示 8 位有符号整数。Single 表示一个单精度浮点数字。TimeSpan 表示一个时间间隔。
TypedReference 描述既包含指向某位置的托管指针，也包含该位置可能存储的类型的运行时表示形式的对象。
UInt16 表示 16 位无符号整数。UInt32 表示 32 位无符号整数。UInt64 表示 64 位无符号整数。
UIntPtr 用于表示指针或句柄的平台特定类型。
Void 指示不返回值的方法，即具有 void 返回类型的方法。委托
AssemblyLoadEventHandler 表示处理 AppDomain 的 AssemblyLoad 事件的方法。AsyncCallback 引用在异步操作完成时调用的回调方法。
CrossAppDomainDelegate 由 DoCallBack 使用，用于跨应用程序域的调用。EventHandler 表示将处理不包含事件数据的事件的方法。
ResolveEventHandler 表示处理 AppDomain 的 TypeResolve、ResourceResolve 和 AssemblyResolve 事件的方法。
UnhandledExceptionEventHandler表示将处理事件的方法，该事件由应用程序域不处理的异常引发。枚举
AttributeTargets 指定可以对它们应用特性的应用程序元素。DayOfWeek 指定一周的某天。
Environment.SpecialFolder 指定用于检索系统特殊文件夹的目录路径的枚举常数。LoaderOptimization 一个枚举，它与 LoaderOptimizationAttribute 类一起使用为可执行文件指定加载程序优化。
PlatformID 描述程序集所支持的平台。TypeCode 指定对象的类型。
UriHostNameType 为 Uri.CheckHostName 方法定义主机名类型。UriPartial 为 Uri.GetLeftPart 方法定义 URI 的各部分。
第五篇：命名空间
本讲基本要求
* 掌握:命名空间的作用及定义；如何使用命名空间。
* 了解:使用早期的函数库
重点、难点
◆命名空间的作用及定义；如何使用命名空间。
在学习本书前面各章时，读者已经多次看到在程序中用了以下语句： using namespace std；
这就是使用了命名空间std。在本讲中将对它作较详细的介绍。
一、为什么需要命名空间（问题提出）
命名空间是ANSIC++引入的可以由用户命名的作用域，用来处理程序中常见的同名冲突。
在C语言中定义了3个层次的作用域，即文件(编译单元)、函数和复合语句。C++又引入了类作用域，类是出现在文件内的。在不同的作用域中可以定义相同名字的变量，互不于扰，系统能够区别它们。
1、全局变量的作用域是整个程序，在同一作用域中不应有两个或多个同名的实体(enuty)，包括变量、函数和类等。
例：如果在文件中定义了两个类，在这两个类中可以有同名的函数。在引用时，为了区别，应该加上类名作为限定： class A //声明A类
{ public：
void funl()；//声明A类中的funl函数
private：
int i； }；
void A::funl()//定义A类中的funl函数
{„„„„}
class B //声明B类
{ public：
void funl()； //B类中也有funl函数
void fun2()； }；
void B::funl()//定义B类中的funl函数
{ „„„„} 这样不会发生混淆。
在文件中可以定义全局变量(global variable)，它的作用域是整个程序。如果在文件A中定义了一个变量a int a=3；
在文件B中可以再定义一个变量a int a=5;在分别对文件A和文件B进行编译时不会有问题。但是，如果一个程序包括文件A和文件B，那么在进行连接时，会报告出错，因为在同一个程序中有两个同名的变量，认为是对变量的重复定义。
可以通过extern声明同一程序中的两个文件中的同名变量是同一个变量。如果在文件B中有以下声明： extem int a；
表示文件B中的变量a是在其他文件中已定义的变量。由于有此声明，在程序编译和连接后，文件A的变量a的作用域扩展到了文件B。如果在文件B中不再对a赋值，则在文件B中用以下语句输出的是文件A中变量a的值： cout<
2、程序中就会出现名字冲突。
在简单的程序设计中，只要人们小心注意，可以争取不发生错误。但是，一个大型的应用软件，往往不是由一个人独立完成的，而是由若干人合作完成的，不同的人分别完成不同的部分，最后组合成一个完整的程序。假如不同的人分别定义了类，放在不同的头文件中，在主文件(包含主函数的文件)需要用这些类时，就用#include命令行将这些头文件包含进来。由于各头文件是由不同的人设计的，有可能在不同的头文件中用了相同的名字来命名所定义的类或函数。例4 名字冲突
程序员甲在头文件headerl．h中定义了类Student和函数fun。//例4中的头文件header1(头文件1，没其文件名为cc8-4-h1.h)#include
{ public: Student(int n,string nam,int a){ num=n;name=nam;age=a;} void get_data();private: int num;string name;int age;};void Student::get_data()//成员函数定义 { cout< Wang 18 2.82843 如果程序员乙写了头文件header2．h，在其中除了定义其他类以外，还定义了类Student和函数fun，但其内容与头文件headerl．h中的Student和函数fun有所不同。//例4中的头文件header2 #include { num=n;name=nam;sex=s;} void get_data();private: int num;string name;char sex;};//此项与headerl不同 void Student::get_data()//成员函数定义 { cout< double fun(double a,double b)//定义全局函数 { return sqrt(a-b);} //返回值与headerl中的fun函数不同 //头文件2中可能还有其他内容 假如主程序员在其程序中要用到headerl．h中的Student和函数fun，因而在程序中包含了头文件headerl．h，同时要用到头文件header2．h中的一些内容(但对header2．h中包含与headerl.h中的Student类和fun函数同名而内容不同的类和函数并不知情，因为在一个头文件中往往包含许多不同的信息，而使用者往往只关心自己所需要的部分，而不注意其他内容)，因而在程序中又包含了头文件header2．h。如果主文件(包含主函数的文件)如下： #include 3、全局命名空间污染(global namespace pollution)。 在程序中还往往需要引用一些库(包括C++编译系统提供的库、由软件开发商提供的库或者用户自己开发的库)，为此需要包含有关的头文件。如果在这些库中包含有与程序的全局实体同名的实体，或者不同的库中有相同的实体名，则在编译时就会出现名字冲突。 为了避免这类问题的出现，人们提出了许多方法，例如：将实体的名字写得长—些(包含十几个或几十个字母和字符)；把名字起得特殊一些，包括一些特殊的字符；由编译系统提供的内部全局标识符都用下划线作为前缀，如_complex()，以避免与用户命名的实体同名；由软件开发商提供的实体的名字用特定的字符作为前缀。但是这样的效果并不理想，而且增加了阅读程序的难度，可读性降低了。c语言和早期的C++语言没有提供有效的机制来解决这个问题，没有使库的提供者能够建立自己的命名空间的工具。人们希望ANSI C++标准能够解决这个问题，提供—种机制、一种工具，使由库的设计者命名的全局标识符能够和程序的全局实体名以及其他库的全局标识符区别开来。 二、什么是命名空间（解决方案） 命名空间：实际上就是一个由程序设计者命名的内存区域，程序设计者可以根据需要指定一些有名字的空间域，把一些全局实体分别放在各个命名空间中，从而与其他全局实体分隔开来。 如： namespace ns1 //指定命名中间nsl { int a； double b;} namespace是定义命名空间所必须写的关键字，nsl是用户自己指定的命名空间的名字(可以用任意的合法标识符，这里用ns1是因为ns是namespace的缩写，含义请楚)，在花括号内是声明块，在其中声明的实体称为命名空间成员(namespace member)。现在命名空间成员包括变量a和b，注意a和b仍然是全局变量，仅仅是把它们隐藏在指定的命名空间中而已。如果在程序中要使用变量a和b，必须加上命名空间名和作用域分辨符“::”，如nsl::a，nsl::b。这种用法称为命名空间限定(qualified)，这些名字(如nsl::a)称为被限定名(qualified name)。C++中命名空间的作用类似于操作系统中的目录和文件的关系，由于文件很多，不便管理，而且容易重名，于是人们设立若干子目录，把文件分别放到不同的子目录中，不同子目录中的文件可以同名。调用文件时应指出文件路径。 命名空间的作用：是建立一些互相分隔的作用域，把一些全局实体分隔开来。以免产生老点名叫李相国时，3个人都站起来应答，这就是名字冲突，因为他们无法辨别老师想叫的是哪一个李相国，同名者无法互相区分。为了避免同名混淆，学校把3个同名的学生分在3个班。这样，在小班点名叫李相国时，只会有一个人应答。也就是说，在该班的范围(即班作用域)内名字是惟一的。如果在全校集合时校长点名，需要在全校范围内找这个学生，就需要考虑作用域问题。如果校长叫李相国，全校学生中又会有3人一齐喊“到”，因为在同一作用域中存在3个同名学生。为了在全校范围内区分这3名学生，校长必须在名字前加上班号，如高三甲班的李相国，或高三乙班的李相国，即加上班名限定。这样就不致产生混淆。 可以根据需要设置许多个命名空间，每个命名空间名代表一个不同的命名空间域，不同的命名空间不能同名。这样，可以把不同的库中的实体放到不同的命名空间中，或者说，用不同的命名空间把不同的实体隐蔽起来。过去我们用的全局变量可以理解为全局命名空间，独立于所有有名的命名空间之外，它是不需要用namespace声明的，实际上是由系统隐式声明的，存在于每个程序之中。 在声明一个命名空间时，花括号内不仅可以包括变量，而且还可以包括以下类型： ·变量(可以带有初始化)； ·常量； ·数(可以是定义或声明)； ·结构体； ·类； ·模板； ·命名空间(在一个命名空间中又定义一个命名空间，即嵌套的命名空间)。例如 namespace nsl { const int RATE=0.08； //常量 doublepay； //变量 doubletax() //函数 {return a*RATE；} namespacens2 //嵌套的命名空间 {int age；} } 如果想输出命名空间nsl中成员的数据，可以采用下面的方法： cout< cout< 可以看到命名空间的声明方法和使用方法与类差不多。但它们之间有一点差别：在声明类时在右花括号的后面有一分号，而在定义命名空间时，花括号的后面没有分号。 三、使用命名空间解决名字冲突（使用指南）有了以上的基础后，就可以利用命名空间来解决名字冲突问题。现在，对例4程序进行修改，使之能正确运行。 例5 利用命名空间来解决例4程序名字冲突问题。 修改两个头文件，把在头文件中声明的类分别放在两个不同的命名空间中。//例8.5中的头文件1，文件名为header1.h using namespace std;#include { public: Student(int n,string nam,int a){ num=n;name=nam;age=a;} void get_data();private: int num;string name;int age;};void Student::get_data()//定义成员函数 { cout< void Student::get_data(){ cout< double fun(double a,double b){ return sqrt(a-b);} } //main file #include cout< ns2::Student stud2(102,”Li“,'f');//用命名空间ns2中声明的Student类定义stud2 stud2.get_data();cout< 分析例4程序出错的原因是：在两个头文件中有相同的类名Student和相同的函数名fun，在把它们包含在主文件中时，就产生名字冲突，存在重复定义。编译系统无法辨别用哪一个头文件中的Student来定义对象studl。现在两个Student和fun分别放在不同的命名空间中，各自有其作用域，互不相干。由于作用域不相同，不会产：生名字冲突。正如同在两个不同的类中可以有同名的变量和函数而不会产生冲突一样。 在定义对象时用ns1::Student(命名空间nsl中的Student)来定义studl，用ns2：：Student(命名空间ns2中的Student)来定义stud2。显然，nsl::Student和ns2::Student是两个不同的类，不会产生混淆。同样，在调用fun函数时也需要用命名空间名ns]或ns2加以限定。ns1::fun()和ns2::fun()是两个不同的函数。注意：对象studl是用nsl：：Student定义的，但对象studl并不在命名空间nsl中。studl的作用域为main函数范围内。在调用对象studl的成员函数get_data时，应写成studl．get_data()，而不应写成nsl::studl.get_data()。程序能顺利通过编译，并得到以下运行结果： 101 Wang l9(对象studl中的数据)2.82843(／5+3的值)102 Li f(对象studg中的数据)1.41421(／5-2的值) 四、使用命名空间成员的方法 从上面的介绍可以知道，在引用命名空间成员时，要用命名空间名和作用域分辨符对命名空间成员进行限定，以区别不同的命名空间中的同名标识符。即: 命名空间名：：命名空间成员名 这种方法是有效的，能保证所引用的实体有惟一的名字。但是如果命名空间名字比较长，尤其在有命名空间嵌套的情况下，为引用一个实体，需要写很长的名字。在一个程序中可能要多次引用命名空间成员，就会感到很不方便。1、使用命名空间别名 可以为命名空间起一个别名(namespace alias)，用来代替较长的命名空间名。如 namespace Television //声明命名空间，名为Television {...} 可以用一个较短而易记的别名代替它。如： namespace TV=Television； //别名TV与原名Television等价 也可以说，别名TV指向原名Television，在原来出现Television的位置都可以无条件地用TV来代替。 2、使用using命名空间成员名 using后面的命名空间成员名必须是由命名空间限定的名字。例如： using nsl::Student； 以上语句声明：在本作用域(using语句所在的作用域)中会用到命名空间ns1中的成员Student，在本作用域中如果使用该命名空间成员时，不必再用命名空间限定。例如在用上面的using声明后，在其后程序中出现的Student就是隐含地指nsl::Student。 using声明的有效范围是从using语句开始到using所在的作用域结束。如果在以上的using语句之后有以下语句： Student studl(101,”Wang“,18)； //此处的Student相当于ns1::Student 上面的语句相当于 nsl::Student studl(101，”Wang“，18)； 又如 using nsl::fun； //声明其后出现的fun是属于命名空间nsl中的fun cout< 但是要注意：在同一作用域中用using声明的不同命名空间的成员中不能有同名的成员。例如： usmgnsl::Student； //声明其后出现的Student是命名空间nsl中的Student usmgns2::Student； //声明其后出现的Student是命名空间ns2小的Student Student stud1； //请问此处的Student是哪个命名中间中的Student? 产生了二义性，编译出错。 3、使用using namespace命名空间名 用上面介绍的using命名空间成员名，一次只能声明一个命名空间成员，如果在一个命名空间中定义了10个实体，就需要使用10次using命名空间成员名。能否在程序中用一个语句就能一次声明一个命名空间中的全部成员呢? C++提供了using namespace语句来实现这一目的。using namespace语句的一般格式为 using namespace 命名空间名； 例如 using nanlespace nsl； 声明了在本作用域中要用到命名空间nsl中的成员，在使用该命名空间的任何成员时都不必用命名空间限定。如果在作了上面的声明后有以下语句： Student studl(101，”Wang”，18)； //Student隐含指命名中间nsl中的Student cout< cout< Student stud2(102，“Li”，'r')； stud2.get_data()； coutt< 五、无名的命名空间 以上介绍的是有名字的命名空间，C++还允许使用没有名字的命名空间，如在文件A中声明了以下的无名命名空间： namespace //命名空间没有名字 { void fun()//定义命名空间成员 { cout<<“OK．”< 则执行无名命名空间中的成员fun函数，输出”OK．”。 在本程序中的其他文件中也无法使用该fun函数，也就是把fun函数的作用域限制在本文件范围中。可以联想到：在C浯言中可以用static声明一个函数，其作用也是使该函数的作用域限于本文件。C++保留了用static声明函数的用法，同时提供了用无名命名空间来实现这一功能。随着越来越多的C++编译系统实现了ANSI C++建议的命名空间的机制，相信使用无名命名空间成员的方法将会取代以前习惯用的对全局变量的静态声明。 六、标准命名空间std 为了解决C++标准库中的标识符与程序中的全局标识符之间以及不同库中的标识符之间的同名冲突，应该将不同库的标识符在不同的命名空间中定义(或声明)。标准C++库的所有的标识符都是在一个名为std的命名空间中定义的，或者说标准头文件(如iostream)中函数、类、对象和类模板是在命名空间std中定义的。std是standard(标准)的缩写，表示这是存放标准库的有关内容的命名空间，含义请楚，不必死记。 这样，在程序中用到C++标准库时，需要使用std作为限定。如 std::cout<<“OK．”< 这样，在std中定义和声明的所有标识符在本文件中都可以作为全局量来使用。但是应当绝对保证在程序中不出现与命名空间std的成员同名的标识符，例如在程序中不能再定义一个名为cout的对象。由于在命名空间std中定义的实体实在太多，有时程序设计人员也弄不请哪些标识符已在命名空间std中定义过，为减少出错机会，有的专业人员喜欢用若干个"using命名空间成员”声明来代替“using namespace命名空间”声明，如 using Std::string； using Std::cout； using Std::cin； 等。为了减少在每一个程序中都要重复书写以亡的using声明，程序开发者往往把编写应用程序时经常会用到的命名空间std成员的usmg声明组成一个头文件，然后在程序中包含此头文件即可。 如果阅读了多种介绍C++的书，可能会发现有的书的程序中有using namespace语句，有的则没有。有的读者会提出：究竟应该有还是应该没有?应当说：用标准的C++编程，是应该对命名空间std的成员进行声明或限定的(可以采取前面介绍过的任一种方法)。但是目前所用的C++库大多是几年前开发的，当时并没有命名空间，库中的有关内容也没有放在std命名空间中，因而在程序中不必对std进行声明。 七、使用早期的函数库 C语言程序中各种功能基本上都是由函数来实现的，在C语言的发展过程中建立了功能丰富的函数库，C++从C语言继承了这份宝贵的财富。在C++程序中可以使用C语言的函数库。如果要用函数库中的函数，就必须在程序文件中包含有关的头文件，在不同的头文件中，包含了不同的函数的声明。 在C++中使用这些头文件有两种方法。 1、用C语言的传统方法 头文件名包括后缀．h，如stdio.h，math.h等。由于C语言没有命名空间，头文件并不存放在命名空间中，因此在C++程序文件中如果用到带后缀．h的头文件时，不必用命名空间。只需在文件中包含所用的头文件即可。如 #include 2、用C++的新方法 C++标准要求系统提供的头文件不包括后缀．h，例如iostream、string。为了表示与C语言的头文件有联系又有区别，C++所用的头文件名是在C语言的相应的头文件名(但不包括后缀．h)之前加一字母c。例如，C语言中有关输入与输出的头文件名为stdio．h在C++中相应的头文件名为cstdio。C语言中的头文件math.h，在C++中相应的头文什名为cmath。C语言中的头文件string．h在C++中相应的头文件名为cstring。注意在C++中，头文件cstnng和头文件strmg不是同一个文件。前者提供C语言中对字符串处理的有关函数(如strcmp，ctrcpy)的声明，后者提供C++中对字符串处理的新功能。此外，由于这些函数都是在命名空间std中声明的，因此在程序中要对命名空间std作声明。如： #include 目前所用的大多数C++编译系统既保留了c的用法，又提供丁C++的新方法。下面两种用法等价，可以任选。C传统方法 C++新方法 #include
鲁公网安备37028302000876号