.NET 技术FAQ(一)

1. 简介
1.1 什么是 .NET？
1.2 .NET 只是 Windows DNA 的一个新名字吗？
1.3 .NET 只适用于建立 Web 网站吗？
1.4 .NET 是在什么时候宣布的？
1.5 .NET 将在何时发布？
1.6 如何开发 .NET 应用程序
1.7 可以从哪里下载 .NET SDK 和 Visual Studio 7？
1.8 .NET 中的关键技术是什么？
1.9 .NET 框架将运行在什么平台上？
1.10 .NET 框架支持什么语言？
1.11 .NET 框架符合标准化趋势吗？
 
2. 基本术语
2.1 什么是 CLR？
2.2 什么是 CTS？
2.3 什么是 CLS？
2.4 什么是 IL？
2.5 什么是 C#？
2.6 在 .NET 范畴里，“被管理”是什么含义？
2.7 什么是映像？
 
3. 元件
3.1 什么是元件？
3.2 怎样创建元件？
3.3 私有元件和共享元件有什么不同？
3.4 元件如何相互找到？
3.5 元件版本如何起作用？
 
4. 应用程序域
4.1 什么是应用程序域？
4.2 如何创建 AppDomain？
4.3 我能编写自己的 .NET 宿主吗？
 
5. 垃圾收集
5.1 什么是垃圾收集？
5.2 对对象的最后一个引用撤销后，它并不一定立即被破坏，对吗？
5.3 .NET 为什么不提供确定化的析构？
5.4 在 .NET 中缺少确定化的析构有问题吗？
5.5 确定化的析构是否影响在被管理代码中使用 COM 对象？
5.6 我听说应该避免使用 Finalize 方法，那么是否应该在我的类里实现 Finalize？
5.7 我有控制垃圾收集算法的手段吗？
5.8 我怎么知道垃圾收集器在做什么？
 
6. 属性
6.1 什么是属性？
6.2 我能创建自己的 metadata 属性吗？
6.3 我能创建自己的 context 属性吗？
 
7. 代码访问安全性
7.1 什么是代码访问安全性 (CAS)?
7.2 CAS 如何起作用？
7.3 谁定义 CAS 代码组？
7.4 如何定义自己的代码组？
7.5 如何改变代码组的权限集？
7.6 能否创建自己的权限集？
7.7 CAS 有问题时，如何诊断自己的程序？
7.8 我受不了 CAS 带来的麻烦，能否关掉它？
 
8. 中间语言 (IL)
8.1 我能看到元件的中间语言吗？
8.2 能否通过反向工程从 IL 中获得源代码？
8.3 如何防止别人通过反向工程获得我的代码？
8.4 我能直接用 IL 编程吗？
8.5 IL 能做到 C# 中做不到的事吗？
 
9. 关于 COM
9.1 COM 消亡了吗？
9.2 DCOM 消亡了吗？
9.3 MTS/COM+ 消亡了吗？
9.4 能在 .NET 中使用 COM 组件吗？
9.5 能在 COM 中使用 .NET 组件吗？
9.6 在 .NET 的世界中 ATL 是多余的吗？
 
10. 杂项
10.1 .NET 的远程计算如何工作？
10.2 如何在 .NET 程序中获得 Win32 API？
 
11. 类库
11.1 文件 I/O
11.1.1 如何读文本文件？
11.1.2 如何写文本文件？
11.1.3 如何读写二进制文件？
11.1.4 如何删除文件？
11.2 文本处理
11.2.1 是否支持正规表达式？
11.3 Internet
11.3.1 如何下载网页？
11.3.2 如何使用代理服务器 (proxy)？
11.4 XML
11.4.1 是否支持 DOM？
11.4.2 是否支持 SAX？
11.4.3 是否支持 XPath？
11.5 线程
11.5.1 是否支持多线程？
11.5.2 如何产生一个线程？
11.5.3 如何停止一个线程？
11.5.4 怎样使用线程池？
11.5.5 怎样知道我的线程池工作项目是在何时完成的？
11.5.6 怎样防止对数据的并发访问？
11.6 跟踪
11.6.1 有内置的跟踪/日志支持吗？
11.6.2 能否将跟踪输出重定向到一个文件？
11.6.3 能否定制跟踪的输出？
 
12. 资源
12.1 从哪里可以获得关于 .NET 的详情？
12.2 示例代码和实用程序
 
1. 简介
1.1 什么是 .NET？
很难用一句话来讲清楚。根据 Microsoft 的说法，.NET 是一个“革命性的新平台，建立在开放的 Internet 协议和标准之上，通过工具和服务将计算和通讯以崭新的方式融合到一起” 。
更为实际的定义是：.NET 是一个开发和运行软件的新环境，便于开发基于 Web 的服务，拥有丰富的运行库服务以支持用多种编程语言编写的组件，具有跨语言和跨平台的互操作能力。
注意，本文中使用术语“.NET”时，它仅指新的 .NET 运行库及其相关技术。有时我们也称其为“.NET 框架”。本文不包括其它 Microsoft 正在往上添加 .NET 名字的任何现有的产品和技术 (例如 SQL Server.NET)。
 
1.2 .NET 只是 Windows DNA 的一个新名字吗？
不。在很多地方，Windows DNA 仅仅是指使用现有技术的一种途径（即所谓的三阶式途径）的市场术语。.NET 更为急进，并且包括一个完整的软件开发和运行库框架。
 
1.3 .NET 只适用于建立 Web 网站吗？
不。如果你编写任何 Windows 软件 (使用 ATL/COM、MFC、VB 甚至 Win32 裸接口)，.NET 都可能为你正在做的事情提供可行的选择 (或补充)。当然，如果你就是在开发 Web 网站，.NET 有很多令你感兴趣的东西—不仅仅是 ASP+。
 
1.4 .NET 是在什么时候宣布的？
在 2000 年 6 月 22 日举行的 Forum 2000 论坛上，Bill Gates 做了一次 演说，勾画了 .NET 的“前景”。2000 年 7 月的 PDC 会议上针对 .NET 技术做了很多会谈，会谈代表得到了包含 .NET Framework/SDK 和 Visual Studio 7 预览版的光盘。
 
1.5 .NET 将在何时发布？
预计是在 2001 年的下半年。
 
1.6 如何开发 .NET 应用程序？
.NET Framework SDK 包含可用于建立 .NET 应用程序的命令行编译器和实用程序。Visual Studio 的下一版本 (称为 Visual Studio 7 或 Visual Studio.NET) 将完全集成对 .NET 开发的支持。
 
1.7 可以从哪里下载 .NET SDK 和 Visual Studio 7？
从 http://msdn.microsoft.com/net 可以下载 SDK 的 Beta 1 版。如果你是 MSDN Universal 订户，你还可以下载 Visual Studio 7 的 Beta 1 版。
 
1.8 .NET 中的关键技术是什么？
ASP.NET、CLR (Common Language Runtime—通用语言运行库)、C# (新一代的类-Java 语言)、SOAP、XML、ADO.NET、多语言支持 (Eiffel、COBOL 等等)
 
1.9 .NET 框架将运行在什么平台上？
Beta 1 支持在 Windows 2000、NT4 SP6a, Windows Me 和 Windows 98 上进行开发。Windows 95 支持运行库。
Microsoft 将按照和 .NET 运行库相似的时间表发布一个新版本 Windows。它的代号是“Whistler”，在很大程度上是对 Windows 2000 的扩充性更新，对 GUI 有重要的改变。Microsoft 将以“.NET-enabled”作为新操作系统的卖点，但看起来它没有和 .NET 运行库绑在一起。如果 .NET 运行库能及时完成，它将包含在 Whistler 之内；否则，Whistler 将单独发货。
 
1.10 .NET 框架支持什么语言？
开始 Microsoft 将提供 C#、C++、VB 和 JScript 编译器。其它供应商宣布他们有意开发像 COBOL、Eiffel、Perl、Smalltalk 和 Python 等语言的 .NET 编译器。
 
1.11 .NET 框架符合标准化趋势吗？
C# 以及称为“通用语言基础结构”的一些东西的推荐标准草案已经提交给了 ECMA。参见 http://msdn.microsoft.com/net/ecma/
 
2. 基本术语
2.1 什么是 CLR？
CLR = Common Language Runtime—通用语言运行库。CLR 是一组标准资源集合，无论编程语言是什么，所有 (理论上) .NET 程序都能从中获益。Robert Schmidt (Microsoft) 在他的 MSDN PDC# 文章 中列出了以下 CLR 资源：
面向对象的编程模型 (继承、多态、异常处理、垃圾收集)
安全模型
类型系统
所有的 .NET 基础类
许多 .NET 框架类
开发、调试和测评工具
运行和代码管理
IL-机器语言 转换器和优化器
这些的含义是，在 .NET 世界里，不同的编程语言将在能力上比过去任何时候都更平等，虽然显然不是所有语言都支持所有 CLR 服务。
 
2.2 什么是 CTS？
CTS = Common Type System—通用类型系统。它是指 .NET 运行库所理解、并且随后 .NET 应用程序可以使用的一系列类型。然而，注意不是所有的 .NET 语言都将支持 CTS 中的所有类型。CTS 是 CLS 的超集。
 
2.3 什么是 CLS？
CLS = Common Language Specification—通用语言规范。它是预计所有 .NET 语言都支持的一个 CTS 的子集。这一思想是让使用 CLS-相容类型的任何程序和以任何语言编写的 .NET 程序可以互相操作。
理论上它能允许在不同的 .NET 语言之间有紧密的互操作性—例如允许从一个 VB 类里继承一个 C# 类。
 
2.4 什么是 IL？
IL = Intermediate Language—中间语言。又称为 MSIL。所有 .NET 源代码 (使用任何语言) 被编译为 IL。然后在软件的安装点上或者运行时，IL 由即时 (JIT) 编译器转换为机器码。
 
2.5 什么是 C#？
C# 是在 .NET 框架中运行的一种新语言。在他们的“C# 简介”白皮书中，Microsoft 这样描述 C#：
“C# 是从 C 和 C++ 派生出来的一种简单的、面向对象的、并且是类型安全的现代编程语言。C# (发音为‘C sharp’) 牢固地根植于在 C 和 C++ 家族之树，将很快为 C 和 C++ 程序员所熟悉。C# 帮助开发者将 Visual Basic 的高生产率和 C++ 的直接控制能力结合起来。”
将以上引言中的“C#”换成“Java”，你会发现这句陈述依然很正确 :)。
假如你是一位 C++ 程序员，你可能想看看我的 C# FAQ。
 
2.6 在 .NET 范畴里，“被管理”是什么含义？
术语“被管理”导致了很多误解。在 .NET 里的不同地方都使用了它，分别指相互差别不大的不同东西。
被管理代码：.NET 框架为运行在其上的程序提供了几个核心的运行服务—例如异常处理和安全性。为使这些服务能工作，代码必须提供运行时的最低程度的一些信息。这样的代码被称为被管理代码。默认情况下，所有 C#、Visual Basic.NET 和 JScript.NET 代码都是被管理代码。如不指明，VS7 C++ 代码不是被管理代码，但能通过一个命令行开关 (/com+) 使编译器产生被管理代码。
被管理数据：是指由 .NET 运行库的垃圾收集器分配和回收的数据。C#、VB.NET 和 JScript.NET 数据总是被管理的。即使使用了 /com+ 开关，默认情况下 VS7 C++ 数据也不是被管理的，但可以使用 __gc 关键字将其指定为被管理数据。
被管理类：通常在 C++ 的 Managed Extensions (ME) 范畴中涉及。使用 ME C++ 时，可以用 __gc 关键字将其指定为被管理的。名副其实，该类的实例所占用的内存由垃圾收集器管理，但还不止如此。该类还成为了完全的 .NET 团体的成员，同时带来了好处和限制。好处之一是获得了与其它语言编写的类之间的互操作性—例如，一个被管理 C++ 类可以继承 VB 类。限制之一是被管理类只能继承一个基类。
 
2.7 什么是映像？
所有的 .NET 编译器都产生关于它们所产生的模块中的类型定义的特殊数据。这些特殊数据同模块封装在一起 (随后模块被封装到元件中)，可以通过称为映像 的机制来访问。System.Reflection 命名空间中包含向模块或元件询问其类型的类。
使用映像来访问 .NET 的特殊数据同使用 ITypeLib/ITypeInfo 来访问 COM 中的类型库数据非常相似，而且使用的目的也很相似—例如确定数据类型大小，以便在上下文、进程、机器的边界间调度它们。
映像还可以被用来动态调用方法 (参见 System.Type.InvokeMember)，甚至在运行时动态创建类型 (参见 System.Reflection.Emit.TypeBuilder )。
 
3. 元件
3.1 什么是元件？
元件有时被描述为一个逻辑上的 .EXE 或 .DLL，它可以是任何一个应用程序 (有一个主入口点) 或库。一个元件由一个或多个文件组成 (dll、exe、html 文件等等)，表示一组资源、类型定义以及这些类型的实现。一个元件也可以包含对其它元件的引用。这些资源、类型和引用在称为清单的一个数据块中描述。清单是元件的一部分，这样一来元件就是自描述的。
元件的一个重要方面使他们是一个类型的唯一标志的一部分。类型的唯一标志是将它所在的元件和类型名组合在一起得到的。这就是说，例如，如果元件 A 输出了一个称为 T 的类型，同时元件 B 输出了一个也称为 T 的类型，.NET 运行库将它们视为完全不同的两个类型。此外，不要混淆元件和命名空间—命名空间仅仅是组织类型名字的一种层次化方法。对于运行库，不论使用哪一个命名空间来组织名字，类型名就是类型名。从运行库来看，是元件加上类型名 (无论类型名属于哪个命名空间) 唯一地标识出一个类型。
元件在 .NET 的安全方面也很重要—许多安全限制是在元件的边界上实施的。
最后，元件是 .NET 中版本控制的单元—详情见下文。
 
3.2 怎样创建元件？
创建元件最简单的方法是直接使用 .NET 编译器。例如，以下 C# 程序：
public class CTest
{
 public CTest()
 {
  System.Console.WriteLine( "Hello from CTest" );
 }
}
能用以下方法编译为一个库元件 (dll)：
csc /t:library ctest.cs
通过运行 .NET SDK 所带的“IL 反汇编”工具，你能看到元件的内容。
另外你也能把你的源代码编译成模块，然后使用元件连接器 (al.exe) 将模块组合成一个元件。对 C# 编译器，/target:module 开关可以指定产生模块而不是元件。
 
3.3 私有元件和共享元件有什么不同？
空间分配和可见性：私有元件通常由一个应用程序使用，被存储到这个应用程序的目录或其下的子目录之下。共享元件通常存储到全局的元件缓冲区中，这里是 .NET 运行库维护的元件的储藏所。共享元件通常是许多应用程序都要用到的代码库，例如 .NET 框架类。
　
版本控制：运行库只对共享元件实施版本约束，而不对私有元件实施。
 
3.4 元件如何相互找到？
通过寻找目录路径。有几个因素会影响路径 (比如 AppDomain 宿主、应用程序配置文件等)，但对于私有元件，搜索路径通常是应用程序的目录及其子目录。对于共享元件，搜索路径通常和私有元件的一样，再加上共享元件缓冲区。
 
3.5 元件版本如何起作用？
每个元件由一个称为兼容性版本的版本号。同样，对元件的引用 (从另一个元件) 包括被引用元件的名称和版本。
版本号有四个数字部分 (例如 5.5.2.33)。前两部分不相同的元件被视为不兼容的。如果前两部分相同，但第三部分不同，元件被认为“可能兼容”。如果仅仅第四部分不同，则元件被视为是兼容的。然而，这只是默认的指导方针—是 版本策略决定施用这些规则的范围。版本策略可以在应用程序配置文件中指定。
记住：版本控制仅仅针对于共享元件，而不对私有元件。
 
4. 应用程序域
4.1 什么是应用程序域？
应用程序域 (AppDomain) 可以被看作一个轻型的进程。在一个 Win32 进程中可以存在多个 AppDomain。AppDomain 的主要目的是将应用程序和其它应用程序隔离开来。
通过使用独立的地址空间，Win32 进程提供隔离性。这种方法很有效，但开销很大并且伸缩性不好。.NET 运行库通过控制对内存的是用来施加 AppDomain 隔离—AppDomain 中的所有内存是由 .NET 运行库来管理的，所以运行库可以确保 AppDomain 之间不能访问彼此的内存。
 
4.2 如何创建 AppDomain？
AppDomains 通常有宿主创建。宿主包括 Windows Shell、ASP+ 和 IE。当你从命令行运行一个 .NET 应用程序时，宿主是 Shell。Shell 为每个应用程序创建一个新的 AppDomain。
AppDomains 也可以由 .NET 应用程序来显式创建。这里是一个创建 AppDomain 的一个 C# 例子，它创建对象的一个实例，并随后执行对象的一个方法：
using System;
using System.Runtime.Remoting;

public class CAppDomainInfo : MarshalByRefObject
{
 public string GetAppDomainInfo()
 {
  return "AppDomain = " + AppDomain.CurrentDomain.FriendlyName;
 }

}

public class App
{
    public static int Main()
    {
  AppDomain ad = AppDomain.CreateDomain( "Andy's new domain", null, null );
  ObjectHandle oh = ad.CreateInstance( "appdomaintest.exe", "CAppDomainInfo" );
  CAppDomainInfo adInfo = (CAppDomainInfo)(oh.Unwrap());
  string info = adInfo.GetAppDomainInfo();
  
  Console.WriteLine( "AppDomain info: " + info );
  return 0;
    }
}
 
4.3 我能编写自己的 .NET 宿主吗？
能。关于怎样来做的例子，看看 Jason Whittington 和 Don Box 开发的 dm.net moniker 的源代码 (http://staff.develop.com/jasonw/clr/readme.htm)。在 .NET SDK 中也有一个叫作 CorHost 的代码示例。
 
5. 垃圾收集
5.1 什么是垃圾收集？
垃圾收集是一个系统，运行库组件通过它来管理对象的生存周期和它们占用的堆内存。对 .NET 而言它并不是一个新概念—Java 和许多其它语言/运行库使用垃圾收集已经有一段时间了。
 
5.2 对对象的最后一个引用撤销后，它并不一定立即被破坏，对吗？
是的。垃圾收集器并不提供销毁对象并是放其内存的时间保证。
关于 C# 中隐含的非确定化对象析构，Chris Sells 有一个令人感兴趣的线索：http://discuss.develop.com/archives/wa.exe?A2=ind0007&L=DOTNET&P=R24819
2000 年 10 月，Microsoft 的 Brian Harry 贴出了一个针对这个问题的很长的分析：http://discuss.develop.com/archives/wa.exe?A2=ind0010A&L=DOTNET&P=R28572
Chris Sells 对 Brian 贴子的答复在这里：http://discuss.develop.com/archives/wa.exe?A2=ind0010C&L=DOTNET&P=R983
 
5.3 .NET 为什么不提供确定化的析构？
因为垃圾收集算法。.NET 的垃圾收集器通过周期地扫描应用程序正在使用的所有对象的列表来工作。扫描过程中所有未被发现的对象就可以被销毁并释放内存。当对对象的最后一个引用撤销后，算法的这种实现使运行库不能立即得到通知—它只能在下一次清理堆时发现。
而且，这种算法尽可能少地进行垃圾收集，以便工作得最有效率。通常，堆容量的消耗会触发收集过程。
 
5.4 在 .NET 中缺少确定化的析构有问题吗？
这确实会影响组件的设计。如果你的对象需要昂贵或紧缺的资源 (例如对数据库的锁定)，你需要提供某种方法让客户端在工作完成后能告诉对象以释放资源。Microsoft 建议，为此目的你应提供一个称为 Dispose () 的方法。然而，这样会在分布式对象中引起问题—在一个分布式系统中由谁来调用 Dispose () 方法？需要有某种形式的引用-计数机制或所有者管理机制来处理分布式对象—不幸的是运行库对此爱莫能助。
 
5.5 确定化的析构是否影响在被管理代码中使用 COM 对象？
是的。从被管理代码中使用 COM 对象时，你实际上是依赖垃圾收集器来最终释放你的对象。如果你的 COM 对象占有昂贵的资源且只能在最终释放对象后才能释放，你可能需要在你的对象上提供一个新接口以支持显式的 Dispose () 方法。
 
5.6 我听说应该避免使用 Finalize 方法，那么是否应该在我的类理实现 Finalize？
对垃圾收集器而言，拥有 Finalize 方法的对象比没有此方法的对象需要做更多的工作。同时也不保证对象 Finalized 的次序，所以对于从 Finalized 方法访问其它对象有不同的看法。最后，不能保证 Finalized 方法一定能被调用。所以，永远不应该依赖它来清理对象的资源。
Microsoft 建议使用以下方式：
public class CTest
{
 public override void Dispose()
 {
  ... // Cleanup activities
  GC.SuppressFinalize(this);
 }
 
 protected override void Finalize()
 {
  Dispose();
 }
}
一般情况下客户端调用 Dispose ()，对象的资源被释放，并且通过调用 SuppressFinalize ()，垃圾收集器被免除了对它进行 Finalize 的义务。在最不利的情况下，即客户端忘记了调用 Dispose ()，有很大的机会通过垃圾收集器调用 Finalize () 来最终释放对象的资源。由于垃圾收集算法的缺陷，这看起来像是相当合理的处理办法了。
 
5.7 我有控制垃圾收集算法的手段吗？
有一点。System.GC 类提供了一对有趣的方法。第一个是 Collect 方法—它强制垃圾收集器立即收集所有未被引用的对象。另一个是 RequestFinalizeOnShutdown ()，它告诉垃圾收集器在应用程序关闭时一定要对每个对象运行 Finalize () 方法。在应用程序关闭时，垃圾收集器一般优先选择快速的推出方式而不是调用 Finzlize ()，所以这个方法能手工强制运行库多负一点责任。
如果你想验证这不仅仅是理论上的说法，是一十下面的测试程序：
using System;

class CTest
{
 protected override void Finalize()
 {
  Console.WriteLine( "This is the Finalizer." );
 }
}

class CApplication
{
 public static void Main()
 {
  Console.WriteLine( "This is Main." );
  CTest test = new CTest();
  
  // GC.RequestFinalizeOnShutdown();
 }
}
运行此程序，然后再去掉 GC.RequestFinalizeOnShutdown() 这一行前面的注释标记并重新运行，注意有什么不同……
 
5.8 我怎么知道垃圾收集器在做什么？
.NET 运行库中很多令人感兴趣的统计通过 'COM+ Memory' 性能对象输出。使用 Performance Monitor 查看它们。
 
6. 属性
6.1 什么是属性？
最少有两种类型的 .NET 属性。第一类我称其为 metadata 属性—它允许将某些数据附加到类或方法上。这些数据称为类的 metadata 的一部分，并且可以像类的其它 metadata 一样通过映射来访问。metadata 的另一种属性是 [serializable]，将它附加到类上表示类的实例可以被串行化。
[serializable] public class CTest {}
另一种类型的属性是上下文属性。上下文类型的属性使用和 metadata 相似的语法，但实际上它们是不同的。上下文类型属性提供一种解释机制，通过这种机制，实例的活动和方法调用可以是预先处理和/或随后处理的。如果你了解 Keith Brown 的通用委托器你可能熟悉这种思想。
 
6.2 我能创建自己的 metadata 属性吗？
是的。简单地从 System.Attribute 导出一个类并将其标记为 AttributeUsage 属性。例如：
[AttributeUsage(AttributeTargets.Class)]
public class InspiredByAttribute : System.Attribute
{
 public string InspiredBy;

 public InspiredByAttribute( string inspiredBy )
 {
  InspiredBy = inspiredBy;
 }
}

[InspiredBy("Andy Mc's brilliant .NET FAQ")]
class CTest
{
}
class CApp
{
 public static void Main()
 {
   object[] atts = typeof(CTest).GetCustomAttributes();
            foreach( object att in atts )
      if( att is InspiredByAttribute )
  Console.WriteLine( "Class CTest was inspired by {0}", _
     ((InspiredByAttribute)att).InspiredBy  );
 }
}
 
6.3 我能创建自己的 context 属性吗？
是的。