Embed

DotNet_

Document Sample

Shared by: huanghengdong

Tags

Stats

views:: 6
posted:: 2/9/2012
language:
pages:: 167

Public Domain

1

1. .NET Framework 概念概述

.NET Framework 是支持生成和运行下一代应用程序和 XML Web Services 的内部 Windows 组件。

.NET Framework 具有两个主要组件：公共语言运行库和 .NET Framework 类库。公共语言运行库是 .NET Framework 的基础。您可以将运行库看作一个在执

行时管理代码的代理，它提供内存管理、线程管理和远程处理等核心服务，并且还强制实施严格的类型安全以及可提高安全性和可靠性的其他形式的代码准确

性。事实上，代码管理的概念是运行库的基本原则。以运行库为目标的代码称为托管代码，而不以运行库为目标的代码称为非托管代码。 .NET Framework 的

另一个主要组件是类库，它是一个综合性的面向对象的可重用类型集合，您可以使用它开发多种应用程序，这些应用程序包括传统的命令行或图形用户界面

(GUI) 应用程序，也包括基于 ASP.NET 所提供的最新创新的应用程序（如 Web 窗体和 XML Web Services）。

公共语言运行库的功能

公共语言运行库管理内存、线程执行、代码执行、代码安全验证、编译以及其他系统服务。这些功能是在公共语言运行库上运行的托管代码所固有的。

至于安全性，取决于包括托管组件的来源（如 Internet、企业网络或本地计算机）在内的一些因素，托管组件被赋予不同程度的信任。这意味着即使用在同

一活动应用程序中，托管组件既可能能够执行文件访问操作、注册表访问操作或其他须小心使用的功能，也可能不能够执行这些功能。

例用但文

运行库强制实施代码访问安全。如，户可以相信嵌入在网页中的可执行文件能够在屏幕上播放动画或唱歌，不能访问他们的个人数据、件系统或网络。

这样，运行库的安全性功能就使通过 Internet 部署的合法软件能够具有特别丰富的功能。

运行库还通过实现称为通用类型系统 (CTS) 的严格类型验证和代码验证基础结构来加强代码可靠性。 CTS 确保所有托管代码都是可以自我描述的。各种

Microsoft 和第三方语言编译器生成符合 CTS 的托管代码。这意味着托管代码可在严格实施类型保真和类型安全的同时使用其他托管类型和实例。

此外，运行库的托管环境还消除了许多常见的软件问题。例如，运行库自动处理对象布局并管理对对象的引用，在不再使用它们时将它们释放。这种自动内存

管理解决了两个最常见的应用程序错误：内存泄漏和无效内存引用。

运行库还提高了开发人员的工作效率。例如，程序员可以用他们选择的开发语言编写应用程序，却仍能充分利用其他开发人员用其他语言编写的运行库、类库

和组件。任何选择以运行库为目标的编译器供应商都可以这样做。以 .NET Framework 为目标的语言编译器使得用该语言编写的现有代码可以使用 .NET

Framework 的功能，这大大减轻了现有应用程序的迁移过程的工作负担。

尽管运行库是为未来的软件设计的，但是它也支持现在和以前的软件。托管和非托管代码之间的互操作性使开发人员能够继续使用所需的 COM 组件和 DLL。

运行库旨在增强性能。尽管公共语言运行库提供许多标准运行库服务，但是它从不解释托管代码。一种称为实时 (JIT) 编译的功能使所有托管代码能够以它

在其上执行的系统的本机语言运行。同时，内存管理器排除了出现零碎内存的可能性，并增大了内存引用区域以进一步提高性能。

最后，运行库可由高性能的服务器端应用程序（如 Microsoft® SQL Server™ 和 Internet 信息服务 (IIS)）承载。此基础结构使您在享受支持运行库宿主的

行业最佳企业服务器的优越性能的同时，能够使用托管代码编写业务逻辑。

.NET Framework 类库

.NET Framework 类库是一个与公共语言运行库紧密集成的可重用的类型集合。该类库是面向对象的，并提供您自己的托管代码可从中导出功能的类型。这不

但使 .NET Framework 类型易于使用，而且还减少了学习 .NET Framework 的新功能所需要的时间。此外，第三方组件可与 .NET Framework 中的类无缝集

成。

2. 托管执行过程

托管执行过程包括下列步骤：

1.选择编译器。

为获得公共语言运行库提供的优点，必须使用一个或多个针对运行库的语言编译器。

2.将代码编译为 Microsoft 中间语言 (MSIL)。

编译将源代码翻译为 MSIL 并生成所需的元数据。

3.将 MSIL 编译为本机代码。

在执行时，实时 (JIT) 编译器将 MSIL 翻译为本机代码。在此编译过程中，代码必须通过验证过程，该过程检查 MSIL 和元数据以查看是否可以将代码确

定为类型安全。

4.运行代码。

公共语言运行库提供使执行能够发生以及可在执行期间使用的各种服务的结构。

3. 扩展方法

扩展方法使您能够向现有类型 “ 添加 ” 方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型。扩展方法是一种特殊的静态方法，但可以像扩

展类型上的实例方法一样进行调用。对于用 C# 和 Visual Basic 编写的客户端代码，调用扩展方法与调用在类型中实际定义的方法之间没有明显的差异。

最常见的扩展方法是 LINQ 标准查询运算符，这些运算符在现有 System.Collections.IEnumerable 和 System.Collections.Generic.IEnumerable 类型

中添加了查询功能。若要使用这些标准查询运算符，请先使用 using System.Linq 指令将它们纳入范围中。然后，任何实现了 IEnumerable 的类型

看起来都具有 GroupBy、 OrderBy、 Average 等实例方法。在 IEnumerable)>) 类型的实例（如 List 或 Array）后键入 “ 点 ” 时，可以在

IntelliSense 语句结束中看到这些附加方法。

2

可以使用扩展方法来扩展类或接口，但不能重写扩展方法。与接口或类方法具有相同名称和签名的扩展方法永远不会被调用。编译时，扩展方法的优先级总是

比类型本身中定义的实例方法低。换句话说，如果某个类型具有一个名为 Process(int i) 的方法，而您有一个具有相同签名的扩展方法，则编译器

总是绑定到该实例方法。当编译器遇到方法调用时，它首先在该类型的实例方法中寻找匹配的方法。如果未找到任何匹配方法，编译器将搜索为该类型定义的

任何扩展方法，并且绑定到它找到的第一个扩展方法。下面的示例演示编译器如何确定要绑定到哪个扩展方法或实例方法。

定义和调用扩展方法

定义一个静态类以包含扩展方法。

该类必须对客户端代码可见。有关可访问性规则的更多信息，请参见访问修饰符（ C# 编程指南）。

将该扩展方法实现为静态方法，并使其至少具有与包含类相同的可见性。

该方法的第一个参数指定方法所操作的类型；该参数必须以 this 修饰符开头。

在调用代码中，添加一条 using 指令以指定包含扩展方法类的命名空间。

按照与调用类型上的实例方法一样的方式调用扩展方法。

请注意，第一个参数不是由调用代码指定的，因为它表示正应用运算符的类型，并且编译器已经知道对象的类型。您只需通过 n 为这两个形参提供实参。

下面的示例在 MyExtensions.StringExtension 类中实现了一个名为 WordCount 的扩展方法。该方法对 String 类进行操作，而该类被

指定为第一个方法参数。 MyExtensions 命名空间被导入到应用程序命名空间中，并且该方法是在 Main 方法内调用的。

using System.Linq;

using System.Text;

using System;

namespace CustomExtensions

{

//Extension methods must be defined in a static class

public static class StringExtension

{

// This is the extension method.

// The first parameter takes the "this" modifier

// and specifies the type for which the method is defined.

public static int WordCount(this String str)

{

return str.Split(new char[] {' ', '.','?'}, StringSplitOptions.RemoveEmptyEntries).Length;

}

}

}

namespace Extension_Methods_Simple

{

//Import the extension method namespace.

using CustomExtensions;

class Program

{

static void Main(string[] args)

{

string s = "The quick brown fox jumped over the lazy dog." ;

// Call the method as if it were an

// instance method on the type. Note that the first

// parameter is not specified by the calling code.

int i = s.WordCount();

System.Console.WriteLine("Word count of s is {0}", i);

}

}

3

4. A 类是 B 类的基类,并且都有自己的构造,析构函数,请举例证明 B 类从实例化到消亡过程中构

造,析构函数的执行过程.请附 code

父类若没有默认构造 ,子类必须在其构造函数内显式调用父类的带参构造才能保证子类对象的顺利实例化 .

类层层派生 ,在实例化的时候构造函数的调用顺序是怎样的 ? --从顶层基类开始向子类方向顺序调用无参构造 .

默认构造 (无参构造 )和带参构造什么时候调用 ?--默认将从顶层父类的默认构造一直调用到当前类的默认构造 .

下面是 C#继承构造函数实现及调用示例 :

/*

若希望类能够有派生类 ,必须为其实现默认构造函数 .

若类没有实现带参构造 ,编译器将自动创建默认构造函数 .

若类实现了带参构造 ,则编译器不会自动生成默认构造 .

*/

using System; //C#继承构造函数实现及调用

namespace xumh

{

public class MyClass

{

public MyClass()

{

Console.WriteLine("MyClass:默认构造函数 ");

}

public MyClass(int a, int b)

{

Console.WriteLine("MyClass 带参构造 :a={0}, b={1}.", a, b);

}

}

public class MyClass2 : MyClass

{

public MyClass2()

{

Console.WriteLine("MyClass2:默认构造函数 ");

}

public MyClass2(int a, int b)

{

Console.WriteLine("MyClass2 带参构造 :a={0}, b={1}.", a, b);

}

}

//C#继承构造函数实现及调用

public class MyClass3 : MyClass2

{

public MyClass3()

{

Console.WriteLine("MyClass3:默认构造函数 ");

}

public MyClass3(int a, int b)

{

4

Console.WriteLine("MyClass3 带参构造 :a={0}, b={1}.", a, b);

}

}

public class runMyApp

{

static void Main()

{

MyClass3 my = new MyClass3(3,4);

}

}

} //C#继承构造函数实现及调用

/**//*--===------------------------------------------ ===---

输出如下:

MyClass:默认构造函数

MyClass2:默认构造函数

MyClass3 带参构造 :a=3, b=4.

--===------------------------------------------===---*/

5. 什么叫应用程序域？

在 .NET 平台下，程序集并没有直接承载在进程中（而传统的 win32 程序是直接承载的）。实际上 .NET 可执行程序承载在进程的一个逻辑分区中，术语称为应

用程序域（也称 AppDomain)。可见，一个进程可以包含多个应用程序域，每一个应用程序域中承载一个 .NET 可执行程序，这样的好处如下：

应用程序域是 .NET 平台操作系统独立性的关键特性。这种逻辑分区将不同操作系统加载可执行程序的差异抽象化了。

和一个完整的进程相比，应用程序域的 CPU 和内存占用要小的多。因此 CLR 加载和卸载应用程序域比起完整的进程来说也快的多。

应用程序域为承载的应用程序提供了深度隔离。如果进程中一个应用程序域失败了，其他的应用程序域也能保持正常。

AppDomain 的主要成员：

CreateDomain():该静态方法在当前进程中创建一个新的应用程序域。由于 CLR 能够根据需要创建应用程序域，所以必须调用这个方法的机会很少。

GetCurrentThreadId():该静态方法返回当前应用程序域上活动的线程 ID。

UnLoad():该静态方法在进程中卸载指定的应用程序域。

BaseDirectory:获取基目录，该目录用于探测相关的程序集。

CreateInstance():在指定程序集文件中创建指定类型的新实例。

ExecuteAssembly():根据文件名在应用程序域中执行程序集。

GetAssemblies():获取已加载到此应用程序域中的 .NET 程序集（基于 COM 和 C 的二进制文件除外）。

Load():动态加载程序集到当前应用程序域。

6. 进程与线程的关系

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动 ,进程是系统进行资源分配和调度的一个独立单位。

线程是 CPU 调度和分派的基本单位 ,它是比进程更小的能独立运行的基本单位 .线程自己基本上不拥有系统资源 ,只拥有一点在运行中必不可少的资源 (如程序计

数器 ,一组寄存器和栈 ),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程

只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要

比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进

程。

7. 进程间通信的几种方式

1 文件映射

文件映射 (Memory-Mapped Files)能使进程把文件内容当作进程地址区间一块内存那样来对待。因此，进程不必使用文件 I/O 操作，只需简单的指针操作

5

就可读取和修改文件的内容。

Win32 API 允许多个进程访问同一文件映射对象，各个进程在它自己的地址空间里接收内存的指针。通过使用这些指针，不同进程就可以读或修改文件的

内容，实现了对文件中数据的共享。

应用程序有三种方法来使多个进程共享一个文件映射对象。

(1)继承：第一个进程建立文件映射对象，它的子进程继承该对象的句柄。

(2)命名文件映射：第一个进程在建立文件映射对象时可以给该对象指定一个名字 (可与文件名不同 )。第二个进程可通过这个名字打开此文件映射对象。

另外，第一个进程也可以通过一些其它 IPC 机制 (有名管道、邮件槽等 )把名字传给第二个进程。

(3)句柄复制：第一个进程建立文件映射对象，然后通过其它 IPC 机制 (有名管道、邮件槽等 )把对象句柄传递给第二个进程。第二个进程复制该句柄就取

得对该文件映射对象的访问权限。

文件映射是在多个进程间共享数据的非常有效方法，有较好的安全性。但文件映射只能用于本地机器的进程之间，不能用于网络中，而开发者还必须控制

进程间的同步。

2 共享内存

Win32 API 中共享内存 (Shared Memory)实际就是文件映射的一种特殊情况。进程在创建文件映射对象时用 0xFFFFFFFF 来代替文件句柄 (HANDLE)，就表示

了对应的文件映射对象是从操作系统页面文件访问内存，其它进程打开该文件映射对象就可以访问该内存块。由于共享内存是用文件映射实现的，所以它也有

较好的安全性，也只能运行于同一计算机上的进程之间。

3 匿名管道

管道 (Pipe)是一种具有两个端点的通信通道：有一端句柄的进程可以和有另一端句柄的进程通信。管道可以是单向－一端是只读的，另一端点是只写的；

也可以是双向的一管道的两端点既可读也可写。

匿名管道 (Anonymous Pipe)是在父进程和子进程之间，或同一父进程的两个子进程之间传输数据的无名字的单向管道。通常由父进程创建管道，然后由要

通信的子进程继承通道的读端点句柄或写端点句柄，然后实现通信。父进程还可以建立两个或更多个继承匿名管道读和写句柄的子进程。这些子进程可以使用

管道直接通信，不需要通过父进程。

匿名管道是单机上实现子进程标准 I/O 重定向的有效方法，它不能在网上使用，也不能用于两个不相关的进程之间。

4 命名管道

命名管道 (Named Pipe)是服务器进程和一个或多个客户进程之间通信的单向或双向管道。不同于匿名管道的是命名管道可以在不相关的进程之间和不同计

算机之间使用，服务器建立命名管道时给它指定一个名字，任何进程都可以通过该名字打开管道的另一端，根据给定的权限和服务器进程通信。

使不

命名管道提供了相对简单的编程接口，通过网络传输数据并不比同一计算机上两进程之间通信更困难，过如果要同时和多个进程通信它就力不从心了。

5 邮件槽

邮件槽 (Mailslots)提供进程间单向通信能力，任何进程都能建立邮件槽成为邮件槽服务器。其它进程，称为邮件槽客户，可以通过邮件槽的名字给邮件

槽服务器进程发送消息。进来的消息一直放在邮件槽中，直到服务器进程读取它为止。一个进程既可以是邮件槽服务器也可以是邮件槽客户，因此可建立多个

邮件槽实现进程间的双向通信。

通过邮件槽可以给本地计算机上的邮件槽、其它计算机上的邮件槽或指定网络区域中所有计算机上有同样名字的邮件槽发送消息。广播通信的消息长度不

能超过 400 字节，非广播消息的长度则受邮件槽服务器指定的最大消息长度的限制。

邮件槽与命名管道相似，不过它传输数据是通过不可靠的数据报 (如 TCP/IP 协议中的 UDP 包 )完成的，一旦网络发生错误则无法保证消息正确地接收，而

命名管道传输数据则是建立在可靠连接基础上的。不过邮件槽有简化的编程接口和给指定网络区域内的所有计算机广播消息的能力，所以邮件槽不失为应用程

序发送和接收消息的另一种选择。

6 剪贴板

剪贴板 (Clipped Board)实质是 Win32 API 中一组用来传输数据的函数和消息，为 Windows 应用程序之间进行数据共享提供了一个中介， Windows 已建立的

剪切 (复制 )－粘贴的机制为不同应用程序之间共享不同格式数据提供了一条捷径。当用户在应用程序中执行剪切或复制操作时，应用程序把选取的数据用一种

或多种格式放在剪贴板上。然后任何其它应用程序都可以从剪贴板上拾取数据，从给定格式中选择适合自己的格式。

剪贴板是一个非常松散的交换媒介，可以支持任何数据格式，每一格式由一无符号整数标识，对标准 (预定义 )剪贴板格式，该值是 Win32 API 定义的常量；

对非标准格式可以使用 Register Clipboard Format 函数注册为新的剪贴板格式。利用剪贴板进行交换的数据只需在数据格式上一致或都可以转化为某种格式

就行。但剪贴板只能在基于 Windows 的程序中使用，不能在网络上使用。

7 动态数据交换

动态数据交换 (DDE)是使用共享内存在应用程序之间进行数据交换的一种进程间通信形式。应用程序可以使用 DDE 进行一次性数据传输，也可以当出现新

数据时，通过发送更新值在应用程序间动态交换数据。

DDE 和剪贴板一样既支持标准数据格式 (如文本、位图等 )，又可以支持自己定义的数据格式。但它们的数据传输机制却不同，一个明显区别是剪贴板操作

几乎总是用作对用户指定操作的一次性应答－如从菜单中选择 Paste 命令。尽管 DDE 也可以由用户启动，但它继续发挥作用一般不必用户进一步干预。 DDE 有

三种数据交换方式：

(1) 冷链：数据交换是一次性数据传输，与剪贴板相同。

6

(2) 温链：当数据交换时服务器通知客户，然后客户必须请求新的数据。

(3) 热链：当数据交换时服务器自动给客户发送数据。

DDE 交换可以发生在单机或网络中不同计算机的应用程序之间。开发者还可以定义定制的 DDE 数据格式进行应用程序之间特别目的 IPC，它们有更紧密耦

合的通信要求。大多数基于 Windows 的应用程序都支持 DDE。

8 对象连接与嵌入

应用程序利用对象连接与嵌入 (OLE)技术管理复合文档 (由多种数据格式组成的文档 )，OLE 提供使某应用程序更容易调用其它应用程序进行数据编辑的服务。

例如， OLE 支持的字处理器可以嵌套电子表格，当用户要编辑电子表格时 OLE 库可自动启动电子表格编辑器。当用户退出电子表格编辑器时，该表格已在原始

字处理器文档中得到更新。在这里电子表格编辑器变成了字处理器的扩展，而如果使用 DDE，用户要显式地启动电子表格编辑器。

同 DDE 技术相同，大多数基于 Windows 的应用程序都支持 OLE 技术。

9 动态连接库

Win32 动态连接库 (DLL)中的全局数据可以被调用 DLL 的所有进程共享，这就又给进程间通信开辟了一条新的途径，当然访问时要注意同步问题。

虽然可以通过 DLL 进行进程间数据共享，但从数据安全的角度考虑，我们并不提倡这种方法，使用带有访问权限控制的共享内存的方法更好一些。

10 远程过程调用

Win32 API 提供的远程过程调用 (RPC)使应用程序可以使用远程调用函数，这使在网络上用 RPC 进行进程通信就像函数调用那样简单。 RPC 既可以在单机不

同进程间使用也可以在网络中使用。

由于 Win32 API 提供的 RPC 服从 OSF-DCE(Open Software Foundation Distributed Computing Environment) 标准。所以通过 Win32 API 编写的 RPC 应用

程序能与其它操作系统上支持 DEC 的 RPC 应用程序通信。使用 RPC 开发者可以建立高性能、紧密耦合的分布式应用程序。

11 NetBios 函数

Win32 API 提供 NetBios 函数用于处理低级网络控制，这主要是为 IBM NetBios 系统编写与 Windows 的接口。除非那些有特殊低级网络功能要求的应用程

序，其它应用程序最好不要使用 NetBios 函数来进行进程间通信。

12 Sockets

Windows Sockets 规范是以 U.C.Berkeley 大学 BSD UNIX 中流行的 Socket 接口为范例定义的一套 Windows 下的网络编程接口。除了 Berkeley Socket 原有

的库函数以外，还扩展了一组针对 Windows 的函数，使程序员可以充分利用 Windows 的消息机制进行编程。

现在通过 Sockets 实现进程通信的网络应用越来越多，这主要的原因是 Sockets 的跨平台性要比其它 IPC 机制好得多，另外 WinSock 2.0 不仅支持 TCP/IP

协议，而且还支持其它协议 (如 IPX)。 Sockets 的唯一缺点是它支持的是底层通信操作，这使得在单机的进程间进行简单数据传递不太方便，这时使用下面将

介绍的 WM_COPYDATA 消息将更合适些。

13 WM_COPYDATA 消息

当发参

WM_COPYDATA 是一种非常强大却鲜为人知的消息。一个应用向另一个应用传送数据时，送方只需使用调用 SendMessage 函数，数是目的窗口的句柄、

传递数据的起始地址、 WM_COPYDATA 消息。接收方只需像处理其它消息那样处理 WM_COPY DATA 消息，这样收发双方就实现了数据共享。

WM_COPYDATA 是一种非常简单的方法，它在底层实际上是通过文件映射来实现的。它的缺点是灵活性不高，并且它只能用于 Windows 平台的单机环境下。

8. 什么是托管代码？

托管代码 (managed code)由公共语言运行库环境 CLR（而不是直接由操作系统）执行的代码。托管代码应用程序可以获得公共语言运行库服务，例如自动垃圾

回收、运行库类型检查和安全支持等。

托管代码由 .net runtime 来执行。反之就是非托管。

.net runtime 有很多好处 :

1。安全性 ,像数组越界，类型安全什么的。

2。语言互操作性，可以使用多种语言。

3。易用性，垃圾收集。

托管代码在 Framework 下运行，底层的交互由 framework 做。

非托管代码就是脱离 Framework 的控制，同底层交互，资源则需要手动去释放

9. 什么是强类型系统?

C# 是强类型语言；因此每个变量和对象都必须具有声明类型。

10. 什么是装箱拆箱?

.NET 的所有类型都是由基类 System.Object 继承过来的，包括最常用的基础类型： int, byte, short， bool 等等，就是说所有的事物都是对象。如果申明这

7

会

些类型得时候都在堆 (HEAP)中分配内存，造成极低的效率 .正是通过将类型分成值型 (value)和引用型 (regerencetype)，（

C#中定义的值类型包括原类型 Sbyte、

Byte、Short、Ushort、Int、Uint、Long、Ulong、Char、Float、Double、Bool、Decimal）、枚举 (enum)、结构 (struct)，引用类型包括：类、数组、接口、

委托、字符串等。

值型就是在栈中分配内存，在申明的同时就初始化，以确保数据不为 NULL；

引用型是在堆中分配内存，初始化为 null，引用型是需要 GC 来回收内存的，值型不用，超出了值类型作用范围，系统就会自动释放 .

下面就来说装箱和拆箱的定义！

装箱就是隐式的将一个值型转换为引用型对象。比如：

int i=0;

Syste.Object obj=i;

拆箱就是将一个引用型对象转换成任意值型！比如：

int i=0;

System.Object obj=i;

int j=(int)obj;

再写个代码，看看进行了几次装拆箱！

int i=0;

System.Object obj=i;

Console.WriteLine(i+","+(int)obj);

其中共发生了 3 次装箱和一次拆箱.

第一次是将 i 装箱，第 2 次是输出的时候将 i 转换成 string 类型，而 string 类型为引用类型，即又是装箱，第三次装箱就是 (int)obj 的转换成 string 类型，

装箱！

拆箱就是 (int)obj，将 obj 拆箱 .

11. Lambda 表达式

“Lambda 表达式 ”是一个匿名函数，它可以包含表达式和语句，并且可用于创建委托或表达式目录树类型。

所有 Lambda 表达式都使用 Lambda 运算符 =>，该运算符读为 “ goes to” 。该 Lambda 运算符的左边是输入参数（如果有），右边包含表达式或语句块。

Lambda 表达式 x => x * x 读作 “ x goes to x times x” 。可以将此表达式分配给委托类型，如下所示：

delegate int del(int i);

del myDelegate = x => x * x;

int j = myDelegate(5); //j = 25

创建表达式目录树类型：

using System.Linq.Expressions;

// ...

Expression = x => x * x;

=> 运算符具有与赋值运算符 (=) 相同的优先级，并且是右结合运算符。

Lambda 用在基于方法的 LINQ 查询中，作为诸如 Where 和 Where 等标准查询运算符方法的参数。

使用基于方法的语法在 Enumerable 类中调用 Where 方法时（像在 LINQ to Objects 和 LINQ to XML 中那样），参数是委托类型 System. Func。使用 Lambda 表达式创建委托最为方便。

在前面的示例中，请注意委托签名具有一个 int 类型的隐式类型输入参数，并返回 int。可以将 Lambda 表达式转换为该类型的委托，因为该表达式也具有

一个输入参数 ( x )，以及一个编译器可隐式转换为 int 类型的返回值。使用输入参数 5 调用委托时，它将返回结果 25。

在 is 或 as 运算符的左侧不允许使用 Lambda。

适用于匿名方法的所有限制也适用于 Lambda 表达式。

Lambda 表达式

表达式在右边的 Lambda 表达式称为 “ Lambda 表达式 ” 。 Lambda 表达式在构造表达式目录树时广泛使用。 Lambda 表达式返回表达式的结果，并采用以下

基本形式：

(input parameters) => expression

只有在 Lambda 有一个输入参数时，括号才是可选的；否则括号是必需的。两个或更多输入参数由括

在括号中的逗号分隔：

8

(x, y) => x == y

有时，编译器难于或无法推断输入类型。如果出现这种情况，您可以按以下示例中所示方式显式指定类型：

(int x, string s) => s.Length > x

使用空括号指定零个输入参数：

() => SomeMethod()

在上一个示例中，请注意 Lambda 表达式的主体可以包含方法调用。但是，如果要创建将在另一个域（比如 SQL Server）中使用的表达式目录树，则不应

在 Lambda 表达式中使用方法调用。方法在 .NET 公共语言运行时上下文的外部将没有意义。

Lambda 语句

Lambda 语句与 Lambda 表达式类似，只是语句括在大括号中：

(input parameters) => {statement;}

Lambda 语句的主体可以包含任意数量的语句；但是，实际上通常不会多于两个或三个语句。

delegate void TestDelegate(string s);

…

TestDelegate myDel = n => { string s = n + " " + "World"; Console.WriteLine(s); };

myDel("Hello");

像匿名方法一样， Lambda 语句无法用于创建表达式目录树。

Lambda 中的类型推理

在编写 Lambda 时，通常不必为输入参数指定类型，因为编译器可以基于 Lambda 主体、基础委托类型以及 C# 3.0 语言规范中描述的其他因素推断类

型。对于大多数标准查询运算符，第一个输入是源序列中的元素的类型。因此，如果要查询 IEnumerable ，则输入变量将被推断为

Customer 对象，这意味着您可以访问其方法和属性：

customers.Where(c => c.City == "London");

Lambda 的一般规则如下：

Lambda 包含的参数数量必须与委托类型包含的参数数量相同。

Lambda 中的每个输入参数必须都能够隐式转换为其对应的委托参数。

Lambda 的返回值（如果有）必须能够隐式转换为委托的返回类型。

请注意，Lambda 表达式本身没有类型，因为通用类型系统没有 “ Lambda 表达式 ” 这一内部概念。但是，有时会不正式地论及 Lambda 表达式的 “ 类型 ” 。在

这些情况下，类型是指委托类型或 Lambda 表达式所转换为的 Expression 类型。

Lambda 表达式中的变量范围

Lambda 可以引用 “外部变量 ”，这些变量位于在其中定义 Lambda 的封闭方法或类型的范围内。将会存储通过这种方法捕获的变量以供在 Lambda 表达式

中使用，即使变量将以其他方式超出范围或被作为垃圾回收。必须明确地分配外部变量，然后才能在 Lambda 表达式中使用该变量。下面的示例演示这些规

则：

delegate bool D();

delegate bool D2(int i);

class Test

{

D del;

D2 del2;

public void TestMethod(int input)

{

int j = 0;

// Initialize the delegates with lambda expressions.

// Note access to 2 outer variables.

// del will be invoked within this method.

del = () => { j = 10; return j > input; };

9

// del2 will be invoked after TestMethod goes out of scope.

del2 = (x) => {return x == j; };

// Demonstrate value of j:

// Output: j = 0

// The delegate has not been invoked yet.

Console.WriteLine("j = {0}", j);

// Invoke the delegate.

bool boolResult = del();

// Output: j = 10 b = True

Console.WriteLine("j = {0}. b = {1}", j, b oolResult);

}

static void Main()

{

Test test = new Test();

test.TestMethod(5);

// Prove that del2 still has a copy of

// local variable j from TestMethod.

bool result = test.del2(10);

// Output: True

Console.WriteLine(result);

Console.ReadKey();

}

}

下列规则适用于 Lambda 表达式中的变量范围：

捕获的变量将不会被作为垃圾回收，直至引用变量的委托超出范围为止。

在外部方法中看不到 Lambda 表达式内引入的变量。

Lambda 表达式无法从封闭方法中直接捕获 ref 或 out 参数。

Lambda 表达式中的返回语句不会导致封闭方法返回。

Lambda 表达式不能包含其目标位于所包含匿名函数主体外部或内部的 goto 语句、 break 语句或 continue 语句。

12. 匿名方法

在 2.0 之前的 C# 版本中，声明委托的唯一方法是使用命名方法。C# 2.0 引入了匿名方法，而在 C# 3.0 及更高版本中，Lambda 表达式取代了匿名方法，

作为编写内联代码的首选方式。不过，本主题中有关匿名方法的信息同样也适用于 Lambda 表达式。有一种情况下，匿名方法提供了 Lambda 表达式中所没有

的功能。匿名方法使您能够省略参数列表，这意味着可以将匿名方法转换为带有各种签名的委托。这对于 Lambda 表达式来说是不可能的。要将代码块传递为

委托参数，创建匿名方法则是唯一的方法。这里是两个示例：

// Create a handler for a click event

button1.Click += delegate(System.Object o, System.EventArgs e)

{ System.Windows.Forms.MessageBox.Show( "Click!"); };

// Create a delegate instance

delegate void Del(int x);

10

// Instantiate the delegate using an anonymous method

Del d = delegate(int k) { /* ... */ };

通过使用匿名方法，由于您不必创建单独的方法，因此减少了实例化委托所需的编码系统开销。

例如，如果创建方法所需的系统开销是不必要的，则指定代码块（而不是委托）可能非常有用。启动新线程即是一个很好的示例。无需为委托创建更多方法，

线程类即可创建一个线程并且包含该线程执行的代码。

void StartThread()

{

System.Threading.Thread t1 = new System.Threading.Thread

(delegate()

{

System.Console.Write("Hello, ");

System.Console.WriteLine("World!");

});

t1.Start();

}

匿名方法的参数的范围是 “匿名方法块 ”。

如果目标在块外部，那么，在匿名方法块内使用跳转语句（如 goto、 break 或 continue）是错误的。如果目标在块内部，在匿名方法块外部使用跳转语

句（如 goto、 break 或 continue）也是错误的。

如果局部变量和参数的范围包含匿名方法声明，则该局部变量和参数称为该匿名方法的 “外部 ”变量。例如，下面代码段中的 n 即是一个外部变量：

int n = 0;

Del d = delegate() { System.Console.WriteLine( "Copy #:{0}", ++n); };

与局部变量不同，捕获变量的生命周期一直持续到引用该匿名方法的委托符合垃圾回收的条件为止。对 n 的引用是在创建该委托时捕获的。

匿名方法不能访问外部范围的 ref 或 out 参数。

在 “匿名方法块 ”中不能访问任何不安全代码。

在 is 运算符的左侧不允许使用匿名方法。

下面的示例演示实例化委托的两种方法：

使委托与匿名方法关联。

使委托与命名方法 ( DoWork ) 关联。

两种方法都会在调用委托时显示一条消息。

// Declare a delegate

delegate void Printer(string s);

class TestClass

{

static void Main()

{

// Instatiate the delegate type using an anonymous method:

Printer p = delegate(string j)

{

System.Console.WriteLine(j);

};

// Results from the anonymous delegate call:

p("The delegate using the anonymous method is called.");

// The delegate instantiation using a named method "DoWork":

p = new Printer(TestClass.DoWork);

// Results from the old style dele gate call:

p("The delegate using the named method is called.");

11

}

// The method associated with the named delegate:

static void DoWork(string k)

{

System.Console.WriteLine(k);

}

}

/* Output:

The delegate using the anonymous method is called.

The delegate using the named method is called.

*/

13. C++ 模板和 C# 泛型之间的区别

C# 泛型和 C++ 模板都是用于提供参数化类型支持的语言功能。然而，这两者之间存在许多差异。在语法层面上， C# 泛型是实现参数化类型的更简单方

法，不具有 C++ 模板的复杂性。此外， C# 并不尝试提供 C++ 模板所提供的所有功能。在实现层面，主要区别在于， C# 泛型类型替换是在运行时执行

的，从而为实例化的对象保留了泛型类型信息。

以下是 C# 泛型和 C++ 模板之间的主要差异：

C# 泛型未提供与 C++ 模板相同程度的灵活性。例如，尽管在 C# 泛型类中可以调用用户定义的运算符，但不能调用算术运算符。

C# 不允许非类型模板参数，如 template C {} 。

C# 不支持显式专用化，即特定类型的模板的自定义实现。

C# 不支持部分专用化：类型参数子集的自定义实现。

C# 不允许将类型参数用作泛型类型的基类。

C# 不允许类型参数具有默认类型。

在 C# 中，尽管构造类型可用作泛型，但泛型类型参数自身不能是泛型。 C++ 确实允许模板参数。

C++ 允许那些可能并非对模板中的所有类型参数都有效的代码，然后将检查该代码中是否有用作类型参数的特定类型。 C# 要求相应地编写类中的代码，使

之能够使用任何满足约束的类型。例如，可以在 C++ 中编写对类型参数的对象使用算术运算符 + 和 - 的函数，这会在使用不支持这些运算符的类型来实

例化模板时产生错误。 C# 不允许这样；唯一允许的语言构造是那些可从约束推导出来的构造。

14. 身份验证和授权的区别

身份验证：身份验证就是一个解决谁有权力进入系统的问题，通常的做法就是跟系统维护的用户名单进行核对，这样转化为一个实际的技术问题：如果有效

的判断一个用户是不是系统的有效用户。这个过程就是 — Authentication( 身份验证 )

专业说法：接收用户凭据，并根据指定的颁发机构来验证凭据的过程成为身份验证

Asp.net 提供三种身份验证方式： Windows 验证、 Forms 验证、 Passport 验证 .

身份验证的使用是通过配置 Web.config 文件的配置节来实现的。

授权：授权就是确认用户拥有足够的权限来访问请求的资源 .Asp.net 提供两类授权服务：文件授权服务、 URL 授权服务

ASP.NET 授权决定了是否应授予某个标识对特定资源的访问权限。在 ASP.NET 中，有两种方式来授予对给定资源的访问权限：

文件授权它

文件授权由 FileAuthorizationModule 执行。检查 .aspx 或 .asmx 处理程序文件的访问控制列表 (ACL) 以确定用户是否应该具有对文件

的访问权限。ACL 权限用于验证用户的 Windows 标识（如果已启用 Windows 身份验证）或 ASP.NET 进程的 Windows 标识。有关更多信息，请参见 ASP.NET

模拟。

URL 授权 URL 授权由 UrlAuthorizationModule 执行，它将用户和角色映射到 ASP.NET 应用程序中的 URL。这个模块可用于有选择地允许或拒绝特定

用户或角色对应用程序的任意部分（通常为目录）的访问权限。

使用 URL 授权

您为请若

通过 URL 授权，可以显式允许或拒绝某个用户名或角色对特定目录的访问权限。此，在该目录的配置文件中创建一个 authorization 节。要启用 URL

授权，请在配置文件的 authorization 节中的 allow 或 deny 元素中指定一个用户或角色列表。为目录建立的权限也会应用到其子目录，除非子目录中的

配置文件重写这些权限。

下面显示了 authorization 节的语法：

12

allow 或 deny 元素是必需的。必须指定 users 或 roles 属性。可以同时包含二者，但这不是必需的。 verbs 属性可选。

15. ASP.net 的身份验证方式有哪些？分别是什么原理？

身份验证是从用户处获取标识凭据（如用户名和密码）并通过某些授权机构验证那些凭据的过程。如果这些凭据有效，则将提交这些凭据的实体视为通过身份

验证。在身份得到验证后，授权进程将确定该身份是否可以访问给定资源。

Windows 身份验证将 Microsoft Internet 信息服务 (IIS) 所提供的用户标识视为已经过身份验证的用户。 IIS 提供了大量用于验证用户标识的身份验证机

制，其中包括匿名身份验证、 Windows 集成的 (NTLM) 身份验证、Windows 集成的 (Kerberos) 身份验证、基本（ base64 编码）身份验证、摘要式身份验证

以及基于客户端证书的身份验证。

在 ASP.NET 中，使用 WindowsAuthenticationModule 模块来实现 Windows 身份验证。该模块根据 IIS 所提供的凭据构造一个 WindowsIdentity，并将该

标识设置为该应用程序的当前 User 属性值。

Windows 身份验证是 ASP.NET 应用程序的默认身份验证机制，并指定作为使用 authentication 配置元素的应用程序的身份验证模式，如下面的示例所示。

Forms 身份验证提供了一种方法，使您可以使用自己的代码对用户进行身份验证，然后将身份验证标记保留在 Cookie 或页的 URL 中。 Forms 身份验证通过

FormsAuthenticationModule 参与 ASP.NET 页的生命周期。可以通过 FormsAuthentication 类访问 Forms 身份验证信息和功能。

若要使用 Forms 身份验证，可以创建一个登录页。该登录页既收集了用户的凭据，又包括验证这些凭据时所需的代码。如果这些凭据有效，可以调用

FormsAuthentication 类的方法，以便使用适当的身份验证票证 (Cookie) 将请求重定向到最初请求的资源。如果不需要进行重定向，只需获取 Forms 身份

验证 Cookie 或对其进行设置即可。

使用 authentication 配置元素对 Forms 身份验证进行配置。最简单的情况是，在 Web.config 文件或单独的文件中，可以通过指定 URL 将未经身份验证

的请求重定向到某个登录页，然后提供该登录页的最小实现，并提供有效的凭据。下面的示例演示配置文件的一部分。该配置文件为 Authenticate 方法指定

了登录页和身份验证凭据。密码已经使用 HashPasswordForStoringInConfigFile 方法进行加密。

成功通过身份验证之后， FormsAuthenticationModule 模块将会使用经过身份验证的用户信息填充当前的 User 属性。

使用 Forms 身份验证的简便方法是，使用 ASP.NET 成员资格和 ASP.NET 登录控件。ASP.NET 成员资格提供了一种存储和管理信息的方法，它包括各种用户

身份验证方法。 ASP.NET 登录控件使用 ASP.NET 成员资格并封装提示用户输入凭据时所需的逻辑、验证用户或恢复或替换密码等。事实上， ASP.NET 成员资

格和 ASP.NET 登录控件在 Forms 身份验证中提供了一个抽象层，可以替换使用 Forms 身份验证时必须执行的大部分或全部工作。

Passport 身份验证是由 Microsoft 提供的集中身份验证服务，该服务为成员站点提供单一登录和核心配置文件服务。 Passport 之所以让用户受益匪浅，原

因在于用户不必登录访问受到限制的新资源或站点。如果希望您的站点与 Passport 身份验证及授权兼容，则应该使用该提供程序。

16. 解释一下 UDDI、WSDL、SOAP 的意义及其作用.

UDDI 是一种目录服务，企业可以使用它对 Web services 进行注册和搜索。

UDDI，英文为 "Universal Description, Discovery and Integration"，可译为 “ 通用描述、发现与集成服务 ” 。

WSDL（网络服务描述语言， Web Services Description Language ）是一门基于 XML 的语言，用于描述 Web Services 以及如何对它们进行访问。

Web Services 服务提供方通过 WSDL(Web Services Description Language) 描述所提供的服务 ,并将这一描述告知 Web Services 注册服务器。注册服务器依

13

据 WSDL 的描述 ,依照 UDDI (Universal Description Discovery and Integration) 的协定更新服务目录并在 Internet 上发布。用户在使用 Web Services 前

先向注册服务器发出请求 ,获得 Web Services 提供者的地址和服务接口信息 ,之后使用 SOAP 协议 (Simple Object Access Protocol) 与 Web Services 提供

者建立连接 ,进行通信。 Web Services 的技术主要建立在 XML 的规范之上 ,这保证了这一体系结构的平台无关性、语言无关性和人机交互性能。

17. 什么是 SOAP,有哪些应用.

（ SOAP，全写为 Simple Object Access Protocol）是一种标准化的通讯规范，主要用于 Web 服务（ web service）中。SOAP 的出现是为了简化网页服务器（ Web

Server）在从 XML 数据库中提取数据时，无需花时间去格式化页面，并能够让不同应用程序之间透过 HTTP 通讯协定，以 XML 格式互相交换彼此的数据，使其

与编程语言、平台和硬件无关。

SOAP 使用因特网应用层协议作为其传输协议。SMTP 以及 HTTP 协议都可以用来传输 SOAP 消息，但是由于 HTTP 在如今的因特网结构中工作得很好，特别是在网

络防火墙下仍然工作流畅，所以其更为广泛地被采纳。 SOAP 亦可以在 HTTPS 上进行传输。

SOAP 的消息格式采用 XML。

SOAP 消息实例

请求

classifieds

回应

http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous

http://localhost:8080/axis2/services/MyService

ECE5B3F187F29D28BC11433905662036

classifieds

18. 常用的调用 webservice 方法有哪些？

一、 WebService 在 cs 后台程序中的调用

A、通过命名空间和类名直接调用

示例： WebService ws = new WebService();

string s = ws.HelloWorld();

B、通过添加 WEB 引用的方式调用，首先添加 WEB 引用，通过 URL 指向 WEBSERVICE，

14

指定 WEB 引用名，假设为 KK;

示例: kk.WebService n = new kk.WebService();

string ss=n.HelloWorld();

二、 WebService 在前台页面的 JS 调用方法

1、首先通过下面的方法把 Webservice 在前台引用进来

2、然后就可以通过 JS 程序进行调用，示例如下：

function a()

{

WebService.HelloWorld(onresult);

}

//这里的 onresult 是回调函数

function onresult(result)

{

alert(result);

}

function b()

{

WebService.add(1,2,onreturn)

}

function onreturn(result)

{

alert(result);

}

//下面的 'context'是上下文，可以通过回到函数通过重载的方式获得；

function c()

{

WebService.div(1,1,onresultC,onerror,'context');

}

function onresultC(res,c)

{

alert(res);

alert(c);

}

//onerror 是获得异常信息的回调函数，下面给出了获得异常信息的方法

function onerror(error)

{

var a="";

a=String.format("获取服务器端异常的具体类型 :

{0}\t\n 获取详细的异常描述信息 :

{1}\t\n 获取造成异常的 :

{2}\t\n 获取服务器端异常的堆栈

跟踪信息:

{3}\t\n 获取一个布尔值，表示异常是否是由于网络连接超时造成的 {4}",

15

error.get_exceptionType(),

error.get_message(),

error.get_statusCode(),

error.get_stackTrace(),

error.get_timedOut())

alert(a);

}

a();

b();

c();

19. C#可否对内存进行直接的操作？,如果能,如何操作;如果不能,为什么?

可以使用指针

在这篇文章中将描述 C#的一个特性指针和所谓的不安全代码。非安全代码就是不在 CLR 完全控制下执行的代码，它有可能会导致一些问题，因此他们必

须用 “ unsafe” 进行表明：

unsafe

{

...

// unsafe context: can use pointers here

...

}

在其他一些地方也可以使用关键字 ‘ unsafe’ ，例如我们可以将类或方法表明为非安全的：

unsafe class Class1 {}

static unsafe void FastMove ( int* pi, int* pdi, int length) {...}

‘ unsafe’ 关键字的必要性是它可以防止程序员的一些意外的用法。你可能会问既然是不安全的为什么还有人要用它。答案就是有时候，在有些情况下，还

需要用到指针。还有一些与指针紧密联系的操作符，那就是 & 操作符，& 返回它所操作对象的地址。

例如:

unsafe

{

int* pi;

int x = 1;

pi = &x;

System.Console.WriteLine("Value of x is: " + *pi);

}

在这个例子中我们创建了 2 个变量， ’ pi’ 是指向 int 的指针， ’ x’ 是 int，然后我们将 ’ x’ 在内存中的地址赋予 ’ pi’ ，理解我们放在 ’ pi’ 变量中的

是 ’ x’ 的地址而不是 ’ x’ 的值非常重要 (使用 : pi = x 将返回错误 "Cannot implicitly convert type 'int' to 'int*'")

编译后执行将会输出:

Value of x is: 1

指针可以接受 null 值，也可能使用 void 指针类型，下面的代码可以正常编译：

unsafe

{

nt x = 10;

void* px = &x;

double *pd = (double*)px;

}

fixed 关键字和垃圾回收 :在 C# 中使用指针需要比在 C++种更加注意。这是因为垃圾回收器 (g.c.)会运行内存清理，在清理的过程中， g.c.会改变对象的物

理内存位置，如果 g.c.改变了对象的位置指针将指向错误的内存位置。为了避免这样的问题（已经与垃圾回收器连接）， C# 包含 'fixed' 关键字 . 它通知

系统不要让垃圾回收器重新部署对象。

16

如果我们忘了 ’ fixed’ 关键字编译器会给我们相应的警告，但它没有智能到在下面的情况中也会警告我们。

20. 描述一下 C#中索引器的实现过程，是否只能根据数字进行索引？

索引器 (Indexer)是 C#引入的一个新型的类成员，它使得对象可以像数组那样被方便，直观的引用。索引器非常类似于我们前面讲到的属性，但索引器可以有

参数列表，且只能作用在实例对象上，而不能在类上直接作用。

class MyClass

{

public object this [int index]

{

get

{

// 取数据

}

set

{

// 存数据

}

}

}

索引器没有像属性和方法那样的名字，关键字 this 清楚地表达了索引器引用对象的特征。和属性一样，value 关键字在 set 后的语句块里有参数传递意义。实

际上从编译后的 IL 中间语言代码来看，上面这个索引器被实现为：

class MyClass

{

public object get_Item(int index)

{

// 取数据

}

public void set_Item(int index, object value)

{

//存数据

}

}

由于我们的索引器在背后被编译成 get_Item(int index)和 set_Item(int index, object value)两个方法，我们甚至不能再在声明实现索引器的类里面声明

实现这两个方法，编译器会对这样的行为报错。这样隐含实现的方法同样可以被我们进行调用，继承等操作，和我们自己实现的方法别无二致。

索和以这唯（

和方法一样，引器有 5 种存取保护级别， 4 种继承行为修饰，及外部索引器。些行为同方法没有任何差别。一不同的是索引器不能为静态 static），

这在对象引用的语义下很容易理解。值得注意的是在覆盖（ override）实现索引器时，应该用 base[E]来存取父类的索引器。

和属性的实现一样，索引器的数据类型同时为 get 语句块的返回类型和 set 语句块中 value 关键字的类型。

索引器的参数列表也是值得注意的地方。 “ 索引 ” 的特征使得索引器必须具备至少一个参数，该参数位于 this 关键字之后的中括号内。索引器的参数也只能

是传值类型，不可以有 ref（引用 )和 out（输出）修饰。参数的数据类型可以是 C#中的任何数据类型。C#根据不同的参数签名来进行索引器的多态辨析。中括

号内的所有参数在 get 和 set 下都可以引用，而 value 关键字只能在 set 下作为传递参数。

索引器通常用于对象容器中为其内的对象提供友好的存取界面 --这也是为什么 C#将方法包装成索引器的原因所在。

C# 并不将索引类型限制为整数。例如，对索引器使用字符串可能是有用的。通过搜索集合内的字符串并返回相应的值，可以实现此类索引器。由于访问器可

被重载，字符串和整数版本可以共存。

示例 1

说明

下面的示例说明如何声明私有数组字段、 temps 和索引器。使用索引器可直接访问实例 tempRecord[i] 。另一种使用索引器的方法是将数组声明为

public 成员并直接访问它的成员 tempRecord.temps[i] 。

17

请注意，当计算索引器的访问时（例如，在 Console.Write 语句中），将调用 get 访问器。因此，如果 get 访问器不存在，将发生编译时错误。

class TempRecord

{

// Array of temperature values

private float[] temps = new float[10] { 56.2F, 56.7F, 56.5F, 56.9F, 58.8F,

61.3F, 65.9F, 62.1F, 59.2F, 57.5F };

// To enable client code to validate input

// when accessing your indexer.

public int Length

{

get { return temps.Length; }

}

// Indexer declaration.

// If index is out of range, the temps array will throw the exception.

public float this[int index]

{

get

{

return temps[index];

}

set

{

temps[index] = value;

}

}

}

class MainClass

{

static void Main()

{

TempRecord tempRecord = new TempRecord();

// Use the indexer's set accessor

tempRecord[3] = 58.3F;

tempRecord[5] = 60.1F;

// Use the indexer's get accessor

for (int i = 0; i 对象，并向该对象添加 Circle、Triangle 和 Rectangle。

若要更新绘图图面，请使用 foreach 循环对该列表进行循环访问，并对其中的每个 Shape 对象调用 Draw 方法。虽然列表中的每个对象都具有

。

声明类型 Shape，但调用的将是运行时类型（该方法在每个派生类中的重写版本）

public class Shape

{

// A few example members

public int X { get; private set; }

public int Y { get; private set; }

public int Height { get; set; }

public int Width { get; set; }

// Virtual method

public virtual void Draw()

{

Console.WriteLine("Performing base class drawing tasks");

}

}

class Circle : Shape

{

public override void Draw()

{

// Code to draw a circle...

Console.WriteLine("Drawing a circle");

base.Draw();

}

}

class Rectangle : Shape

{

public override void Draw()

{

// Code to draw a rectangle...

Console.WriteLine("Drawing a rectangle");

base.Draw();

}

}

class Triangle : Shape

21

{

public override void Draw()

{

// Code to draw a triangle...

Console.WriteLine("Drawing a triangle");

base.Draw();

}

}

class Program

{

static void Main(string[] args)

{

// Polymorphism at work #1: a Rectangle, Triangle and Circle

// can all be used whereever a Shape is expected. No cast is

// required because an implicit conversion exists from a derived

// class to its base class.

System.Collections.Generic.List shapes = new System.Collections.Generic.List();

shapes.Add(new Rectangle());

shapes.Add(new Triangle());

shapes.Add(new Circle());

// Polymorphism at work #2: the virtual method Draw is

// invoked on each of the derived classes, not the base class.

foreach (Shape s in shapes)

{

s.Draw();

}

// Keep the console open in debug mode.

Console.WriteLine("Press any key to exit.");

Console.ReadKey();

}

}

/* Output:

Drawing a rectangle

Performing base class drawing tasks

Drawing a triangle

Performing base class drawing tasks

Drawing a circle

Performing base class drawing tasks

*/

在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。

多态性概述

虚拟成员

当派生类从基类继承时，它会获得基类的所有方法、字段、属性和事件。派生类的设计器可以选择是否



重写基类中的虚拟成员。

22



继承最接近的基类方法而不重写它



定义隐藏基类实现的成员的新非虚实现

仅当基类成员声明为 virtual 或 abstract 时，派生类才能重写基类成员。派生成员必须使用 override 关键字显式指示该方法将参与虚调用。以下代码提供了一个示例：

public class BaseClass

{

public virtual void DoWork() { }

public virtual int WorkProperty

{

get { return 0; }

}

}

public class DerivedClass : BaseClass

{

public override void DoWork() { }

public override int WorkProperty

{

get { return 0; }

}

}

字段不能是虚拟的，只有方法、属性、事件和索引器才可以是虚拟的。当派生类重写某个虚拟成员时，即使该派生类的实例被当作基类的实例访问，也会调用该成员。以下代码提供了一个示例：

DerivedClass B = new DerivedClass();

B.DoWork(); // Calls the new method.

BaseClass A = (BaseClass)B;

A.DoWork(); // Also calls the new method.

虚方法和属性允许派生类扩展基类，而无需使用方法的基类实现。有关更多信息，请参见使用 Override 和 New 关键字进行版本控制（C# 编程指南）。接口提供另一种方式来定义将实现留给派

生类的方法或方法集。有关更多信息，请参见接口（C# 编程指南）和在类和接口之间选择。

使用新成员隐藏基类成员

new

如果希望派生成员具有与基类中的成员相同的名称，但又不希望派生成员参与虚调用，则可以使用 new 关键字。关键字放置在要替换的类成员的返回类型之前。以下代码提供了一个示例：

public class BaseClass

{

public void DoWork() { WorkField++; }

public int WorkField;

public int WorkProperty

{

get { return 0; }

}

}

public class DerivedClass : BaseClass

{

public new void DoWork() { WorkField++; }

public new int WorkField;

public new int WorkProperty

{

get { return 0; }

}

}

23

通过将派生类的实例强制转换为基类的实例，仍然可以从客户端代码访问隐藏的基类成员。例如：

DerivedClass B = new DerivedClass();

B.DoWork(); // Calls the new method.

BaseClass A = (BaseClass)B;

A.DoWork(); // Calls the old method.

阻止派生类重写虚拟成员

无论在虚拟成员和最初声明虚拟成员的类之间已声明了多少个类，虚拟成员永远都是虚拟的。如果类 A 声明了一个虚拟成员，类 B 从 A 派生，类 C 从类 B 派生，则类 C 继承该虚拟成员，并且可以

选择重写它，而不管类 B 是否为该成员声明了重写。以下代码提供了一个示例：

public class A

{

public virtual void DoWork() { }

}

public class B : A

{

public override void DoWork() { }

}

override sealed

派生类可以通过将重写声明为 sealed 来停止虚拟继承。这需要在类成员声明中的关键字前面放置关键字。以下代码提供了一个示例：

public class C : B

{

public sealed override void DoWork() { }

}

在上面的示例中，方法 DoWork 对从 C 派生的任何类都不再是虚方法，但它仍是 C 的实例的虚方法 -- 即使将这些实例强制转换为类型 B 或类型 A 也是如此。派生类可以通过使用

new 关键字

替换密封的方法，如下面的示例所示：

public class D : C

{

public new void DoWork() { }

}

在此情况下，如果在 D 中使用类型为 D 的变量调用 DoWork，被调用的将是新的 DoWork。如果使用类型为 C、B 或 A 的变量访问 D 的实例，对 DoWork 的调用将遵循虚拟继承的规则，

即把这些调用传送到类 C 的 DoWork 实现。

从派生类访问基类虚拟成员

已替换或重写某个方法或属性的派生类仍然可以使用基关键字访问基类的该方法或属性。以下代码提供了一个示例：

public class Base

{

public virtual void DoWork() {/*...*/ }

}

public class Derived : Base

{

public override void DoWork()

{

//Perform Derived's work here

//...

// Call DoWork on base class

base.DoWork();

}

}

使用 Override 和 New 关键字进行版本控制

24

C# 语言经过专门设计，以便不同库中的基类与派生类之间的版本控制可以不断向前发展，同时保持向后兼容。这具有多方面的意义。例如，这意味

着在基类中引入与派生类中的某个成员具有相同名称的新成员在 C# 中是完全支持的，不会导致意外行为。它还意味着类必须显式声明某方法是要

重写一个继承方法，还是一个隐藏具有类似名称的继承方法的新方法。

在 C# 中，派生类可以包含与基类方法同名的方法。

 基类方法必须定义为 virtual。

 如果派生类中的方法前面没有 new 或 override 关键字，则编译器将发出警告，该方法将有如存在 new 关键字一样执行操作。

 如果派生类中的方法前面带有 new 关键字，则该方法被定义为独立于基类中的方法。

 如果派生类中的方法前面带有 override 关键字，则派生类的对象将调用该方法，而不是调用基类方法。

 可以从派生类中使用 base 关键字调用基类方法。

 override、virtual 和 new 关键字还可以用于属性、索引器和事件中。

默认情况下，C# 方法为非虚方法。如果某个方法被声明为虚方法，则继承该方法的任何类都可以实现它自己的版本。若要使方法成为虚方法，必须

在基类的方法声明中使用 virtual 修饰符。然后，派生类可以使用 override 关键字重写基虚方法，或使用 new 关键字隐藏基类中的虚方法。如果

override 关键字和 new 关键字均未指定，编译器将发出警告，并且派生类中的方法将隐藏基类中的方法。有关更多信息，请参见编译器警告（等

级 2）CS0108。

为了在实践中演示上述情况，我们暂时假定公司 A 创建了一个名为 GraphicsClass 的类，您的程序将使用此类。GraphicsClass 如下所示：

C#

复制代码

class GraphicsClass

{

public virtual void DrawLine() { }

public virtual void DrawPoint() { }

}

您的公司使用此类，并且您在添加新方法时将其用来派生自己的类：

C#

复制代码

class YourDerivedGraphicsClass : GraphicsClass

{

public void DrawRectangle() { }

}

您的应用程序运行正常，直到公司 A 发布了 GraphicsClass 的新版本，类似于下面的代码：

C#

复制代码

25

class GraphicsClass

{

public virtual void DrawLine() { }

public virtual void DrawPoint() { }

public virtual void DrawRectangle() { }

}

现在，GraphicsClass 的新版本中包含一个名为 DrawRectangle 的方法。开始时，没有出现任何问题。新版本仍然与旧版本保持二进制兼容。

已经部署的任何软件都将继续正常工作，即使新类已安装到这些软件所在的计算机系统上。在您的派生类中，对方法 DrawRectangle 的任何现有

调用将继续引用您的版本。

但是，一旦您使用 GraphicsClass 的新版本重新编译应用程序，

就会收到来自编译器的警告。请参见编译器警告

有关更多信息，（等级 2）CS0108。

此警告提示您必须考虑希望 DrawRectangle 方法在应用程序中的工作方式。

如果您希望自己的方法重写新的基类方法，请使用 override 关键字：

C#

复制代码

class YourDerivedGraphicsClass : GraphicsClass

{

public override void DrawRectangle() { }

}

override 关键字可确保派生自 YourDerivedGraphicsClass 的任何对象都将使用 DrawRectangle 的派生类版本。派生自

YourDerivedGraphicsClass 的对象仍可以使用基关键字访问 DrawRectangle 的基类版本：

C#

复制代码

base.DrawRectangle();

如果您不希望自己的方法重写新的基类方法，则需要注意以下事项。为了避免这两个方法之间发生混淆，可以重命名您的方法。这可能很耗费时间且

容易出错，而且在某些情况下并不可行。但是，如果您的项目相对较小，则可以使用 Visual Studio 的重构选项来重命名方法。有关更多信息，请参

见重构类和类型。

或者，也可以通过在派生类定义中使用关键字 new 来防止出现该警告：

C#

复制代码

class YourDerivedGraphicsClass : GraphicsClass

{

public new void DrawRectangle() { }

26

}

使用 new 关键字可告诉编译器您的定义将隐藏基类中包含的定义。这是默认行为。

重写和方法选择

当在类中指定方法时，如果有多个方法与调用兼容（例如，存在两种同名的方法，并且其参数与传递的参数兼容），则 C# 编译器将选择最佳方法进

行调用。下面的方法将是兼容的：

C#

复制代码

public class Derived : Base

{

public override void DoWork(int param) { }

public void DoWork(double param) { }

}

在 Derived 的一个实例中调用 DoWork 时，C# 编译器将首先尝试使该调用与最初在 Derived 上声明的 DoWork 版本兼容。重写方法不被视

为是在类上进行声明的，而是在基类上声明的方法的新实现。仅当 C# 编译器无法将方法调用与 Derived 上的原始方法匹配时，它才尝试将该调

用与具有相同名称和兼容参数的重写方法匹配。例如：

C#

复制代码

int val = 5;

Derived d = new Derived();

d.DoWork(val); // Calls DoWork(double).

由于变量 val 可以隐式转换为 double 类型，因此 C# 编译器将调用 DoWork(double)，而不是 DoWork(int)。有两种方法可以避免此情况。

首先，避免将新方法声明为与虚方法同名。其次，可以通过将 Derived 的实例强制转换为 Base 来使 C# 编译器搜索基类方法列表，从而使其调

用虚方法。由于是虚方法，因此将调用 Derived 上的 DoWork(int) 的实现。例如：

((Base)d).DoWork(val); // Calls DoWork(int) on Derived.

23. 面向对象的设计原则

一、单一职责原则（ The Single Responsiblity Principle，ＳＲＰ）

就一个类而言，应该仅有一个引起它变化的原因。软件设计真正要做的许多内容，就是发现职责并把那些职责相互分离。测试驱动的开发实践常常会在设计出

现臭味之前就迫使我们分离职责。

二、开闭原则（ The Open－ Close Principle，ＯＣＰ）

软件实体（类、模块、函数）应该是可扩展的，但是不可修改的。也就是说：对于扩展是开放的，对于更改是封闭的。怎样可能在不改动模块源代码的情况下

去更改它的行为呢？怎样才能在无需对模块进行改动的情况下就改变它的功能呢？关键是抽象！因此在进行面向对象设计时要尽量考虑接口封装机制、抽象机

制和多态技术。该原则同样适合于非面向对象设计的方法，是软件工程设计方法的重要原则之一。

三、替换原则（ The Liskov Substitution Principle, ＬＳＰ）

子类应当可以替换父类并出现在父类能够出现的任何地方。这个原则是 Liskov 于 1987 年提出的设计原则。它同样可以从 Bertrand Meyer 的 DBC (Design by

Contract〔基于契约设计〕 ) 的概念推出。

四、依赖倒置原则（ The Dependency Inversion Pricinple，ＤＩＰ）

１、高层模块不应该依赖于低层模块。二者都应该依赖于抽象。

27

２、抽象不应该依赖于细节。细节应该依赖于抽象。在进行业务设计时，与特定业务有关的依赖关系应该尽量依赖接口和抽象类，而不是依赖于具体类。具体

类只负责相关业务的实现，修改具体类不影响与特定业务有关的依赖关系。在结构化设计中，我们可以看到底层的模块是对高层抽象模块的实现（高层抽象模

块通过调用底层模块），这说明，抽象的模块要依赖具体实现相关的模块，底层模块的具体实现发生变动时将会严重影响高层抽象的模块，显然这是结构化方

法的一个 "硬伤 "。面向对象方法的依赖关系刚好相反，具体实现类依赖于抽象类和接口。

五、接口分离原则（ The Interface Segregation Principle，ＩＳＰ）

采用多个与特定客户类有关的接口比采用一个通用的涵盖多个业务方法的接口要好。 ISP 原则是另外一个支持诸如 COM 等组件化的使能技术。缺少 ISP，

组件、类的可用性和移植性将大打折扣。这个原则的本质相当简单。如果你拥有一个针对多个客户的类，为每一个客户创建特定业务接口，然后使该客户类继

承多个特定业务接口将比直接加载客户所需所有方法有效。

以上五个原则是面向对象中常常用到的原则。此外，除上述五原则外，还有一些常用的经验诸如类结构层次以三到四层为宜、类的职责明确化（一个类对应一

个具体职责）等可供我们在进行面向对象设计参考。但就上面的几个原则看来，我们看到这些类在几何分布上呈现树型拓扑的关系，这是一种良好、开放式的

线性关系、具有较低的设计复杂度。一般说来，在软件设计中我们应当尽量避免出现带有闭包、循环的设计关系，它们反映的是较大的耦合度和设计复杂化。

24. 用户控件和自定义控件的定义及区别

一 ).用户控件和自定义控件概述

用户控件 (UserControl): 扩展名为 *.ascx,跟 *.aspx 在结构上相似，是指页面中加载的功能块 ,只是用户控件不能单独作为页面运行 ,必须嵌入

到 *.aspx 页面或其它用户控件中使用 .

自定义控件，跟 HtmlControl 或 WebControl 相似，编译后可以添加引用到工具栏里面，直接用鼠标拖动使用 .

(二 ).使用

在一个大系统中 ,有时候会只能几个 *.aspx 页面，其余的都是做成 *.ascx 页面，这样可以增强页面之间的藕合性 ,一个用户控件 *.ascx 都作为一个

独立的功能块.

自定义控件是指编译后直接可以放到工具箱中用，就像 TextBox,DataGrid 一样在设计器中可以用鼠标拖动到页面上使用 .

自定义服务器控件分为两种：

1.一种是用 *.aspx 代码和 *.cs 代码编译后生成 DLL,再添加引用到工具箱使用 .一般用于 WebForm 中 .

2.另一种是只用 *.cs 实现 ,再编译生成 DLL,添加到工具箱使用 . 一般用于 WinForm 中 .

自定义控件生成步骤:

比如:

1. 将一个 Button 从设计器拖到页面中 , 对按钮大小 ,颜色或文本设置一个固定值 ,保存文件名为 : a.cs

2. csc /r:System.dll /t:library/out:..\..\A.dll a.cs

3. 右击工具箱空白处，弹出右击菜单后，选 “ 添加移除项 ” ,将刚生成的 DLL 添加到工具箱里面来，这样，就可以像一般的 Button 一样拖

动使用了

25. CTS、CLS 和 CLR 分别作何解释？

.NET 定义了一个称为通用类型系统 Common Type System(CTS)的类型标准。任何以 .NET 平台作为目标的语言必须建立它的数据类型与 CTS 的类型间的映射。所

有 .NET 语言共享这一类型系统，实现它们之间无缝的互操作。该方案还提供了语言之间的继承性。例如，用户能够在 VB.NET 中派生一个由 C#编写的类。

很显然，编程语言的区别不仅仅在于类型。例如，一些语言支持多继承性，一些语言支持无符号数据类型，一些语言支持运算符重载。用户应认识到这一点，

因此 .NET 通过定义公共语言规范 (CLS： Common Language Specification)，限制了由这些不同引发的互操作性问题。 CLS 制定了一种以 .NET 平台为目标的语言

所必须支持的最小特征，以及该语言与其他 .NET 语言之间实现互操作性所需要的完备特征。认识到这点很重要，这里讨论的特征问题已不仅仅是语言间的简单

语法区别。例如， CLS 并不去关心一种语言用什么关键字实现继承，只是关心该语言如何支持继承。

CLS 是 CTS 的一个子集。这就意味着一种语言特征可能符合 CTS 标准，但又超出 CLS 的范畴。例如：C#支持无符号数字类型，该特征能通过 CTS 的测试，但 CLS

却仅仅识别符号数字类型。因此，如果用户在一个组件中使用 C#的无符号类型，就可能不能与不使用无符号类型的语言 (如 VB.NET)设计的 .NET 组件实现互操

作。这里用的是 “ 可能不 ” ，而不是 “ 不可能 ” ，因为这一问题实际依赖于对 non-CLS-compliant 项的可见性。事实上， CLS 规则只适用于或部分适用于那些

与其他组件存在联系的组件中的类型。实际上，用户能够安全实现含私有组件的项目，而该组件使用了用户所选择使用的 .NET 语言的全部功能，且无需遵守

CLS 的规范。另一方面，如果用户需要 .NET 语言的互操作性，那么用户的组件中的公共项必须完全符合 CLS 规范。

最后一个 C 是公共语言运行库 Common Language Runtime(CLR)。简单地说， CLR 是 CTS 的实现，也就是说， CLR 是应用程序的执行引擎和功能齐全的类库，该

类库严格按照 CTS 规范实现。作为程序执行引擎， CLR 负责安全地载入和运行用户程序代码，包括对不用对象的垃圾回收和安全检查。在 CLR 监控之下运行的

代码，称为托管代码 (managed code)。作为类库， CLR 提供上百个可用的有用类型，而这些类型可通过继承进行扩展。对于文件 I/O、创建对话框、启动线程

—

等类型 — 基本上能使用 Windows API 来完成的操作，都可由其完成。

.NET 语言编译器生成与平台无关的代码，称为通用中间语言 (CIL，简称 IL)。从概念上来讲，这一点非常类似 Java 中的字节码。但与 Java 字节码所不同的是，

Microsoft 设计的 IL 可以由任一语言编译器很容易地生成。

前面提到的，程序集包含 IL，而不是源代码。在运行过程中，当第一次调用一个方法，为了更快的执行程序，实时 Just-In-Time (JIT)编译器将该方法的 IL 代

28

码转换成源代码 (与平台有关 )。 .NET 只编译需要在运行库中使用的那部分 IL。当然，它将会把转换得到的源代码放入缓存中，以便以后的调用能够直接使用

该源代码。

26. 列举一下你所了解的 XML 技术及其应用

1、数据交换

用 XML 在应用程序和公司之间作数据交换。 XML 使用元素和属性来描述数据。在数据传送过程中， XML 始终保留了诸如父 /子关系这样的数据结构。几个应

用程序可以共享和解析同一个 XML 文件，不必使用传统的字符串解析或拆解过程。相反，普通文件不对每个数据段做描述 (除了在头文件中 )，也不保留数据关

系结构。使用 XML 做数据交换可以使应用程序更具有弹性，因为可以用位置 (与普通文件一样 )或用元素名 (从数据库 )来存取 XML 数据。

2、 Web 服务

Web 服务让使用不同系统和不同编程语言的人们能够相互交流和分享数据。其基础在于 Web 服务器用 XML 在系统之间交换数据。交换数据通常用 XML 标记，

能使协议取得规范一致，比如在简单对象处理协议 (Simple Object Access Protocol, SOAP) 平台上。 SOAP 可以在用不同编程语言构造的对象之间传递消息。

这意味着一个 C#对象能够与一个 Java 对象进行通讯。这种通讯甚至可以发生在运行于不同操作系统上的对象之间。 DCOM, CORBA 或 Java RMI 只能在紧密

耦合的对象之间传递消息， SOAP 则可在松耦合对象之间传递消息。

3、内容管理

XML 只用元素和属性来描述数据，而不提供数据的显示方法。这样， XML 就提供了一个优秀的方法来标记独立于平台和语言的内容。使用象 XSLT 这样的语

言能够轻易地将 XML 文件转换成各种格式文件，比如 HTML,WML, PDF, flat file, EDI 等等。 XML 具有的能够运行于不同系统平台之间和转换成不同格式目标

文件的能力使得它成为内容管理应用系统中的优秀选择。

4、 Web 集成

使为

现在有越来越多的设备也支持 XML 了。得 Web 开发商可以在个人电子助理和浏览器之间用 XML 来传递数据。什么将 XML 文本直接送进这样的设备去呢？

这样作的目的是让用户更多地自己掌握数据显示方式，更能体验到实践的快乐。常规的客户 /服务 (C/S)方式为了获得数据排序或更换显示格式，必须向服务器

发出申请；而 XML 则可以直接处理数据，不必经过向服务器申请查询 -返回结果这样的双向 “ 旅程 ” ，同时在设备也不需要配制数据库。甚至还可以对设备上

的 XML 文件进行修改并将结果返回给服务器。

5、配制

XML 以更为优秀的方式为应用程序标记配制数据。使用 .NET 里的类，如 XmlDocument 和 XmlTextReader，将配制数据标记为 XML 格式，能使其更具可读性，

并能方便地集成到应用系统中去。使用 XML 配制文件的应用程序能够方便地处理所需数据，不用象其他应用那样要经过重新编译才能修改和维护应用系

统。

27. 值类型和引用类型的区别？写出 C#的样例代码.

1. 通用类型系统

C#中，变量是值还是引用仅取决于其数据类型。

C#的基本数据类型都以平台无关的方式来定义。 C#的预定义类型并没有内置于语言中，而是内置于 .NET Framework 中。 .NET 使用通用类型系统（ CTS）定义了

可以在中间语言（ IL）中使用的预定义数据类型，所有面向 .NET 的语言都最终被编译为 IL，即编译为基于 CTS 类型的代码。

例如，在 C#中声明一个 int 变量时，声明的实际上是 CTS 中 System.Int32 的一个实例。这具有重要的意义：

确保 IL 上的强制类型安全；

实现了不同 .NET 语言的互操作性；

所有的数据类型都是对象。它们可以有方法，属性，等。例如：

int i;

i = 1;

string s;

s = i.ToString();

2. 值类型

C#的所有值类型均隐式派生自 System.ValueType：

结构体： struct（直接派生于 System.ValueType）；

数值类型：

整型：（，（，（

sbyte System.SByte 的别名） short System.Int16） int System.Int32） long （ System.Int64） byte System.Byte） ushort System.UInt16）

，，（，（，

29

uint （ System.UInt32）， ulong（ System.UInt64）， char（ System.Char）；

浮点型： float（ System.Single）， double（ System.Double）；

用于财务计算的高精度 decimal 型： decimal（ System.Decimal）。

bool 型： bool（ System.Boolean 的别名）；

用户定义的结构体（派生于 System.ValueType）。

枚举： enum（派生于 System.Enum）；

可空类型（派生于 System.Nullable泛型结构体， T?实际上是 System.Nullable的别名）。

每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。例如：

int i = new int();

等价于：

Int32 i = new Int32();

等价于：

int i = 0;

等价于：

Int32 i = 0;

使用 new 运算符时，将调用特定类型的默认构造函数并对变量赋以默认值。在上例中，默认构造函数将值 0 赋给了 i。 MSDN 上有完整的默认值表。

关于 int 和 Int32 的细节，在我的另一篇文章中有详细解释：《理解 C#中的 System.Int32 和 int 》。

所有的值类型都是密封（ seal）的，所以无法派生出新的值类型。

值得注意的是，即而其

System.ValueType 直接派生于 System.Object。 System.ValueType 本身是一个类类型，不是值类型。关键在于 ValueType 重写了 Equals()

方法，从而对值类型按照实例的值来比较，而不是引用地址来比较。

可以用 Type.IsValueType 属性来判断一个类型是否为值类型：

TestType testType = new TestType ();

if (testTypetype.GetType().IsValueType)

{

Console.WriteLine("{0} is value type.", testType.ToString());

}

3. 引用类型

C#有以下一些引用类型：

数组（派生于 System.Array）

用户用定义的以下类型：

类： class（派生于 System.Object）；

接口： interface（接口不是一个 “ 东西 ” ，所以不存在派生于何处的问题。 Anders 在《 C# Programming Language 》中说，接口只是表示一种

约定 [contract]）；

委托： delegate（派生于 System.Delegate）。

object（ System.Object 的别名）；

字符串： string（ System.String 的别名）。

可以看出：

引用类型与值类型相同的是，结构体也可以实现接口；

引用类型可以派生出新的类型，而值类型不能；

引用类型可以包含 null 值，值类型不能（可空类型功能允许将 null 赋给值类型）；

引用类型变量的赋值只复制对对象的引用，而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时，将复制包含的值。

对于最后一条，经常混淆的是 string。我曾经在一本书的一个早期版本上看到 String 变量比 string 变量效率高；我还经常听说 String 是引用类型，string

是值类型，等等。例如：

string s1 = "Hello, ";

30

string s2 = "world!";

string s3 = s1 + s2;//s3 is "Hello, world!"

这确实看起来像一个值类型的赋值。再如：

string s1 = "a";

string s2 = s1;

s1 = "b";//s2 is still "a"

改变 s1 的值对 s2 没有影响。这更使 string 看起来像值类型。实际上，这是运算符重载的结果，当 s1 被改变时， .NET 在托管堆上为 s1 重新分配了内存。这

样的目的，是为了将做为引用类型的 string 实现为通常语义下的字符串。

4. 值类型和引用类型在内存中的部署

经常听说，并且经常在书上看到：值类型部署在栈上，引用类型部署在托管堆上。实际上并没有这么简单。

MSDN 上说：托管堆上部署了所有引用类型。这很容易理解。当创建一个应用类型变量时：

object reference = new object();

关键字 new 将在托管堆上分配内存空间，并返回一个该内存空间的地址。左边的 reference 位于栈上，是一个引用，存储着一个内存地址；而这个地址指向的

内存（位于托管堆）里存储着其内容（一个 System.Object 的实例）。下面为了方便，简称引用类型部署在托管推上。

再来看值类型。《 C#语言规范》上的措辞是 “ 结构体不要求在堆上分配内存（ However, unlike classes, structs are value types and do not require

heap allocation） ” 而不是 “ 结构体在栈上分配内存 ” 。这不免容易让人感到困惑：值类型究竟部署在什么地方？

4.1 数组

考虑数组：

int[] reference = new int[100];

根据定义，数组都是引用类型，所以 int 数组当然是引用类型（即 reference.GetType().IsValueType 为 false）。

而 int 数组的元素都是 int，根据定义，int 是值类型（即 reference[i].GetType().IsValueType 为 true）。那么引用类型数组中的值类型元素究竟位于栈还

是堆？

如果用 WinDbg 去看 reference[i]在内存中的具体位置，就会发现它们并不在栈上，而是在托管堆上。

实际上，对于数组：

TestType[] testTypes = new TestType[100];

如果 TestType 是值类型，则会一次在托管堆上为 100 个值类型的元素分配存储空间，并自动初始化这 100 个元素，将这 100 个元素存储到这块内存里。

如果 TestType 是引用类型，则会先在托管堆为 testTypes 分配一次空间，并且这时不会自动初始化任何元素（即 testTypes[i]均为 null）。等到以后有代码

初始化某个元素的时候，这个引用类型元素的存储空间才会被分配在托管堆上。

4.2 类型嵌套

更容易让人困惑的是引用类型包含值类型，以及值类型包含引用类型的情况：

public class ReferenceTypeClass

{

private int _valueTypeField;

public ReferenceTypeClass()

{

_valueTypeField = 0;

}

public void Method()

{

int valueTypeLocalVariable = 0;

}

}

ReferenceTypeClass referenceTypeClassInstance = new ReferenceTypeClass();//Where is _valueTypeField?

referenceTypeClassInstance.Method();//Where is valueTypeLocalVariable?

31

public struct ValueTypeStruct

{

private object _referenceTypeField;

public ValueTypeStruct()

{

_referenceTypeField = new object();

}

public void Method()

{

object referenceTypeLocalVariable = new object();

}

}

ValueTypeStruct valueTypeStructInstance = new ValueTypeStruct();//Where is _referenceTypeField？

valueTypeStructInstance.Method(); //Where is referenceTypeLocalVariable?

单看 valueTypeStructInstance，这是一个结构体实例，感觉似乎是整块扔到栈上的。但是字段 _referenceTypeField 是引用类型，局部变量

referenceTypeLocalVarible 也是引用类型。

referenceTypeClassInstance 也有同样的问题，referenceTypeClassInstance 本身是引用类型，似乎应该整块部署在托管堆上。但字段 _valueTypeField 是值

类型，局部变量 valueTypeLocalVariable 也是值类型，它们究竟是在栈上还是在托管堆上？

规律是：

引用类型部署在托管堆上；

值类型总是分配在它声明的地方：作为字段时，跟随其所属的变量（实例）存储；作为局部变量时，存储在栈上。

我们来分析一下上面的代码。对于引用类型实例，即 referenceTypeClassInstance：

从上下文看， referenceTypeClassInstance 是一个局部变量，所以部署在托管堆上，并被栈上的一个引用所持有；

值类型字段 _valueTypeField 属于引用类型实例 referenceTypeClassInstance 的一部分，所以跟随引用类型实例 referenceTypeClassInstance 部署在托管堆

上（有点类似于数组的情形）；

valueTypeLocalVariable 是值类型局部变量，所以部署在栈上。

而对于值类型实例，即 valueTypeStruct：

根据上下文，值类型实例 valueTypeStructInstance 本身是一个局部变量而不是字段，所以位于栈上；

其引用类型字段 _referenceTypeField 不存在跟随的问题，必然部署在托管堆上，并被一个引用所持有（该引用是 valueTypeStruct 的一部分，位于栈）；

其引用类型局部变量 referenceTypeLocalVariable 显然部署在托管堆上，并被一个位于栈的引用所持有。

所以，简单地说“值类型存储在栈上，引用类型存储在托管堆上 ”是不对的。必须具体情况具体分析。

5. 正确使用值类型和引用类型

这一部分主要参考《 Effective C# 》，并非本人原创，希望能让你加深对值类型和引用类型的理解。

5.1 辨明值类型和引用类型的使用场合

C#中，我们用 struct/class 来声明一个类型为值类型 /引用类型。

考虑下面的例子：

TestType[] testTypes = new TestType[100];

则大而刚分

如果 TestTye 是值类型，只需要一次分配，小为 TestTye 的 100 倍。如果 TestTye 是引用类型，开始需要 100 次分配，配后数组的各元素值为 null，

然后再初始化 100 个元素，结果总共需要进行 101 次分配。这将消耗更多的时间，造成更多的内存碎片。所以，如果类型的职责主要是存储数据，值类型比较

合适。

一般来说，值类型（不支持多态）适合存储供 C#应用程序操作的数据，而引用类型（支持多态）应该用于定义应用程序的行为。

通常我们创建的引用类型总是多于值类型。如果以下问题的回答都为 yes，那么我们就应该创建为值类型：

该类型的主要职责是否用于数据存储？

该类型的共有借口是否完全由一些数据成员存取属性定义？

是否确信该类型永远不可能有子类？

是否确信该类型永远不可能具有多态行为？

32

5.2 将值类型尽可能实现为具有常量性和原子性的类型

具有常量性的类型很简单：

如果构造的时候验证了参数的有效性，之后就一直有效；

省去了许多错误检查，因为禁止更改；

确保线程安全，因为多个 reader 访问到同样的内容；

可以安全地暴露给外界，因为调用者不能更改对象的内部状态。

具有原子性的类型都是单一的实体，我们通常会直接替换一个原子类型的整个内容。

下面是一个典型的可变类型：

public struct Address

{

private string _city;

private string _province;

private int _zipCode;

public string City

{

get { return _city; }

set { _city = value; }

}

public string Province

{

get { return _province; }

set

{

ValidateProvince(value);

_province = value;

}

}

public int ZipCode

{

get { return _zipCode; }

set

{

ValidateZipCode(value);

_zipCode = value;

}

}

}

下面创建一个实例：

Address address = new Address();

address.City = "Chengdu";

address.Province = "Sichuan";

address.ZipCode = 610000;

然后更改这个实例：

address.City = "Nanjing"; //Now Province and ZipCode are invalid

address.ZipCode = 210000; //Now Province is still invalid

address.Province = "Jiangsu";

33

可见，内部状态的改变意味着可能违反对象的不变式（ invariant），至少是临时的违反。如果上面是一个多线程的程序，那么在 City 更改的过程中，另一个

线程可能看到不一致的数据视图。如果不是多线程的程序，也有问题：

当 ZipCode 的值无效而抛出异常时，对象仅作了一部分改变，因此处于无效的状态，为了修复这个问题，需要在 Address 中添加相当多的内部校验代码；

为了实现异常安全，我们需要在所有改变多个字段的客户代码处放上防御性的代码；

线程安全也要求我们在每一个属性的访问器上添加线程同步检查。

显然，这是一个相当可观的工作量。下面我们把 Address 实现为常量类型：

public struct Address

{

private string _city;

private string _province;

private int _zipCode;

public Address (string city, string province, int zipCode)

{

_city = city;

_province = province;

_zipCode = zipCode;

ValidateProvince(province);

ValidateZipCode(zipCode);

}

public string City

{

get { return _city; }

}

public string Province

{

get { return _province; }

}

public int ZipCode

{

get { return _zipCode; }

}

}

如果要改变 Address，不能修改现有的实例，只能创建一个新的实例：

Address address = new Address("Chengdu", "Sichuan", 610000);//create a instance

address = new Address("Nanjing", "Jiangsu", 210000);//modify the instance

address 将不存在任何无效的临时状态。那些临时状态只存在于 Address 的构造函数执行过程中。这样一来， Address 是异常安全的，也是线程安全的。

5.3 确保 0 为值类型的有效状态

.NET 的默认初始化机制会将引用类型设置为二进制意义上的 0，即 null。而对于值类型，不论我们是否提供构造函数，都会有一个默认的构造函数，将其设置

为 0。

一种典型的情况是枚举：

public enum Sex

{

Male = 1;

Female = 2;

}

然后用做值类型的成员：

34

public struct Employee

{

private Sex _sex;

//other

}

创建 Employee 结构体将得到一个无效的 Sex 字段：

Employee employee = new Employee ();

employee 的 _sex 是无效的，因为其为 0。我们应该将 0 作为一个为初始化的值明确表示出来：

public Sex

{

None = 0;

Male = 1;

Female = 2;

}

如果值类型中包含引用类型，会出现另一种初始化问题：

public struct ErrorLog

{

private string _message;

//other

}

然后创建一个 ErrorLog：

ErrorLog errorLog = new ErrorLog ();

errorLog 的 _message 字段将是一个空引用。我们应该通过一个属性来将 _message 暴露给客户代码，从而使该问题限定在 ErrorLog 的内部：

public struct ErrorLog

{

private string _message;

public string Message

{

get

{

return (_message ! = null) ? _message : string.Empty;

}

set { _message = value; }

}

//other

}

5.4 尽量减少装箱和拆箱

装箱指把一个值类型放入一个未具名类型的引用类型中，比如：

int valueType = 0;

object referenceType = i;//boxing

拆箱则是从前面的装箱对象中取出值类型：

object referenceType;

35

int valueType = (int)referenceType;//unboxing

装箱和拆箱是比较耗费性能的，还会引入一些诡异的 bug，我们应当避免装箱和拆箱。

装箱和拆箱最大的问题是会自动发生。比如：

Console.WriteLine("A few numbers: {0}, {1}.", 25, 32);

其中， Console.WriteLine()接收的参数类型是 (string， object， object)。因此，实际上会执行以下操作：

int i = 25;

obeject o = i;//boxing

然后把 o 传给 WriteLine()方法。在 WriteLine()方法的内部，为了调用 i 上的 ToString()方法，又会执行：

int i = (int)o;//unboxing

string output = i,ToString();

所以正确的做法应该是：

Console.WriteLine("A few numbers: {0}, {1}.", 25.ToString(), 32.ToString());

25.ToString()只是执行一个方法并返回一个引用类型，不存在装箱 /拆箱的问题。

另一个典型的例子是 ArryList 的使用：

public struct Employee

{

private string _name;

public Employee(string name)

{

_name = name;

}

public string Name

{

get { return _name; }

set { _name = value; }

}

public override string ToString()

{

return _name;

}

}

ArrayList employees = new ArrayList();

employees.Add(new Employee("Old Name"));//boxing

Employee ceo = (Employee)employees[0];//unboxing

ceo.Name = "New Name";//employees[0].ToString() is still "Old Name"

上面的代码不仅存在性能的问题，还容易导致错误发生。

在这种情况下，更好的做法是使用泛型集合：

List employees = new List();

由于 List是强类型的集合， employees.Add()方法不进行类型转换，所以不存在装箱 /拆箱的问题。

6. 总结

C#中，变量是值还是引用仅取决于其数据类型。

C#的值类型包括：结构体（数值类型， bool 型，用户定义的结构体），枚举，可空类型。

36

C#的引用类型包括：数组，用户定义的类、接口、委托， object，字符串。

数组的元素，不管是引用类型还是值类型，都存储在托管堆上。

引用类型在栈中存储一个引用，其实际的存储位置位于托管堆。为了方便，本文简称引用类型部署在托管推上。

值类型总是分配在它声明的地方：作为字段时，跟随其所属的变量（实例）存储；作为局部变量时，存储在栈上。

值类型在内存管理方面具有更好的效率，并且不支持多态，适合用作存储数据的载体；引用类型支持多态，适合用于定义应用程序的行为。

应该尽可能地将值类型实现为具有常量性和原子性的类型。

应该尽可能地确保 0 为值类型的有效状态。

应该尽可能地减少装箱和拆箱。

1. ADO.net 中常用的对象有哪些？分别描述一下.

Command 对象

1.Command 对象概述

Command 对象可以使用数据库命令直接与数据源进行通信。它的属性如下：

Name： Command 对象的程序化名称。在代码中使用此名称来引用 Command 对象。

Connection：对 Connection 对象的引用， Command 对象将使用该对象与数据库通信。

CommandType： Text | StoreProduce | TableDirect 。

CommandText： SQL 语句 | StoreProduce。

Parameters：命令对象包含的参数。

可以通过一下三种方式来创建 Command 对象：

方式一

string strConn, strSQL;

strConn = "Provider=SQLOLEDB;Data Source=(local) \\NetSDK;Initial Catalog=Northwind;Trusted_Connection=Yes;";

strSQL = "SELECT CustomerID,CompanyName FROM Customers";

OleDbConnection cn = new OleDbConnection(strConn);

cn.Open();

OleDbCommand cmd;

cmd = cn.CreateCommand();

cmd.CommandText = strSQL;

方式二

string strConn, strSQL;

strConn = "Provider=SQLOLEDB;Data Source=(local) \\NetSDK;Initial Catalog=Northwind;Trusted_Connection=Yes;";

strSQL = "SELECT CustomerID,CompanyName FROM Customers";

OleDbConnection cn = new OleDbConnection(strConn);

cn.Open();

OleDbCommand cmd;

cmd = new OleDbCommand();

cmd.CommandText = strSQl;

cmd.Connection = cn;方式三

string strConn, strSQL;

strConn = "Provider=SQLOLEDB;Data Source=(local) \\NetSDK;Initial Catalog=Northwind;Trusted_Connection=Yes;";

strSQL = "SELECT CustomerID,CompanyName FROM Customers";

OleDbConnection cn = new OleDbConnection(strConn);

cn.Open();

OleDbCommand cmd;

cmd = new OleDbCommand(strSQL, cn);

37

2.Command 对象参数

常用属性如下：

ParameterName：参数名称，如 "@CatID"。

DbType， SqlType， OleDbType：参数的数据类型。

Direction： ParameterDirection 枚举值。

ParameterDirection.Input（默认值） | ParameterDirection.InputOutput |

ParameterDirection.Output | ParameterDirection.ReturnValue

3.执行

四种执行方式：

ExecuteNonQuery() 返回受命令影响的行数。

ExecuteScalar() 返回第一行第一列（使用与集函数）。如 Count(*),Sum,Avg 等聚合函数。

如则（

ExecuteReader() 返回一个 DataReader 对象。果 SQL 不是查询 Select，返回一个没有任何数据的 System.Data.SqlClient.SqlDataReader 类型的集合 EOF）。

ExecuteXmlReader()返回一个 XmlReader 对象。

4.参数化查询

使用示例

string strConn, strSQL;

strConn = "Provider=SQLOLEDB;Data Source=(local) \\NetSDK;Initial Catalog=Northwind;Trusted_Connection=Yes;";

OleDbConnection cn = new OleDbConnection(strConn);

cn.Open();

strSQl = "SELECT OrderID,CustomerID,EmployeeID,OrderDate FROM Order WHERE CustomerID = ?";

OleDbCommand cmd = new OleDbCommand(strSQl,cn);

cmd.Parameters.Add("@CustomerID",OleDbType.Wchar,5);

cmd.Parameters[0].Value = "ALFKI";

OleDbDataReader rdr = cmd.ExecuteReader();

----------------------------------------------------------------------------------------------------------------------------

Connection 对象可用于连接到数据库管理数据库的事务。

1.Connection 对象的创建

4 种数据库连接方式：

OLEDB:System.Data.Oledb.OledbConnection

SQL:System.Data.SqlCilent.SqlConnection

ODBC:System.Data.Odbc.OdbcConnection

Oracle:System.Data.OracleClient.OracleConnection

我们来看一个 OleDbConnection 创建的实例，一共有 2 种方法。

第一种：创建一个没有初始化的 OleDbConnection 对象，然后用 ConnectionString 来初始化。

创建 Connection 对象

String strConn;

strConn = "Provider=SQLOLEDB;Data Source={local) \\NETSDK;Initial Catalog=Northwind;Trusted_Connection=Yes;";

OleDbConnection cn;

cn = new OleDbConnection();

cn.ConnectionString = strConn;

第二种：使用构造函数来初始化 OleDbConnection 对象。

创建 Connection 对象

String strConn;

strConn = "Provider=SQLOLEDB;Data Source={local) \\NETSDK;Initial Catalog=Northwind;Trusted_Connection=Yes;" ；

OleDbConnection cn;

38

cn = new OleDbConnection(strConn);

2.连接字符串

连接字符串的几个常用参数：

Provider：这个属性用于设置或返回连接提供程序的名称，仅用于 OleDbConnection 对象。

Connection Timeout 或 Connect Timeout：在中止尝试并产生异常前，等待连接到服务器的连接时间长度（以秒为单位）。默认是 15 秒。

Initail Catalog：数据库的名称。

Data Source：连接打开时使用的 SQL Server 名称，或者是 Microsoft Access 数据库的文件名。

Password： SQL Server 帐户的登录密码。

User ID： SQL Server 登录帐户。

Integrated Security 或 Trusted Connection：此参数决定是否是安全连接。可能的值有 True、 False 和 SSPI（ SSPI 是 True 的同义词）。

Persist Security Info：当设置为 False 时，如果连接是打开的或曾经处于打开状态，那么安全敏感信息（如密码）不会作为连接的一部分返回。设置属性

值为 True 可能有安全风险。 False 是默认值。

3.打开和关闭连接

Open 方法：打开连接

Close 方法：关闭连接

注：如果使用了连接池，关闭连接对象不会真正地关闭对数据源地连接。

如果只用 DataAdapter，就不必显式地打开和关闭连接。当调用这些对象的方法时（ Fill 方法、 Update 方法）会自动检查连接是否打开。

----------------------------------------------------------------------------------- -----------------------------------------

DataReader 对象

1.DataReader 对象概述

但如可但

DataReader 对象只能对查询获得的数据集进行自上而下的访问，效率很高。果仅仅是访问数据的话，以使用 DataReader。 DataReader 要求一直连接，

读相这带

所以将结果的一小部分先放在内存中，完后再从数据库中读取一部分，当于一个缓存机制。对于查询结果百万级的情况来说，来的好处是显而易见的。

DataReader 对象有如下几个特点：

快速访问数据。由于 DataReader 对象是只进和只读的，所以开销相对较小，速度比 DataSet 快。

只进和只读。不能处理数据，只能显示数据。

自己管理连接。 DataAdapter 对象可以自动地打开和关闭连接， DataReader 对象必须显式地打开和关闭连接。

使用较少地服务器资源。

2.创建 DataReader 对象

具体步骤：

（ 1）创建和打开数据库连接。

（ 2）创建一个 Command 对象。

（ 3）从 Command 对象中创建 DataReader。

（ 4）执行 ExecuteReader 对象。

（ 5）使用 DataReader 对象。

（ 6）关闭 DataReader 对象。

（ 7）关闭 Connection 对象。

DataReader 对象创建示例

DataReader 对象使用示例

//打开 Connection 并创建 Command

SqlConnection conn = new SqlConnection("data source=localhost;integrated security=true;initial catalog=pubs;");

conn.Open();

SqlCommand cmdAuthors = new SqlCommand("select * from Authors", conn);

//创建 DataReader 对象并读取数据

SqlDataReader dr;

39

dr = cmdAuthors.ExecuteReader();

while(dr.Read())

{

ListBox.Items.Add(dr["au_lname"]+","+dr["au_fname"]);

}

//关闭 DataReader 和 Connection

dr.Close();

conn.Close();

当使用 DataReader 对象进行连接时，需要使用 Try...Catch...Finally 语句，这样可以确保若在某方面失败，连接将会关闭。否则，连接会无限期保持打

开状态。

捕捉错误

try

{

conn.Open();

dr = cmdAuthors.ExecuteReader();

//使用 DataReader 中返回的数据

}

catch

{

//错误处理

}

finally

{

dr.Close();

conn.Close();

}

3.从 DataReader 读取数据

为每个记录调用 Read 方法：可以调用 Read 方法来访问 DataRead 对象中的一个记录，因为 DataReader 对象中的默认位置是在第一个记录的前面，所以必须

在访问任何数据之前调用 Read 方法。当不再有可用记录时， Read 方法就返回一个空值。

调用 Read 方法示例

while (dr.Read())

{

lbName.Text += dr["au_name"];

}

访问字段：可以通过顺序位置，名字或者调用适当的 Get 方法来访问一个字段， Get 方法包括 GetDateTime， GetDouble， GetInt32 或 GetString 等。

调用 Get 方法来访问数据

dr.Read();

lbName.Text =dr.GetString(1) + "," +dr.GetString(2);

通过名字引用当前记录的数据字段

dr["au_fname"];

----------------------------------------------------------------------------------- -----------------------------------------

在 ADO.NET 中 DataSet 的作用是为数据源提供一个断开式的存储，而不必关心数据源，操作只用在 DataSet 中进行就行了。

DataSet 中的几个重要对象：

TablesCollection 对象：一这

DataSet 里的表用 DataTable 来表示，个 DataSet 里面可以包含多个 DataTable，些 DataTable 就构成了 TablesCollection 对象。

每个 DataTable 中都包含一个 ColumnsColleciton 和一个 RowsCollection 对象。

40

RelationsCollection 对象：各个 DataTable 之间的关系通过 DataRelation 来表达，这些 DataRelation 构成的集合就是 RelationsCollection 对象。

ExtendedProperties 对象：这个对象用来定义特定的信息，比如密码、更新时间等。

1.DataTable 对象

创建一个 DataTable：

DataTable MyTable;

MyTable = new DataTable ("Test");

MyTable.CaseSensitive = False;// 是否区分大小写

MyTable.MinimumCapacity = 100;// 数据库的最小记录空间

创建表列

DataTable MyTable;

DataColumn MyColumn;

MyTable = new DataTable ("表名 ");

MyColumn = MyTable.Columns.Add(" 列名 "， typeof(string));

MyColumn = MyTable.Columns.Add(" 列名 "， typeof(int));

创建表达式列

示例

//方法一

DataColumn tax = new DataColumn();

tax.DataType = typeof(Currency);

tax.Expression = "total*rate*0.20";

//方法二

MyTable.Columns.Add("tax", typeof(Currency), "total*rate*0.20");

2.DataView 对象

DataView 就时数据视图，为数据库结构提供了外模式的实现。同时 DataView 也可以为窗体控件和 Web 控件提供数据绑定功能，在每一个 DataTable 中内建

了一个 DataView 为： DataTable.DefaultView()。

创建 DataView：

DataView sortedView=new DataView(dataTable);

对 DataView 进行排序：

dataTable.DefaultView.sort="lastName";

dataTable.DefaultView.sort="lastName,FirstName DESC";

对 DataView 进行筛选和排序：

通过 RowFilter 属性设置实现筛选

DataView dv = new DataView(ds.Tables["Authors"]);

dv.RowFilter = "state ＝ 'CA'";

dv.Sort = "au_lname";

3.DataColumn 对象

示例

DataColumn colCustomerID = dtCustomers.Columns.Add("CustomerId",typeof(Int32));

colCustomerID.AllowDBNull = false;

colCustomerID.Unique = true;

4.DataRow 对象

调用 NewRow 方法来创建一个新的 DataRow 对象

创建 DataRow 对象

DataRow drNewEmployee = dtEmployees.NewRow();

41

//使用索引或列名操作新行

drNewEmployee(0) = 11;

drNewEmployee(1) = "Smith";

//调用 Add 方法将行添加到 DataRowCollection 中

dtEmployees.Rows.Add(drNewEmployee);

对行进行批处理更改：

BeginEdit()开始更改， EndEdit()结束更改，同时将更改结果写入 DataSet， CancelEdit()，取消更改

例如：

row.BeginEdit();

对 row 进行更改

row.EndEdit();

从 DataTable 中删除 DataRow 对象：

一： DataRowCollection 对象的 Remove 方法

示例

DataRow drEmployee = dtEmployees.Rows(3);

dtEmployees.Rows.Remove(drEmployee);

二： DataRow 对象的 Delete 方法

示例

drEmployee.Delete;

比较： Remove 方法时从 DataRowCollection 中删除 DataRow，而 Dalete 方法只是对删除的行做标记。

DataRow 类包括 RowState 属性。RowState 属性值表示从第一次创建 DataTable（或从数据库加载 DataTable）开始，行是否发生更改，如何更改以及通过何

种方式更改。属性的可选值： Modified | Detached | Added。

5.创建表关系

示例

//创建 DataRelation

DataRelation dr;

DataColumn parentCol;

DataColumn childCol;

parentCol = ds.Tables["Customers"].Columns["CustomerID"];

childCol = ds.Tables["Orders"].Columns.["CustomerID"];

dr = new DataRelation("CustOrders", parentCol, childCol);

ds.Relations.Add(dr);

currentParentRow = ds.Tables["Customers"].Rows[DataGridName.SelectedIndex];

foreach(DataRow r in currentParentRow.GetChildRow("CustOrders"))

{

Lable1.Text += r["OrderID"] + ",";

}

6.绑定数据

示例一

GridView.DataSource = ds;

GridView.DataMember = "Authors";

GridView.DataBind();示例二

GridView.DataSource = ds.Tables["Authors"];

GridView.DataBind();示例三

DataView dv = new DataView(ds.Tables["Authors"]);

42

dv.RowFilter = "state = 'CA'";

GridView.DataSource = dv;

GridView.DataBind();

DataAdapter（即数据适配器）对象是一种用来充当 DataSet 对象与实际数据源之间桥梁的对象。 DataSet 对象是一个非连接的对象，它与数据源无关。而

DataAdapter 则正好负责填充它并把它的数据提交给一个特定的数据源，它与 DataSet 配合使用，可以执行新增、查询、修改和删除等多种操作。

用以两

DataAdapter 对象是一个双向通道，来把数据从数据源中读到一个内存表中，及把内存中的数据写回到一个数据源中。种情况下使用的数据源可能相同，

也可能不相同。而这两种操作分别称作填充（ fill）和更新（ update）。

DataAdapter 对象的常用属性如表 1 所示。

表1 SqlDataAdapter 对象的属性

属性描述

DeleteCommand 获取或设置一个语句或存储过程，以从数据集删除记录

InsertCommand 获取或设置一个语句或存储过程，以在数据源中插入新记录

SelectCommand 获取或设置一个语句或存储过程，用于在数据源中选择记录

UpdateBatchSize 获取或设置每次到服务器的往返过程中处理的行数

UpdateCommand 获取或设置一个语句或存储过程，用于更新数据源中的记录

DataAdapter 对象的常用方法如表 2 所示

表2 SqlDataAdapter 对象的方法

方法描述

Dispose 删除该对象

Fill 用从源数据读取的数据行填充至 DataSet 对象中

FillSchema 将一个 DataTable 加入到指定的 DataSet 中，并配置表的模式

GetFillParameters 返回一个用于 SELECT 命令的 DataParameter 对象组成的数组

Update 在 DataSet 对象中的数据有所改动后更新数据源。

关于 DataAdapter 对象中常用的 Fill 和 Update 方法，下面以 SqlDataAdapter（ DataSet 和 SQL Server 之间的桥接器）为例进行说明。

当 SqlDataAdapter 对象通过 Fill 方法填充 DataSet 对象时，它为返回的数据创建必需的表和列（如果这些表和列尚不存在）。但是，除非将

MissingSchemaAction 属性设置为 AddWithKey，则这个隐式创建的架构中不包括主键信息。可以使用 FillSchema 方法， SqlDataAdapter 对象创建 DataSet

否也让

对象的架构，并在用数据填充它之前就将主键信息包括进去

28. 如何理解委托和事件？

委托是一种定义方法签名的类型，可以与具有兼容签名的任何方法关联。您可以通过委托调用方法。委托用于将方法作为参数传递给其他方法。事件处理程序

就是通过委托调用的方法。您可以创建一个自定义方法，当发生特定事件时某个类（例如 Windows 控件）就可以调用您的方法。下面的示例演示了一个委

托声明：

public delegate int PerformCalculation(int x, int y);

与委托的签名（由返回类型和参数组成）匹配的任何可访问类或结构中的任何方法都可以分配给该委托。方法可以是静态方法，也可以是实例方法。这样就可

以通过编程方式来更改方法调用，还可以向现有类中插入新代码。只要知道委托的签名，就可以分配您自己的方法。

在方法重载的上下文中，方法的签名不包括返回值。但在委托的上下文中，签名的确包括返回值。换句话说，方法和委托必须具有相同的返回值。

将方法作为参数进行引用的能力使委托成为定义回调方法的理想选择。例如，可以向排序算法传递对比较两个对象的方法的引用。分离比较代码使得可以采用

更通用的方式编写算法。

委托概述

委托具有以下特点：

委托类似于 C++ 函数指针，但它们是类型安全的。

委托允许将方法作为参数进行传递。

委托可用于定义回调方法。

委托可以链接在一起；例如，可以对一个事件调用多个方法。

43

方法不必与委托签名完全匹配。有关更多信息，请参见 Covariance and Contravariance 委托中的协变和逆变（ C# 编程指南）。

C# 2.0 版引入了匿名方法的概念，此类方法允许将代码块作为参数传递，以代替单独定义的方法。 C# 3.0 引入了 Lambda 表达式，利用它们可以更

简练地编写内联代码块。匿名方法和 Lambda 表达式（在某些上下文中）都可编译为委托类型。这些功能统称为匿名函数

委托的声明

public delegate void MyDelegate(string str);

1.委托的定义和方法的定义类似，只是在前面加了一个 delegate,但委托不是方法，它是一种类型。是一种特殊的类型 ,看成是一种新的对象类型比较好理解。

用于对与该委托有相同签名的方法调用。

2.委托相当于 C++中的函数指针，但它是类型安全的。

3.委托是从 System.Delegate 派生，但不能象定义常规类型一样直接从 System.Delegate 派生，对委托的声明只能通过上面的声明格式进行定义。关键字

delegate 通知编译器这是一个委托类型，从而在编译的时候对该类进行封装 ,对这一过程 C#定义了专门的语法来处理这一过程。

4.不能从一个委托类型进行派生，因为它也是默认 sealed 的

5.委托即可以对静态方法进行调用也可以对实例方法进行调用。

6.每个委托类型包含一个自己的调用列表，当组合一个委托或从一个委托中删除一个委托时都将产生个新的调用列表。

7.两个不同类型的委托即使它们有相同的签名和返回值，但还是两个不同类型的委托。但其实在使用中可看作是相同的。

委托的比较

C#中对委托定义了两个操作符 == 和 !=

在以下情况下两个委托是相等的：

1.当两个委托都同时为 null 的时候

2.当两个委托都不为 null 时 ,下列情况下是相等的。

a.当两个委托的各自的调用列表只含有一个入口点的时候在下列情况下是相等的

(1) 调用同一对象的同一静态方法

(2) 调用同一对象的同一实例方法

b.当两个委托具有多个入口点时

在下列情况下是相等的

(1)只有当它们调用列表中的调用的方法按顺序都一一对应相同的对象及对象的同一方法的时候

如上所述的两个不同类型的委托但是它们具有相同的签名和返回值时，只要满足上述条件的，即使它们类型不同，但比较的结果也是相同的。

委托的异常处理

当调用该委托的方法中发生了异常时，首先在调用该委托的方法中搜寻 catch 语句块。如果没有，则去该委托调用的方法中去寻找有没有 catch 语句块，这和

调用方法发生异常的处理是一样的。

当调用一个为 null 的委托即委托中列表中不存在调用方法时，将发生 NullRefrenceException

委托的注意点:

当一个委托有多个入口点的时候 ,调用委托将依该委托的调用列表中的方法的顺序依次调用 .这些方法共享一个参数集合 ,所以当委托有返回值的时候调用完这

个委托后的返回值是最后一个方法的返回值或是有 out 参数 .如果该委托的参数为 ref(引用类型 ),那么在招待第一个方法的时候如果对这个参数的值有所改变 ,

那么这个改变将会影响到后面的方法调用.

委托的一个例子

using System;

using System.Collections.Generic;

using System.Text;

namespace ConsoleApplication1

{

class Program

{

static void Main(string[] args)

{

// 创建一个委托实例，封装 C 类的静态方法 M1

MyDelegate d1 = new MyDelegate(C.M1);

44

d1("D1"); // M1

// 创建一个委托实例，封装 C 类的静态方法 M2

MyDelegate d2 = new MyDelegate(C.M2);

d2("D2"); // M2

// 创建一个委托实例，封装 C 类的实例方法 M3

MyDelegate d3 = new MyDelegate(new C().M3);

d3("D3"); // M3

// 从一个委托 d3 创建一个委托实例

MyDelegate d4 = new MyDelegate(d3);

d4("D4"); // M3

// 组合两个委托

MyDelegate d5 = d1 + d2;

d5 += d3;

d5("D5"); // M1,M2,M3

// 从组合委托中删除 d3

MyDelegate d6 = d5 - d3;

d6("D6"); // M1,M2

d6 -= d3; // 虽然 d6 调用列表中已经没有 d3 了，但这样只是不可能的移除没有错误发生

d6("D6"); // M1,M2

d6 -= d6;

//d6("D6"); 此时 d6 的调用列表为空， d6 为 null,所以引发 System.NullReferenceException

MyDelegate d7 = new MyDelegate(C1.P1);

d7("D7"); // C1.P1

MyDelegate d8 = new MyDelegate(new C2().P1);

d8("D8"); // C2.P1

}

}

// 声明一个委托 MyDelegate

public delegate void MyDelegate(string str);

public class C

{

public static void M1(string str)

{

Console.WriteLine("From:C.M1: {0}", str);

}

public static void M2(string str)

{

Console.WriteLine("From:C.M2: {0}", str);

}

public void M3(string str)

{

Console.WriteLine("From:C.M3: {0}", str);

}

}

public class C1

{

public static void P1(string str)

{

Console.WriteLine("From:C1.P1: {0}", str);

45

}

}

public class C2

{

public void P1(string str)

{

Console.WriteLine("From:C2.P1: {0}", str);

}

}

}

事件概述

事件就是当对象或类状态发生改变时，对象或类发出的信息或通知。发出信息的对象或类称为 "事件源 ",对事件进行处理的方法称为 "接收者 ",通常事件源在发

出状态改变信息时 ,它并不知道由哪个事件接收者来处理 .这就需要一种管理机制来协调事件源和接收者 ,C++中通过函数指针来完成的 .在 C#中事件使用委托来

为触发时将调用的方法提供类型安全的封装。

事件的声明

1.声明一个委托

public delegate void EventHandler(object sender, System.EventArgs e);

2.声明一个事件

public event EventHandler Changed;

3.引发一个事件

public OnChanged(EnventArgs e)

{

if ( Changed != null)

{

Changed(this,e);

}

}

4.定义事件处理程序

public MyText_OnChanged(Object sender,EventArgs e)

{

...

}

5.订阅事件 (将事件处理程序添加到事件的调用列表中 )

myText.Changed += EventHandler(MyText_OnChanged);

下面的一个小例子说明了怎样定义一个完整的事件机制:

using System;

using System.Collections.Generic;

using System.Text;

namespace ConsoleApplication1

{

class Program

{

static void Main(string[] args)

{

MyText myText = new MyText();

// 将事件处理程序添加到事件的调用列表中 (即事件布线 )

myText.Changed += new MyText.ChangedEventHandler(myText_Ch anged);

46

string str = "";

while (str != "quit")

{

Console.WriteLine("please enter a string:");

str = Console.ReadLine();

myText.Text = str;

}

}

// 对 Change 事件处理的程序

private static void myText_Changed(object sender, EventArgs e)

{

Console.WriteLine("text has been changed :{0}\n" ,((MyText)sender).Text);

}

}

public class MyText

{

private string _text = "";

// 定义事件的委托

public delegate void ChangedEventHandler(object sender, EventArgs e);

// 定义一个事件

public event ChangedEventHandler Changed;

// 用以触发 Change 事件

protected virtual void OnChanged(EventArgs e)

{

if (this.Changed != null)

this.Changed(this, e);

}

// Text 属性

public string Text

{

get { return this._text; }

set

{

this._text = value;

// 文本改变时触发 Change 事件

this.OnChanged(new EventArgs());

}

}

}

}

29. C#接口和抽象类.

一、抽象类：

抽象类是特殊的类，只是不能被实例化；除此以外，具有类的其他特性；重要的是抽象类可以包括抽象方法，这是普通类所不能的。抽象方法只能声明于

抽象类中，且不包含任何实现，派生类必须覆盖它们。另外，抽象类可以派生自一个抽象类，可以覆盖基类的抽象方法也可以不覆盖，如果不覆盖，则其派生

类必须覆盖它们。

二、接口：

接口是引用类型的，类似于类 ,和抽象类的相似之处有三点：

47

1、不能实例化；

2、包含未实现的方法声明；

3、派生类必须实现未实现的方法，抽象类是抽象方法，接口则是所有成员（不仅是方法包括其他成员）；

另外，接口有如下特性：

接口除了可以包含方法之外，还可以包含属性、索引器、事件，而且这些成员都被定义为公有的。除此之外，不能包含任何其他的成员，例如：常量、域、构

造函数、析构函数、静态成员。一个类可以直接继承多个接口，但只能直接继承一个类（包括抽象类）。

三、抽象类和接口的区别：

1.类是对对象的抽象，可以把抽象类理解为把类当作对象，抽象成的类叫做抽象类 .而接口只是一个行为的规范或规定，微软的自定义接口总是后

带 able 字段，证明其是表述一类类 “ 我能做。。。 ” .抽象类更多的是定义在一系列紧密相关的类间，而接口大多数是关系疏松但都实现某一功能的类中 .

2.接口基本上不具备继承的任何具体特点 ,它仅仅承诺了能够调用的方法 ;

3.一个类一次可以实现若干个接口 ,但是只能扩展一个父类

4.接口可以用于支持回调 ,而继承并不具备这个特点 .

5.抽象类不能被密封。

6.抽象类实现的具体方法默认为虚的，但实现接口的类中的接口方法却默认为非虚的，当然您也可以声明为虚的 .

7.（接口）与非抽象类类似，抽象类也必须为在该类的基类列表中列出的接口的所有成员提供它自己的实现。但是，允许抽象类将接口方法映射到

抽象方法上。

8.抽象类实现了 oop 中的一个原则，把可变的与不可变的分离。抽象类和接口就是定义为不可变的，而把可变的座位子类去实现。

9.好的接口定义应该是具有专一功能性的，而不是多功能的，否则造成接口污染。如果一个类只是实现了这个接口的中一个功能，而不得不去实现

接口中的其他方法，就叫接口污染。

10.尽量避免使用继承来实现组建功能，而是使用黑箱复用，即对象组合。因为继承的层次增多，造成最直接的后果就是当你调用这个类群中某一类，

就必须把他们全部加载到栈中！后果可想而知 .（结合堆栈原理理解）。同时，有心的朋友可以留意到微软在构建一个类时，很多时候用到了对象组合的方法。

比如 asp.net 中， Page 类，有 Server Request 等属性，但其实他们都是某个类的对象。使用 Page 类的这个对象来调用另外的类的方法和属性，这个是非常

基本的一个设计原则。

11.如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法 .

四、抽象类和接口的使用：

1. 如果预计要创建组件的多个版本，则创建抽象类。抽象类提供简单的方法来控制组件版本。

2.如果创建的功能将在大范围的全异对象间使用，则使用接口。如果要设计小而简练的功能块，则使用接口。

3.如果要设计大的功能单元，则使用抽象类 .如果要在组件的所有实现间提供通用的已实现功能，则使用抽象类。

4.抽象类主要用于关系密切的对象；而接口适合为不相关的类提供通用功能。

30. UDP 连接和 TCP 连接的异同.

TCP 与 UDP 的区别：

1、 TCP 是面向连接的，比如你给别人打电话，就必须等线路接通后，对方拿起话筒才能相互通话。

UDP 是面向非连接的，与手机短信非常相似，你在发短信的时候，只需要输入对方手机号就行了。

2、 TCP 对系统资源的要求较多， UDP 对系统资源的要求少。

3、 TCP 程序结构比较复杂， UDP 程序结构较简单

4、 TCP 保证数据可靠性， UDP 适用于一次只传送少量数据，对可靠性要求不高。

5、 TCP 保证数据顺序， UDP 不保证数据顺序。

31. 什么是 code-Behind 技术.

Code Behind 就是所谓的代码分离，自从 Microsoft 公司推出了 ASP.NET 以后， Code Behind 就是一个热门的话题。在一般的 ASP.NET 文件中， Code Behind

主要是用二个文件来创建一个 ASP.NET 的页面，其中一个是设计文件，一般以 .aspx 或者 .ascx 做为扩展名，而另外一个是程序代码文件，一般以 .vb 或者 .cs

做为扩展名，其程序设计语言主要是 VB.Net 或者是 C#。

32. 活动目录的作用.

Active Directory（活动目录）是 Windows Server 2003 域环境中提供目录服务的组件。目录服务在微软平台上从 Windows Server 2000 开始引入，所以我们

可以理解为活动目录是目录服务在微软平台的一种实现方式。当然目录服务在非微软平台上都有相应的实现。

33. .net 中读写 XML 的类都归属于哪些命名空间？

Asp.Net XML 操作基类 (修改 ,删除 ,新增 ,创建 )

48

using System.Xml;

namespace EC

{

///

/// XML 操作基类

///

public class XmlObject : IDisposable

{

//以下为单一功能的静态类

#region 读取 XML 到 DataSet

/**************************************************

* 函数名称 :GetXml(string XmlPath)

* 功能说明 :读取 XML 到 DataSet

* 参数 :XmlPath:xml 文档路径

* 使用示列:

* using EC; //引用命名空间

* string xmlPath = Server.MapPath("/EBDnsConfig/DnsConfig.xml"); // 获取 xml 路径

* DataSet ds = EC.XmlObject.GetXml(xmlPath); // 读取 xml 到 DataSet 中

************************************************/

///

/// 功能 :读取 XML 到 DataSet 中

///

/// xml 路径

/// DataSet

public static DataSet GetXml(string XmlPath)

{

DataSet ds = new DataSet();

ds.ReadXml(@XmlPath);

return ds;

}

#endregion

#region 读取 xml 文档并返回一个节点

/**************************************************

* 函数名称 :ReadXmlReturnNode(string XmlPath,string Node)

* 功能说明 :读取 xml 文档并返回一个节点 :适用于一级节点

* 参数 : XmlPath:xml 文档路径 ;Node 返回的节点名称

* 适应用 Xml:

*

* ns1.everdns.com

*

* 使用示列:

* using EC; //引用命名空间

* string xmlPath = Server.MapPath("/EBDnsConfig/DnsConfig.xml"); // 获取 xml 路径

* Response.Write(XmlObject.ReadXmlReturnNode(xmlPath, "mailmanager"));

************************************************/

///

/// 读取 xml 文档并返回一个节点 :适用于一级节点

49

///

/// xml 路径

/// 节点

///

public static string ReadXmlReturnNode(string XmlPath,string Node)

{

XmlDocument docXml = new XmlDocument();

docXml.Load(@XmlPath);

XmlNodeList xn = docXml.GetElementsByTagName(Node);

return xn.Item(0).InnerText.ToString();

}

#endregion

#region 查找数据 ,返回一个 DataSet

/**************************************************

* 函数名称 :GetXmlData(string xmlPath, string XmlPathNode)

* 功能说明 :查找数据 ,返回当前节点的所有下级节点 ,填充到一个 DataSet 中

* 参数 :xmlPath:xml 文档路径 ;XmlPathNode:当前节点的路径

* 使用示列:

* using EC; //引用命名空间

* string xmlPath = Server.MapPath("/EBDomainConfig/DomainConfig.xml"); // 获取 xml 路径

* DataSet ds = new DataSet();

* ds = XmlObject.GetXmlData(xmlPath, "root/items");// 读取当前路径

* this.GridView1.DataSource = ds;

* this.GridView1.DataBind();

* ds.Clear();

* ds.Dispose();

* Xml 示例 :

************************************************/

///

/// 查找数据 ,返回当前节点的所有下级节点 ,填充到一个 DataSet 中

///

/// xml 文档路径

/// 节点的路径 :根节点 /父节点 /当前节点

///

public static DataSet GetXmlData(string xmlPath, string XmlPathNode)

{

XmlDocument objXmlDoc = new XmlDocument();

objXmlDoc.Load(xmlPath);

DataSet ds = new DataSet();

StringReader read = new StringReader(objXmlDoc.SelectSingleNode(XmlPathNode).Outer Xml);

ds.ReadXml(read);

return ds;

}

#endregion

#region 更新 Xml 节点内容

/**************************************************

* 函数名称 :XmlNodeReplace(string xmlPath,string Node,string Content)

50

* 功能说明 :更新 Xml 节点内容

* 参数 :xmlPath:xml 文档路径 ;Node:当前节点的路径 ;Content:内容

* 使用示列:

* using EC; //引用命名空间

* string xmlPath = Server.MapPath("/EBDomainConfig/DomainConfig.xml"); // 获取 xml 路径

* XmlObject.XmlNodeReplace(xmlPath, "root/test", "56789"); // 更新节点内容

************************************************/

///

/// 更新 Xml 节点内容

///

/// xml 路径

/// 要更换内容的节点 :节点路径根节点 /父节点 /当前节点

/// 新的内容

public static void XmlNodeReplace(string xmlPath,string Node,string Content)

{

XmlDocument objXmlDoc = new XmlDocument();

objXmlDoc.Load(xmlPath);

objXmlDoc.SelectSingleNode(Node).InnerText = Content;

objXmlDoc.Save(xmlPath);

}

#endregion

#region 删除 XML 节点和此节点下的子节点

/**************************************************

* 函数名称 :XmlNodeDelete(string xmlPath,string Node)

* 功能说明 :删除 XML 节点和此节点下的子节点

* 参数 :xmlPath:xml 文档路径 ;Node:当前节点的路径 ;

* 使用示列:

* using EC; //引用命名空间

* string xmlPath = Server.MapPath("/EBDomainConfig/DomainConfig.xml"); // 获取 xml 路径

* XmlObject.XmlNodeDelete(xmlPath, "root/test"); // 删除当前节点

************************************************/

///

/// 删除 XML 节点和此节点下的子节点

///

/// xml 文档路径

/// 节点路径

public static void XmlNodeDelete(string x mlPath,string Node)

{

XmlDocument objXmlDoc = new XmlDocument();

objXmlDoc.Load(xmlPath);

string mainNode = Node.Substring(0, Node.LastIndexOf("/"));

objXmlDoc.SelectSingleNode(mainNode).RemoveChild(objXmlDoc.SelectSingleNode(Node));

objXmlDoc.Save(xmlPath);

}

#endregion

51

34. 如何理解.net 中的垃圾回收机制.

垃圾收集器用来在 .NET 中进行内存管理，特别是它可以恢复正在运行中的应用程序需要的内存。到目前为止，Windows 平台已经使用了两种技术来释放进程向

系统动态请求的内存：

完全以手工方式使应用程序代码完成这些工作。

让对象维护引用计数。

让应用程序代码负责释放内存是低级、高性能的语言使用的技术，例如 C++。这种技术很有效，且可以让资源在不需要时就释放 (一般情况下 )，但其最大的缺

点是频繁出现错误。请求内存的代码还必须明确通知系统它什么时候不再需要该内存。但这是很容易被遗漏的，从而导致内存泄漏。

尽管现代的开发环境提供了帮助检测内存泄漏的工具，但它们很难跟踪错误，因为直到内存已大量泄漏从而使 Windows 拒绝为进程提供资源时，它们才会发挥

作用。到那个时候，由于对内存的需求，会使整个计算机变得相当慢。

维护引用计数是 COM 对象采用的一种技术，其方法是每个 COM 组件都保留一个计数，记录客户机目前对它的引用数。当这个计数下降到 0 时，组件就会删除自

己，并释放相应的内存和资源。它带来的问题是仍需要客户机通知组件它们已经完成了内存的使用。只要有一个客户机没有这么做，对象就仍驻留在内存中。

在某些方面，这是比 C++内存泄漏更为严重的问题，因为 COM 对象可能存在于它自己的进程中，从来不会被系统删除 (在 C++内存泄漏问题上，系统至少可以在

进程中断时释放所有的内存 )。

.NET 运行库采用的方法是垃圾收集器，这是一个程序，其目的是清理内存，方法是所有动态请求的内存都分配到堆上 (这对所有的语言都一样，但在 .NET 中，

CLR 维护它自己的托管堆，以供 .NET 应用程序使用 )，当 .NET 检测到给定进程的托管堆已满，需要清理时，就调用垃圾收集器。垃圾收集器处理目前代码中的

所有变量，检查对存储在托管堆上的对象的引用，确定哪些对象可以从代码中访问 —— 即哪些对象有引用。没有引用的对象就不能再从代码中访问，因而被

删除。 Java 就使用与此类似的垃圾收集系统。

之所以在 .NET 中使用垃圾收集器，是因为中间语言已用来处理进程。其规则要求，第一，不能引用已有的对象，除非复制已有的引用。第二，中间语言是类型

安全的语言。在这里，其含义是如果存在对对象的任何引用，该引用中就有足够的信息来确定对象的类型。

垃圾收集器机制不能和诸如非托管 C++这样的语言一起使用，因为 C++允许指针自由地转换数据类型。

垃圾收集器的一个重要方面是它是不确定的。换言之，不能保证什么时候会调用垃圾收集器： .NET 运行库决定需要它时，就可以调用它 (除非明确调用垃圾收

集器 )。但可以重写这个过程，在代码中调用垃圾收集器。

GC 的全称是 garbage collection，中文名称垃圾回收，是 .NET 中对内存管理的一种功能。垃圾回收器跟踪并回收托管内存中分配的对象，定期执行垃圾回收

以回收分配给没有有效引用的对象的内存。当使用可用内存不能满足内存请求时， GC 会自动进行。

在进行垃圾回收时，垃圾回收器会首先搜索内存中的托管对象，然后从托管代码中搜索被引用的对象并标记为有效，接着释放没有被标记为有效的对象并

收回内存，最后整理内存将有效对象挪动到一起。这就是 GC 的四个步骤。

由上可见， GC 是很影响性能的，所以一般说来这种事情况还是尽量少发生为好。

为了减少一些性能影响，.NET 的 GC 支持对象老化，或者说分代的概念，代是对象在内存中相对存现时期的度量单位，对象的代数或存现时期说明对象所

属的代。目前 .NET 的垃圾回收器支持三代。每进行一次 GC,没有被回收的对象就自动提升一代。较近创建的对象属于较新的代，比在应用程序生命周期中较早

创建的对象的代数低。最近代中的对象位于零代中。每一次 GC 的时候，都首先回收零代中的对象，只有在较低代数的对象回收完成后仍不能满足需求的情况

下才回收较高代数的对象。

35. using 几种用法

1. 导入命名空间 ,如 using System;为了不用写类的全名 .

2. 用来对一个命名空间重命名 ,如 using sysData=System.Data;引用时 sysData.DataSet.

3. 释放资源 , using: 释放 ()中的对象。释放托管资源和非托管资源 :

a) 连

非托管资源 : 和外部物理设备连接的资源如 :文件，接 , 需可

还有流对象等 .CLR 不会释放非托管资源，要自己释放，以使用 Using()

b) 托管资源： CLR 会自己释放，但不是立刻释放．使用 Using()会立刻释放资源

36. new 有几种用法

在 C# 中， new 关键字可用作运算符、修饰符或约束。

1） new 运算符：用于创建对象和调用构造函数。这种大家都比较熟悉，没什么好说的了。

2） new 修饰符：在用作修饰符时， new 关键字可以显式隐藏从基类继承的成员。

3） new 约束：用于在泛型声明中约束可能用作类型参数的参数的类型。

关于第二种用法看下例：

using System;

namespace ConsoleApplication1

52

{

public class BaseA

{

public int x = 1;

public void Invoke()

{

Console.WriteLine(x.ToString());

}

public int TrueValue

{

get { return x; }

set { x = value; }

}

}

public class DerivedB : BaseA

{

new public int x = 2;

new public void Invoke()

{

Console.WriteLine(x.ToString());

}

new public int TrueValue

{

get { return x; }

set { x = value; }

}

}

class Test

{

static void Main(string[] args)

{

DerivedB b = new DerivedB();

b.Invoke();//调用 DerivedB 的 Invoke 方法，输出： 2

Console.WriteLine(b.x.ToString());// 输出 DerivedB 的成员 x 值： 2

BaseA a = b;

a.Invoke();//调用 BaseA 的 Invoke 方法，输出： 1

a.TrueValue = 3;//调用 BaseA 的属性 TrueValue，修改 BaseA 的成员 x 的值

Console.WriteLine(a.x.ToString());// 输出 BaseA 的成员 x 的值： 3

Console.WriteLine(b.TrueValue.ToString());// 输出 DerivedB 的成员 x 的值，仍然是： 1

//可见，要想访问被隐藏的基类的成员变量、属性或方法，办法就是将子类造型为父类，然

//后通过基类访问被隐藏的成员变量、属性或方法。

}

}

}

new 约束指定泛型类声明中的任何类型参数都必须具有公共的无参数构造函数 .请看下例 :

using System;

using System.Collections.Generic;

53

namespace ConsoleApplication2

{

public class Employee

{

private string name;

private int id;

public Employee()

{

name = "Temp";

id = 0;

}

public Employee(string s, int i)

{

name = s;

id = i;

}

public string Name

{

get { return name; }

set { name = value; }

}

public int ID

{

get { return id; }

set { id = value; }

}

}

class ItemFactory where T : new()

{

public T GetNewItem()

{

return new T();

}

}

public class Test

{

public static void Main()

{

ItemFactory EmployeeFactory = new ItemFactory ();

////此处编译器会检查 Employee 是否具有公有的无参构造函数。

//若没有则会有 The Employee must have a public parameterless constructor 错误。

Console.WriteLine("{0}'ID is {1}.", EmployeeFactory.GetNewItem().Name, EmployeeFactory.GetNewItem().ID);

}

}

54

}

37. datagrid.datasouse 可以连接什么数据源？

对于 DataGrid 有效的数据源包括：

DataTable 类

DataView 类

DataSet 类

DataViewManager 类

如果数据源是数据集，则它可能是窗体中的一个对象或者是 XML Web services 传递给窗体的对象。可以绑定到类型化数据集或非类型化数据集。有关将数据

集添加到窗体的详细信息，请参见用于创建数据集的 Visual Studio 工具。有关使用 XML Web services 访问数据集的详细信息，请参见分布式应用程序

和数据集成介绍。

如果其他结构中的对象（例如，数组中的元素）公开公共属性，也可以将 DataGrid 控件绑定到这些结构。网格将显示结构中元素的所有公共属性。例如，如

果将 DataGrid 控件绑定到一个客户对象数组，则网格将显示这些客户对象的所有公共属性。在某些情况下，这意味着虽然可以绑定到结构，但可能没有实用

的应用程序。例如，可以绑定到一个整数数组，但是因为 Integer 数据类型不支持公共属性，所以该网格不能显示任何数据。

如果下列结构的元素公开公共属性，则可以绑定到这些结构：

任何实现 IList 接口的组件。这包括一维数组。

任何实现 IListSource 接口的组件。

任何实现 IBindingList 接口的组件。

38. 概述反射和序列化

反射的定义：审查元数据并收集关于它的类型信息的能力。元数据（编译以后的最基本数据单元）就是一大堆的表，当编译程序集或者模块时，编译器会创建

一个类定义表，一个字段定义表，和一个方法定义表等。

System.reflection 命名空间包含的几个类，允许你反射（解析）这些元数据表的代码 :

System.Reflection.Assembly

System.Reflection.MemberInfo

System.Reflection.EventInfo

System.Reflection.FieldInfo

System.Reflection.MethodBase

System.Reflection.ConstructorInfo

System.Reflection.MethodInfo

System.Reflection.PropertyInfo

System.Type

以下是上面几个类的使用方法：

（ 1）使用 Assembly 定义和加载程序集，加载在程序集清单中列出模块，以及从此程序集中查找类型并创建该类型的实例。

（ 2）使用 Module 了解包含模块的程序集以及模块中的类等，还可以获取在模块上定义的所有全局方法或其他特定的非全局方法。

（ 3）使用 ConstructorInfo 了解构造函数的名称、参数、访问修饰符（如 pulic 或 private）和实现详细信息（如 abstract 或 virtual）等。使用 Type 的

GetConstructors 或 GetConstructor 方法来调用特定的构造函数。

（ 4）使用 MethodInfo 了解方法的名称、返回类型、参数、访问修饰符（如 pulic 或 private）和实现详细信息（如 abstract 或 virtual）等。使用 Type 的

GetMethods 或 GetMethod 方法来调用特定的方法。

（ 5）使用 FiedInfo 了解字段的名称、访问修饰符（如 public 或 private）和实现详细信息（如 static）等，并获取或设置字段值。

（ 6）使用 EventInfo 了解事件的名称、事件处理程序数据类型、自定义属性、声明类型和反射类型等，添加或移除事件处理程序。

（ 7）使用 PropertyInfo 了解属性的名称、数据类型、声明类型、反射类型和只读或可写状态等，获取或设置属性值。

（ 8）使用 ParameterInfo 了解参数的名称、数据类型、是输入参数还是输出参数，以及参数在方法签名中的位置等。

反射的作用：

1、可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型

2、应用程序需要在运行时从某个特定的程序集中载入一个特定的类型，以便实现某个任务时可以用到反射。

3、反射主要应用与类库，这些类库需要知道一个类型的定义，以便提供更多的功能。

应用要点：

1、现实应用程序中很少有应用程序需要使用反射类型

55

2、使用反射动态绑定需要牺牲性能

3、有些元数据信息是不能通过反射获取的

4、某些反射类型是专门为那些 clr 开发编译器的开发使用的，所以你要意识到不是所有的反射类型都是适合每个人的。

序列化就是把一个对象保存到一个文件或数据库字段中去，反序列化就是在适当的时候把这个文件再转化成原来的对象使用。

在 C#中常见的序列化的方法主要也有三个： BinaryFormatter、 SoapFormatter、 XML 序列化

39. 概述 o/r mapping 的原理

ORM，即 Object-Relationl Mapping，它的作用是在关系型数据库和对象之间作一个映射，这样，我们在具体的操作数据库的时候，就不需要再去和复杂的 SQL

语句打交道，只要像平时操作对象一样操作它就可以了。下面是在网上转载的一段文章中对它的描述：

让我们从 O/R 开始。字母 O 起源于 "对象 "(Object),而 R 则来自于 "关系 "(Relational)。几乎所有的程序里面，都存在对象和关系数据库。在业务逻辑

层和用户界面层中，我们是面向对象的。当对象信息发生变化的时候，我们需要把对象的信息保存在关系数据库中。

当你开发一个应用程序的时候 (不使用 O/R Mapping),你可能会写不少数据访问层的代码，用来从数据库保存，删除，读取对象信息，等等。你在 DAL 中写了很

多的方法来读取对象数据，改变状态对象等等任务。而这些代码写起来总是重复的。

如果打开你最近的程序，看看 DAL 代码，你肯定会看到很多近似的通用的模式。我们以保存对象的方法为例，你传入一个对象，为 SqlCommand 对象添

加 SqlParameter，把所有属性和对象对应，设置 SqlCommand 的 CommandText 属性为存储过程，然后运行 SqlCommand。对于每个对象都要重复的写这些代码。

除此之外，还有更好的办法吗？有，引入一个 O/R Mapping。实质上，一个 O/R Mapping 会为你生成 DAL。与其自己写 DAL 代码，不如用 O/R Mapping。

你用 O/R Mapping 保存，删除，读取对象， O/R Mapping 负责生成 SQL，你只需要关心对象就好。

40. 用 sealed 修饰的类有什么特点

sealed 修饰符用于防止从所修饰的类派生出其它类 .如果一个密封类被指定为其他类的基类，则会发生编译时错误 .

密封类不能同时为抽象类.

sealed 修饰符主要用于防止非有意的派生，但是它还能促使某些运行时优化 .具体说来，由于密封类永远不会有任何派生类，所以对密封类的实例的虚拟函数

成员的调用可以转换为非虚拟调用来处理.

41. 概述三层结构体系

1.表示层 (USL)：主要表示 WEB 方式，也可以表示成 WINFORM 方式。如果逻辑层相当强大和完善，无论表现层如何定义和更改，逻辑层都能完善地提供服务。

2.业务逻辑层 (BLL)：主要是针对具体的问题的操作，也可以理解成对数据层的操作，对数据业务逻辑处理。如果说数据层是积木，那逻辑层就是对这些积木

的搭建。

3.数据访问层 (DAL)：主要是对原始数据 (数据库或者文本文件等存放数据的形式 )的操作层，而不是指原始数据，也就是说，是对数据的操作，而不是数据库，

具体为业务逻辑层或表示层提供数据服务。

“三层结构”开发模式的一个非常明显的缺点就是其执行速度不够快。当然这个“执行速度”是相对于非分层的应用程序来说的。

42. asp.net 如何实现 MVC 模式，举例说明

MVC 是个将一个应用的实现分成三个组件角色的框架技术：模型，视图和控制器。

在基于 MVC 的应用里， Model(模型 )是负责保持状态的应用组件。这个状态通常都持久于数据库之中（譬如，我们也许会有一个 Product（产品）类用来代表

SQL 中的 Products 数据表中的订单数据 )。

在基于 MVC 的应用里，View(视图 )是负责显示用户界面的组件。这个 UI 通常是使用模型数据来创建的（譬如，我们也许会生成一个 Product"编辑 "视图，根据

当前 Product 对象的状态，显示文本框，下拉框和复选框等 )。

在基于 MVC 的应用里，Controller(控制器 )是处理用户交互，操作模型和最终选择用哪个视图来显示 UI 的组件。在 MVC 应用中，视图只是用来显示信息而已，

是控制器来处理和回应用户的输入和交互的。

使用 MVC 方法的一个好处是，它有助于促进应用中模型，视图，控制器间的关注的清晰分离。保持关注的清晰分离使得对应用的测试极其容易，因为不同应用

组件间的契约的定义和表达是更明确的。

MVC 模式也有利于促进红 /绿式测试驱动的开发（ TDD)，通过它，你可以在你实际编写应用代码本身之前首先实现自动化的单元测试，这些单元测试定义和核

实了新代码的需求。

ASP.NET MVC 框架的一些简要细节

在几个星期后，相关代码可以下载之后，我将写一些关于这个新的 ASP.NET MVC 框架的深入性的教程贴子（与此同时，想进一步了解它的最佳方式是观看我的

Alt.net 讲座的录像）：

这里是关于 ASP.NET MVC 框架的一些简要细节：

56

它将促进清晰的关注分离，可测试性，和 TDD。 MVC 框架中的所以核心契约都是基于接口的，可以轻易地通过 mock 来模拟（包括基于接口的

IHttpRequest/IHttpResponse 这些基本的东西）。你可以不用在 ASP.NET 进程中运行控制器（这使得单元测试很快），就单元测试你的应用。你可以使用你想

使用的任何单元测试框架来做单元测试，包括 NUnit, MBUnit, MS Test 等等。

这个框架具有高度的可扩展性和可插拔性。MVC 框架中所有的东西都是这样设计的，它们可以被轻易地替换掉或者定制（譬如，你可以插入你自己的视图引擎，

（，。

路径转向策略 routing policy）参数序列化等等）它还支持使用现有的依赖注入 dependency injection）控制反转 IOC）器模型 Windsor, Spring.Net,

（和（容（

NHibernate 等等）。

它包括一个非常强大的 URL 映射组件，允许你使用非常干净的 URL 来建造应用。 URL 不需要拥有文件扩展，是设计来轻松支持 SEO 和 REST 友好的命名模式的。

在我或

譬如，我上面的项目中，可以轻松地把 /products/edit/4 映射到 ProductsController 类的 Edit 方法上，者把 /Blogs/scottgu/10-10-2007/SomeTopic/

映射到 BlogEngineController 类的 DisplayPost 方法上。

MVC 框架支持将现有的 ASP.NET .ASPX, .ASCX,和 .Master 标识文件当作视图模板（ view template)之用 (这意味着你可以轻松地使用很多现有的 ASP.NET 特

性，象嵌套的母版页，块，声明式服务控件，模板，数据绑定，本地化等等）。但是，它不使用现有的将交互返回服务器的 postback 模型，取而代之

的是，你将把用户的所有交互转给控制器类来调度，这有助于关注的清晰分离和提高可测试性（这也意味着，在基于 MVC 的视图内没有 viewstate 或 page 的

生命周期之说）。

ASP.NET MVC 框架将完全支持象 forms/windows 认证，URL 授权，成员 /角色，输出和数据缓存，session/profile 状态管理，健康监测，配置系统，以及 provider

架构等等现有的 ASP.NET 特性。

43. 私有成员会被继承么？

会，但是不能被访问 .所以看上去他们似乎是不能被继承的，但实际上确实被继承了 . 派生类可以访问基类的公共成员、受保护成员、内部成员和受保护内部

成员。即使派生类继承基类的私有成员，仍不能访问这些成员。但是，所有这些私有成员在派生类中仍然存在，且执行与基类自身中相同的工作。例如，假定

一个受保护基类方法访问私有字段。要使继承的基类方法正常工作，派生类中必须有该字段。

44. 请描述一下修饰符 protected internal.

被 protected internal 修饰的属性 /方法只能在它的在同一个程序集（ Assembly）中的子类被访问 .

45. C#提供一个默认的无参数构造函数，当我实现了另外一个有一个参数的构造函数时候，还想

保留这个无参数的构造函数.这样我应该写几个构造函数？

两个，一旦你实现了一个构造函数， C#就不会再提供默认的构造函数了，所以需要手动实现那个无参数构造函数 .

46. 重载和覆写有什么区别？

override 表示重写，用于继承类对基类中虚成员的实现

overload 表示重载，用于同一个类中同名方法不同参数（包括类型不同或个数不同）的实现

47. 在方法定义中，virtual 有什么含意？

abstract 定义的类方法必须在继承的类中进行实现，而且没有实际的代码，类似接口

virtual 定义的方法中可以有实际的代码，但是可以在父类的子类中定义 override 类型的同名方法

48. 能够将非静态的方法覆写成静态方法么？

不能，覆写方法的签名必须与被覆写方法的签名保持一致，除了将 virtual 改为 override.

49. 可以覆写私有的虚方法么？

不可以，甚至子类中无法访问父类中的私有方法 .

50. 能够阻止某一个类被其他类继承么？

可以，使用关键字 sealed.

51. 能够实现允许某个类被继承，但不允许其中的某个方法被覆写么？

可以，标记这个类为 public，并标记这个方法为 sealed.

52. 什么是抽象类（abstract class）？

一种不可以被实例化的类 .抽象类中一般含有抽象方法，当然也可有具体实现 .继承类只有实现过所有抽象类的抽象方法后才能被实例化 .

53. 何时必须声明一个类为抽象类？

当这个类中包含抽象方法时，或是该类并没有完全实现父类的抽象方法时 .

57

54. 接口（interface）是什么？

只含有共有抽象方法（ public abstract method）的类 .这些方法必须在子类中被实现 .

55. 为什么不能指定接口中方法的修饰符？

接口中的方法用来定义对象之间通信的契约，指定接口中的方法为私有或保护没有意义 .他们默认为公有方法 .

56. 那么如果这些接口中有重复的方法名称呢？

这种情况中你可以决定如何实现 .当然需要特别得小心 .但是在编译环节是没有问题的 .

57. 如何区别重载方法？

不同的参数类型，不同的参数个数，不同的参数顺序.

58. const 和 readonly 有什么区别？

C#的 readonly 关键字只能在字段上面使用

public readonly TcpClient client;

不能在类，方法，属性上面使用 readonly!!

顺便看了一下 readonly 和 const 的区别：

· readonly 和 const 都是用来标识常量的。

· const 可用于修饰 class 的 field 或者一个局部变量（ local variable）；而 readonly 仅仅用于修饰 class 的 field。

· const 常量的值必定在编译时就已明确并且恒定的；而 readonly 常量却有一点不同，那就是其值可以在运行时编译，当然，它也必须遵守作为常

量的约束，那就是值必须恒定不变。

· const 常量必须在声明的同时对其进行赋值，并且确保该值在编译时可确定并恒定；而 readonly 常量则可以根据情况选择在声明的同时对其赋予

一个编译时确定并恒定的值，或者将其值的初始化工作交给实例构造函数（ instant constructor）完成。如： public readonly string m_Now =

DateTime.Now.ToString();， m_Now 会随着运行时实际情况变化而变化。

· const 常量属于类级别（ class level）而不是实例对象级别（ instant object level），并且它不能跟 static 结合一起使用，该常量的值将由

整个类的所有实例对象共同分享（详细论述参见后面的 Remark 区域）。

· readonly 常量既可以是类级别也可以是实例对象级别的，这取决于它的声明以及初始化工作怎么实施。readonly 可以与 static 结合使用，用于

指定该常量属于类级别，并且把初始化工作交由静态构造函数（ static constructor）完成（有关如何把 readonly 常量声明为类级别或实例对象级别的论述

清参见后面的 Remark 区域）。

· 能被 const 修饰声明为常量的类型必须是以下的基元类型（ primitive type）： sbyte, byte, short, ushort, int, uint, long, ulong, char,

float, double, float, bool, decimal, string 。

· object, 数组（ Array）和结构（ struct）不能被声明为 const 常量。

· 一般情况下，引用类型是不能被声明为 const 常量的，不过有一个例外：string。该引用类型 const 常量的值可以有两种情况，string 或 null。

其实， string 虽然是引用类型，但是 .NET 却对它特别处理，这种处理叫做字符串恒定性（ immutable），使得 string 的值具有只读特性。

Examples：

using System;

public class Order

{

public Order()

{

Guid guid = Guid.NewGuid();

ID = guid.ToString("D");

}

// 对于每一份订单，其订单序号都是实时确定的常量。

public readonly string ID;

public override string ToString()

{

58

return "Order ID: " + ID;

}

}

Explaintion：

· 如果结合数据库使用， ID field 通常都会都会与某个表的主健（ primary key）关联起来，如 Orders 表的 OrderID。

· 数据库的主健通常采用以下三种方式：

o 自动递增值。你可以通过把 DataColumn.AutoIncrement 设定为 true 值来激活自动递增特性。

o 唯一名称。这个是使用自己定义的算法来生成一个唯一序列号。

o GUID（全局唯一标识符）。你可以通过 System.Guid 结构来生成 GUID，如上例。

using System;

class Customer

{

public Customer(string name, int kind)

{

m_Name = name;

m_Kind = kind;

}

public const int NORMAL = 0;

public const int VIP = 1;

public const int SUPER_VIP = 2;

private string m_Name;

public string Name

{

get { return m_Name; }

}

private readonly int m_Kind;

public int Kind

{

get { return m_Kind; }

}

public override string ToString()

{

if(m_Kind == SUPER_VIP)

return "Name: " + m_Name + "[SuperVip]";

else if(m_Kind == VIP)

return "Name: " + m_Name + "[Vip]";

else

return "Name: " + m_Name + "[Normal]";

}

}

Remarks:

·一般情况下，如果你需要声明的常量是普遍公认的并作为单个使用，例如圆周率，黄金分割比例等。你可以考虑使用 const 常量，如：public const double

PI = 3.1415926;。如果你需要声明常量，不过这个常量会随着实际的运行情况而决定，那么， readonly 常量将会是一个不错的选择，例如上面第一个例子的

订单号 Order.ID。

另如而那更（

· 外，果要表示对象内部的默认值的话，这类值通常是常量性质的，么也可以考虑 const。多时候我们对源代码进行重构时使用 Replace Magic Number

with Symbolic Constant），要去除魔数（ Magic Number）的影响都会借助于 const 的这种特性。

·对于 readonly 和 const 所修饰的变量究竟是属于类级别的还是实例对象级别的问题，我们先看看如下代码：

59

Using directives#region Using directives

using System;

using System.Collections.Generic;

using System.Text;

#endregion

namespace ConstantLab

{

class Program

{

static void Main(string[] args)

{

Constant c = new Constant(3);

Console.WriteLine("ConstInt = " + Constant.ConstInt.ToString());

Console.WriteLine("ReadonlyInt = " + c.ReadonlyInt.ToString());

Console.WriteLine("InstantReadonlyInt = " + c.Ins tantReadonlyInt.ToString());

Console.WriteLine("StaticReadonlyInt = " + Constant.StaticReadonlyInt.ToString());

Console.WriteLine("Press any key to continue");

Console.ReadLine();

}

}

class Constant

{

public Constant(int instantReadonlyInt)

{

InstantReadonlyInt = instantReadonlyInt;

}

public const int ConstInt = 0;

public readonly int ReadonlyInt = 1;

public readonly int InstantReadonlyIn t;

public static readonly int StaticReadonlyInt = 4;

}

}

· 发

使用 Visual C#在 Main()里面使用 IntelliSence 插入 Constant 的相关 field 的时候，现 ReadonlyInt 和 InstantReadonlyInt 需要指定 Constant

的实例对象；而 ConstInt 和 StaticReadonlyInt 却要指定 Constant class（参见上面代码）。可见，用 const 或者 static readonly 修饰的常量是属于类级

别的；而 readonly 修饰的，无论是直接通过赋值来初始化或者在实例构造函数里初始化，都属于实例对象级别。

· 一般情况下，如果你需要表达一组相关的编译时确定常量，你可以考虑使用枚举类型（ enum），而不是把多个 const 常量直接嵌入到 class 中作

为 field，不过这两种方式没有绝对的孰优孰劣之分。

using System;

enum CustomerKind

{

SuperVip,

60

Vip,

Normal

}

class Customer

{

public Customer(string name, CustomerKind kind)

{

m_Name = name;

m_Kind = kind;

}

private string m_Name;

public string Name

{

get { return m_Name; }

}

private CustomerKind m_Kind;

public CustomerKind Kind

{

get { return m_Kind; }

}

public override string ToString()

{

return "Name: " + m_Name + "[" + m_Kind.ToString() + "]";

}

}

然当并你使

· 而，这种结合使用枚举和条件判断的代码阻碍了你进行更灵活的扩展，有可能导致日后的维护成本增加，可以代之以多态，用 Replace Conditional

with Polymorphism 来对代码进行重构。

Comments：

·readonly field 准确来说应该翻译成为 “ 只读域 ” ，这里是为了统一翻译用语才将它和 const 两者所修饰的量都说成 “ 常量 ” ，希望没有引起误会。

59. System.String 和 System.StringBuilder 有什么区别？

String 对象是不可改变的。每次使用 System.String 类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的

空间。在需要对字符串执行重复修改的情况下，与创建新的 String 对象相关的系统开销可能会非常昂贵。如果要修改字符串而不创建新的对象，则可

以使用 System.Text.StringBuilder 类。例如，当在一个循环中将许多字符串连接在一起时，使用 StringBuilder 类可以提升性能。

StringBuilder 类并没有 String 类的功能强大，只提供基本的替换和添加和删除字符串中的文本，但它的工作效率非常高，当定义 StringBuilder 对象时可

以指定内存的内存容量，如果不指定系统就会根据对象初始化时的字符串长度来确定。它有两个主要参数 Length 和 Capacity 分别表示字符串的实际长度和字

符串占据的内存空间长度。对字符串的修改就是在这个内存中进行的，大大提高了添加和替换的的效率。

如定义：

StringBuilder sb=new StringBuilder("Hello,Welcome",100);// 初始化对象并设置初始容量为 100

sb.Append(" to www.csdn.net");

sb.Replace(old,new);//将 old 替换为 new,作用与 String.Replace()一样只是不需要在过程中复制字符。

StringBuilder 的成员：

StringBuilder sb=new StringBuilder(" www.csdn.net");//定义初值为 www.csdn.net 的对象。

StringBuilder sb=new StringBuilder(20);初始化容量为 20 的空对象。

61

另外 StringBuilder 还有 MaxCapacity 属性用来限定对象可以使用的最大容量。默认大约是 int.MaxValue（ 20 亿）

可以在使用过程中定义 sb.MaxCapacity=value;

sb.Append(),给当前字符串追加字符串。

sb.AppendFormat()— — 添加特定格式的字符串

sb.Insert()— — 插入一个子字符串

sb.Remove()— — 从当前字符串删除字符

sb.Replace()— — 替换字符串中指定的字符

sb.ToString()— — 将 sb 转化为 String 对象

60. string

字符串驻留池 (String Pooling)：公共语言运行库通过维护一个哈希表来存放字符串，该表称为字符串驻留池。它包含程序中以编程方式声明或

创建的每个唯一的字符串的一个引用。因此，具有特定值的字符串的实例在系统中只有一个。 [应该是应用了单例模式的应用。单例可以参考：老生常谈 :

单件模式 ],这里非常谢谢飞林沙的提示 ,应该是享元模式，同样可以参考如下文章：老生常谈：享元模式

字符串驻留：根据字符串驻留池的定义可以看出字符串驻留技术的用处。主要目的是减少内存开销和系统开销，充分利用资源。提供了两个重要的方

法：

1:String.Intern :检索系统对指定 String 的引用。如果 str 的值已经留用，则返回系统的引用；否则返回对带有 str 值的字符串的新引用。

2:String.IsInterned 方法 :检索对指定 String 的引用。如果 str 位于公共语言运行库 “ 拘留池 ” 中，则为对它的 String 引用；否则为

nullNothingnullptrnull 引用

字符串的不可更改特性：当一个字符串创建后，我们就不能对它进行增加长，或者是缩减，也不能修改其中的任何字符。但有朋友可以会问，那为

什么能对字符串进行那么多的操作呢？例如："+"操作符，Substring 等等。其实这些操作都会产生一个全新的字符串，而不是在原来字符串在修改。只要是把

操作后的数据赋值给一个新的字符串变量，那么就是产生一个和原字符串完全不同的对象。先看下赋值的情况：把一个变量直接赋值给一个新的字符串变量，

根据上面的理论来看，下面应该会返回 false,但实际结果返回的是 true,因为在字符串驻留的存在。

string b = "aaa";

string c = b;

Console.WriteLine(Object.ReferenceEquals(b, c));

但是这并不代表 b 和 c 是一样的，我们再看下如下代码：分别分返回 aaa,aaaa,false，既然 string 属于引用类型，但为什么修改 c 的值后， b 的值没有

跟着变呢，这只因为把字符串赋值给另一个字符串时，会创建一个全新的 String 对象。

string b = "aaa";

string c = b;

c = b + "a";

Console.WriteLine(b);

Console.WriteLine(c);

Console.WriteLine(Object.ReferenceEquals(b, c));

字符串中的"+"操作符：通常我们会对字符串进行修改，例如 "+"号，表示连接多个字符串。但加号会产生非常多的字符串，这样会造成非常多的内存

开销和系统开销，这里可以利用 StringBuilder 来解决多字符串连接的性能问题。来看下下面的示例代码：

string b = "aaa";

b = b + "a";

StringBuilder strb = new StringBuilder();

strb.Append("aaa");

strb.Append("a");

IL 代码：由于 ConCat 操作后会生成全新的对象，而 StringBuild 是在原对象上修改变量，并不会生成新对象，这样就会产生性能优势。上面的代码只是

示范，一般在大量字符串拼接时这种性能问题会倍增。

安全字符串：如果字符串中存放了此比较敏感的信息，例如用户的密码，信用卡信息之类的，如果此时有非安全代码或者是非托管代码访问这些字符串，这些

代码可以扫描进程的地址空间，访问包含敏感数据的字符串，以一种非授权的方式来使用这些数据。即使只使用这些字符串时间很短，马上回进行垃圾回收，

也是需要一定时间的，而且 string 本身无法修改的特性，使这些非安全的或者是非托管代码在访问时会留 string 的副本在内存中。

FCL 解决了这个问题，它就是 System.Security.SecureString：表示应保密的文本。文本在使用时出于保密目的被加密，并在不再需要时从计算机内存中

62

删除。无法继承此类。当你构造一个 SecureString 对象时，系统会在内存中分配一个非托管区域，里面包含一个字符数组，里面的内容均是经常加密的。之

所以是非托管空间，就是为了不让垃圾回收器来管理。

System.Security.SecureString 实现了 IDisposable 接口，这样可以保证在使用完后立即对字符串进行销毁。

61. 如何把一个 array 复制到 arrayList 里

foreach( object o in array )arrayList.Add(o);

62. 概述反射和序列化

反射 :程序集包含模块，而模块包含类型，类型又包含成员 .反射则提供了封装程序集、模块和类型的对象 .您可以使用反射动态地创建类型的实例，将类型绑

定到现有对象，或从现有对象中获取类型 .然后，可以调用类型的方法或访问其字段和属性

序列化 :序列化是将对象转换为容易传输的格式的过程 .例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象 .在另

一端，反序列化将从该流重新构造对象.

63. 用 sealed 修饰的类有什么特点

sealed 修饰符用于防止从所修饰的类派生出其它类 .如果一个密封类被指定为其他类的基类，则会发生编译时错误 .

密封类不能同时为抽象类.

sealed 修饰符主要用于防止非有意的派生，但是它还能促使某些运行时优化 .具体说来，由于密封类永远不会有任何派生类，所以对密封类的实例的虚拟函数

成员的调用可以转换为非虚拟调用来处理.

64. 程序设计: 猫大叫一声，所有的老鼠都开始逃跑，主人被惊醒.(C#语言)

要求： 1.要有联动性，老鼠和主人的行为是被动的 .

2.考虑可扩展性，猫的叫声可能引起其他联动效应 .

要点： 1. 联动效果，运行代码只要执行 Cat.Cryed()方法 .2. 对老鼠和主人进行抽象

评分标准 : .构造出 Cat、 Mouse、 Master 三个类，并能使程序运行 (2 分 )

从 Mouse 和 Master 中提取抽象（ 5 分）

联动效应，只要执行 Cat.Cryed()就可以使老鼠逃跑，主人惊醒 .(3 分 )

public interface Observer

{

void Response(); //观察者的响应，如是老鼠见到猫的反映

}

public interface Subject

{

void AimAt(Observer obs); // 针对哪些观察者，这里指猫的要扑捉的对象 ---老鼠

}

public class Mouse : Observer

{

private string name;

public Mouse(string name, Subject subj)

{

this.name = name;

subj.AimAt(this);

}

public void Response()

{

Console.WriteLine(name + " attempt to escape!");

}

}

63

public class Master : Observer

{

public Master(Subject subj)

{

subj.AimAt(this);

}

public void Response()

{

Console.WriteLine("Host waken!");

}

}

public class Cat : Subject

{

private ArrayList observers;

public Cat()

{

this.observers = new ArrayList();

}

public void AimAt(Observer obs)

{

this.observers.Add(obs);

}

public void Cry()

{

Console.WriteLine("Cat cryed!");

foreach (Observer obs in this.observers)

{

obs.Response();

}

}

}

class MainClass

{

static void Main(string[] args)

{

Cat cat = new Cat();

Mouse mouse1 = new Mouse("mouse1", cat);

Mouse mouse2 = new Mouse("mouse2", cat);

Master master = new Master(cat);

cat.Cry();

}

}

//---------------------------------------------------------------------------------------------

设计方法二 : 使用 event -- delegate 设计 ..

public delegate void SubEventHandler();

public abstract class Subject

64

{

public event SubEventHandler SubEvent;

protected void FireAway()

{

if (this.SubEvent != null)

this.SubEvent();

}

}

public class Cat : Subject

{

public void Cry()

{

Console.WriteLine("cat cryed.");

this.FireAway();

}

}

public abstract class Observer

{

public Observer(Subject sub)

{

sub.SubEvent += new SubEventHandler(Response);

}

public abstract void Response();

}

public class Mouse : Observer

{

private string name;

public Mouse(string name, Subject sub) : base(sub)

{

this.name = name;

}

public override void Response()

{

Console.WriteLine(name + " attempt to escape!");

}

}

public class Master : Observer

{

public Master(Subject sub) : base(sub){}

public override void Response()

{

Console.WriteLine("host waken");

}

}

class Class1

{

static void Main(string[] args)

{

Cat cat = new Cat();

65

Mouse mouse1 = new Mouse("mouse1", cat);

Mouse mouse2 = new Mouse("mouse2", cat);

Master master = new Master(cat);

cat.Cry();

}

}

65. C#中 property 与 attribute 的区别，他们各有什么用处，这种机制的好处在哪里？

66. C#中要使一个类支持 FOREACH 遍历，实现过程怎样？

在 C#中，凡是实现了 IEnumerator 接口的数据类型都可以用 foreach 语句进行迭代访问，可是，对于自定义类型如何实现这个接口以支持 foreach 的迭代呢？

要实现这个功能，先来看看 IEnumerable 和 IEnumerator 接口的定义：

public interface IEnumerable

{

//IEnumerable 只有一个方法，返回可循环访问集合的枚举数。

IEnumerator GetEnumerator() ;

}

public interface IEnumerator

{

// 方法

//移到集合的下一个元素。如果成功则返回为 true；如果超过集合结尾，则返回 false。

bool MoveNext();

// 将集合设置为初始位置，该位置位于集合中第一个元素之前

void Reset();

// 属性：获取集合中的当前元素

object Current { get; }

}

如果我们的自定义数据类型派生于这两个接口，并实现接口中的方法，即可用 foreach 进行迭代。

下面是一个实现的简单例子：

using System;

using System.Collections ;

using System.Collections.Generic;

using System.Text;

namespace IEnumberableTest

{

class Program

{

static void Main(string[] args)

{

myEnum enum1 = new myEnum(20);

foreach ( point p in enum1)

{

Console.WriteLine("("+p.x .ToString ()+","+p.y.ToString ()+","+p.z.ToString ()+")");

}

Console.Read();

66

}

}

//一个结构体，用于类 myEnum

struct point

{

public int x;

public int y;

public int z;

}

//我们的一个派生于 IEnumerable 和 IEnumerator 接口的自定义类

class myEnum :IEnumerable,IEnumerator

{

//定义索引

private int index;

//定义一个 point 结构的数组

private point[] points;

//类的构造函数，用于初始化 point 结构数组

public myEnum(int numofpoint)

{

this.index = -1;

points = new point[numofpoint];

for (int i = 0; i = points.Length ? false : true;

}

}

}

67. 大概描述一下 ASP.NET 服务器控件的生命周期

ASP.NET 服务器控件生命周期所要经历的 11 个阶段。

(1)初始化 :在此阶段中，主要完成两项工作：一、初始化在传入 Web 请求生命周期内所需的设置 ;二、跟踪视图状态。首先，页面框架通过默认方式引发 Init

事件，并调用 OnInit()方法，控件开发人员可以重写该方法为控件提供初始化逻辑。此后，页面框架将调用 TrackViewState 方法来跟踪视图状态。需要注意

的是：多数情况下， Control 基类提供的 TrackViewState 方法实现已经足够了。只有在控件定义了复杂属性时，开发人员才可能需要重写 TrackViewState 方

法。

(2)加载视图状态 :此阶段的主要任务是检查 ASP.NET 服务器控件是否存在以及是否需要将其状态恢复到它在处理之前的请求结束的状态。因此该过程发生在页

面回传过程中，而不是初始化请求过程。在此阶段，页面框架将自动恢复 ViewState 字典。如果服务器控件不维持其状态，或者它有能力通过默认方式保存其

所有状态而使用 ViewState 字典，那么开发人员则不必实现任何逻辑。针对那些无法在 ViewState 字典中存储的数据类型或者需要自定义状态管理的情况，开

发人员可以通过重写 LoadViewState 方法来自定义状态的恢复和管理。

(3)处理回发数据 :若要使控件能够检查客户端发回的窗体数据，那么必须实现 System.Web.UI.IPostBackDataHandler 接口的 LoadPostData()方法。因此只

有处理回发数据的控件参与此阶段。

控状此开

(4)加载 :至此阶段开始，件树中的 ASP.NET 服务器控件已创建并初始化、态已还原并且窗体控件反映了客户端的数据。时，发人员可以通过重写 OnLoad()

方法来实现每个请求共同的逻辑。

(5)发送回发更改通知 :在此阶段， ASP.NET 服务器控件通过引发事件作为一种信号，表明由于回发而发生的控件状态变化 (因此该阶段仅用于回发过程 )。为了

建立这种信号，开发人员必须再次使用 System.Web.UI.IPostBackDataHandler 接口，并实现另一方法 - RaisePostBackChangedEvent()。其判断过程为：如果

则页

控件状态因回发而更改， LoadPostData()返回 true;否则返回 false。面框架跟踪所有返回 true 的控件并在这些控件上调用 RaisePostDataChangedEvent()。

(6)处理回发事件 :该阶段处理引起回发的客户端事件。为了便于将客户端事件映射到服务器端事件上进行处理，开发人员在此阶段可以通过实现

System.Web.UI.IPostBackEventHandler 接口的 RaisePostBackEvent()方法来实现该逻辑。由此途径，服务器控件将成功捕获回发的客户端事件进行服务器端

的相应处理。

(7)预呈现 :该阶段完成在生成控件之前所需要的任何工作。通常情况下是通过重写 OnPreRender()方法完成该工作。需要注意的是：在该阶段，可以保存在预

呈现阶段对控件状态所做的更改，而在呈现阶段进行的更改则会丢失。

(8)保存状态 :如果 ASP.NET 服务器控件不维持状态，或者它有能力通过默认方式保存其所有状态而使用 ViewState 字典，那么开发人员不必在该阶段实现任何

逻辑。因为这个保存状态的过程是自动的。如果 ASP.NET 服务器控件需要自定义状态保存，或者控件无法在 ViewState 字典中存储特殊的数据类型，则需要通

过重写 SaveViewState()方法来实现状态保存。

(9)呈现 :表示向 HTTP 输出流中写入标记文本的过程。开发人员通过重写 Render()方法使其在输出流上自定义标记文本。

(10)处置 :在此阶段中，通过重写 Dispose ()方法完成释放对昂贵资源的引用，如数据库链接等。

(11)卸载 :完成的工作与 "处置 "阶段相同，但是，开发人员通常在 Dispose()方法中执行清除，而不处理 Unload 事件。

68. 类划分的依据.类粒度问题

69. 数据库存储过程和函数的区别

存储过程:

存储过程可以使得对数据库的管理、以及显示关于数据库及其用户信息的工作容易得多。存储过程是 SQL 语句和可选控制流语句的预编译集合，以一个名称

存储并作为一个单元处理。存储过程存储在数据库内，可由应用程序通过一个调用执行，而且允许用户声明变量、有条件执行以及其它强大的编程功能。

68

存储过程可包含程序流、逻辑以及对数据库的查询。它们可以接受参数、输出参数、返回单个或多个结果集以及返回值。

可以出于任何使用 SQL 语句的目的来使用存储过程，它具有以下优点：

1、可以在单个存储过程中执行一系列 SQL 语句。

2、可以从自己的存储过程内引用其它存储过程，这可以简化一系列复杂语句。

3、存储过程在创建时即在服务器上进行编译，所以执行起来比单个 SQL 语句快。

用户定义函数：

Microsoft SQL Server 2000 允许创建用户定义函数。与任何函数一样，用户定义函数是可返回值的例程。根据所返回值的类型，每个用户定义函数可分成以

下三个类别：

1、返回可更新数据表的函数

如果用户定义函数包含单个 Select 语句且该语句可更新，则该函数返回的表格格式结果也可以更新。

2、返回不可更新数据表的函数

如果用户定义函数包含不止一个 Select 语句，或包含一个不可更新的 Select 语句，则该函数返回的表格格式结果也不可更新。

3、返回标量值的函数

用户定义函数可以返回标量值。

存储过程

功能强大，限制少

不能直接引用返回值

用 select 语句返回记录集

自定义函数

诸多限制，有许多语句不能使用，许多功能不能实现

可以直接引用返回值

用表变量返回记录集

70. 数据库事务是什么？

事务是作为单个逻辑工作单元执行的一系列操作。一个逻辑工作单元必须有四个属性，称为原子性、一致性、隔离性和持久性 (ACID) 属性，只有这样才能成

为一个事务。

原子性

事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行。

一致性

事务在完成时，必须使所有的数据都保持一致状态。在相关数据库中，所有规则都必须应用于事务的修改，以保持所有数据的完整性。事务结束时，所有的内

部数据结构（如 B 树索引或双向链表）都必须是正确的。

隔离

由并发事务所做的修改必须与任何其他并发事务所做的修改隔离。事务识别数据时数据所处的状态，要么是另一并发事务修改它之前的状态，要么是第二个事

务修改它之后的状态，事务不会识别中间状态的数据。这称为可串行性，因为它能够重新装载起始数据，并且重播一系列事务，以使数据结束时的状态与原始

事务执行的状态相同。

持久性

事务完成之后，它对于系统的影响是永久性的。该修改即使出现系统故障也将一直保持。

71. Sql Server 数据库事务介绍 Sql 语句，SqlTransaction 和 TransactionScope 的使用方法

Sql 语句事务

Sql Server2005/2008 提供了 begin tran， commit tran 和 rollback tran 三个语句来显示的使用事务。 begin tran 表示事务开始， commit tran 表示事务提

交， rollback tran 表示事务回滚。具体代码如下：

begin try

begin tran

69

insert into dbo.TransTestTable values (66,'66');

update dbo.TransTestTable set [Name] = '77' where [Id] = 66;

--RAISERROR ('Error raised in TRY block.',16,1);

commit tran

end try

begin catch

rollback tran

end catch

代码中的 begin try 和 begin catch 是捕获异常时使用的，只在 sql server2005/2008 中支持， sql server 2000 上不支持这个语句。在 begin try 和

end try 之间的代码运行时如果发生异常，则程序会跳转到 begin catch 和 end catch 中执行相关的 rollback tran 回滚操作。在 begin tran 和 commit tran

之间就是一个事务，否

insert 和 update 必须同时成功，则就同时失败。只

RAISERROR 语句的意思是抛出一个异常，在 sql server2005/2008 中支持，sql server

2000 上不支持这个语句。

执行上面的代码，我们会发现，插入和更新同时都成功了。把 RAISERROR 的注释去掉后，再执行，我们会发现，插入和更新都回滚了。因为 RAISERROR

抛出异常后，没有执行到 commit tran，而是直接执行 begin catch 里面的 rollback tran 回滚语句了

SqlTransaction 使用 :

SqlTransaction 是 System.Data.SqlClient 命名空间下的一个事务类，主要方法有 Commit()和 Rollback()两个函数，更多方法和属性请参考 MSDN。具体代

码如下：

static void Main(string[] args)

{

SqlConnection sqlConn = new SqlConnection(

ConfigurationManager.ConnectionStrings["ConnStr"].ConnectionString);

SqlTransaction sqlTrans = null;

try

{

sqlConn.Open();

sqlTrans = sqlConn.BeginTransaction();// 事务开始

SqlCommand sqlComm = new SqlCommand("", sqlConn, sqlTrans);

sqlComm.CommandTimeout = 120;

sqlComm.CommandType = System.Data.CommandType.Text;

string insertSql = "insert into dbo.TransTestTable values (66,'66');";

string updateSql = "update dbo.TransTestTable set [N ame] = '77' where [Id] = 66;";

sqlComm.CommandText = insertSql;

sqlComm.ExecuteNonQuery();// 执行 insert

sqlComm.CommandText = updateSql;

sqlComm.ExecuteNonQuery();// 执行 update

//throw new Exception("test exception.the transaction must rollback");

sqlTrans.Commit();//事务提交

}

catch (Exception ex)

{

sqlTrans.Rollback();//事务回滚

Console.WriteLine(ex.Message);

}

finally

{

70

if (sqlConn.State != System.Data.ConnectionState.Closed)

sqlConn.Close();

}

Console.ReadLine();

}

上面的代码显示了 SqlTransaction 类的基本使用方法。首先使用 SqlConnection 建立连接后， sqlConn.BeginTransaction() 表示事务的开始，在执行一些基

本操作后（代码是执行一个 insert 和一个 update）后，执行 sqlTrans.Commit();表示事务提交，这时候，刚才 insert 和 update 的数据在数据库才能被使

用。如果把 throw new Exception("test exception.the transaction must rollback"); 这句的注释去掉，我们会发现，程序没有执行提交，而是直接执行

了 catch 中的 Rollback()，进行了回滚。那么刚才的 insert 和 update 一起被回滚。

TransactionScope 用法：

TransactionScope 继承 IDisposable 接口，所以一般在 using 中使用。具体代码如下：

static void Main(string[] args)

{

using (TransactionScope scope = new TransactionScope())

{

SqlConnection sqlConn = new SqlConnection(

ConfigurationManager.ConnectionStrings["ConnStr"].ConnectionString);

sqlConn.Open();

string insertSql = "insert into [TransTestTable] values(11,'11')";

string updateSql = "update [TransTestTable] set [Name] = '111' where [Id] = 11";

SqlCommand sqlComm = new SqlCommand(insertSql, sqlConn);

sqlComm.CommandType = System.Data.CommandType.Text;

sqlComm.ExecuteNonQuery();

sqlComm = new SqlCommand(updateSql, sqlConn);

sqlComm.CommandType = System.Data.CommandType.Text;

sqlComm.ExecuteNonQuery();

sqlConn.Close();

scope.Complete();

}

Console.ReadLine();

}

在 using 中定义了一个 TransactionScope，相当于定义了一个事务范围即这个事务作用域为 using 内。程序执行了两个动作，一个 insert，一个 update，最

后执行了 scope.Complete();相当于提交事务。如果把 scope.Complete();注释掉，我们会发现 insert 和 update 都被回滚了，因为在 using 作用域内，如果

没有提交命令，那么 scope 在销毁时，会自动回滚所有的操作。

72. 数据库游标的作用？如何知道游标已经到了最后？

73. 数据库触发器分为事前触发和事后触发，这两种触发有和区别.语句级触发和行级触发有何区

别.

触发器种类

71

触发器的种类可划分为 4 种： 1.数据操纵语言 (DML)触发器、 2.替代 (INSTEAD OF)触发器、 3.数据定义语言 (DDL)触发器、 4.数据库事件触发器。

数据操纵语言 (DML)触发器：简称 DML 触发器，是定义在表上的触发器，创建在表上。由 DML 事件引发的触发器，编写 DML 触发器时的两点要素是： 1.确定触

发的表，即在其上定义触发器的表。2.确定触发的事件，DML 触发器的触发事件有 INSERT、UPDATE 和 DELETE 三种 ;替代触发器，简称 INSTEADOF 触发器，创建

在视图上，用来替换对视图进行的删除、插入和修改操作 ; 数据定义语言 (DDL)触发器，简称 DDL 触发器，定义在模式上，触发事件是数据对象的创建和修改 ;

数据库事件触发器，定义在整个数据库或模式上，触发事件是数据库事件 .

ORACLE 产生数据库触发器的语法为：

CREATE [OR REPLACE] TRIGGER 触发器名

{BEFORE|AFTER|INSTEAD OF} 触发事件 1 [OR 触发事件 2...]

ON 表名

WHEN 触发条件

[FOR EACH ROW]

DECLARE

声明部分

BEGIN

主体部分

END;

其中：

触发器名：触发器对象的名称。由于触发器是数据库自动执行的，因此该名称只是一个名称，没有实质的用途。一个触发器可由多个不同的数据操纵语言操作

触发。在触发器中，可用 INSERTING、 DELETING、 UPDATING 谓词来区别不同的数据操纵语言操作。这些谓词可以在 IF 分支条件语句中作为判断条件来使用。

触发时间：指明触发器何时执行，该值可取 , 触发的时间有 BEFORE 和 AFTER 两种，分别表示触发动作发生在 DML 语句执行之前和语句执行之后。确定触发级

别，有语句级触发器和行级触发器两种。语句级触发器表示 SQL 语句只触发一次触发器，行级触发器表示 SQL 语句影响的每一行都要触发一次。

Before：表示在数据库动作之前触发器执行 ;在 SQL 语句的执行过程中，如果存在行级 BEFORE 触发器，则 SQL 语句在对每一行操作之前，都要先执行一次行级

BEFORE 触发器，然后才对行进行操作。如果存在行级 AFTER 触发器，则 SQL 语句在对每一行操作之后，都要再执行一次行级 AFTER 触发器。

after：表示在数据库动作之后出发器执行。如果存在语句级 AFTER 触发器，则在 SQL 语句执行完毕后，要最后执行一次语句级 AFTER 触发器。

触发事件：指明哪些数据库动作会触发此触发器 ,指 INSERT、 DELETE 或 UPDATE 事件，事件可以并行出现，中间用 OR 连接 ;

insert：数据库插入会触发此触发器 ;

update：数据库修改会触发此触发器 ;

delete：数据库删除会触发此触发器。

表名：数据库触发器所在的表。

for each row：表示触发器为行级触发器，省略则为语句级触发器 ,对表的每一行触发器执行一次。

触发器的创建者或具有 DROP ANY TIRGGER 系统权限的人才能删除触发器。删除触发器的语法如下：

DROP TIRGGER 触发器名

可以通过命令设置触发器的可用状态，使其暂时关闭或重新打开，即当触发器暂时不用时，可以将其置成无效状态，在使用时重新打开。该命令语法如下：

ALTER TRIGGER 触发器名 {DISABLE|ENABLE}

其中， DISABLE 表示使触发器失效， ENABLE 表示使触发器生效。

同存储过程类似，触发器可以用 SHOW ERRORS 检查编译错误。

如果有多个触发器被定义成为相同时间、相同事件触发，且最后定义的触发器是有效的，则最后定义的触发器被触发，其他触发器不执行。触发器体内禁止使

用 COMMIT、ROLLBACK、SAVEPOINT 语句，也禁止直接或间接地调用含有上述语句的存储过程。定义一个触发器时要考虑上述多种情况，并根据具体的需要来决

定触发器的种类。

触发器的作用

触发器的主要作用就是其能够实现由主键和外键所不能保证的复杂的参照完整性和数据的一致性。除此之外，触发器还有其它许多不同的功能：

(1) 强化约束 (Enforce restriction)

触发器能够实现比 CHECK 语句更为复杂的约束。

(2) 跟踪变化 Auditing changes

触发器可以侦测数据库内的操作，从而不允许数据库中未经许可的指定更新和变化。

(3) 级联运行 (Cascaded operation)。

触发器可以侦测数据库内的操作，并自动地级联影响整个数据库的各项内容。例如，某个表上的触发器中包含有对另外一个表的数据操作 (如删除，更新，插

入 )而该操作又导致该表上触发器被触发。

(4) 存储过程的调用 (Stored procedure invocation) 。

72

为了响应数据库更新触，发器可以调用一个或多个存储过程，甚至可以通过外部过程的调用而在 DBMS( 数据库管理系统 )本身之外进行操作。

由此可见，触发器可以解决高级形式的业务规则或复杂行为限制以及实现定制记录等一些方面的问题。例如，触发器能够找出某一表在数据修改前后状态发生

的差异，并根据这种差异执行一定的处理。此外一个表的同一类型 (INSERT、 UPDATE、 DELETE)的多个触发器能够对同一种数据操作采取多种不同的处理。

总体而言，触发器性能通常比较低。

系因而

当运行触发器时，统处理的大部分时间花费在参照其它表的这一处理上，为这些表既不在内存中也不在数据库设备上，删除表和插入表总是位于内存中。

可见触发器所参照的其它表的位置决定了操作要花费的时间长短

数据库触发器有以下两种：

（ 1）语句级触发器 :在 CREATE TRIGGER 语句中不包含 FOR EACH ROW 子句；

（ 2）行级触发器：有 FOR EACH ROW 子句。

区别：语句级触发器对于触发事件只能触发一次，而且不能访问受触发器影响的每一行的列值。行级触发器可对受触发器影响的每一行触发。并且能够访问原

列值和通过 SQL 语句处理新列值。

74. 用 C＃实现以下功能

a 产生一个 int 数组，长度为 100，并向其中随机插入 1-100，并且不能重复 .

b 对上面生成的数组排序，需要支持升序、降序两种顺序

75. 请说出强名的含义

签名机制

1. 用 SN.exe 生成一个 key 文件 , 这个 key 文件包括一个 public key 和一个 private key.

2. 用这个 key 文件签名 assembly 时 , 编译器将用 private key 签名程序集 , 并将 public key 嵌入 manifest 中

3. 编译器哈希 manifest 中所有的 assembly 内容 , 并将此哈希值各自 assembly 的 FileDef Talbe 中 .

4. 当如上 3 步处理后 , 编译器将哈希 PE 文件的整个内容 (除 authenticode signature, 强名称数据 , PE 头 ), 然后将此哈希值用 private key 签名 . 得到 RSA

数字签名.

5. 将此数字签名嵌入到 PE 文件的 CLR 头

防修改机制

1. 当签名后的 assembly 安装到 GAC, 系统会哈希 PE 文件 (同签名 ), 得到哈希值

2. 系统读取 PE 文件中 CLR 头中的 RSA 签名 , 并用 public key(包含在 manifest 中 )解密

3. 比较第 1 步得到的哈希值和第 2 步得到解密值是否一致 , 从而判断其是否被修改 .

一个程序集包括四个区分彼此的属性：文件名（不包括扩展） ,版本号 ,文化标识 ,公钥标识

现在让我们来看看一个比较常见的强名称程序集：

Name= MSCorLib

Version=1.0.3300.0

Culture=neutral

PublicKeyToken=b77a5c561934e089

如果我们自己编写一个弱名称程序集，那么通常 PublicKeyToken 这一项就没有。

下面我尝试着说一说强名称的机制。

首先，你通过 SN.exe 获得一个公钥和一个密钥。

然后，使用公钥对程序集的可执行文件（不包括 DOS 头、 PE 头等）进行哈希算法，得到一个文件散列值。

最后，使用密钥对文件散列值进行加密，得到一个密文。

这样，最后的强名称程序集里面要三样东西：公钥标识（公钥的散列值的最后八个字节）, 公钥 , 密文

使用公钥和程序集的可执行文件（不包括 DOS 头、PE 头等）进行哈希算法可以得到一个文件散列值，使用公钥和密文也可以得到一个文件散列值，如果这两个

散列值完全一致， OK，验证通过。

最后，说说公钥标识（公钥的散列值的最后八个字节）的作用：

区分程序集，上面提到过它是程序集区分彼此的四大属性之一

验证公钥

总的来说，强名称机制最起码起到两个作用：

区分程序集

73

避免程序集被恶意更改

76. CLR 特性,PE 文件

MSIL(Microsoft Intermediate Language)微软的中间语言。和 JAVA 的虚拟机类似，是与 CPU 无关的指令集。当编译为托管代码时，编译器将源代码翻译

为 MSIL，

如上图所示。 MSIL 包括用于加载、存储和初始化对象以及对对象调用方法的指令，还包括用于算术和逻辑运算、控制流、直接内存访问、异常处理和其他操

作的指令。在可以执行代码前，必须将 MSIL 转换为 CPU 特定的代码，这通常是通过实时 (JIT) 编译器完成的。由于公共语言运行库为它支持的每种计算

机结构都提供了一种或多种 JIT 编译器，因此可以在任何受支持的结构上对同一组 MSIL 进行 JIT 编译和执行。这样总结上面的就是：中间语言是一组独

立于 CPU 的指令集，它可以被即时编译器 Jitter 翻译成目标平台的本地代码。

PE

Windows PE 和一个 .NET PE 的主要区别在于 Windows PE 是由操作系统执行的，而 .NET PE 却被转变成为 .NET Framework 的 CLR. 识别一个 PE 是 .NET 还是

Windows 取决于他的通用的目标文件格式 (COFF) 是否使用 Windows 的操作系统 . 目标文件格式 (COFF) 指定了任何文件都分成两个部分：文件数据本身以及

描述文件内包含的数据内容的头文件串。

MSIL 汇编程序从 MSIL 汇编语言生成可移植可执行的 (PE) 文件。可以运行结果可执行文件（该文件包含 MSIL 和所需的元数据）以确定 MSIL 是否按预期

执行。这就是我为什么会谈到 PE。

那么 PE 文件是怎么执行的呢？下面是一个典型的 .NET 应用程序的执行过程：

用户执行编译器输出的应用程序 (PE 文件 )，操作系统载入 PE 文件，以及其他的 DLL(.NET 动态连接库 )。

操作系统装载器根据 PE 文件中的可执行文件头跳转到程序的入口点。显然，操作系统并不能执行中间语言，该入口点也被设计为跳转到 mscoree.dll（ .NET

平台的核心支持 DLL）的 _ CorExeMain()函数入口。

CorExeMain()函数开始执行 PE 文件中的中间语言代码。这里的执行的意思是 CRL（通用语言运行时）按照调用的对象方法为单位，用 JIT(即时编译器 )将中间

语言编译成本地机二进制代码，执行并根据需要存于机器缓存。

程序的执行过程中， GC(垃圾收集器 )负责内存的分配，释放等管理功能。

程序执行完毕，操作系统卸载应用程序。

CLR 的特性：

1．跨语言应用

当编程人员在用自己喜欢的编程语言写源代码的时候 , 这个源代码在被转化成媒介语言（ IL）之前，先被编译成了一个独立的可执行单元（ PE）。这样无论

你是一个 VB。 NET 程序员，或一个 C#程序员，甚至是使用托管的 C++的程序员。只要被编译成 IL 就是同等的。

首先，编译输出的 exe 是一个由中间语言（ IL），元数据 (Metadata)和一个额外的被编译器添加的目标平台的标准可执行文件头（比如 Win32 平台就是加了一

个标准 Win32 可执行文件头）组成的 PE（ portable executable，可移植执行体）文件，而不是传统的二进制可执行文件 --虽然他们有着相同的扩展名。中间

它中

语言是一组独立于 CPU 的指令集，可以被即时编译器 Jitter 翻译成目标平台的本地代码。间语言代码使得所有 Microsoft.NET 平台的高级语言 C#,VB.NET，

VC.NET 等得以平台独立，以及语言之间实现互操作。元数据是一个内嵌于 PE 文件的表的集合。

2．安全性

.NET 提供了一组安全方案。负责进行代码的访问安全性检查。允许我们对保护资源和操作的访问。代码需要经过身份确认和出处鉴别后才能得到不同程度的

信任。安全策略是一组可配置的规则，公共语言运行库在决定允许代码执行的操作时遵循此规则。安全策略由管理员设置，并由运行库强制。运行库确保代码

只能访问安全策略允许的资源和调用安全策略允许的代码。

每当发生加载程序集的尝试时，运行库就使用安全策略确定授予程序集的权限。在检查了描述程序集标识的信息（称为证据）后，运行库使用安全策略决定代

码的信任程度和由此授予程序集的权限。证据包括但不仅限于代码的出版商、它的站点以及它的区域。安全策略还确定授予应用程序域的权限。

3．版本化和程序

由于使用了元数据，所以你可以使用 XCOPY 简单的复制

77. 通过超链接怎样传递中文参数？

Server.UrlEncode();

Server.UrlDecode();

74

78. 请编程遍历页面上所有 TextBox 控件并给它赋值为 string.Empty？

79. 请编程实现一个冒泡排序算法？

80. 一个长度为 10000 的字符串，通过随机从 a-z 中抽取 10000 个字符组成.请用 c＃语言编写主

要程序来实现.

81. 对于这样的一个枚举类型：

enum Color:byte{

Red,

Green,

Blue,

Orange

}

string[] ss=Enum.GetNames(typeof(Color));

byte[] bb=Enum.GetValues(typeof(Color));

试写一段程序显示出枚举类型中定义的所有符号名称以及它们对应的数值.

82. 您了解设计模式么？请列出您所知道的设计模式的名称.

83. 什么是 Application Pool？

应用程序池是将一个或多个应用程序链接到一个或多个工作进程集合的配置 .因为应用程序池中的应用程序与其他应用程序被工作进程边界分隔 .所以某个应

用程序池中的应用程序不会受到其他应用程序池中应用程序所产生的问题的影响 .例如不同的权限设置。

84. SQL Server 的两种索引是何形式？索引的作用？索引的优缺点？

聚集索引：表中存储的数据按照索引的顺序存储，检索效率比普通索引高，但对数据新增 /修改 /删除的影响比较大。

非聚集索引：不影响表中的数据存储顺序，检索效率比聚集索引低，对数据新增 /修改 /删除的影响很小。

一张表只有一个聚唨簇索引，可有多个非聚簇索引

85. 微软推出了一系列的 Application Block，请举出您所知道的 Application Block 并说明其作

用？

缓存应用程序块。开发人员可以使用这个应用程序块向应用程序中加入本地缓存。

密码应用程序块。开发人员可以使用这个应用程序块向应用程序中加入哈希和对称加密。

数据访问应用程序块。开发人员可以使用这个应用程序块向应用程序中加入标准数据库功能。

异常处理应用程序块。开发人员和决策者可以使用这个应用程序块创建一个处理发生穿过企业应用架构层异常的固定策略。

日志应用程序块。开发人员可以使用这个应用程序块在应用程序中包含标准的日志功能。

安全应用程序块。开发人员可以使用这个应用程序块向应用程序中加入授权和安全缓存功能。

验证应用程序块。开发人员可以用这个应用程序块为业务对象创建验证规则，这些规则跨越应用程序不同层。

策略注入应用程序块。开发人员可以使用这个应用程序块实现拦截策略，这用于使普通特征的实现更简单而有效，例如跨越一个应用的日志、缓存、异常

处理和验证。

Enterprise Library 还包括一个核心功能集，包括配置、度量、对象构建服务。这些功能被所有应用程序块所使用。

86. 请列举一些您用到过的设计模式以及在什么情况下使用该模式？

87. Please describe the different between XML,XSD,XSL through their definition.

xml， xsl， xslt， xsd， uddi， wsdl， soap 辨析

xml 所用的标签可以为用户自定义标签，主要存储数据信息和内容

以下都应用在 xml 中：

xsl 是可扩展样式语言，是对 xml 的内容进行逻辑控制，其版本标准一般是在 1999 年之前定义的

xslt 为可扩展样式表语言转换，是 xsl 的一部分， xsl 的功能主要有两个，一个是 xml 标签转换，主要体现在从一种 xml 形式转换到另一种 xml 形式；还有一

75

个就是对 xml 进行格式化，即用样式进行润色，渲染； xslt 的作用主要就是前一种，故现在提到 xsl 时就狭义上指 xslt

xsd 是 xml 的一种模式，主要用来规范注册该 xsd 引用的 xml 文档信息，比如数据类型的字节大小等；

命名空间（引用）：

对命名空间进行命名

（

当您在编程语言例如，中有

C++）定义命名空间时，一些对可用在该名称中的字符的限制。XML 命名空间标识符还必须符合特定的语法 — 统一资源标识符 (URI)

引用的语法。这表示 XML 命名空间标识符必须遵守由 RFC 2396 定义的 URI 的常用语法。

URI 被定义为用来标识抽象或物理资源的紧凑字符串。在大多数情况下， URI 引用用来标识物理资源（网页、要下载的文件等），但是，对于 XML 命名空间

来说， URI 引用用于标识抽象资源（特别是命名空间）。

按照 URI 规范，有两种常规类型的 URI：统一资源定位器 (URL) 和统一资源名称 (URN)。这两种类型的 URI 都可以用作命名空间标识符。下面是一个可用

作命名空间标识符的两个 URL 的示例：

http://www.develop.com/student http://www.ed.g ov/elementary/students 下面是几个也可用作命名空间标识符的 URN 的示例：

urn:www-develop-com:student urn:www.ed.gov:elementary.students urn:uuid:E7F73B13 -05FE-44ec-81CE-F898C4A6CDB4 命名空间标识符最重要的属性是

它的唯一性。作者可以通过向 Internet 命名机构注册域名来保证 URL 的唯一性，然后要负责确保域名后面使用的所有字符串都保持唯一。

URN 以同样的方式工作。下面是基本的 URN 语法：

urn:: 为了保证 URN 的一致性，作者必须再次向 Internet 命名机构注册他们的命名空间标识符。然

后，作者负责按照某个方案来生成特定于命名空间的唯一字符串。

例

定义 XML 命名空间的组织应当为新命名空间名称的创建制定一个一致的方案。如，这

W3C 经常定义新的 XML 命名空间。些组织使用一个相当直观的试探法，

该试探法使用当前年份以及工作组的名称。图 2 阐释了由 W3C 使用的模式。

根据定义， URI 是唯一的，因此完全不必在 XML 命名空间标识符的上面放置其他命名空间。只要命名空间作者保证命名空间标识符的唯一性，总是可以只用

单个命名空间限定符来唯一地标识 XML 中的内容。这大大简化了这一在 XML 中处理命名空间的工作。

XML 处理器将命名空间标识符视为不透明的字符串，而从不将它们视为可解析的资源。重申一遍：命名空间标识符仅仅是字符串！当两个命名空间标识符中的

各个字符都完全相同时，它们就被视为相同。

最后，它确实与选择使用哪个类型的 URI 引用无关。许多开发人员因 URL 更易于读取和记忆而喜欢使用它们，而其他开发人员因 URN 的灵活性而喜欢使用

它们。无论选择哪种类型，您都要确保知道如何保证唯一性。

定义命名空间

“ Namespaces in XML Recommendation” 没有提供用来定义 XML 命名空间中有何内容的语法。在许多情况下，这种类型的语法定义甚至不是必需的。目前，

大多数 XML 命名空间都是在正式规范文档中定义的，这些文档描述元素的名称，以及属性及其语义。这恰好说明了如何正式定义所有的 W3C 命名空间（请参

阅 http://www.w3.org/TR/xslt 上的 XSLT 1.0 规范，以查看相关示例）。

在定义了某个命名空间之后，软件开发人员按照规范中所概述的那样实现该命名空间。例如， MSXML 3.0、 Xalan 和 Saxon 都是对 XSLT 1.0 规范的实现。对

这些实现进行硬编码，以便查找那些属于 XSLT 1.0 命名空间 (http://www.w3.org/1999/XSL/Transform) 的元素。要使用这些实现，您需要向它们提供一个

正确使用 XSLT 1.0 命名空间中名称的 XML 文档（下一节将介绍这方面的详细信息）。如果要更改 XSLT 1.0 命名空间中的任何内容，支持软件将必须进行

更新。

XML 架构工作组 (http://www.w3.org/XML/Schema) 已经合并了一个新规范（ XML 架构），该规范为在命名空间中定义元素、属性和类型定义了一个基于 XML

的语法。 XML 架构最终使得提供命名空间的语法定义成为可能，如下所示。

76

本例定义的 http://www.develop.com/student 命名空间包含五个命名元素： student、 id、

name、 language 和 rating。此架构不仅提供命名空间，而且还提供其他元数据，例如， student 子元素的顺序以及它们的类型。

在有了语法命名空间定义（例如，那些由 XML 架构提供的定义）时，就可以构建更高级的软件，以便在运行时利用名称和类型信息。 XML 架构仍然未定义所

定义元素和属性的语义，因此仍将需要一个随附的规范。将来，大多数 XML 命名空间都将通过规范和架构定义同时定义。

使用命名空间

我将命名空间的使用过程定义为：使用 XML 文档中给定命名空间中的一个或多个元素或属性。这要求您了解如下由 “ Namespaces in XML Recommendation ”

概述的语法：用命名空间标识符限定元素名称和属性名称。

元素和属性的名称实际上都由两部分组成：一个命名空间名称和一个本地名称。这样的两部分名称就是所谓的限定名或 QName。

在 XML 文档中，我们使用命名空间前缀来限定元素和属性的本地名称。前缀实际上只是命名空间标识符 (URI) 的缩写，URI 通常相当长。前缀首先通过命名

空间声明映射到命名空间标识符。命名空间声明的语法是：

xmlns:='' 命名空间声明看起来就像（元素的）属性，但是从文档的逻辑结构来看，它们不被正式视为属性（即，在使用 DOM

时，它们将不出现在元素的属性集中）。

命名空间前缀被视为在声明元素以及它的任何子代元素的作用域内。声明的前缀可用在任何元素或属性名称的前面（用冒号分隔，例如， s:student）。这个

包括前缀的完整名称是限定名 (QName) 的词法形式：

QName = : 前缀通过映射到当前位于作用域中的前缀的命名空间标识符与元素或属性关联。

让我们假设某个开发人员希望使用 XSLT 1.0 命名空间。他将需要提供一个命名空间声明，以便将任意前缀映射到正式的 XSLT 1.0 命名空间标识符

然只如

(http://www.w3.org/1999/XSL/Transform) 。后，需在该开发人员希望从 XSLT 1.0 命名空间中使用的每个元素或属性前面加上相应的前缀，下例所示：

上例显示了在命名空间中引用元素的语法。前缀为 “ x” 的每个元素都来自 http://www.w3.org/1999/XSL/Transform 命名

而（

空间，没有前缀的任何元素例如，hello_world）不来自命名空间。理器现在可以区分 XSLT 1.0 编程构造和将要输出的文本元素例如，

都处（ hello_world）。

如果 XSLT 1.0 命名空间中有一个字符拼错了，则 XSLT 1.0 处理器将无法将该文档识别为它能够理解的词汇。

在本质上，每个元素现在都有一个由两部分组成的名称：一个命名空间标识符和一个本地名称。这两个名称组合在一起通常称作命名空间名称（注意：这不同

于 QName， QName 由前缀和本地名称组合而成）。

下面的 XML 文档是另一个示例，它显示了如何从本专栏前面显示的 XML 架构定义使用元素：

3235329 Jeff Smith C#

9.5 请注意，无论命名空间是如何定义的，引用它们的语法都是相同的。

当文档使用多个命名空间中的元素或属性时，通常针对给定的元素进行多个命名空间声明，如下例所示：

3235329 Jeff Smith C#

9.5 在这里，student 和 rating 来自同一个命名空间，而 id 和 language 分别来自不同的命名空间，但是 name 不

属于命名空间。

77

命名空间前缀还可以通过在嵌套作用域中重新声明来进行重写，如下所示：

3235329 Jeff Smith

C# 35 在本例中，除了 name 元素，所有的内容都来自同一个命名空间 —

urn:names-r-us 命名空间。尽管可以重新声明命名空间前缀，但是却无法取消对命名空间前缀的声明。例如，下面的声明是非法的：

3235329 ? ·?·?· 对于大多数软件开发人员

来说，面向前缀的语法（用来在 XML 命名空间中引用内容）是相当直观的。如果 “ Namespaces in XML Recommendation ” 只包含这些内容，则命名空间所

引起的混淆会小得多。

默认命名空间

可以使用另一种类型的命名空间声明来将命名空间标识符与元素名称相关联。这就是所谓的默认命名空间声明，它使用下面的语法：

xmlns='' 请注意，这里没有前缀。在针对某个元素使用默认命名空间声明时，其作用域中的所有非限定元素名称都自动与指定的命

名空间标识符相关联。然而，默认命名空间声明决不会影响属性。如果要将属性与命名空间标识符相关联，唯一的方法就是使用前缀。

请考虑下例：

Jeff Smith C# 35 在这里，“ student” 来自 http://www.develop.com/student 命名空间，而 “ name” 和

“ rating” 来自默认命名空间 urn:foo。 id 属性不属于命名空间，这是由于属性不会自动与默认的命名空间标识符相关联。

本例还阐释了您可以取消对默认命名空间的声明（只需将默认的命名空间标识符重新设置为空字符串），如 language 元素所示（请记住，对于前缀声明不能

这样做）。因此， language 元素也不属于命名空间。

默认命名空间的语法旨在提高方便程度，但是它们会导致更多的混淆，而不是带来更大的价值。这种混淆通常源自如下事实：元素和属性以不同的方式处理，

而且嵌套元素被指定为默认的命名空间标识符也不是立即可见的。然而，除了属性起作用时，在前缀和默认命名空间之间进行选择最终将主要是样式方面的问

题。

webservice：

uddi(Universal Description, Discovery, and Integration) ， wsdl(Web Services Description Language)， soap（ Simple Object Access Protocol ）都

是 webservice 中用到的技术， uddi 指一种基于 soap 通信的注册机构，里面存储着每个 web 服务的 wsdl 信息，当调用 web 服务时就通过查询 uddi 获取 web

服务的 wsdl 信息； wsdl 存储着 web 服务的一系列参数信息，比如所用语言，编码方式等； soap 主要用来通信用。

88. 请用代码简单描述一下 Singleton、抽象工厂、Bridge、Composite（任选三个）的设计模

式的概念

89. 描述数据适配器中的多表查询?

90. SQL SERVER 中的表存到多少条记录时，速度明显变慢？

91. 总结 C# 集合类 Array Arraylist List Hashtable Dictionary Stack Queue

我们用的比较多的非泛型集合类主要有 ArrayList 类和 HashTable 类。我们经常用 HashTable 来存储将要写入到数据库或者返回的信息，在这之间要不断

的进行类型的转化，增加了系统装箱和拆箱的负担，如果我们操纵的数据类型相对确定的化用 Dictionary 集合类来存储数据就方便多了，例

如我们需要在电子商务网站中存储用户的购物车信息 (商品名，对应的商品个数 )时，完全可以用 Dictionary 来存储购物车信息，而不需要任

78

何的类型转化。

1.数组是固定大小的，不能伸缩。虽然 System.Array.Resize 这个泛型方法可以重置数组大小，

但是该方法是重新创建新设置大小的数组，用的是旧数组的元素初始化。随后以前的数组就废弃！而集合却是可变长的

2.数组要声明元素的类型，集合类的元素类型却是 object.

3.数组可读可写不能声明只读数组。集合类可以提供 ReadOnly 方法以只读方式使用集合。

4.数组要有整数下标才能访问特定的元素，然而很多时候这样的下标并不是很有用。集合也是数据列表却不使用下标访问。

很多时候集合有定制的下标类型，对于队列和栈根本就不支持下标访问！

1. 数组

int[] intArray1;

//初始化已声明的一维数组

intArray1 = new int[3];

intArray1 = new int[3]{1,2,3};

intArray1 = new int[]{1,2,3};

2. ArrayList 类对象被设计成为一个动态数组类型，其容量会随着需要而适当的扩充

方法

Add()向数组中添加一个元素，

Remove()删除数组中的一个元素

RemoveAt(int i)删除数组中索引值为 i 的元素

Reverse()反转数组的元素

Sort()以从小到大的顺序排列数组的元素

Clone()复制一个数组

3. List

可通过索引访问的对象的强类型列表。提供用于对列表进行搜索、排序和操作的方法 ,在决定使用 List 还是使用 ArrayList 类（两者具有类似的功能）时，

如则但如

记住 List 类在大多数情况下执行得更好并且是类型安全的。果对 List 类的类型 T 使用引用类型，两个类的行为是完全相同的。是，果对类型 T 使

用值类型，则需要考虑实现和装箱问题。

如果对类型 T 使用值类型，则编译器将特别针对该值类型生成 List 类的实现。这意味着不必对 List 对象的列表元素进行装箱就可以使用该元素，并且在

创建大约 500 个列表元素之后，不对列表元素装箱所节省的内存将大于生成该类实现所使用的内存。

4. Dictionary

表示键和值的集合。 Dictionary 遍历输出的顺序，就是加入的顺序，这点与 Hashtable 不同

5. SortedList 类

与哈希表类似，区别在于 SortedList 中的 Key 数组排好序的

6.Hashtable 类

哈希表，名 -值对。类似于字典 (比数组更强大 )。哈希表是经过优化的，访问下标的对象先散列过。如果以任意类型键值访问其中元素会快于其他集合。

GetHashCode()方法返回一个 int 型数据，使用这个键的值生成该 int 型数据。哈希表获取这个值最后返回一个索引，表示带有给定散列的数据项在字典中存

储的位置。

Hashtable 和 Dictionary 类型

1：单线程程序中推荐使用 Dictionary, 有泛型优势 , 且读取速度较快 , 容量利用更充分 .

2：多线程程序中推荐使用 Hashtable, 默认的 Hashtable 允许单线程写入 , 多线程读取 , 对 Hashtable 进一步调用 Synchronized() 方法可以获得完全

线程安全的类型 . 而 Dictionary 非线程安全 , 必须人为使用 lock 语句进行保护 , 效率大减 .

3：Dictionary 有按插入顺序排列数据的特性 (注 : 但当调用 Remove() 删除过节点后顺序被打乱 ), 因此在需要体现顺序的情境中使用 Dictionary 能获

得一定方便.

HashTable 中的 key/value 均为 object 类型，由包含集合元素的存储桶组成。存储桶是 HashTable 中各元素的虚拟子组，与大多数集合中进行的搜索和检索

相比，存储桶可令搜索和检索更为便捷。每一存储桶都与一个哈希代码关联，该哈希代码是使用哈希函数生成的并基于该元素的键。 HashTable 的优点就在于

79

其索引的方式，速度非常快。如果以任意类型键值访问其中元素会快于其他集合，特别是当数据量特别大的时候，效率差别尤其大。

HashTable 的应用场合有：做对象缓存，树递归算法的替代，和各种需提升效率的场合。

Dictionary 和 HashTable 内部实现差不多，但前者无需装箱拆箱操作，效率略高一点。

HashTable 是经过优化的，访问下标的对象先散列过，所以内部是无序散列的，保证了高效率，也就是说，其输出不是按照开始加入的顺序，而 Dictionary

遍历输出的顺序，就是加入的顺序，这点与 Hashtable 不同。如果一定要排序 HashTable 输出，只能自己实现：

//Hashtable sorting

System.Collections.ArrayList akeys = new System.Collections.ArrayList(ht.Keys); //from Hashtable

akeys.Sort(); //Sort by leading letter

foreach (string skey in akeys)

{

Console.Write(skey + ":");

Console.WriteLine(ht[skey]);

}

HashTable 与线程安全：

为了保证在多线程的情况下的线程同步访问安全，微软提供了自动线程同步的 HashTable:

如果 HashTable 要允许并发读但只能一个线程写 , 要这么创建 HashTable 实例 :

//Thread safe HashTable

System.Collections.Hashtable htSyn = System.Collections.Hashtable.Synchronized( new System.Collections.Hashtable());

这样 , 如果有多个线程并发的企图写 HashTable 里面的 item, 则同一时刻只能有一个线程写 , 其余阻塞 ; 对读的线程则不受影响。

另外一种方法就是使用 lock 语句，但要 lock 的不是 HashTable，而是其 SyncRoot；虽然不推荐这种方法，但效果一样的，因为源代码就是这样实现的 :

7. Stack 类

栈，后进先出。 push 方法入栈， pop 方法出栈。

System.Collections.Stack stack=new System.Collections.Stack();

stack.Push(1);

stack.Push(2);

8.Queue 类

队列，先进先出。 enqueue 方法入队列， dequeue 方法出队列。

System.Collections.Queue queue=new System.Collections.Queue();

92. TREE 控件

93. 请解释 web.config 文件中的重要节点

Web.config 文件是一个 XML 文本文件，它用来储存 ASP.NET Web 应用程序的配置信息（如最常用的设置 ASP.NET Web 应用程序的身份验证方式），它可以

出现在应用程序的每一个目录中。当你通过 .NET 新建一个 Web 应用程序后，默认情况下会在根目录自动创建一个默认的 Web.config 文件，包括默认的配置设

置，所有的子目录都继承它的配置设置。如果你想修改子目录的配置设置，你可以在该子目录下新建一个 Web.config 文件。它可以提供除从父目录继承的配

置信息以外的配置信息，也可以重写或修改父目录中定义的设置。

(一 ).Web.Config 是以 XML 文件规范存储 ,配置文件分为以下格式

1.配置节处理程序声明

特点：位于配置文件的顶部，包含在标志中。

2.特定应用程序配置

特点 : 位于中。可以定义应用程序的全局常量设置等信息 .

3.配置节设置

特点 : 位于节中，控制 Asp.net 运行时的行为 .

4.配置节组

80

特点 : 用标记，可以自定义分组，可以放到内部或其它标记的内部 .

(二 ).配置节的每一节

1.节

根元素，其它节都是在它的内部.

2.节

此节用于定义应用程序设置项。对一些不确定设置，还可以让用户根据自己实际情况自己设置

用法:

I.

定义了一个连接字符串常量，并且在实际应用时可以修改连接字符串，不用修改程式代码 .

II.

定义了一个错误重定向页面.

3.节

格式:

I.default language: 定义后台代码语言 ,可以选择 C#和 VB.net 两种语言 .

IIdebug : 为 true 时，启动 aspx 调试；为 false 不启动 aspx 调试，因而可以提高应用程序运行

时的性能。一般程序员在开发时设置为 true,交给客户时设置为 false.

4.节

格式:

/>

I.mode : 具有 On,Off,RemoteOnly 3 种状态。 On 表示始终显示自定义的信息 ; Off 表示始终显示详细的 asp.net 错误信息 ; RemoteOnly 表示只对不在本地 Web

服务器上运行的用户显示自定义信息 .

II.defaultRedirect: 用于出现错误时重定向的 URL 地址 . 是可选的

III.statusCode: 指明错误状态码，表明一种特定的出错状态 .

IV. redirect:错误重定向的 URL.

5.节

格式:

I.requestEncoding: 它用来检查每一个发来请求的编码 .

II.responseEncoding: 用于检查发回的响应内容编码 .

III.fileEncoding: 用于检查 aspx,asax 等文件解析的默认编码 .

6.节

81

格式:

I.mode: 分为 off,Inproc,StateServer,SqlServer 几种状态

这里有详细介绍此属性 : http://blog.csdn.net/chengking/archive/2005/10/27/518079.aspx

II. stateConnectionString :指定 Asp.net 应用程序存储远程会话状态的服务器名，默认为本机

III.sqlConnectionString: 当用会话状态数据库时，在这里设置连接字符串

IV. Cookieless: 设置为 true 时，表示不使用 cookie 会话状态来标识客户；否则，相反 .

V. TimeOut: 用来定义会话状态存储的时间，超过期限，将自动终止会话 .

7.节

格式:

I.Windows: 使用 IIS 验证方式

II.Forms: 使用基于窗体的验证方式

III.Passport: 采用 Passport cookie 验证模式

IV.None: 不采用任何验证方式

里面内嵌 Forms 节点的属性涵义 :

I.Name: 指定完成身份验证的 Http cookie 的名称 .

II.LoginUrl: 如果未通过验证或超时后重定向的页面 URL，一般为登录页面，让用户重新登录

III.Protection: 指定 cookie 数据的保护方式 .

可设置为 : All None Encryption Validation 四种保护方式

a. All 表示加密数据，并进行有效性验证两种方式

b. None 表示不保护 Cookie.

c. Encryption 表示对 Cookie 内容进行加密

d. validation 表示对 Cookie 内容进行有效性验证

IV. TimeOut: 指定 Cookie 的失效时间 . 超时后要重新登录 .

在运行时对 Web.config 文件的修改不需要重启服务就可以生效（注：节例外）。当然 Web.config 文件是可以扩展的。你可以自定义新配置

参数并编写配置节处理程序以对它们进行处理。

web.config 配置文件（默认的配置设置）以下所有的代码都应该位于

和

之间，出于学习的目的下面的示例都省略了这段 XML 标记。

82

1、节

作用：配置 ASP.NET 身份验证支持（为 Windows、 Forms、 PassPort、None 四种）。该元素只能在计算机、站点或应用程序级别声明。元

素必需与节配合使用。

示例：

以下示例为基于窗体（ Forms）的身份验证配置站点，当没有登陆的用户访问需要身份验证的网页，网页自动跳转到登陆网页。

其中元素 loginUrl 表示登陆网页的名称， name 表示 Cookie 名称。

2、节

控（。（

作用：制对 URL 资源的客户端访问如允许匿名用户访问）此元素可以在任何级别计算机、点、用程序、目录或页）声明。需与

站应子上必

节配合使用。

示例：以下示例禁止匿名用户的访问

注：你可以使用 user.identity.name 来获取已经过验证的当前的用户名；可以使用 web.Security.FormsAuthentication.RedirectFromLoginPage 方法将已验

证的用户重定向到用户刚才请求的页面 .具体的

3、节

作用：配置 ASP.NET 使用的所有编译设置。默认的 debug 属性为 “ True” .在程序编译完成交付使用之后应将其设为 False（ Web.config 文件中有详细说明，

此处省略示例）

4、

作用：为 ASP.NET 应用程序提供有关自定义错误信息的信息。它不适用于 XML Web services 中发生的错误。

示例：当发生错误时，将网页跳转到自定义的错误页面。

其中元素 defaultRedirect 表示自定义的错误网页的名称。 mode 元素表示：对不在本地 Web 服务器上运行的用户显示自定义 (友好的 )信息。

5、节

作用：配置 ASP.NET HTTP 运行库设置。该节可以在计算机、站点、应用程序和子目录级别声明。示例：控制用户上传文件最大为 4M，最长时间为 60 秒，最

多请求数为 100

6、

作用：标识特定于页的配置设置（如是否启用会话状态、视图状态，是否检测用户的输入等）。可以在计算机、站点、应用程序和子目录级别声明。

示例：不检测用户在浏览器输入的内容中是否存在潜在的危险数据（注：该项默认是检测，如果你使用了不检测，一要对用户的输入进行编码或验证 )，在从

客户端回发页时将检查加密的视图状态，以验证视图状态是否已在客户端被篡改。 (注：该项默认是不验证）

7、

作用：为当前应用程序配置会话状态设置（如设置是否启用会话状态，会话状态保存位置）。

示例：

注：

mode="InProc"表示：在本地储存会话状态（你也可以选择储存在远程服务器或 SAL 服务器中或不启用会话状态）

cookieless="true"表示：如果用户浏览器不支持 Cookie 时启用会话状态 (默认为 False）

timeout="20"表示：会话可以处于空闲状态的分钟数

83

8、

作用：配置 ASP.NET 跟踪服务，主要用来程序测试判断哪里出错。

示例：以下为 Web.config 中的默认配置：

注：

enabled="false"表示不启用跟踪；

requestLimit="10"表示指定在服务器上存储的跟踪请求的数目

pageOutput="false"表示只能通过跟踪实用工具访问跟踪输出；

traceMode="SortByTime"表示以处理跟踪的顺序来显示跟踪信息

localOnly="true" 表示跟踪查看器 (trace.axd) 只用于宿主 Web 服务器

自定义 Web.config 文件配置

自定义 Web.config 文件配置节过程分为两步。

1.在在配置文件顶部和标记之间声明配置节的名称和处理该节中配置数据的 .NET Framework 类的名称。

2.是在区域之后为声明的节做实际的配置设置。

示例：创建一个节存储数据库连接字符串

......

访问 Web.config 文件你可以通过使用 ConfigurationSettings.AppSettings 静态字符串集合来访问 Web.config 文件示例：获取上面例子中建立的连接字

符串。例如：

protected static string Isdebug = ConfigurationSett ings.AppSettings["debug"]

二、 web.config 中的 session 配置详解

打开某个应用程序的配置文件 Web.config 后，我们会发现以下这段：

这一段就是配置应用程序是如何存储 Session 信息的了。我们以下的各种操作主要是针对这一段配置展开。让我们先看看这一段配置中所包含的内容的意

思。 sessionState 节点的语法是这样的：

必须有的属性是属性选项描述

mode 设置将 Session 信息存储到哪里

Ø Off 设置为不使用 Session 功能，

Ø InProc 设置为将 Session 存储在进程内，就是 ASP 中的存储方式，这是默认值，

Ø StateServer 设置为将 Session 存储在独立的状态服务中，

Ø SQLServer 设置将 Session 存储在 SQL Server 中。

可选的属性是：属性选项描述

Ø cookieless 设置客户端的 Session 信息存储到哪里，

Ø ture 使用 Cookieless 模式，

Ø false 使用 Cookie 模式，这是默认值，

Ø timeout 设置经过多少分钟后服务器自动放弃 Session 信息，默认为 20 分钟。

例

stateConnectionString 设置将 Session 信息存储在状态服务中时使用的服务器名称和端口号，如：。

"tcpip=127.0.0.1:42424” 当 mode 的值是 StateServer

是，这个属性是必需的。

sqlConnectionString 设置与 SQL Server 连接时的连接字符串。例如 "data source= localhost;Integrated Security=SSPI;Initial Catalog=northwind" 。

当 mode 的值是 SQLServer 时，这个属性是必需的。

stateNetworkTimeout 设置当使用 StateServer 模式存储 Session 状态时，经过多少秒空闲后，断开 Web 服务器与存储状态信息的服务器的 TCP/IP 连接的。

默认值是 10 秒钟。

ASP.NET 中客户端 Session 状态的存储

大分客

在我们上面的 Session 模型简介中，家可以发现 Session 状态应该存储在两个地方，别是客户端和服务器端。户端只负责保存相应网站的 SessionID，

而其他的 Session 信息则保存在服务器端。在 ASP 中，客户端的 SessionID 实际是以 Cookie 的形式存储的。如果用户在浏览器的设置中选择了禁用 Cookie，

那末他也就无法享受 Session 的便利之处了，甚至造成不能访问某些网站。为了解决以上问题，在 ASP.NET 中客户端的 Session 信息存储方式分为： Cookie

和 Cookieless 两种。

ASP.NET 中，默认状态下，在客户端还是使用 Cookie 存储 Session 信息的。如果我们想在客户端使用 Cookieless 的方式存储 Session 信息的方法如下：

找到当前 Web 应用程序的根目录，打开 Web.Config 文件，找到如下段落：

这段话中的 cookieless="false"改为： cookieless="true"，这样，客户端的 Session 信息就不再使用 Cookie 存储了，而是将其通过 URL 存储。关闭当

前的 IE，打开一个新 IE，重新访问刚才的 Web 应用程序，就会看到类似下面的样子：

其中，http://localhost/MyTestApplication/(ulqsek45heu3ic2a5zgdl245) /default.aspx 中黑体标出的就是客户端的 Session ID。注意，这段信息是由 IIS

自动加上的，不会影响以前正常的连接。

ASP.NET 中服务器端 Session 状态的存储准备工作：

为了您能更好的体验到实验现象，您可以建立一个叫做 SessionState.aspx 的页面，然后把以下这些代码添加到中。

Sub Session_Add(sender As Object, e As EventArgs)

Session("MySession") = text1.Value

span1.InnerHtml = "Session data updated! Your session contains: " & Session("MySession"). ToString() & " "

End Sub

Sub CheckSession(sender As Object, eAs EventArgs)

If (Session("MySession")Is Nothing) Then

span1.InnerHtml = "NOTHING, SESSION DATA LOST!"

85

Else

span1.InnerHtml = "Your session contains: " & Session("MySession").ToString() & ""

End If

End Sub

这个 SessionState.aspx 的页面可以用来测试在当前的服务器上是否丢失了 Session 信息。

将服务器 Session 信息存储在进程中

让我们来回到 Web.config 文件的刚才那段段落中：

当 mode 的值是 InProc 时，说明服务器正在使用这种模式。

这种方式和以前 ASP 中的模式一样，就是服务器将 Session 信息存储在 IIS 进程中。当 IIS 关闭、重起后，这些信息都会丢失。但是这种模式也有自己最

大好处，就是性能最高。应为所有的 Session 信息都存储在了 IIS 的进程中，所以 IIS 能够很快的访问到这些信息，这种模式的性能比进程外存储 Session 信

息或是在 SQL Server 中存储 Session 信息都要快上很多。这种模式也是 ASP.NET 的默认方式。

好了，现在让我们做个试验。打开刚才的 SessionState.aspx 页面，随便输入一些字符，使其存储在 Session 中。然后，让我们让 IIS 重起。注意，并不

是使当前的站点停止再开始，而是在 IIS 中本机的机器名的节点上点击鼠标右键，选择重新启动 IIS。(想当初使用 NT4 时，重新启动 IIS 必须要重新启动计算

机才行，微软真是 @#$%^&)返回到 SessionState.aspx 页面中，检查刚才的 Session 信息，发现信息已经丢失了。

将服务器 Session 信息存储在进程外

首先，让我们来打开管理工具 ->服务，找到名为：ASP.NET State Service 的服务，启动它。实际上，这个服务就是启动一个要保存 Session 信息的进程。

启动这个服务后，你可以从 Windows 任务管理器 ->进程中看到一个名为 aspnet_state.exe 的进程，这个就是我们保存 Session 信息的进程。

然后，回到 Web.config 文件中上述的段落中，将 mode 的值改为 StateServer。保存文件后的重新打开一个 IE，打开 SessionState.aspx 页面，保存一些

信息到 Session 中。这时，让我们重起 IIS，再回到 SessionState.aspx 页面中查看刚才的 Session 信息，发现没有丢失。

实际上，这种将 Session 信息存储在进程外的方式不光指可以将信息存储在本机的进程外，还可以将 Session 信息存储在其他的服务器的进程中。这时，

不光需要将 mode 的值改为 StateServer，还需要在 stateConnectionString 中配置相应的参数。例如你的计算你是 192.168.0.1，你想把 Session 存储在 IP

为 192.168.0.2 的计算机的进程中，就需要设置成这样： stateConnectionString="tcpip=192.168.0.2:42424" 。当然，不要忘记在 192.168.0.2 的计算机中

装上 .NET Framework，并且启动 ASP.NET State Services 服务。

86

将服务器 Session 信息存储在 SQL Server 中

首先，还是让我们来做一些准备工作。启动 SQL Server 和 SQL Server 代理服务。在 SQL Server 中执行一个叫做 InstallSqlState.sql 的脚本文件。这

个脚本文件将在 SQL Server 中创建一个用来专门存储 Session 信息的数据库，及一个维护 Session 信息数据库的 SQL Server 代理作业。我们可以在以下路径

中找到那个文件：

[system drive]\winnt\Microsoft.NET\Framework\[version]\

然后打开查询分析器，连接到 SQL Server 服务器，打开刚才的那个文件并且执行。稍等片刻，数据库及作业就建立好了。这时，你可以打开企业管理器，

看到新增了一个叫 ASPState 的数据库。但是这个数据库中只是些存储过程，没有用户表。实际上 Session 信息是存储在了 tempdb 数据库的

ASPStateTempSessions 表中的，另外一个 ASPStateTempApplications 表存储了 ASP 中 Application 对象信息。这两个表也是刚才的那个脚本建立的。另外查

看管理 ->SQL Server 代理 ->作业，发现也多了一个叫做 ASPState_Job_DeleteExpiredSessions 的作业，这个作业实际上就是每分钟去 ASPStateTempSessions

表中删除过期的 Session 信息的。

接着，我们返回到 Web.config 文件，修改 mode 的值改为 SQLServer。注意，还要同时修改 sqlConnectionString 的值，格式为：

sqlConnectionString="data source=localhos t; Integrated Security=SSPI;"

其中 data source 是指 SQL Server 服务器的 IP 地址，如果 SQL Server 与 IIS 是一台机子，写 127.0.0.1 就行了。 Integrated Security=SSPI 的意思是

使用 Windows 集成身份验证，这样，访问数据库将以 ASP.NET 的身份进行，通过如此配置，能够获得比使用 userid=sa;password=口令的 SQL Server 验证方式

更好的安全性。当然，如果 SQL Server 运行于另一台计算机上，你可能会需要通过 Active Directory 域的方式来维护两边验证的一致性。

让向这即刚

同样，我们做个试验。 SessionState.aspx 中添加 Session 信息，时发现 Session 信息已经存在 SQL Server 中了，使你重起计算机，才的 Session

信息也不会丢失。现在，你已经完全看见了 Session 信息到底是什么样子的了，而且又是存储在 SQL Server 中的，能干什么就看你的发挥了。

总结

通过这篇文章，你可以看到在 Session 的管理和维护上， ASP.NET 比 ASP 有了很大的进步，我们可以更加随意的挑选适合的方法了。对于企业级的应用来

说，这无疑对于服务器的同步、服务器的稳定性、可靠性都是有利的。相信在强大的微软支持下，新一代的电子商务平台将会搭建的更好！

同时，大家也会发现，在这个整个技术中包括了操作系统、 Web 服务及数据库多种技术的整合。我相信，也许 Windows 没有 Unix 稳定， IIS

没有 Apache 稳定，SQL Server 也没有 Oracle 强大，但是，谁可以将他们如此完美的联动到一起呢？所以说，虽然微软每一方面都不是太强，但是如果把微软

的东西都整合到一起，谁敢说他不强大呢？微软就是微软！

三、 Asp.net 关于 form 认证的一般设置

asp.net 关于 form 认证的一般设置：

1: 在 web.config 中，加入 form 认证；

2: 如果有注册页面时还应该允许匿名用户调用注册页面进行注册 ;

以下代码应该在之间 ,而不应该包含到 ..之间 ;

----------------表示允许匿名用户对 userReg.aspx 页面进行访问 .

3 在登录成功后要创建身份验证票, 表明已经通过认证的合法用户;

if(登陆成功 )

System.Web.Security.FormsAuthentication.SetAuthCookie( 用户名称 , false);

四、访问 Web.config 文件

87

你可以通过使用 ConfigurationSettings.AppSettings 静态字符串集合来访问 Web.config 文件示例：获取上面例子中建立的连接字符串。例如：

protected static string Isdebug = ConfigurationSettings.AppSettings["scon"]

94. 什么是 viewstate，能否禁用？是否所用控件都可以禁用?

95. 请解释 ASP.NET 中 button linkbutton imagebutton 及 hyperlink 这四个控件之间的功别

96. 请解释一下.NET 多层应用程序中层与层之间以那几种方式进行数据传递.并解释你自己的项

目中采用那种方式进行.

97. 如果需要在 datagride 控件中的某一列中添加下拉列表框并绑定数据怎么解决？

98. 请解释 asp.net 中的数据绑定与传统数据绑定有什么区别？

99. Repeater Web 服务器控件概述

Repeater Web 服务器控件是一个容器控件，它使您可以从页的任何可用数据中创建出自定义列表。 Repeater 控件不具备内置的呈现功能，这表示用户必须

通过创建模板为 Repeater 控件提供布局。当该页运行时， Repeater 控件依次通过数据源中的记录，并为每个记录呈现一个项。

由于 Repeater 控件没有默认的外观，因此可以使用该控件创建许多种列表，其中包括：

表布局

逗号分隔的列表（例如， a、 b、 c、 d 等）

XML 格式的列表

配合模板使用 Repeater 控件

若要使用 Repeater 控件，请创建定义控件内容布局的模板。模板可以包含标记和控件的任意组合。如果未定义模板，或者如果模板都不包含元素，则当应用

程序运行时，该控件不显示在页上。

下表描述了 Repeater 控件支持的模板。

模板属性说明

ItemTemplate 包含要为数据源中每个数据项都要呈现一次的 HTML 元素和控件。

AlternatingItemTemplate 包含要为数据源中每个数据项都要呈现一次的 HTML 元素和控件。通常，可以使用此模板为交替项创建不同的外观，例如指定一种与在

ItemTemplate 中指定的颜色不同的背景色。

HeaderTemplate 和包含在列表的开始和结束处分别呈现的文本和控件。

FooterTemplate

SeparatorTemplate 包含在每项之间呈现的元素。典型的示例可能是一条直线（使用 hr 元素）。

100. 比较 GridView 和 DataGrid Web 服务器控件

GridView 控件是 DataGrid 控件的后继控件。与 DataGrid 控件相似， GridView 控件旨在在 HTML 表中显示数据。当绑定到数据源时， DataGrid 和

GridView 控件分别将 DataSource 中的一行显示为输出表中的一行。

DataGrid 和 GridView 控件都是从 WebControl 类派生的。虽然 GridView 控件与 DataGrid 控件具有类似的对象模型，但与 DataGrid 控件相比，前者

还具有许多新功能和优势，包括：

更丰富的设计时功能。

改进的数据源绑定功能。

排序、分页、更新和删除的自动处理。

其他列类型和设计时列操作。

具有 PagerTemplate 属性的自定义页导航用户界面 (UI)。

GridView 控件和 DataGrid 控件之间的差异包括：

不同的自定义分页支持。

不同的事件模型。

88

改进的设计时功能

使用 DataGrid 控件时，数据的排序、分页和就地编辑需要附加的编码。 GridView 控件则使您无需编写任何代码即可添加排序、分页和编辑功能。实际上，

可以通过在控件上设置属性来自动完成这些任务（以及诸如到数据源的数据绑定等其他常见任务）。

在设计器（如 Microsoft Visual Studio）中工作时，可以利用内置在 GridView 控件中的设计器功能。 GridView 控件提供了对智能标记面板的支持，这种

面板为执行常见任务（如设置属性和启动模板编辑）提供了方便的界面。

改进的数据源绑定功能

通常，将 DataSet 控件、 DbDataReader 控件或集合（如 Array、 ArrayList 或 System.Collections 命名空间中的其他一些类）分配给 DataGrid 控

件或 GridView 控件的 DataSource 属性。 DataGrid 控件和 GridView 控件可以绑定任何实现 IEnumerable 或 IListSource 接口的对象。

DataGrid 控件可以以声明方式绑定 DataSourceControl 控件，但这只适用于数据选择。必须手动编码才能实现排序、分页、更新和删除。 GridView 控件

支持 DataSourceID 属性，该属性接受任何实现了 IDataSource 接口因此可以利用数据源控件的排序、分页、更新和删除功能的对象，例如，

SqlDataSource 控件。

其他列类型

GridView 控件支持以下列类型： BoundField、 HyperLinkField、 ButtonField、 CommandField、 ImageField 和 CheckBoxField。

内置和自定义分页支持

DataGrid 控件需要其他编码用于分页。GridView 控件通过设置 PagerSettings 属性自动支持分页。PagerSettings 属性支持四种模式： Numeric（默认

值）、 NextPrevious、 NumericFirstLast 和 NextPreviousFirstLast。 Numeric 模式显示带编号的页链接而不是 “ 下一个 /上一个 ” 链接，并且

NumericFirstLast 选项添加第一个和最后一个页链接。 GridView 控件的 PagerStyle 属性可以用于设置页导航的样式和位置。

另外，可以使用 PagerTemplate 自定义 GridView 控件的页导航按钮。

GridView 中的自定义分页支持由绑定数据源控件提供，而 AllowCustomPaging 机制则是由 DataGrid 控件提供的。

扩展的事件模型

DataGrid 和 GridView 控件具有不同的事件模型。

DataGrid 控件引发操作的单个事件，而 GridView 控件能够引发操作前和操作后的事件。 GridView 控件支持在对字段排序时发生的 Sorting 事件。注意，

此排序事件发生在 GridView 控件自动处理排序操作之前，这样您将有机会检查或更改 SortExpression 属性，或通过在传递的事件参数上将 Cancel 属性

设置为 true 来取消此操作。

GridView 控件支持在 GridView 控件完成排序操作之后发生的 Sorted 事件，这样您将有机会更改排序操作的结果或设置其格式。相反， DataGrid 控件支

持在对列进行排序时发生的 SortCommand 事件。同样， GridView 控件支持在 GridView 控件自动处理更新操作之前和之后发生的 RowUpdating 和

RowUpdated 事件。相比之下， DataGrid 控件支持在对网格中的项单击 “ 更新 ” 按钮时发生的 UpdateCommand 事件。

101. ASP.NET 保存用户状态

保持方法谁需要数据保持多长时间数据量大小

Application 所有用户整个应用程序生命期任意大小

Cookie 一个用户可以很短，如果用户不删除也可以很长小的、简单数据

Form Post 一个用户到下一次请求（可以跨越多个请求重复使用）任意大小

QueryString 一个或一组用户到下一次请求（可以跨越多个请求重复使用）小的、简单数据

Sessions 一个用户用户活动时一直保持＋一段时间（一般 20 分钟）

Cache 所有用户或某些用户根据需要可大可小、可简单可复杂

Context 一个用户一个请求可以保持大对象，但是一般不这样使用

ViewState 一个用户一个 Web 窗体最小

Config file 所有用户知道配置文件被更新可以保持大量数据，通常组织小的字符串和 XML 结构

Application

让我们通过回答上面的状态问题判定条件来说明该对象。谁需要数据？所有的用户需要访问它。需要保持数据多长时间？永久保持，或在应用程序生存期

中保持。数据多大？可以是任何大小 --在任何给定的时刻只有数据的一个副本存在。

在传统 ASP 中，Application 对象提供了一个保存频繁使用但很少改变的数据片的位置，例如菜单内容和参考数据。尽管在 ASP.NET 中 Application 依然

作为数据容器存在，但是有其它一些更适合以前保存在传统 ASP 应用程序的 Application 集合中的数据的对象。

在传统的 ASP 中，如果被保存的数据在应用程序的生存期中根本不会改变（或很少改变，例如只读数据和大多数情况下是读操作的数据）， Application

对象是理想的选择。连接字符串就是保存在 Application 变量中的一个最普通的数据片，但是在 ASP.NET 中类似的配置数据最好保存在 Web.config 文件中。

89

如果使用 Application 对象一个需要考虑的问题是任何写操作要么在 Application_OnStart 事件（ global.asax）中，要么在 Application.Lock 部分中完成。

尽管使用 Application.Lock 来确保写操作正确地执行是必要的，但是它串行化了对 Application 对象的请求，而这对于应用程序来说是个严重的性能瓶颈。

图 2 演示了怎样使用 Application 对象，它包括一个 Web 窗体和它的代码文件。

Application.Lock();

Application[txtName.Text] = txtValue.Text;

Application.UnLock();

Cookies

当特定的用户需要特定的数据片，并且需要把数据在某个可变的时段中保持的时候，cookie 就非常方便。它的生命周期可能与浏览器窗体的一样短，也可

以长达数月、数年。 cookie 可以小到只有几个字节的数据，因为它们在每个浏览器请求中传递，它们的内容需要尽可能的小。

Cookie 提供了一条灵活的、强大的维护用户请求间数据的途径，这就是为什么 Internet 上大多数动态站点使用它们的原因。因为 cookie 可以存储的数据

量很受限制，最好只在 cookie 中保存键字段，其它的数据保存在数据库或其它的服务器端数据容器中。但是由于不是所有的浏览器都支持 cookie，并且它可

以被用户禁止或删除，因此它们也不能用于保存关键数据。你应该很好地处理用户的 cookie 被删除的情况。最后， cookie 作为简单的明文文本保存在用户的

计算机中，因此在它里面不能保存敏感的、未加密的数据。

图通这

有种特殊的 cookie 可以保存单个值或名称 /值对的集合。 4 显示了单个和多个值 cookie 的示例，过 ASP.NET 的内建追踪特性输出。些值可以在 ASP.NET

页面中使用 Request.Cookies 和 Response.Cookies 集合来维护

//使用 HttpCookie 类是指 cookie 的值和 /或子值

HttpCookie cookie;

if(Request.Cookies[txtName.Text] == null)

cookie = new HttpCookie(txtName.Text, txtValue.Text);

cookie = Request.Cookies[txtName.Text];

Response.Cookies[txtName.Text].Value = null;

Response.Cookies[txtName.Text].Expires =

System.DateTime.Now.AddMonths(-1); //上个月

Form Post / 隐藏的窗体字段

特定的用户需要窗体的数据，并且它需要在单个请求到应用程序终止的任何阶段都保持。这些数据事实上可以是任意大小的，它随着每个 form post 在网

络上向前和向后发送。

在传统的 ASP 中，这是在应用程序中暴露状态的通常的途径，特别是在多页面窗体应用程序中。但是在 ASP.NET 中这种技术不太适合了，因为只要你使用

postback 模型（也就是页面发回给自己）， Web 控件和 ViewState 自动处理了这些操作。 ViewState 是 ASP.NET 对这种技术的实现，我将在本文的后部分讨论

它。访问通过 POST 发送的窗体值是使用 HttpRequest 对象的窗体集合完成的。在图 6 中，一个 ASP.NET 页面设置了某个用户的 ID，在这以后它保持在一个隐

藏的窗体字段中。后面的向任何页面的请求保留这个值，直到页面使用 Submit 按钮链接到其它的用户。

username = Request.Form["username"].ToString();

lblUsername.Text = username;

在 ASP.NET 中一个页面上只能存在一个服务器端窗体，并且该窗体必须提交返回到自身（仍然可以使用客户端窗体，没有限制）。隐藏窗体字段再也没有用于

在 .NET 框架组件上建立的应用程序间传递数据的主要原因之一是 .NET 框架组件控件都可以使用 ViewState 自动维护自己的状态。ViewState 简单地把使用隐藏

窗体字段设置和检索值所包含的工作封装进一个使用简单的集合对象中。

QueryString

QueryString 对象中保存的数据由单独的用户使用。它的生命周期可能只有一个请求那么短，也可能有用户使用应用程序的时间那么长（如果构造正确的

话）。这类数据一般小于 1KB。 QueryString 中的数据在 URL 中传递，对于用户来说是可见的，因此你能猜到，使用这种技术时，敏感的数据或可用于控制应

用程序的数据需要加密。

也就是说， QueryString 是在 ASP.NET Web 窗体间发送信息的一条很好的途径。例如，如果有一个含有产品列表的数据表格（ DataGrid），并且在表格上

有一个链接导向产品的细节页面，使用 QueryString 就是理想的，可以把产品的 ID 包含在链接到产品细节页面的 QueryString 中（例如

productdetails.aspx?id=4）。使用 QueryStrings 的另一个好处是页面的状态包含在 URL 中。这意味着用户可以把某个通过 QueryStrings 建立的窗体放入他

的收藏夹中。当它们作为收藏返回到页面时，将与作收藏的时候一样。很明显这只在页面不依赖 QueryString 外的所有状态和不作任何改变的时候有作用。

敏感数据，以及任何不希望用户操作的变量应该避免出现在此处（除非加密使用户不能阅读）。并且 URL 中不合法的字符必须使用 Server.UrlEncode 编

码，如图 7 所示。当处理单个 ASP.NET 页面时，对维护状态来说 ViewState 是比 QueryString 好的选择。对于长期的数据存储， Cookie、 Sessions 或 Cache

90

都比 QueryStrings 更加适于作为数据容器。

Request.QueryString[key].ToString();

Sessions

它（

Sessions 数据对于特定的用户是特定的。的生存期是用户持续请求的时间加上后来一段时间一般是 20 分钟）。Sessions 可以保持或大或小的数据量，

但是如果应用程序用于成百上千的用户，那么总共的存储应该保持最小。

不幸的是在传统的 ASP 中 Sessions 对象的名声很不好，因为它把应用程序约束到特定的计算机上，阻碍了用户分组和 Web 范围的可伸缩性。在 ASP.NET

中几乎没有这些问题，因为改变 Sessions 保存的位置很简单。在默认情况下（性能最好的情况）， Sessions 数据仍然保存在本地 Web 服务器的内存中，但是

ASP.NET 支持使用外部状态服务器或数据库管理 Sessions 数据。

使用 Sessions 对象很简单，并且它的语法与传统 ASP 相同。但是 Sessions 对象是保存用户数据的方法中效率很低的一种，因为即使用户停止使用应用程

序后它仍然保持在内存中一段时间。这对于非常繁忙的站点的可伸缩性有严重的影响。其它的选择允许对释放内存的更多的控制，例如 Cache 对象也许更适合

大量的大数据值。并且在默认情况下 ASP.NET Sessionss 依赖于 cookie，因此如果用户禁止或不支持 cookie，Sessionss 就不能工作，但是可以配置 Sessionss

支持 cookie 无关。对于小的数据量，Sessionss 对象是保存只需要在用户当前对话中保持的特定数据的极好位置。下面的例子演示了怎样设置和从 Sessionss

对象中检索值：

// 设置 Sessions 值

Sessions[txtName.Text] = txtValue.Text;

该 Web 窗体与 Application 对象中使用的几乎相同，当允许页面追踪时 Sessions 集合的内容也是可见的。

你需要记住的是即使没有使用， Sessionss 也会有应用程序开销。把 Sessionss 状态设置为只读的也可以优化只需要读而不需要写数据的页面。可以使用下面

两种途径之一来配置 Sessionss：

ASP.NET Sessionss 可以在 Web.config 或 Machine.config 中的 Sessionsstate 元素中配置。下面是在 Web.config 中的设置的例子：

Cache

Cache 对象用于单个用户、一组用户或所有的用户。这种数据为多个请求保持。它可以保持很长时间，但是不能超过应用程序重新启动的时间，并且数据

的终止基于时间或者其它的依赖关系。它可以高效率地保持大量或少量地数据。

Cache 是 ASP.NET 中最 "酷 "的对象之一。它提供了难以置信的灵活性、通用性和性能，因此在 ASP.NET 应用程序中它通常是比 Application 或 Sessions

更好的保持数据的对象。本文没有详细介绍 Cache 对象的使用方法，但是仍然可以说它是一个万能对象。与其它的集合对象相似，它是一个简单的名称－值集

合，但是通过使用指定特定用户的键值可以缓存特定用户的值。同样你可以缓存不同的相关数据的多个数据集，例如几个有键（如 fordcars 、 chevycars、

gmcars）的汽车集合。 Cache 中的数据可以给定一个绝对的、可变的或基于文件的终止时间。它们也实现了一个回调功能，在被缓存的值从缓存中提取时被调

用，这个功能很有用，因为接着你能检查它是否为最新的数据变量，如果不是（或数据源不可用），就重新缓存被终止的值。

添加和访问缓存中值的语法与先前谈到的相似。但是 Cache 给访问集合内容的标准索引器方法作了补充，它支持多种方法，允许对被缓存数据的更多的控

制。

// 给缓存添加项

Cache["myKey"] = myValue;

// 从缓存中读取项

Response.Write(Cache["myKey"]);

Cache 对象的最强大的特性之一是当缓存中的某个项终止时执行回调的能力。它使用了委托或函数指针，这在本文中没有讨论。幸运的是一旦你有了某些

这些技术怎样工作的示例，就能通过简单的剪切和粘贴在应用程序中使用它们，不需要知道委托是怎样工作的复杂过程。有很多使用这种功能的原因，最通常

的是在数据终止时用当前数据重新填充缓存，或者如果重新填充缓存的数据源不可用时恢复旧的缓存数据。

Context

Context 对象保持单个用户、单个请求的数据，并且数据只在该请求期间保持。Context 容器可以保持大量的数据，但是典型的情况下是保存小的数据片，

因为它经常通过 global.asax 中的某个处理方法为每个请求实现。

Context 容器（从 Page 对象访问或使用 System.Web.HttpContext.Current）被提供用于保持需要在不同的 HttpModules 和 HttpHandlers 之间传递的值。

它也可以用于保持某个完整请求的相应信息。例如，IbuySpy 入口在 global.asax 中的 Application_BeginRequest 事件过程中给容器填满了许多配置信息。注

意这只在当前请求中可用，如果你希望在下一个请求中也能使用，请考虑使用 ViewState。

从 Context 集合中设置和获取数据使用的语法与前面讨论的其它集合对象（如 Application、 Sessions 和 Cache）的相似。下面是两个简单的例子：

91

// 给 Context 添加项

Context.Items["myKey"] = myValue;

// 从 Context 中读取项

Response.Write(Context["myKey"]);

ViewState

ViewState 为单个用户保持状态信息，保持期为 ASPX 页面工作时间。ViewState 容器可以保持大量的数据，但是必须小心管理 ViewState 的大小，因为它

增加了每个请求和回应的下载（ download）大小。

ViewState 是 ASP.NET 中的一个新容器，也许你已经使用它了，但是你可能还是不了解它。这是因为所有的内建 Web 控件都使用 ViewState 在页面回发

（ postback）间保持自己的值。但是你必须小心，因为它影响应用程序的性能。影响的大小依赖于回发之间使用 ViewState 的多少 --对大多数 Web 窗体来说数

量非常小。

确定某个页面上每个控件使用的 ViewState 的数量最简单的方法是打开页面追踪并检查每个控件负载了多少个 ViewState。如果某个特定控件不需要在回

请你

发之间保持数据，通过把 EnableViewState 设置为 false 关闭该对象的 ViewState。也可以通过在浏览器中查看的 HTML 源并检查隐藏窗体字段 __VIEWSTATE

来确定某个给定的 ASP.NET 页面 ViewState 的总共大小。注意这些内容都是使用 Base64 编码的，用于放置偶然的查看和维护。 ViewState 也可以通过给 @Page

指令添加 EnableViewState="false"在整个页面中禁止。

典型的 Web 窗体不需要直接维护 ViewState。但是如果你建立自定义 Web 控件，就需要了解它是怎样工作的，并为你的控件实现它，这样该控件的工作方

式才能与随 ASP.NET 发布的 Web 控件同样地工作。向 ViewState 读取或写入值都可以通过上面讨论地其它集合对象的语法完成：

// 给 ViewState 添加项

ViewState["myKey"] = myValue;

//从 Context 读取项

Response.Write(ViewState["myKey"]);

Web.config 和 Machine.config 文件

这些文件中的数据对于某个应用程序的所有用户来说都可以使用。 Web.config 文件中存储的数据可用于应用程序的整个生命周期。这些数据一般很小，该

对象一般用于保持文件位置和数据库连接的字符串。大的数据片最好保存在其它位置。

作为其它多样集合对象的补充，每

ASP.NET 引入了一组 XML 配置文件用于管理应用程序甚至于整个服务器的很多设置。个 ASP.NET 应用程序使用 Web.config

文件来设置它的许多属性，每个服务器在系统文件夹下有一个作为应用程序基础的 Machine.config 文件。这些设置都作为默认值使用，除非重载。作为保存

配置数据的补充，这些文件可以保存应用程序（或多个应用程序）需要的数据。

无论什么时候应用程序启动都会读取配置信息，接着这些信息被缓冲。由于被缓冲了，应用程序可以快速读取它们，因此不需要考虑应用程序的瓶颈，因

为它经常执行某个文本文件的一些整型信息。此外，某个应用程序的 Web.config 的改变将导致应用程序重新启动。这确保了对配置文件信息的修改立即反映

到应用程序中。

数据库连接信息，默认图像路径和 XML 数据文件路径是通常保存在 Web.config 文件中的数据片。在 Web.config 文件中保存数据的语法如下，在理想的情

况下你也许希望使用集成的 SQL 身分验证：

为了访问 ASP.NET 页面中的值，可以使用 ConfigurationSettings 集合，它在 System.Configuration 名字空间中。下面的简单例子演示了怎样提取前面

的连接字符串到一个本地变量中：

String strConnString =

ConfigurationSettings.AppSettings["connectionString"];

因

给 System.Configuration 名字空间添加一个引用减少了引用这些值的代码数量。为对 Web.config 或 Machine.config 的修改将导致应用程序立即重新启动，

92

典型情况下这些值只由服务器系统管理员手动修改。因此你可以认为这些文件是保存只读数据而不是应用程序中修改的数据的好位置。

102. ASP.NET 状态保存客户端保存方式比较

客户端保存的方式一般有如下 4 种：

1 ViewState:

利用场合为：在对同一页的多个请求间自动保留值，多用于客户端的一些事件。，典型利用场合为：页面信息重置，登陆出错次数统计， Grid 列排序等。

优点：不利用服务器端资源，实现简单，相对高的性：因为经过哈希计算和压缩，并且针对 Unicode 实现进行编码。

缺点：因为 ViewState 存储在页面本身，所以无法存储较大的值。并且通过源文件可以看见其中的值，虽然经过哈希计算和压缩，但仍有被篡改的风险。

可存储的类型： string,integer,bool,array,arr aylist,hashtable 以及其他可以序列化的类型。

2 HiddenField:

利用场合为：存储少量页面中经常改动的信息，多和客户端脚本一块使用，典型利用场合为：客户端经历一系列验证之后向服务器端回发，服务器端从客户

端 HiddenField 中获取值，进行处理。例如： LeyserHomepage 中，要删除一项产品，需要在客户端弹出确认 Form，用户确认之后再 PostBac k 回服务器端进

行数据库 Delete 操作，当用户确认要删除时，将当前要删除的产品 ID 存放到一个 HiddenField 中，然后执行 Form(0).submit 回发到服务器端，服务器端再

从 HiddenField 获取产品 ID 值，进行数据库操作。

优点：不使用服务器资源，广泛支持，实现简单

缺点：安全性不高，因为它被包含在页面上进行发送，所以可以通过源文件看见他的内容。存储结构少，仅仅支持 string,integer,bool,array,arraylis t

等简单的数据结构。并且在其上只存放简单的单值，若要存放多值，需要额外编码。存储量少，因为它被存储在页面本身，所以无法存储较大的值。而且大

的数据量会受到和代理的阻止。注意：使用了 HiddenField 之后，需要回发到服务器进行处理，应该使用 Http Post 方法而不是 Http Get 方法 (通过 URL

请求访问)

3 Cookie:

利用场合为：存储少量页面中经常改动的信息，典型利用场合为：为登陆过的网站保存登陆用户名，为用户输入提供方便，还有在一些用户自定义项目上保

存用户的个性化设置。

优点：不使用服务器资源，实现简单，可配置到期时间。

缺点：大小受到限制，一般浏览器支持的最大的 Cookie 容量为 4096 字节。客户端用户可能会配置为拒绝 Cookie。安全性：保存在客户端的信息可能会被恶

意用户修改或者获取，所以不应该保存敏感信息。持久性：保存期限受到客户端的配置影响。

Cookie 通常用于存取已知用户自定义内容的个性化情况。在大多数此类情况中， Cookie 是作为 “ 标识 ” 而不是 “ 身份验证 ” ，所以在 Cookie 中只存储

用户名、账户名或唯一用户 ID（例如 GUID）并使用它来访问站点的用户个性化结构是足够的了。

4 QueryString:

利用场合为：将信息从一页传递给另一页的最简单的方法。

优点：不使用服务器资源，支持广泛，实现简单

缺点：安全性，因为直接在 URL 中暴露给用户，所以有被篡改的风险。容量有限，一般的浏览器都有 255 个字符的限制。只有在通过其 URL 请求页时查询字

符串才是可行的选择。不能从已提交给服务器的页读取查询字符串。

视图状态 :需要为将回发到自身的页存储少量信息。 ViewState 属性的使用将提供具有基本安全性的功能。

隐藏域：需要为将回发到自身或另一页的页存储少量信息，并且不需要较高的安全性。（客户端事件）只能在提交到服务器的页上使用隐藏域。

Cookie：需要在客户端存储少量信息并且不需要较高的安全性。（个性化）

查询字符串：可以将少量信息从一页传输到另一页，并且不需要较高的安全性。（页面跳转）只有在请求同一页，或通过链接请求另一页时，才能使用查

询字符串。

103. 请解释什么是上下文对象，在什么情况下要使用上下文对象

为继承 IHttpModule 和 IHttpHandler 接口的类提供了对当前 HTTP 请求的 HttpContext 对象的引用。该对象提供对请求的内部 Request、Response 和

Server 属性的访问。

1.生存周期 :从客户端用户点击并产生了一个向服务器发送请求开始 ---服务器处理完请求并生成返回到客户端为止 .

注 :针对每个不同用户的请求 ,服务器都会创建一个新的 HttpContext 实例直到请求结束 ,服务器销毁这个实例 .

2.为什么会有 HttpContext 类呢 :在 ASP 年代 ,大家都是通过在 .asp 页面的代码中使用 Request,Respose,Server 等等这些 Http 特定信息的 .但在

ASP.NET 时代 ,这中方式已经无法满足应用 ,(比如我们要在 IHttpModule 中处理 Request 时 ,我们使用什么方法来获取呢 ?于是就产生了 HttpContext 类 ,它对

Request,Respose,Server 等等都进行了封装 ,并保证在整个请求周期内都可以随时随地的调用 .)

3.特殊性 :当然 HttpContext 不仅仅只有这点功能 .ASP.NET 中它还提供了很多特殊的功能 .例如 Cache.还有 HttpContext.Item,通过它你可以在

HttpContext 的生存周期内提前存储一些临时的数据 ,方便随时使用 .具体的大家还是参考上面的 MSDN 提供内容 .

93

104. HttpContext.Cache 和 HttpRuntime.Cache

Asp.Net 中可以方便的使用缓存，对于 Cache，一般有两种方式调用： HttpContext.Cache 和 HttpRuntime.Cache。那么这两种 Cache 有什么区别呢？

先来看看 Msdn 上的注释：

HttpRuntime.Cache：获取当前应用程序的 Cache。

HttpContext.Cache：为当前 HTTP 请求获取 Cache 对象。

那么是不是说对于 HttpRuntime.Cache 就是应用程序级，而 HttpContext.Cache 则是针对每个用户的呢？ NO，而实际上，两者调用的是同一个对象。他们的区

别仅仅在于调用方式不一样（就我所知）。

事实胜过雄辩，写个例子来证实一下（限于篇幅仅贴出关键代码，完整代码见附件 W ebDemo.rar）：

///

/// 通过 HttpRuntime.Cache 的方式来保存 Cache

///

private void btnHttpRuntimeCacheSave_Click(object sender, System.EventArgs e)

{

HttpRuntime.Cache.Insert(cacheKey, cacheValue, null, DateTime.Now.AddMinutes(3), TimeSpan.Zero);

}

///

/// 通过 HttpRuntime.Cache 的方式来读取 Cache

///

private void btnHttpRuntimeCacheLoad_Click(object sender, System.EventArgs e)

{

if (HttpRuntime.Cache[cacheKey] == null)

{

cacheContent = "No Cache";

}

else

{

cacheContent = (string)HttpRuntime.Cache[cacheKey];

}

lblCacheContent.Text = cacheContent;

}

///

/// 通过 HttpContext.Cache 的方式来保存 Cache

///

private void btnHttpContextCacheSave_Click(object sender, System.EventArgs e)

{

HttpContext.Current.Cache.Insert(cacheKey, cacheValue, null, DateTime.Now.AddMinutes(3), TimeSpan.Zero);

}

///

/// 通过 HttpContext.Cache 的方式来读取 Cache

///

private void btnHttpContextCacheLoad_Click(object sender, System.EventArgs e)

{

if (HttpContext.Current.Cache[cacheKey] == null)

{

cacheContent = "No Cache";

}

94

else

{

cacheContent = (string)HttpContext.Current.Cache[cacheKey];

}

lblCacheContent.Text = cacheContent;

}

通过这个例子可以很容易证明：

HttpContext.Cache 保存的 Cache， HttpContext.Cache 和 HttpRuntime.Cache 都可以读取。

HttpRuntime.Cache 保存的 Cache， HttpContext.Cache 和 HttpRuntime.Cache 都可以读取。

无论是哪个用户通过什么方式对 Cache 的改变，其他用户无论用什么方式读取的 Cache 内容也会随之变。

105. 用存储过程和触发器如何解决并发？

106. SQL 触发器

CREATE TRIGGER trigger_name

ON { table | view }

[ WITH ENCRYPTION ]

{

{ { FOR | AFTER | INSTEAD OF } { [ INSERT ] [ , ] [ UPDATE ] }

[ WITH APPEND ]

[ NOT FOR REPLICATION ]

AS

[ { IF UPDATE ( column )

[ { AND | OR } UPDATE ( column ) ]

[ ... n ]

| IF ( COLUMNS_UPDATED ( ) { bitwise_operator } updated_bitmask )

{ comparison_operator } column_bitmask [ ... n ]

} ]

sql_statement [ ... n ]

}

}

参数

trigger_name

是触发器的名称。触发器名称必须符合标识符规则，并且在数据库中必须唯一。可以选择是否指定触发器所有者名称。

Table | view

是在其上执行触发器的表或视图，有时称为触发器表或触发器视图。可以选择是否指定表或视图的所有者名称。

WITH ENCRYPTION

加密 syscomments 表中包含 CREATE TRIGGER 语句文本的条目。使用 WITH ENCRYPTION 可防止将触发器作为 SQL Server 复制的一部分发布。

AFTER

指定触发器只有在触发 SQL 语句中指定的所有操作都已成功执行后才激发。所有的引用级联操作和约束检查也必须成功完成后，才能执行此触发器。

如果仅指定 FOR 关键字，则 AFTER 是默认设置。

不能在视图上定义 AFTER 触发器。

INSTEAD OF

指定执行触发器而不是执行触发 SQL 语句，从而替代触发语句的操作。

在表或视图上，每个 INSERT、UPDATE 或 DELETE 语句最多可以定义一个 INSTEAD OF 触发器。然而，可以在每个具有 INSTEAD OF 触发器的视图上定义视图。

95

INSTEAD OF 触发器不能在 WITH CHECK OPTION 的可更新视图上定义。如果向指定了 WITH CHECK OPTION 选项的可更新视图添加 INSTEAD OF 触发器，SQL Server 将产生一个错误。

用户必须用 ALTER VIEW 删除该选项后才能定义 INSTEAD OF 触发器。

{ [DELETE] [,] [INSERT] [,] [UPDATE] }

是指定在表或视图上执行哪些数据修改语句时将激活触发器的关键字。必须至少指定一个选项。在触发器定义中允许使用以任意顺序组合的这些关键字。如果指定的选项多于一个，需用逗号分隔这些

选项。

对于 INSTEAD OF 触发器，不允许在具有 ON DELETE 级联操作引用关系的表上使用 DELETE 选项。同样，也不允许在具有 ON UPDATE 级联操作引用关系的表上使用 UPDATE 选项。

WITH APPEND

指定应该添加现有类型的其它触发器。只有当兼容级别是 65 或更低时，才需要使用该可选子句。如果兼容级别是 70 或更高，则不必使用 WITH APPEND 子句添加现有类型的其它触发器（这是兼

容级别设置为 70 或更高的 CREATE TRIGGER 的默认行为）。有关更多信息，请参见 sp_dbcmptlevel。

WITH APPEND 不能与 INSTEAD OF 触发器一起使用，或者，如果显式声明 AFTER 触发器，也不能使用该子句。只有当出于向后兼容而指定 FOR 时（没有 INSTEAD OF 或 AFTER），才能

使用 WITH APPEND。以后的版本将不支持 WITH APPEND 和 FOR（将被解释为 AFTER）。

NOT FOR REPLICATION

表示当复制进程更改触发器所涉及的表时，不应执行该触发器。

AS

是触发器要执行的操作。

sql_statement

是触发器的条件和操作。触发器条件指定其它准则，以确定 DELETE、INSERT 或 UPDATE 语句是否导致执行触发器操作。

当尝试 DELETE、INSERT 或 UPDATE 操作时，Transact-SQL 语句中指定的触发器操作将生效。

触发器可以包含任意数量和种类的 Transact-SQL 语句。触发器旨在根据数据修改语句检查或更改数据；它不应将数据返回给用户。触发器中的 Transact-SQL 语句常常包含控制流语言。CREATE

TRIGGER 语句中使用几个特殊的表：

 deleted 和 inserted 是逻辑（概念）表。这些表在结构上类似于定义触发器的表（也就是在其中尝试

用户操作的表）；这些表用于保存用户操作可能更改的行的旧值或新值。例如，若要检索 deleted 表中的

所有值，请使用：

 SELECT *

 FROM deleted

 如果兼容级别等于 70，那么在 DELETE、INSERT 或 UPDATE 触发器中，SQL Server 将不允许引用

inserted 和 deleted 表中的 text、ntext 或 image 列。不能访问 inserted 和 deleted 表中

的 text、 ntext 和 image 值。若要在 INSERT 或 UPDATE 触发器中检索新值，请将 inserted 表

与原始更新表联接。当兼容级别是 65 或更低时，对 inserted 或 deleted 表中允许空值的 text、

ntext 或 image 列，将返回空值；如果这些列不可为空，则返回零长度字符串。

当兼容级别是 80 或更高时，SQL Server 允许在表或视图上通过 INSTEAD OF 触发器更新 text、ntext 或 image 列。

n

是表示触发器中可以包含多条 Transact-SQL 语句的占位符。对于 IF UPDATE (column) 语句，可以通过重复 UPDATE (column) 子句包含多列。

IF UPDATE (column)

测试在指定的列上进行的 INSERT 或 UPDATE 操作，不能用于 DELETE 操作。可以指定多列。因为在 ON 子句中指定了表名，所以在 IF UPDATE 子句中的列名前不要包含表名。若要测试在多

个列上进行的 INSERT 或 UPDATE 操作，请在第一个操作后指定单独的 UPDATE(column) 子句。在 INSERT 操作中 IF UPDATE 将返回 TRUE 值，因为这些列插入了显式值或隐性 (NULL)

值。

说明 IF UPDATE (column) 子句的功能等同于 IF、IF...ELSE 或 WHILE 语句，并且可以使用 BEGIN...END 语句块。有关更多信息，请参见控制流语言。

96

可以在触发器主体中的任意位置使用 UPDATE (column)。

column

是要测试 INSERT 或 UPDATE 操作的列名。该列可以是 SQL Server 支持的任何数据类型。但是，计算列不能用于该环境中。有关更多信息，请参见数据类型。

IF (COLUMNS_UPDATED())

测试是否插入或更新了提及的列，仅用于 INSERT 或 UPDATE 触发器中。COLUMNS_UPDATED 返回 varbinary 位模式，表示插入或更新了表中的哪些列。

COLUMNS_UPDATED 函数以从左到右的顺序返回位，最左边的为最不重要的位。最左边的位表示表中的第一列；向右的下一位表示第二列，依此类推。如果在表上创建的触发器包含 8 列以上，则

COLUMNS_UPDATED 返回多个字节，最左边的为最不重要的字节。在 INSERT 操作中 COLUMNS_UPDATED 将对所有列返回 TRUE 值，因为这些列插入了显式值或隐性 (NULL) 值。

可以在触发器主体中的任意位置使用 COLUMNS_UPDATED。

bitwise_operator

是用于比较运算的位运算符。

updated_bitmask

是整型位掩码，表示实际更新或插入的列。例如，表 t1 包含列 C1、C2、C3、C4 和 C5。假定表 t1 上有 UPDATE 触发器，若要检查列 C2、C3 和 C4 是否都有更新，指定值 14；若要检

查是否只有列 C2 有更新，指定值 2。

comparison_operator

是比较运算符。使用等号 (=) 检查 updated_bitmask 中指定的所有列是否都实际进行了更新。使用大于号 (>) 检查 updated_bitmask 中指定的任一列或某些列是否已更新。

column_bitmask

是要检查的列的整型位掩码，用来检查是否已更新或插入了这些列。

注释

触发器常常用于强制业务规则和数据完整性。SQL Server 通过表创建语句（ALTER TABLE 和 CREATE TABLE）提供声明引用完整性 (DRI)；但是 DRI 不提供数据库间的引用完整性。若要强制

引用完整性（有关表的主键和外键之间关系的规则），请使用主键和外键约束（ALTER TABLE 和 CREATE TABLE 的 PRIMARY KEY 和 FOREIGN KEY 关键字）。如果触发器表存在约束，则在

INSTEAD OF 触发器执行之后和 AFTER 触发器执行之前检查这些约束。如果违反了约束，则回滚 INSTEAD OF 触发器操作且不执行（激发）AFTER 触发器。

可用 sp_settriggerorder 指定表上第一个和最后一个执行的 AFTER 触发器。在表上只能为每个 INSERT、UPDATE 和 DELETE 操作指定一个第一个执行和一个最后一个执行的 AFTER 触

发器。如果同一表上还有其它 AFTER 触发器，则这些触发器将以随机顺序执行。

如果 ALTER TRIGGER 语句更改了第一个或最后一个触发器，则将除去已修改触发器上设置的第一个或最后一个特性，而且必须用 sp_settriggerorder 重置排序值。

只有当触发 SQL 语句（包括所有与更新或删除的对象关联的引用级联操作和约束检查）成功执行后，AFTER 触发器才会执行。AFTER 触发器检查触发语句的运行效果，以及所有由触发语句引起的

UPDATE 和 DELETE 引用级联操作的效果。

触发器限制

CREATE TRIGGER 必须是批处理中的第一条语句，并且只能应用到一个表中。

触发器只能在当前的数据库中创建，不过触发器可以引用当前数据库的外部对象。

如果指定触发器所有者名称以限定触发器，请以相同的方式限定表名。

在同一条 CREATE TRIGGER 语句中，可以为多种用户操作（如 INSERT 和 UPDATE）定义相同的触发器操作。

如果一个表的外键在 DELETE/UPDATE 操作上定义了级联，则不能在该表上定义 INSTEAD OF DELETE/UPDATE 触发器。

在触发器内可以指定任意的 SET 语句。所选择的 SET 选项在触发器执行期间有效，并在触发器执行完后恢复到以前的设置。

与使用存储过程一样，当触发器激发时，将向调用应用程序返回结果。若要避免由于触发器激发而向应用程序返回结果，请不要包含返回结果的 SELECT 语句，也不要包含在触发器中进行变量赋值

的语句。包含向用户返回结果的 SELECT 语句或进行变量赋值的语句的触发器需要特殊处理；这些返回的结果必须写入允许修改触发器表的每个应用程序中。如果必须在触发器中进行变量赋值，则

应该在触发器的开头使用 SET NOCOUNT 语句以避免返回任何结果集。

97

DELETE 触发器不能捕获 TRUNCATE TABLE 语句。尽管 TRUNCATE TABLE 语句实际上是没有 WHERE 子句的 DELETE（它删除所有行），但它是无日志记录的，因而不能执行触发器。因为

TRUNCATE TABLE 语句的权限默认授予表所有者且不可转让，所以只有表所有者才需要考虑无意中用 TRUNCATE TABLE 语句规避 DELETE 触发器的问题。

无论有日志记录还是无日志记录，WRITETEXT 语句都不激活触发器。

触发器中不允许以下 Transact-SQL 语句：

ALTER DATABASE CREATE DATABASE DISK INIT

DISK RESIZE DROP DATABASE LOAD DATABASE

LOAD LOG RECONFIGURE RESTORE DATABASE

RESTORE LOG

说明由于 SQL Server 不支持系统表中的用户定义触发器，因此建议不要在系统表中创建用户定义触发器。

多个触发器

SQL Server 允许为每个数据修改事件（DELETE、INSERT 或 UPDATE）创建多个触发器。例如，如果对已有 UPDATE 触发器的表执行 CREATE TRIGGER FOR UPDATE，则将创建另一个更

新触发器。在早期版本中，在每个表上，每个数据修改事件（INSERT、UPDATE 或 DELETE）只允许有一个触发器。

说明如果触发器名称不同，则 CREATE TRIGGER（兼容级别为 70）的默认行为是在现有的触发器中添加其它触发器。如果触发器名称相同，则 SQL Server 返回一条错误信息。但是，如果兼容

级别等于或小于 65，则使用 CREATE TRIGGER 语句创建的新触发器将替换同一类型的任何现有触发器，即使触发器名称不同。有关更多信息，请参见 sp_dbcmptlevel。

递归触发器

当在 sp_dboption 中启用 recursive triggers 设置时，SQL Server 还允许触发器的递归调用。

递归触发器允许发生两种类型的递归：

 间接递归

 直接递归

使用间接递归时，应用程序更新表 T1，从而激发触发器 TR1，该触发器更新表 T2。在这种情况下，触发器 T2 将激发并更新 T1。

使用直接递归时，应用程序更新表 T1，从而激发触发器 TR1，该触发器更新表 T1。由于表 T1 被更新，触发器 TR1 再次激发，依此类推。

下例既使用了间接触发器递归，又使用了直接触发器递归。假定在表 T1 中定义了两个更新触发器 TR1 和 TR2。触发器 TR1 递归地更新表 T1。UPDATE 语句使 TR1 和 TR2 各执行一次。

而 TR1 的执行将触发 TR1（递归）和 TR2 的执行。给定触发器的 inserted 和 deleted 表只包含与唤醒调用触发器的 UPDATE 语句相对应的行。

说明只有启用 sp_dboption 的 recursive triggers 设置，才会发生上述行为。对于为给定事件定义的多个触发器，并没有确定的执行顺序。每个触发器都应是自包含的。

禁用 recursive triggers 设置只能禁止直接递归。若要也禁用间接递归，请使用 sp_configure 将 nested triggers 服务器选项设置为 0。

如果任一触发器执行了 ROLLBACK TRANSACTION 语句，则无论嵌套级是多少，都不会进一步执行其它触发器。

嵌套触发器

触发器最多可以嵌套 32 层。如果一个触发器更改了包含另一个触发器的表，则第二个触发器将激活，然后该触发器可以再调用第三个触发器，依此类推。如果链中任意一个触发器引发了无限循环，

则会超出嵌套级限制，从而导致取消触发器。若要禁用嵌套触发器，请用 sp_configure 将 nested triggers 选项设置为 0（关闭）。默认配置允许嵌套触发器。如果嵌套触发器是关闭的，则

也将禁用递归触发器，与 sp_dboption 的 recursive triggers 设置无关。

延迟名称解析

98

SQL Server 允许 Transact-SQL 存储过程、触发器和批处理引用编译时不存在的表。这种能力称为延迟名称解析。但是，如果 Transact-SQL 存储过程、触发器或批处理引用在存储过程或触发

器中定义的表，则只有当兼容级别设置（通过执行 sp_dbcmptlevel 设置）等于 65 时，才会在创建时发出警告。如果使用批处理，则在编译时发出警告。如果引用的表不存在，将在运行时返回

错误信息。有关更多信息，请参见延迟名称解析和编译。

权限

CREATE TRIGGER 权限默认授予定义触发器的表所有者、sysadmin 固定服务器角色成员以及 db_owner 和 db_ddladmin 固定数据库角色成员，并且不可转让。

若要检索表或视图中的数据，用户必须在表或视图中拥有 SELECT 语句权限。若要更新表或视图的内容，用户必须在表或视图中拥有 INSERT、DELETE 和 UPDATE 语句权限。

如果视图中存在 INSTEAD OF 触发器，用户必须在该视图中有 INSERT、DELETE 和 UPDATE 特权，以对该视图发出 INSERT、DELETE 和 UPDATE 语句，而不管实际上是否在视图上执行了

这样的操作。

示例

A. 使用带有提醒消息的触发器

当有人试图在 titles 表中添加或更改数据时，下例将向客户端显示一条消息。

说明消息 50009 是 sysmessages 中的用户定义消息。有关创建用户定义消息的更多信息，请参见 sp_addmessage。

USE pubs

IF EXISTS (SELECT name FROM sysobjects

WHERE name = 'reminder' AND type = 'TR')

DROP TRIGGER reminder

GO

CREATE TRIGGER reminder

ON titles

FOR INSERT, UPDATE

AS RAISERROR (50009, 16, 10)

GO

B. 使用带有提醒电子邮件的触发器

当 titles 表更改时，下例将电子邮件发送给指定的人员 (MaryM)。

USE pubs

IF EXISTS (SELECT name FROM sysobjects

WHERE name = 'reminder' AND type = 'TR')

DROP TRIGGER reminder

GO

CREATE TRIGGER reminder

ON titles

FOR INSERT, UPDATE, DELETE

AS

EXEC master..xp_sendmail 'MaryM',

'Don''t forget to print a report for the distributors.'

GO

99

C. 在 employee 和 jobs 表之间使用触发器业务规则

由于 CHECK 约束只能引用定义了列级或表级约束的列，表间的任何约束（在下例中是指业务规则）都必须定义为触发器。

下例创建一个触发器，当插入或更新雇员工作级别 (job_lvls) 时，该触发器检查指定雇员的工作级别（由此决定薪水）是否处于为该工作定义的范围内。若要获得适当的范围，必须引用 jobs 表。

USE pubs

IF EXISTS (SELECT name FROM sysobjects

WHERE name = 'employee_insupd' AND type = 'TR')

DROP TRIGGER employee_insupd

GO

CREATE TRIGGER employee_insupd

ON employee

FOR INSERT, UPDATE

AS

/* Get the range of level for this job type from the jobs table. */

DECLARE @min_lvl tinyint,

@max_lvl tinyint,

@emp_lvl tinyint,

@job_id smallint

SELECT @min_lvl = min_lvl,

@max_lvl = max_lvl,

@emp_lvl = i.job_lvl,

@job_id = i.job_id

FROM employee e INNER JOIN inserted i ON e.emp_id = i.emp_id

JOIN jobs j ON j.job_id = i.job_id

IF (@job_id = 1) and (@emp_lvl 10)

BEGIN

RAISERROR ('Job id 1 expects the default level of 10.', 16, 1)

ROLLBACK TRANSACTION

END

ELSE

IF NOT (@emp_lvl BETWEEN @min_lvl AND @max_lvl)

BEGIN

RAISERROR ('The level for job_id:%d should be between %d and %d.',

16, 1, @job_id, @min_lvl, @max_lvl)

ROLLBACK TRANSACTION

END

D. 使用延迟名称解析

下例创建两个触发器以说明延迟名称解析。

USE pubs

IF EXISTS (SELECT name FROM sysobjects

WHERE name = 'trig1' AND type = 'TR')

DROP TRIGGER trig1

GO

-- Creating a trigger on a nonexistent table.

CREATE TRIGGER trig1

on authors

FOR INSERT, UPDATE, DELETE

AS

100

SELECT a.au_lname, a.au_fname, x.info

FROM authors a INNER JOIN does_not_exist x

ON a.au_id = x.au_id

GO

-- Here is the statement to actually see the text of the trigger.

SELECT o.id, c.text

FROM sysobjects o INNER JOIN syscomments c

ON o.id = c.id

WHERE o.type = 'TR' and o.name = 'trig1'

-- Creating a trigger on an existing table, but with a nonexistent

-- column.

USE pubs

IF EXISTS (SELECT name FROM sysobjects

WHERE name = 'trig2' AND type = 'TR')

DROP TRIGGER trig2

GO

CREATE TRIGGER trig2

ON authors

FOR INSERT, UPDATE

AS

DECLARE @fax varchar(12)

SELECT @fax = phone

FROM authors

GO

-- Here is the statement to actually see the text of the trigger.

SELECT o.id, c.text

FROM sysobjects o INNER JOIN syscomments c

ON o.id = c.id

WHERE o.type = 'TR' and o.name = 'trig2'

E. 使用 COLUMNS_UPDATED

下例创建两个表：一个 employeeData 表和一个 auditEmployeeData 表。人力资源部的成员可以修改 employeeData 表，该表包含敏感的雇员薪水信息。如果更改了雇员的社会保险号

码 (SSN)、年薪或银行帐户，则生成审核记录并插入到 auditEmployeeData 审核表。

通过使用 COLUMNS_UPDATED() 功能，可以快速测试对这些包含敏感雇员信息的列所做的更改。只有在试图检测对表中的前 8 列所做的更改时，COLUMNS_UPDATED() 才起作用。

USE pubs

IF EXISTS(SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES

WHERE TABLE_NAME = 'employeeData')

DROP TABLE employeeData

IF EXISTS(SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES

WHERE TABLE_NAME = 'auditEmployeeData')

DROP TABLE auditEmployeeData

GO

CREATE TABLE employeeData (

emp_id int NOT NULL,

emp_bankAccountNumber char (10) NOT NULL,

emp_salary int NOT NULL,

emp_SSN char (11) NOT NULL,

emp_lname nchar (32) NOT NULL,

emp_fname nchar (32) NOT NULL,

101

emp_manager int NOT NULL

)

GO

CREATE TABLE auditEmployeeData (

audit_log_id uniqueidentifier DEFAULT NEWID(),

audit_log_type char (3) NOT NULL,

audit_emp_id int NOT NULL,

audit_emp_bankAccountNumber char (10) NULL,

audit_emp_salary int NULL,

audit_emp_SSN char (11) NULL,

audit_user sysname DEFAULT SUSER_SNAME(),

audit_changed datetime DEFAULT GETDATE()

)

GO

CREATE TRIGGER updEmployeeData

ON employeeData

FOR update AS

/*Check whether columns 2, 3 or 4 has been updated. If any or all of columns 2, 3 or 4 have been changed, create an audit

record. The bitmask is: power(2,(2-1))+power(2,(3-1))+power(2,(4-1)) = 14. To check if all columns 2, 3, and 4 are updated,

use = 14 in place of >0 (below).*/

IF (COLUMNS_UPDATED() & 14) > 0

/*Use IF (COLUMNS_UPDATED() & 14) = 14 to see if all of columns 2, 3, and 4 are updated.*/

BEGIN

-- Audit OLD record.

INSERT INTO auditEmployeeData

(audit_log_type,

audit_emp_id,

audit_emp_bankAccountNumber,

audit_emp_salary,

audit_emp_SSN)

SELECT 'OLD',

del.emp_id,

del.emp_bankAccountNumber,

del.emp_salary,

del.emp_SSN

FROM deleted del

-- Audit NEW record.

INSERT INTO auditEmployeeData

(audit_log_type,

audit_emp_id,

audit_emp_bankAccountNumber,

audit_emp_salary,

audit_emp_SSN)

SELECT 'NEW',

ins.emp_id,

ins.emp_bankAccountNumber,

ins.emp_salary,

ins.emp_SSN

FROM inserted ins

102

END

GO

/*Inserting a new employee does not cause the UPDATE trigger to fire.*/

INSERT INTO employeeData

VALUES ( 101, 'USA-987-01', 23000, 'R-M53550M', N'Mendel', N'Roland', 32)

GO

/*Updating the employee record for employee number 101 to change the salary to 51000 causes the UPDATE trigger to fire

and an audit trail to be produced.*/

UPDATE employeeData

SET emp_salary = 51000

WHERE emp_id = 101

GO

SELECT * FROM auditEmployeeData

GO

/*Updating the employee record for employee number 101 to change both the bank account number and social security number

(SSN) causes the UPDATE trigger to fire and an audit trail to be produced.*/

UPDATE employeeData

SET emp_bankAccountNumber = '133146A0', emp_SSN = 'R-M53550M'

WHERE emp_id = 101

GO

SELECT * FROM auditEmployeeData

GO

F. 使用 COLUMNS_UPDATED 测试 8 列以上

如果必须测试影响到表中前 8 列以外的列的更新时，必须使用 UBSTRING 函数测试由 COLUMNS_UPDATED 返回的适当的位。下例测试影响 Northwind.dbo.Customers 表中的第 3、第

5 或第 9 列的更新。

USE Northwind

DROP TRIGGER tr1

GO

CREATE TRIGGER tr1 ON Customers

FOR UPDATE AS

IF ( (SUBSTRING(COLUMNS_UPDATED(),1,1)=power(2,(3-1))

+ power(2,(5-1)))

AND (SUBSTRING(COLUMNS_UPDATED(),2,1)=power(2,(1-1)))

)

PRINT 'Columns 3, 5 and 9 updated'

GO

UPDATE Customers

SET ContactName=ContactName,

Address=Address,

Country=Country

GO

107. 描述从 web 页面请求到页面返回的主要事件和过程

页面生命周期执行一系列步骤：页面的初始化、实例化控件、还原和维护状态、运行事件处理程序代码、呈现。为了在合适的阶段执行所需的代码，所以要对

页面生命周期非常熟悉。在页生命周期的各个阶段，页面会逐个引发定义的事件，通过对代码开发，在页面的生命事件中执行我们所需要的程序

页生命周期阶段

1、页请求：发生在页面生命周期之前，用户请求页时，ASP.NET 将确定是否需要分析和编译页，从而确定是否开始页面的生命周期，或者是否可以在不运行

页的情况下发送页面缓存以进行响应。

2、开始：设置页属性，如：HttpContext 以及其他属性；在此阶段，页面需要确定是回发请求还是新请求，并设置 IsPostBack 属性；设置页面的 UICulture

103

属性。

3、页面初始化：加载所有主题；控件生成，并设置 UniqueID；

注： ViewState、 ControlState 中的值还未加载至控件；如果页面是回发，则回发数据也还未加载；故此时控件可以访问，但值可能出错。

4、加载：如果当前请求是回发请求，则为控件加载 ViewState 和 ControlState 中的值。

5、验证：调用所有验证程序控件的 Validate 方法，此方法将设置验证程序控件和页的 IsValid 属性。

6、回发事件处理：如果请求是回发请求，则调用所有事件处理程序。

7、呈现：首先对该页和所有控件进行保存视图状态，然后对每个控件调用 Render 方法，它会提供一个文本编写器，用于将控件的输入写入页的 Response

属性的 OutputStream 中。

8、卸载：完成呈现，并已将页发送至客户端、准备丢弃该页后，调用卸载。将卸载属性如： Response 和 Request 等等。

页生命周期事件：

1、 PreInit

完成操作：检查 IsPostBack 属性来确定是不是第一次处理该页；

创建或重新创建动态控件

动态设置主控页

动态设置 Theme 属性

读取或设置配置文件属性

注：如果请求是回发请求，则控件的值尚未从视图状态恢复，即：不应该在此事件中设置控件属性。

2、 Init

完成操作：在所有控件都已经初始化并且应用所有外观设置后引发。使用该事件来读取和初始化控件属性。

3、 InitComplete

完成操作：由 Page 对象引发，使用该事件来处理要求完成所有初始化工作的任务。

4、 PreLoad

完成操作：为页和所有控件加载视图状态，然后处理 Request 实例包括的任何回发数据。

注：如果需要在 Load 之前对页或控件进行处理，需要该事件。

5、 Load

完成操作：以递归方式加载所有控件。

6、控件事件

完成操作：处理控件引发的事件。

注：在回发请求中，如果页包含验证程序控件，请在执行任何处理之前检查 Page 和各个验证控件的 IsValid 属性。

7、 LoadComplete

8、 PreRender

在控件输出前最后的修改机会。

注：在该事件发生前的操作：

Page 对所有控件递归进行 EnsureChildControl 操作

设置了 DataSourceID 属性的数据绑定控件会调用 DataBind 方法。

9、 SaveStateComplete

在该事件发生前，已经对控件的 ViewState 进行了保存。将忽略对页和控件所作的所有修改。

10、 Render

方法，便于开发

11、 UnLoad

应用程序生命周期

在应用程序的生命周期期间，应用程序会引发可处理的事件并调用可重写的特定方法。若要处理应用程序事件或方法，可以在应用程序根目录中创建一个名为

Global.asax 的文件。如果创建了 Global.asax 文件， ASP.NET 会将其编译为从 HttpApplication 类派生的类，然后使用该派生类表示应用程序。

HttpApplication 进程的一个实例每次只处理一个请求。由于在访问应用程序类中的非静态成员时不需要将其锁定，这样可以简化应用程序的事件处理过程。

这样还可以将特定于请求的数据存储在应用程序类的非静态成员中。例如，可以在 Global.asax 文件中定义一个属性，然后为该属性赋一个特定于请求的值。

在

Application_Start 和 Application_End 方法是不表示 HttpApplication 事件的特殊方法。应用程序域的生命周期期间，ASP.NET 仅调用这些方法一次，

而不是对每个 HttpApplication 实例都调用一次。

104

108. 怎样理解 web 应用程序的“无状态编程”？

http 是 hyper text transfer protocol 的缩写，顾名思义，这个协议支持着超文本的传输。那么什么是超文本呢？说白了就是使用 html 编写的页面。通常，

我们使用客户端浏览器访问服务器的资源，最常见的 url 也是以 html 为后缀的文件。因此，我们可以说超文本是网络上最主要的资源。

既然 http 协议的目的在于支持超文本的传输，更加广义一些就是支持资源的传输，那么在客户端浏览器向 http 服务器发送请求，继而 http

服务器将相应的资源发回给客户端这样一个过程中，无论对于客户端还是服务器，都没有必要记录这个过程，因为每一次请求和响应都是相对独立的，就好

像你在自动售货机前投下硬币购买商品一样，谁都不会也不需要记住这样一个交易过程。一般而言，一个 url 对应着唯一的超文本，而 http 服务器也绝对公

不还它正使

平公正，管你是 michael，是 jordon，都会根据接收到的 url 请求返回相同的超文本。是因为这样的唯一性，得记录用户的行为状态变得毫无意义，

所以，http 协议被设计为无状态的连接协议符合它本身的需求。然而，随着时间的推移，人们发现静态的 html 着实无聊而乏味，增加动态生成的内容才会

令 web 应用程序变得更加有用。于是乎， html 的语法在不断膨胀，其中最重要的是增加了表单（ form）；客户端也增加了诸如脚本处理、 dom 处理等功能；

对于服务器，则相应的出现了 cgi（ common gateway interface）以处理包含表单提交在内的动态请求。在这种客户端与服务器进行动态交互的 web 应用程序

出现之后， http 无状态的特性严重阻碍了这些应用程序的实现，毕竟交互是需要承前启后的，简单的购物车程序也要知道用户到底在之前选择了什么商品。

于是，两种用于保持 http 连接状态的技术就应运而生了，一个是 cookie，而另一个则是 session。 cookie 是通过客户端保持状态的解决方案。从定义上来

说， cookie 就是由服务器发给客户端的特殊信息，而这些信息以文本文件的方式存放在客户端，然后客户端每次向服务器发送请求的时候都会带上这些特殊

的信息。让我们说得更具体一些：当用户使用浏览器访问一个支持 cookie 的网站的时候，用户会提供包括用户名在内的个人信息并且提交至服务器；接着，

服务器在向客户端回传相应的超文本的同时也会发回这些个人信息，当然这些信息并不是存放在 http 响应体（ response body）中的，而是存放于 http 响应

头（ response header）；当客户端浏览器接收到来自服务器的响应之后，浏览器会将这些信息存放在一个统一的位置，对于 windows 操作系统而言，我们可

以从： [系统盘 ]:\documents and settings\[用户名 ]\cookies 目录中找到存储的 cookie；自此，客户端再向服务器发送请求的时候，都会把相应的 cookie

再次发回至服务器。而这次， cookie 信息则存放在 http 请求头（ request header）了。

服就

有了 cookie 这样的技术实现，务器在接收到来自客户端浏览器的请求之后，能够通过分析存放于请求头的 cookie 得到客户端特有的信息，

从而动态生成与该客户端相对应的内容。通常，我们可以从很多网站的登录界面中看到 “请记住我”这样的选项，如果你勾选了它之后再登录，那么在下一

次访问该网站的时候就不需要进行重复而繁琐的登录动作了，而这个功能就是通过 cookie 实现的。

它由因

与 cookie 相对的一个解决方案是 session，是通过服务器来保持状态的。于 session 这个词汇包含的语义很多，此需要在这里明确一下 session

的含义。首先，我们通常都会把 session 翻译成会话，因此我们可以把客户端浏览器与服务器之间一系列交互的动作称为一个 session。从这个语义出发，我

们会提到 session 持续的时间，会提到在 session 过程中进行了什么操作等等；其次，session 指的是服务器端为客户端所开辟的存储空间，在其中保存的信

息就是用于保持状态。从这个语义出发，我们则会提到往 session 中存放什么内容，如何根据键值从 session 中获取匹配的内容等。

要使用 session，第一步当然是创建 session 了。那么 session 在何时创建呢？当然还是在服务器端程序运行的过程中创建的，不同语言实现的应

用程序有不同创建 session 的方法，而在 java 中是通过调用 httpservletrequest 的 getsession 方法（使用 true 作为参数）创建的。在创建了 session 的

同时，服务器会为该 session 生成唯一的 session id，而这个 session id 在随后的请求中会被用来重新获得已经创建的 session；在 session 被创建之后，

就可以调用 session 相关的方法往 session 中增加内容了，而这些内容只会保存在服务器中，发到客户端的只有 session id；当客户端再次发送请求的时候，

会将这个 session id 带上，服务器接受到请求之后就会依据 session id 找到相应的 session，从而再次使用之。正式这样一个过程，用户的状态也就得以保

持了。有关 session 的内容还比较多，在以后的 post 中，我还将继续讲述。

综上所述， http 本身是一个无状态的连接协议，为了支持客户端与服务器之间的交互，我们就需要通过不同的技术为交互存储状态，而这些不同的技术

就是 cookie 和 session 了。

109. 请你列举你最熟悉的.net 名称空间以及他们的主要内容.

.NET Framework 中的基本编程命名空间包括：

 System.Collections — 它包含的接口和类定义各种对象（如列表、队列、数组、哈希表和字典）集合。

 System.Collections.Generic -- 包含定义泛型集合的接口和类；泛型集合允许用户创建强类型的集合，这种集合在类型安全和性能上均优于非泛型强类型集合。

 System.IO — 它包含的类型用于支持数据流和文件的同步和异步读写。

 System.Text — 它包含表示 ASCII、Unicode、UTF-7 和 UTF-8 字符编码的类；用于来回转换字符块和字节块的抽象基类；以及在不创建 String 中间实例

的情况下操作和格式化 String 对象的帮助器类。

 System.Threading — 提供启用多线程编程的类和接口。此命名空间包括一个管理线程组的 ThreadPool 类，一个启用在指定时间后要调用的委托的 Timer 类，

以及一个同步互斥线程的 Mutex 类。System.Threading 还为线程调度和等待通知提供了相应的类。

.NET Framework 中的数据和 XML 命名空间包括：

 System.Data — 由构成 ADO.NET 结构的类组成，该结构是托管应用程序的主要数据访问方法。ADO.NET 结构使您可以生成可用于有效管理来自多个数据源的

数据的组件。ADO.NET 还提供对分布式应用程序中的数据进行请求、更新和协调的工具。

105

 System.Data.Common — 包含由 .NET Framework 数据提供程序共享的类。数据提供程序描述一个类的集合，这些类用于在托管空间中访问数据源，例如数

据库。

 System.Xml — 根据标准来支持 XML 处理的类。

 System.Data.SqlClient — 构成 SQL Server .NET Framework 数据提供程序的类，该提供程序允许您连接到 SQL Server 7.0、执行命令并读取结果。

System.Data.SqlClient 命名空间与 System.Data.OleDb 命名空间类似，但为访问 SQL Server 7.0 和更高版本进行了优化。

 System.Transactions -- 允许您编写自己的事务性应用程序和资源管理器的类。具体来说，您可以创建事务并和一个或多个参与者参与事务（本地或分布式

110. 您经常访问哪些有关.net 的网站？

111. .net framework 逻辑上分几个部分.

112. SQLSERVER 服务器中，给定表 table1 中有两个字段 ID、LastUpdateDate，ID 表示

更新的事务号，LastUpdateDate 表示更新时的服务器时间，请使用一句 SQL 语句获得最后

更新的事务号.(10)

Select ID

FROM table1

Where LastUpdateDate = (Select MAX(LastUpdateDate) FROM table1)

113. 简要谈一下您对微软.NET 构架下 remoting 和 webservice 两项技术的理解以及实际中

的应用.(10)

WS 主要是可利用 HTTP，穿透防火墙 .而 Remoting 可以利用 TCP/IP，二进制传送提高效率 .

114. 公司要求开发一个继承 System.Windows.Forms.ListView 类的组件，要求达到以下的

特殊功能：点击 ListView 各列列头时，能按照点击列的每行值进行重排视图中的所有行 (排

序的方式如 DataGrid 相似).根据您的知识，请简要谈一下您的思路：(10)

根据点击的列头 ,包该列的 ID 取出 ,按照该 ID 排序后 ,在给绑定到 ListView 中

115. 在.net 中，配件的意思是？

程序集 .（中间语言，源数据，资源，装配清单）

116. 根据线程安全的相关知识，分析以下代码，当调用 test 方法时 i>10 时是否会引起死锁?

并简要说明理由.

public void test(int i)

{

lock(this)

{

if (i>10)

{

i--;

test(i);

}

}

}

不会发生死锁，（但有一点 int 是按值传递的，所以每次改变的都只是一个副本，因此不会出现死锁 .但如果把 int 换做一个 object，那么死锁会发生）

117. 如何处理几十万条并发数据？

用存储过程或事务 .取得最大标识的时候同时更新 ..注意主键不是自增量方式这种方法并发的时候是不会有重复主键的 ..取得最大标识要有一个存储过程来获

106

取.

118. Session 相关问题

asp 中 Session 的工作原理：

asp 的 Session 是具有进程依赖性的。 ASP Session 状态存于 IIS 的进程中，也就是 inetinfo.exe 这个程序。所以当 inetinfo.exe 进程崩溃时，这些信息也

就丢失。另外，重起或者关闭 IIS 服务都会造成信息的丢失。

asp.net Session 的实现

asp.net 的 Session 是基于 HttpModule 技术做的， HttpModule 可以在请求被处理之前，对请求进行状态控制，由于 Session 本身就是用来做状态维护的，因

此用 HttpModule 做 Session 是再合适不过了。

存储位置

InProc： session 在服务器中以活动对象方式存储（ aspnet_wp.exe）

StateServer: session 被序列化并保存在单独的 aspnet_state.exe 的内存中。 StateServer 能够运行在另一台服务器上

SQLServer: session 被序列化并保存在 SQL Server 中

性能：

InProc：最快，但是 session 数据越多， web 服务器上消耗的内存也越多，它可能影响性能。

StateServer：如果你存储大量对象，序列化和反序列化可能影响到性能

SQLServer：它也有与 StateServer 一样的序列化性能问题。

健壮性

InProc：如果工作者进程（ aspnet_wp.exe）进行资源回收或者应用程序域 (appdomain)重启动， session state 就会丢失。这是因为 session state 是保存在

一个应用程序域的内存空间中的。对配置文件（如 web.config 和 machine.config）的修改或者 \bin 目录的任何改变（例如在你使用 VS 编译应用程序后产生

了一个新的 dll）都可能引起重启动。

StateServer：解决了 InProc 模式的 session state 丢失问题。允许一个 webfarm 在中央服务器中存储 session。只能在 State Server 上出现失败。

SQLServer：与 StateServer 相似。 session state 的数据在 SQL Server 重启后仍然保留着。

警告

InProc：它不能在 web garden 模式下工作，因为在这个模式下会有多个 aspnet_wp.exe 在同一台机器上运行。建议在使用 web garden 使切换到 State Server

或 SQL Server。仅在 InProc 模式下支持 Session_End 事件。

Session 丢失原因

原因 1： bin 目录中的文件被改写， asp.net 有一种机制，为了保证 dll 重新编译之后，系统正常运行，它会重新启动一次网站进程，这时就会导致 Session

丢失，所以如果有 access 数据库位于 bin 目录，或者有其他文件被系统改写，就会导致 Session 丢失

文如一系而

原因 2：件夹选项中，果没有打开 “ 在单独的进程中打开文件夹窗口 ” ，旦新建一个窗口，统可能认为是新的 Session 会话，无法访问原来的 Session，

所以需要打开该选项，否则会导致 Session 丢失

原因 3：似乎大部分的 Session 丢失是客户端引起的，所以要从客户端下手，看看 cookie 有没有打开

原因 4： Session 的时间设置是不是有问题，会不会因为超时造成丢失

原因 5： IE 中的 cookie 数量限制（每个域 20 个 cookie）可能导致 session 丢失

原因 6：使用 web garden 模式，且使用了 InProc mode 作为保存 session 的方式

解决丢失的经验

1. 判断是不是原因 1 造成的，可以在每次刷新页面的时候，跟踪 bin 中某个文件的修改时间

2. 做 Session 读写日志，每次读写 Session 都要记录下来，并且要记录 SessionID、Session 值、所在页面、当前函数、函数中的第几次 Session 操作，这样

找丢失的原因会方便很多

3. 如果允许的话，建议使用 state server 或 sql server 保存 session，这样不容易丢失

4. 在 global.asa 中加入代码记录 Session 的创建时间和结束时间，超时造成的 Session 丢失是可以在 SessionEnd 中记录下来的。

5. 如果有些代码中使用客户端脚本，如 javascript 维护 Session 状态，就要尝试调试脚本，是不是因为脚本错误引起 Session 丢失

119. 堆和栈的区别？

堆（ Heap）栈（ Stack）

1、内存分配方面：

107

堆：一般由程序员分配释放，若程序员不释放，程序结束时可能由 OS 回收。注意它与数据结构中的堆是两回事，分配方式是类似于链表。可能用到

的关键字如下： new、 malloc、 delete、 free 等等。

栈：由编译器 (Compiler)自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、申请方式方面：

堆：需要程序员自己申请，并指明大小。在 c 中 malloc 函数如 p1 = (char *)malloc(10)；在 C++中用 new 运算符，但是注意 p1、p2 本身是在栈中的。

因为他们还是可以认为是局部变量。

栈：由系统自动分配。例如，声明在函数中一个局部变量 int b；系统自动在栈中为 b 开辟空间。

3、系统响应方面：

堆：操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点

从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样代码中的 delete

语句才能正确的释放本内存空间。另外由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

4、大小限制方面：

堆：是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由

低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

栈：在 Windows 下 , 栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在

WINDOWS 下，栈的大小是固定的（是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示 overflow。因此，能从栈获得的空间较小。

5、效率方面：

堆：是由 new 分配的内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便，另外，在 WINDOWS 下，最好的方式是用 VirtualAlloc 分配

内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

栈：由系统自动分配，速度较快。但程序员是无法控制的。

6、存放内容方面：

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

栈：在函数调用时第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址然后是函数的各个参数，在大多数的 C 编译

器中，参数是由右往左入栈，然后是函数中的局部变量。注意: 静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指

针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

7、存取效率方面：

堆： char *s1 = "Hellow Word"；是在编译时就确定的；

栈： char s1[] = "Hellow Word"；是在运行时赋值的；用数组比用指针速度要快一些，因为指针在底层汇编中需要用 edx 寄存器中转一下，而数组

在栈上直接读取。

120. 成员变量和成员函数前加 static 的作用？

它们被称为常成员变量和常成员函数，又称为类成员变量和类成员函数 .分别用来反映类的状态 .比如类成员变量可以用来统计类实例的数量，类成员函数负责

这种统计的动作.

121. DataReader 与 Dataset 有什么区别？

一个是只能向前的只读游标，一个是内存中的表 . DataReader 和 DataSet 最大的区别在于 ,DataReader 使用时始终占用 SqlConnection,在线操作数据库 ..任何对

SqlConnection 的操作都会引发 DataReader 的异常 ..因为 DataReader 每次只在内存中加载一条数据 ,所以占用的内存是很小的 ..因为 DataReader 的特殊性和

高性能 .所以 DataReader 是只进的 ..你读了第一条后就不能再去读取第一条了 ..

DataSet 则是将数据一次性加载在内存中 .抛弃数据库连接 ..读取完毕即放弃数据库连接 ..因为 DataSet 将数据全部加载在内存中 .所以比较消耗内存 ...但是

确比 DataReader 要灵活 ..可以动态的添加行 ,列 ,数据 .对数据库进行回传更新操作

122. 什么是 SOAP,有哪些应用.

SOAP（ Simple Object Access Protocol ）简单对象访问协议是在分散或分布式的环境中交换信息并执行远程过程调用的协议，是一个基于 XML 的协议 .使用

SOAP，不用考虑任何特定的传输协议（最常用的还是 HTTP 协议），可以允许任何类型的对象或代码，在任何平台上，以任何一直语言相互通信 .这种相互通信

采用的是 XML 格式的消息 . SOAP 也被称作 XMLP，为两个程序交换信息提供了一种标准的工作机制 .在各类机构之间通过电子方式相互协作的情况下完全有必要

为此制定相应的标准 . SOAP 描述了把消息捆绑为 XML 的工作方式 .它还说明了发送消息的发送方、消息的内容和地址以及发送消息的时间 .SOAP 是 Web Service

（ ,怎（ .大

的基本通信协议 .SOAP 规范还定义了怎样用 XML 来描述程序数据 Program Data）样执行 RPC Remote Procedure Call）多数 SOAP 解决方案都支持 RPC-style

应用程序 .SOAP 还支持 Document-style 应用程序（ SOAP 消息只包含 XML 文本信息） .最后 SOAP 规范还定义了 HTTP 消息是怎样传输 SOAP 消息的 .MSMQ、 SMTP、

TCP/IP 都可以做 SOAP 的传输协议 . SOAP 是一种轻量级协议，用于在分散型、分布式环境中交换结构化信息 . SOAP 利用 XML 技术定义一种可扩展的消息处

108

理框架，它提供了一种可通过多种底层协议进行交换的消息结构. 这种框架的设计思想是要独立于任何一种特定的编程模型和其他特定实现的语义 .

SOAP 定义了一种方法以便将 XML 消息从 A 点传送到 B 点 . 为此，它提供了一种基于 XML 且具有以下特性的消息处理框架： 1) 可扩展， 2) 可通过多种

底层网络协议使用， 3) 独立于编程模型 .

123. XML 与 HTML 的主要区别

1. XML 是区分大小写字母的， HTML 不区分 .

2. 在 HTML 中，如果上下文清楚地显示出段落或者列表键在何处结尾，那么你可以省略或者之

类的结束标记 .在 XML 中，绝对不能省略掉结束标记 .

3. 在 XML 中，拥有单个标记而没有匹配的结束标记的元素必须用一个 / 字符作为结尾 .这样分析器就知

道不用查找结束标记了.

4. 在 XML 中，属性值必须分装在引号中 .在 HTML 中，引号是可用可不用的 .

5. 在 HTML 中，可以拥有不带值的属性名 .在 XML 中，所有的属性都必须带有相应的值 .

124. .net 的错误处理机制

在 ASP.NET 中，错误处理分为两个层面：页面输入信息验证、CLR 提供的结构化错误处理机制。在页面输入信息判断中，可以采用 JavaScript、VBScript 等脚

本进行判断，也可以使用 .NET 环境下带有的 Validation 和正则表达式的方式将信息在提交执行处理前，进行格式判断。格式判断包括：网络地址、电子信箱、

输入字符串长短和输入信息的数据类型的判断等。

结构化异常处理是 CLR 的基础部分，具有以下特点：可以跨语言，异常可以在一种语言中引发，在另外一种语言中捕捉处理；分层处理，一个异常可以

包括另外一个异常，这意味着系统可以捕获底层对象（如数据层和业务层）的异常，引发自己的异常，包含有底层对象的异常。这样可以将异常进行细致分类，

使得异常更容易处理。

结构化异常处理，一般要使用 3 部分代码。

（ 1） Try：是程序中可能出现错误的操作部分。

（ 2） Catch：是用来处理各种错误的部分（可以有多个）。必须正确排列捕获异常的 Catch 子句，范围小的 Exception 放在前面的 Catch。即如果 Exception

之间存在继承关系，就应把子类的 Exception 放在前面的 Catch 子句中。

（ 3） Finally 块的代码用来清理资源或执行要在 Try 块末尾执行的其他操作（可以省略）。无论是否产生异常， Finally 块都会执行。

结构化异常处理

设所将

异常是在程序设计中无法避免的错误，计的程序必须能够处理所有可能出现的错误。以要全面考虑异常处理，一切可能出现异常的代码都进行 try

的捕捉，然后建立自己的异常处理机制，按照不同的异常情况进行分类处理。

异常产生的时候，需要知道是什么原因造成的错误以及错误的相关信息。根据实际情况抛出具体类型的异常，然后建立捕捉机制，捕捉到异常时做出具

体的处理。在编写代码过程中，可以使用系统已定义的相关异常类以及自定义的异常类来实例化并抛出需要的异常。如一个不可能实现的接口，可以抛出

System.NotSupportedExceptiion 的异常来告诉接口的调用者。

在处理异常的时候，应该将可处理的具体异常分别在 catch 块中作出相应处理，否则程序将终止运行。针对每一种异常，以不同方式处理，避免对所有

异常做出一样的处理。并且在异常产生时，给用户一个友好的提示（最终用户对系统异常的具体内容是不明白的，这就需要给出相关的信息提示和解决方案，

或告诉联系管理员等），并在可能的情况下给用户提供选择（确定和取消），让用户来决定系统的运行方向。同时，程序中要将异常做日志记录。不是所有异

常都是必须记录的，例如一些可捕捉并且已经安排程序进行处理的异常就不需要记录它。

可以采取如下形式记录异常：

在文件中记录异常。便于技术人员查看所发生的异常，从而日后对程序进行改进。

在数据库中记录异常。数据库支持查询，这样在后期就能够对异常进行分类查询等操作，便于查看与管理。

在 Eventlog 中记录异常。能够远程操作，方便系统管理员监控所有计算机的异常。

除了可预料到的异常外，还有未预料到的异常。这类异常是无法进行管理的，发生后将系统程序转移到特定的错误页面，提示用户系统出错，结束程序。做好

日志能为解决和调试问题带来很多方便。要避免使用了 Try-Catch 但没有处理异常的情况，否则就相当于给异常放行 (这种情况还不如根本不去捕获 )。

异常处理，还应该注意在 Finally 块中释放相关资源、还原相关设置信息等收尾工作。基本程序结构如下：

try

{

int x = 123/0; //会抛出一个除数为 0 的异常

}

catch

{

// ... //在这里捕捉到这个异常，然后进行相关处理

109

}

finally

{

// ... //在这里做最后的清理或是其他工作

}

但给并

本章的异常处理是针对容易出现错误的地方 (操作数据库 )应用此技术，是只是捕捉到 SQL 异常后，用户一个错误提示，没有进一步作程序的处理。

C#中常见异常类

Exception：所有异常对象的基类。

SystemException：运行时产生的所有错误的基类。

IndexOutOfRangeException：当一个数组的下标超出范围时运行时引发。

NullReferenceException：当一个空对象被引用时运行时引发。

InvalidOperationException：当对方法的调用对对象的当前状态无效时，由某些方法引发。

ArgumentException：所有参数异常的基类。

ArgumentNullException：在参数为空 (不允许 )的情况下，由方法引发。

ArgumentOutOfRangeException：当参数不在一个给定范围之内时，由方法引发。

InteropException：目标在或发生在 CLR 外面环境中的异常的基类。

ComException：包含 COM 类的 HRESULT 信息的异常。

SEHException：封装 Win32 结构异常处理信息的异常。

SqlException：封装了 SQL 操作异常。

125. 利用 operator 声明且仅声明了==，有什么错误么?

要同时修改 Equale 和 GetHash() ? 重载了 "==" 就必须重载 "!="

126. ADO.NET 相对于 ADO 等主要有什么改进？

1:ado.net 不依赖于 ole db 提供程序 ,而是使用 .net 托管提供的程序；

2:不使用 com

3:不在支持动态游标和服务器端；

4:可以断开 connection 而保留当前数据集可用

5:强类型转换

6:xml 支持

127. 写一个 HTML 页面，实现以下功能，左键点击页面时显示“您好”，右键点击时显示“禁

止右键”并在 2 分钟后自动关闭页面.

setTimeout('window.close();',3000);

function show()

{

if (window.event.button == 1)

{

alert("左 ");

}

else if (window.event.button == 2)

{

alert("右 ");

}

}

110

128. 大概描述一下 ASP.NET 服务器控件的生命周期

初始化加载视图状态处理回发数据加载发送回发更改通知处理回发事件预呈现保存状态呈现处置卸载

129. 和有什么区别？

表示绑定的数据源

是服务器端代码块

130. UML 基本概念

用例图（ use case diagram）就是由主角、用例以及它们之间的关系构成的图。该图说明了用例模型中的关系。

可以将用例图组织到用例包中，并归用例包所有，让特定包中仅显示互为关联关系的内容。

用例图由参与者（ Actor）、用例（ Use Case）、系统边界、箭头组成，用画图的方法来完成。

参与者不是特指人，是指系统以外的，在使用系统或与系统交互中所扮演的角色。因此参与者可以是人，可以是事物，也可以是时间或其他系统等

等。还有一点要注意的是，参与者不是指人或事物本身，而是表示人或事物当时所扮演的角色。比如小明是图书馆的管理员，他参与图书馆管理系统的交互，

这时他既可以作为管理员这个角色参与管理，也可以作为借书者向图书馆借书，在这里小明扮演了两个角色，是两个不同的参与者。参与者在画图中用简笔人

物画来表示，人物下面附上参与者的名称。

用例是对包括变量在内的一组动作序列的描述，系统执行这些动作，并产生传递特定参与者的价值的可观察结果。这是 UML 对用例的正式定义，对

我们初学者可能有点难懂。我们可以这样去理解，用例是参与者想要系统做的事情。对于对用例的命名，我们可以给用例取一个简单、描述性的名称，一般为

带有动作性的词。用例在画图中用椭圆来表示，椭圆下面附上用例的名称。

系统边界是用来表示正在建模系统的边界。边界内表示系统的组成部分，边界外表示系统外部。系统边界在画图中方框来表示，同时附上系统的名

称，参与者画在边界的外面，用例画在边界里面。因为系统边界的作用有时候不是很明显，所以我个人理解，在画图时可省略。

箭头用来表示参与者和系统通过相互发送信号或消息进行交互的关联关系。箭头尾部用来表示启动交互的一方，箭头头部用来表示被启动的一方，

其中用例总是要由参与者来启动。

131. 绑定表达式与的区别

1.Bind 是可更新的，是 Bind 绑定列可编辑，并且可以和数据源控件交互，直接和数据库交互，但是用 Bind 的话，程序端的自定义操作就不能用了，比如

Convert,ToString()等 ,或自己写的函数 ,在程序端都不可以

2.eval 是只读数据，用 eval 的话不可以和数据源控件交互，是单向的，但是可以自定义操作

比如上面的

132. 页面重定 Response.Redirect(),Server.Transfer(),Server.Execute()

Response.Redirect 方法导致浏览器链接到一个指定的 URL。当 Response.Redirect()方法被调用时，它会创建一个应答，应答头中指出了状态代码 302（表示

目标已经改变）以及新的目标 URL。浏览器从服务器收到该应答，利用应答头中的信息发出一个对新 URL 的请求。这就是说，使用 Response.Redirect 方法

时重定向操作发生在客户端，总共涉及到两次与服务器的通信（两个来回）：第一次是对原始页面的请求，得到一个 302 应答，第二次是请求 302 应答中声明

的新页面，得到重定向之后的页面。

Server.Transfer 方法把执行流程从当前的 ASPX 文件转到同一服务器上的另一个 ASPX 页面。调用 Server.Transfer 时，当前的 ASPX 页面终止执行，执行流程

转入另一个 ASPX 页面，但新的 ASPX 页面仍使用前一 ASPX 页面创建的应答流。如果用 Server.Transfer 方法实现页面之间的导航，浏览器中的 URL 不会改

变，因为重定向完全在服务器端进行，浏览器根本不知道服务器已经执行了一次页面变换。默认情况下， Server.Transfer 方法不会把表单数据或查询字符串

从一个页面传递到另一个页面，但只要把该方法的第二个参数设置成 True，就可以保留第一个页面的表单数据和查询字符串。同时，使用 Server.Transfer

时应注意一点：目标页面将使用原始页面创建的应答流，这导致 ASP.NET 的机器验证检查（ Machine Authentication Check， MAC）认为新页面的 ViewState

已被篡改。因此，如果要保留原始页面的表单数据和查询字符串集合，必须把目标页面 Page 指令的 EnableViewStateMac 属性设置成 False。

Server.Execute 方法允许当前的 ASPX 页面执行一个同一 Web 服务器上的指定 ASPX 页面，当指定的 ASPX 页面执行完毕，控制流程重新返回原页面发出

被

Server.Execute 调用的位置。这种页面导航方式类似于针对 ASPX 页面的一次函数调用，调用的页面能够访问发出调用页面的表单数据和查询字符串集合，

所以要把被调用页面 Page 指令的 EnableViewStateMac 属性设置成 False。默认情况下，被调用页面的输出追加到当前应答流。但是，Server.Execute 方法有

一个重载的方法，允许通过一个 TextWriter 对象（或者它的子对象，例如 StringWriter 对象）获取被调用页面的输出，而不是直接追加到输出流，这样，在

原始页面中可以方便地调整被调用页面输出结果的位置。

133. 页面间传值的几种方式

1. 使用 QueryString 变量

QueryString 是一种非常简单的传值方式，他可以将传送的值显示在浏览器的地址栏中。如果是传递一个或多个安全性要求不高或是结构简单的数值

时，可以使用这个方法。但是对于传递数组或对象的话，就不能用这个方法了。下面是一个例子：

a.aspx 的 C#代码

111

private void Button1_Click(object sender, System.EventArgs e)

{

string s_url;

s_url = "b.aspx?name=" + Label1.Text;

Response.Redirect(s_url);

}

b.aspx 中 C#代码

private void Page_Load(object sender, EventArgs e)

{

Label2.Text = Request.QueryString["name"];

}

2. 使用 Application 对象变量

Application 对象的作用范围是整个全局，也就是说对所有用户都有效。其常用的方法用 Lock 和 UnLock。

a.aspx 的 C#代码

private void Button1_Click(object sender, System.EventArgs e)

{

Application["name"] = Label1.Text;

Server.Transfer("b.aspx");

}

b.aspx 中 C#代码

private void Page_Load(object sender, EventArgs e)

{

string name;

Application.Lock();

name = Application["name"].ToString();

Application.UnLock();

}

3. 使用 Session 变量

想必这个肯定是大家使用中最常见的用法了，其操作与 Application 类似，作用于用户个人，所以，过量的存储会导致服务器内存资源的耗尽。

a.aspx 的 C#代码

private void Button1_Click(object sender, System.EventArgs e)

{

Session["name"] = Label.Text;

}

b.aspx 中 C#代码

private void Page_Load(object sender, EventArgs e)

{

string name;

name = Session["name"].ToString();

}

4. 使用 Cookie 对象变量

这个也是大家常使用的方法，与 Session 一样，其是什对每一个用户而言的，但是有个本质的区别，即 Cookie 是存放在客户端的，而 session 是存

放在服务器端的。而且 Cookie 的使用要配合 ASP.NET 内置对象 Request 来使用。

112

a.aspx 的 C#代码

private void Button1_Click(object sender, System.EventArgs e)

{

HttpCookie cookie_name = new HttpCookie("name");

cookie_name.Value = Label1.Text;

Reponse.AppendCookie(cookie_name);

Server.Transfer("b.aspx");

}

b.aspx 中 C#代码

private void Page_Load(object sender, EventArgs e)

{

string name;

name = Request.Cookie["name"].Value.ToString();

}

5. 使用 Server.Transfer 方法

这个才可以说是面象对象开发所使用的方法，其使用 Server.Transfer 方法把流程从当前页面引导到另一个页面中，新的页面使用前一个页面的应答

流，所以这个方法是完全面象对象的，简洁有效。

a.aspx 的 C#代码

public string Name

{

get{ return Label1.Text;}

}

private void Button1_Click(object sender, System.EventArgs e)

{

Server.Transfer("b.aspx");

}

b.aspx 中 C#代码

private void Page_Load(object sender, EventArgs e)

{

a newWeb; //实例 a 窗体

newWeb = (source)Context.Handler;

string name;

name = newWeb.Name;

}

134. IList、ICollection、IEnumerable 之辨析

祖宗 :IEnumerable

此接口只有一个方法 GetEnumerator();

是 FrameWork 为了实现迭代器模式设计的接口。所有继承了 IEnumerable 的类，要使用 foreach 迭代器时，就需要使用该方法。因此也只有实现了该接口的类

才可以使用 foreach。

ICollection 继承自 IEnumerable， IList 继承自 ICollection

这两个接口都是为了给集合提供一些公用的方法。只是分了两个层次， IList 比 ICollection 多几个方法，增加，移除成员。可以简单理解为： ICollection

主要针对静态集合； IList 主要针对动态集合。

IList,ICollection,IEnumerable 在命名空间 System.Collections 中。

IList,ICollection,IEnumerable 在 System.Collections.Generic 命名空间中。

113

IList,ICollection,IEnumerab le 是 2.0 引入泛型以后新增的。主要是提高重用性与类型安全。

IEnumerable继承自 IEnumerable

ICollection继承自 IEnumerable

IList继承自 ICollection

因此可以完全使用泛型接口，而放弃使用 ICollection 和 IList。泛型接口提供了更好的类型安全和编译时的检验。

补充：

IEnumerable和 IEnumerable 都只有一个方法。ICollection和 ICollection 的结构是不一样的。ICollection比 ICollection 多几个方法。它包含了

几个 IList 中的几个方法。也许是对以前的改进。

135. IEnumerable 与 IEnumerator 区别

public interface IEnumerable

{

IEnumerator GetEnumerator();

}

public interface IEnumerator

{

bool MoveNext();

void Reset();

Object Current { get; }

}

IEnumerable 和 IEnumerator 有什么区别？这是一个很让人困惑的问题（在很多 forum 里都看到有人在问这个问题）。研究了半天，得到以下几点认识：

1、一个 Collection 要支持 foreach 方式的遍历，必须实现 IEnumerable 接口（亦即，必须以某种方式返回 IEnumerator object）。

2、 IEnumerator object 具体实现了 iterator（通过 MoveNext()， Reset()， Current）。

3、从这两个接口的用词选择上，也可以看出其不同：IEnumerable 是一个声明式的接口，声明实现该接口的 class 是 “ 可枚举（ enumerable）” 的，但并没有

说明如何实现枚举器（ iterator）； IEnumerator 是一个实现式的接口， IEnumerator object 就是一个 iterator。

4、 IEnumerable 和 IEnumerator 通过 IEnumerable 的 GetEnumerator()方法建立了连接， client 可以通过 IEnumerable 的 GetEnumerator()得到 IEnumerator

object，在这个意义上，将 GetEnumerator()看作 IEnumerator object 的 factory method 也未尝不可。

IEnumerator 是所有枚举数的基接口。

枚举数只允许读取集合中的数据。枚举数无法用于修改基础集合。

最初，枚举数被定位于集合中第一个元素的前面。 Reset 也将枚举数返回到此位置。在此位置，调用 Current 会引发异常。因此，在读

取 Current 的值之前，必须调用 MoveNext 将枚举数提前到集合的第一个元素。

在调用 MoveNext 或 Reset 之前， Current 返回同一对象。 MoveNext 将 Current 设置为下一个元素。

在传递到集合的末尾之后，枚举数放在集合中最后一个元素后面，且调用 MoveNext 会返回 false。如果最后一次调用 MoveNext 返

回 false，则调用 Current 会引发异常。若要再次将 Current 设置为集合的第一个元素，可以调用 Reset，然后再调

用 MoveNext。

只要集合保持不变，枚举数就将保持有效。如果对集合进行了更改（例如添加、修改或删除元素），则该枚举数将失效且不可恢复，并且下一次

对 MoveNext 或 Reset 的调用将引发 InvalidOperationException。如果在 MoveNext 和 Current 之间修改集合，

那么即使枚举数已经无效， Current 也将返回它所设置成的元素。

枚举数没有对集合的独占访问权；因此，枚举一个集合在本质上不是一个线程安全的过程。甚至在对集合进行同步处理时，其他线程仍可以修改该集合，

这会导致枚举数引发异常。若要在枚举过程中保证线程安全，可以在整个枚举过程中锁定集合，或者捕捉由于其他线程进行的更改而引发的异常。

136. 如何自己实现 IEnumerable 和 IEnumerator 接口以支持 foreach 语句

在 C#中，凡是实现了 IEnumerator 接口的数据类型都可以用 foreach 语句进行迭代访问，可是，对于自定义类型如何实现这个接口以支持 foreach 的迭代呢？要

实现这个功能，先来看看 IEnumerable 和 IEnumerator 接口的定义：

public interface IEnumerable

{

114

//IEnumerable 只有一个方法，返回可循环访问集合的枚举数。

IEnumerator GetEnumerator() ;

}

public interface IEnumerator

{

// 方法

//移到集合的下一个元素。如果成功则返回为 true；如果超过集合结尾，则返回 false。

bool MoveNext();

// 将集合设置为初始位置，该位置位于集合中第一个元素之前

void Reset();

// 属性：获取集合中的当前元素

object Current { get; }

}

如果我们的自定义数据类型派生于这两个接口，并实现接口中的方法，即可用 foreach 进行迭代。

下面是一个实现的简单例子：

using System;

using System.Collections ;

using System.Collections.Generic;

using System.Text;

namespace IEnumberableTest

{

class Program

{

static void Main(string[] args)

{

myEnum enum1 = new myEnum(20);

foreach ( point p in enum1)

{

Console.WriteLine("("+p.x .ToString ()+","+p.y.ToString ()+","+p.z.ToString ()+")");

}

Console.Read();

}

}

//一个结构体，用于类 myEnum

struct point

{

public int x;

public int y;

public int z;

}

//我们的一个派生于 IEnumerable 和 IEnumerator 接口的自定义类

class myEnum :IEnumerable,IEnumerator

{

//定义索引

private int index;

//定义一个 point 结构的数组

private point[] points;

//类的构造函数，用于初始化 point 结构数组

public myEnum(int numofpoint)

115

{

this.index = -1;

points = new point[numofpoint];

for (int i = 0; i = points.Length ? false : true;

}

}

}

137. 使用 ASP.NET Global.asax 文件

Global.asax 文件，有时候叫做 ASP.NET 应用程序文件，提供了一种在一个中心位置响应应用程序级或模块级事件的方法。你可以使用这个文件实现应用程

序安全性以及其它一些任务。下面让我们详细看一下如何在应用程序开发工作中使用这个文件。

概述

Global.asax 位于应用程序根目录下。虽然 Visual Studio .NET 会自动插入这个文件到所有的 ASP.NET 项目中，但是它实际上是一个可选文件。删除它不

会出问题 — — 当然是在你没有使用它的情况下。 .asax 文件扩展名指出它是一个应用程序文件，而不是一个使用 aspx 的 ASP.NET 文件。

Global.asax 文件被配置为任何（通过 URL 的）直接 HTTP 请求都被自动拒绝，所以用户不能下载或查看其内容。 ASP.NET 页面框架能够自动识别出对

Global.asax 文件所做的任何更改。在 Global.asax 被更改后 ASP.NET 页面框架会重新启动应用程序，包括关闭所有的浏览器会话，去除所有状态信息，并

重新启动应用程序域。

编程

Global.asax 文件继承自 HttpApplication 类，它维护一个 HttpApplication 对象池，并在需要时将对象池中的对象分配给应用程序。 Global.asax 文件包

116

含以下事件：

· Application_Init：在应用程序被实例化或第一次被调用时，该事件被触发。对于所有的 HttpApplication 对象实例，它都会被调用。

· Application_Disposed：在应用程序被销毁之前触发。这是清除以前所用资源的理想位置。

· Application_Error：当应用程序中遇到一个未处理的异常时，该事件被触发。

· Application_Start：在 HttpApplication 类的第一个实例被创建时，该事件被触发。它允许你创建可以由所有 HttpApplication 实例访

问的对象。

· Application_End：在 HttpApplication 类的最后一个实例被销毁时，该事件被触发。在一个应用程序的生命周期内它只被触发一次。

· Application_BeginRequest：在接收到一个应用程序请求时触发。对于一个请求来说，它是第一个被触发的事件，请求一般是用户输入的

一个页面请求（ URL）。

· Application_EndRequest：针对应用程序请求的最后一个事件。

· 在该

Application_PreRequestHandlerExecute： ASP.NET 页面框架开始执行诸如页面或 Web 服务之类的事件处理程序之前，事件被触发。

· Application_PostRequestHandlerExecute ：在 ASP.NET 页面框架结束执行一个事件处理程序时，该事件被触发。

· Applcation_PreSendRequestHeaders ：在 ASP.NET 页面框架发送 HTTP 头给请求客户（浏览器）时，该事件被触发。

· Application_PreSendContent：在 ASP.NET 页面框架发送内容给请求客户（浏览器）时，该事件被触发。

· Application_AcquireRequestState ：在 ASP.NET 页面框架得到与当前请求相关的当前状态（ Session 状态）时，该事件被触发。

· Application_ReleaseRequestState：在 ASP.NET 页面框架执行完所有的事件处理程序时，该事件被触发。这将导致所有的状态模块保存

它们当前的状态数据。

· Application_ResolveRequestCache：在 ASP.NET 页面框架完成一个授权请求时，该事件被触发。它允许缓存模块从缓存中为请求提供服

务，从而绕过事件处理程序的执行。

· Application_UpdateRequestCache ：在 ASP.NET 页面框架完成事件处理程序的执行时，该事件被触发，从而使缓存模块存储响应数据，

以供响应后续的请求时使用。

· Application_AuthenticateRequest：在安全模块建立起当前用户的有效的身份时，该事件被触发。在这个时候，用户的凭据将会被验证。

· Application_AuthorizeRequest：当安全模块确认一个用户可以访问资源之后，该事件被触发。

· Session_Start：在一个新用户访问应用程序 Web 站点时，该事件被触发。

· Session_End：在一个用户的会话超时、结束或他们离开应用程序 Web 站点时，该事件被触发。

这个事件列表看起来好像多得吓人，但是在不同环境下这些事件可能会非常有用。

使用这些事件的一个关键问题是知道它们被触发的顺序。 Application_Init 和 Application_Start 事件在应用程序第一次启动时被触发一次。相似地，

Application_Disposed 和 Application_End 事件在应用程序终止时被触发一次。此外，基于会话的事件（ Session_Start 和 Session_End）只在用户进入和

离开站点时被使用。其余的事件则处理应用程序请求，这些事件被触发的顺序是：

· Application_BeginRequest

· Application_AuthenticateRequest

· Application_AuthorizeRequest

· Application_ResolveRequestCache

· Application_AcquireRequestState

· Application_PreRequestHandlerExecute

· Application_PreSendRequestHeaders

· Application_PreSendRequestContent

· >

· Application_PostRequestHandlerExecute

· Application_ReleaseRequestState

· Application_UpdateRequestCache

· Application_EndRequest

这些事件常被用于安全性方面。

138. ASP.NET VIEWSTATE

一、 ViewState 的作用

ViewState 用于维护页面的 UI 状态

Web 是没有状态的， ASP.NET 页面也没有状态，它们在到服务器的每个往返过程中被实例化、执行、呈现和处理。作为 Web 开发人员，您可以使用众所周知

117

的技术（如以会话状态将状态存储在服务器上，或将页面回传到自身）来添加状态。

在 ASP.NET 之前，通过多次回传将值恢复到窗体字段中完全是页面开发人员的责任，他们将不得不从 HTTP 窗体中逐个拾取回传值，然后再将其推回字段

中。幸运的是，现在 ASP.NET 可以自动完成这项任务，从而为开发人员免除了一项令人厌烦的工作，同时也无需再为窗体编写大量的代码。但这并不是

ViewState。

ViewState（英文）是一种机制，ASP.NET 使用这种机制来跟踪服务器控件状态值，否则这些值将不作为 HTTP 窗体的一部分而回传。例如，由 Label

控件显示的文本默认情况下就保存在 ViewState 中。作为开发人员，您可以绑定数据，或在首次加载该页面时仅对 Label 编程设置一次，在后续的回传中，

该标签文本将自动从 ViewState 中重新填充。因此，除了可以减少繁琐的工作和代码外， ViewState 通常还可以减少数据库的往返次数。

二、 ViewState 的工作原理

它当该

ViewState 确实没有什么神秘之处，是由 ASP.NET 页面框架管理的一个隐藏的窗体字段。 ASP.NET 执行某个页面时，页面上的 ViewState 值

和所有控件将被收集并格式化成一个编码字符串，然后被分配给隐藏窗体字段的值属性（即）。由于隐藏窗体字段是发送到客户端的页面

的一部分，所以 ViewState 值被临时存储在客户端的浏览器中。如果客户端选择将该页面回传给服务器，则 ViewState 字符串也将被回传。在上面的图 2 中

可以看到 ViewState 窗体字段及其回传的值。

回传后， ASP.NET 页面框架将解析 ViewState 字符串，并为该页面和各个控件填充 ViewState 属性。然后，控件再使用 ViewState 数据将自己重新

恢复为以前的状态。

关于 ViewState 还有三个值得注意的小问题。

1）如果要使用 ViewState，则在 ASPX 页面中必须有一个服务器端窗体标记 ()。窗体字段是必需的，这样包含 ViewState 信息

的隐藏字段才能回传给服务器。而且，该窗体还必须是服务器端的窗体，这样在服务器上执行该页面时， ASP.NET 页面框架才能添加隐藏的字段。

2）页面本身将 20 字节左右的信息保存在 ViewState 中，用于在回传时将 PostBack 数据和 ViewState 值分发给正确的控件。因此，即使该页面或

应用程序禁用了 ViewState，仍可以在 ViewState 中看到少量的剩余字节。

3）在页面不回传的情况下，可以通过省略服务器端的标记来去除页面中的 ViewState。

三、充分利用 ViewState

ViewState 为跨回传跟踪控件的状态提供了一条神奇的途径，因为它不使用服务器资源、不会超时，并且适用于任何浏览器。如果您要编写控件，那

么肯定需要了解如何在控件中维护状态（英文）。

开发人员在编写页面时同样可以按照几乎相同的方式来利用 ViewState，只是有时页面会包含不由控件存储的 UI 状态值。您可以跟踪 ViewState 中

的值，使用的编程语法与会话和高速缓存的语法类似。

四、选择会话状态还是 ViewState？

在某些情况下，将状态值保存在 ViewState 中并不是最佳选择，最常用的替代方法就是会话状态，它通常更适用于：

1）大量的数据。由于 ViewState 增加了发送到浏览器的页面的大小（ HTML 有效负载），同时也增加了回传的窗体的大小，因此不适合存储大量数

据。

2）未在 UI 中显示的安全数据。尽管 ViewState 数据已被编码，并且可以选择对其进行加密，但始终不将数据发送到客户端才是最安全的。因此，

（

会话是更安全的选择。由于数据库需要额外的凭据进行验证，因此将数据存储在数据库中会更安全。可以添加 SSL 以获得更安全的链接。）但是，如果在 UI

中已经显示了该专用数据，那么您应该已经确认了链接的安全性。在这种情况下，将同样的值放入 ViewState 不会降低安全性。

3）尚未序列化到 ViewState 中的对象，如 DataSet。 ViewState 序列化程序只为一小部分常用的对象类型进行了优化，如下所示。其他可序列化的类

型或许可以保留在 ViewState 中，但速度会变慢，并会生成一个非常大的 ViewState。

五、使用 ViewState 获得最佳性能

使用 ViewState 时，每个对象都必须先序列化到 ViewState 中，然后再通过回传进行反序列化，因此使用 ViewState 并非是没有代价的。但是，如

果遵循某些简单的原则对 ViewState 的成本加以控制，则通常不会产生明显的性能影响。

1）在不需要时禁用 ViewState。下面的 “减少使用 ViewState”一节将详细介绍这一问题。

使上这并可

2）用优化过的 ViewState 序列化程序。面列出的类型具有专门的序列化程序，些程序运行速度很快，已经过优化，以生成很小的 ViewState。

如果要序列化一个未在上面列出的类型，可以创建一个自定义 TypeConverter 来显著提高它的性能。

3）尽量减少使用对象，如果可能，尽量减少放入 ViewState 中的对象的数目。例如，不要使用二维字符串数组（名称 /值，其对象的数目与数组的长

度一样多），而应使用两个字符串数组（只有两个对象）。但是，在将两个已知类型存储在 ViewState 中之前，在这两者之间转换不会获得任何性能提高，

因为这样做实际上相当于付出了两次转换的代价。

六、减少使用 ViewState

默认情况下 ViewState 将被启用，并且是由每个控件（而非页面开发人员）来决定存储在 ViewState 中的内容。有时，这一信息对应用程序并没有什

么用处。尽管也没什么害处，但却会明显增加发送到浏览器的页面的大小。因此如果不需要使用 ViewState，最好还是将它关闭，特别是当 ViewState 很大的

时候。

可以基于每个控件、每个页面或每个应用程序来关闭 ViewState。在以下情况中将不再需要 ViewState：

118

页面：页面不回传给自身。

控件： 1）处理的不是控件的事件。 2）控件没有动态的或数据绑定的属性值（或对于每一个请求它们都设置在代码中）。

DataGrid 控件是 ViewState 的一个重量级用户。默认情况下，在网格中显示的所有数据也都存储在 ViewState 中，当需要一个复杂的操作（如复杂

的搜索）来获取数据时，这是非常有用的。但是， DataGrid 的这种行为有时也使得 ViewState 成为累赘。

七、禁用 ViewState

通过将对象的 EnableViewState 属性设置为 False 禁用了 ViewState。可以针对单个控件、整个页面或整个应用程序禁用 ViewState，如下所示：

每个控件（在标记上）

每个页面（在指令中）

每个应用程序（在 web.config 中）

八、使 ViewState 更安全

由于 ViewState 没有被格式化为清晰的文本，某些人有时会认为它被加密了，其实并没有。相反， ViewState 只是进行了 Base64 编码，以确保值在

往返过程中不会发生变化，而并不考虑应用程序使用的响应 /请求编码。

可以向应用程序中添加两种 ViewState 安全级别：

1）防篡改

2）加密

需要注意的是，ViewState 安全性对于处理和呈现 ASP.NET 页面所需的时间有直接的影响。简单地说，安全性越高，速度越慢。因此如果不需要，请

不要为 ViewState 添加安全性。

九、防篡改

尽管散列代码不能确保 ViewState 字段中实际数据的安全，但它能够显著降低有人通过 ViewState 骗过应用程序的可能性，即防止回传应用程序通常

禁止用户输入的值。

可以通过设置 EnableViewStateMAC 属性来指示 ASP.NET 向 ViewState 字段中追加一个散列代码：

可以在页面级别上设置 EnableViewStateMAC，也可以在应用程序级别上设置。在回传时，ASP.NET 将为 ViewState 数据生成一个散列代码，并将其

与存储在回传值中的散列代码进行比较。如果两处的散列代码不匹配，该 ViewState 数据将被丢弃，同时控件将恢复为原来的设置。

默认情况下，此也

ASP.NET 使用 SHA1 算法来生成 ViewState 散列代码。外，可以通过在 machine.config 文件中设置来选择 MD5 算

法，如下所示：

十、加密

可以使用加密来保护 ViewState 字段中的实际数据值。首先，必须如上所述设置 EnableViewStatMAC="true"。然后，将 machineKey

validation 类型设置为 3DES。这将指示 ASP.NET 使用 Triple DES 对称加密算法来加密 ViewState 值。

十一、 Web 领域中的 ViewState 安全性

默认情况下，ASP.NET 将创建一个随机的验证密钥，并存储在每个服务器的本地安全授权 (LSA) 中。要验证在另一台服务器上创建的 ViewState 字

段，两台服务器的 validationKey 必须设置为相同的值。如果要通过上述方式之一，对运行于 Web 领域配置中的应用程序进行 ViewState 安全设置，则需要

为所有服务器提供一个唯一的、共享的验证密钥。

验证密钥是一个包含 20 到 64 位密码增强字节的随机字符串，用 40 到 128 个十六进制字符表示。密钥越长越安全，因此建议使用 128 个字符的

密钥（如果计算机支持）。

十二、总结

可

ASP.NET ViewState 是一种新的状态服务，供开发人员基于每个用户来跟踪 UI 状态。它

ViewState 没有什么神秘之处，只是利用了一个老的 Web 编

程技巧：在一个隐藏的窗体字段中来回传递状态，并将它直接应用于页面处理框架中。但效果却非常好 - 在基于 Web 的窗体中只需编写并维护很少的代码。

用户可能并不总是需要它，但我想您在需要它的时候会发现， ViewState 是提供给页面开发人员的诸多 ASP.NET 新功能中非常令人满意的一种功能。

139. 泛型

140. 扩展方法

141. 多线程

任何程序在执行时，至少有一个主线程，下面这段小程序可以给读者一个直观的印象：

//SystemThread.cs

119

using System;

using System.Threading;

namespace ThreadTest

{

class RunIt

{

[STAThread]

static void Main(string[] args)

{

Thread.CurrentThread.Name="System Thread";//给当前线程起名为 "System Thread"

Console.WriteLine(Thread.CurrentThread.Name+"'Status:"+Thread.CurrentThread.ThreadState);

Console.ReadLine();

}

}

}

编译执行后你看到了什么？是的，程序将产生如下输出：

System Thread's Status:Running

在这里，我们通过 Thread 类的静态属性 CurrentThread 获取了当前执行的线程，对其 Name 属性赋值 “ System Thread” ，最后还输出了它的当前状态

（ ThreadState）。所谓静态属性，就是这个类所有对象所公有的属性，不管你创建了多少个这个类的实例，但是类的静态属性在内存中只有一个。很容易理

解 CurrentThread 为什么是静态的 — — 虽然有多个线程同时存在，但是在某一个时刻， CPU 只能执行其中一个。

就像上面程序所演示的，我们通过 Thread 类来创建和控制线程。注意到程序的头部，我们使用了如下命名空间：

using System;

using System.Threading;

在 .net framework class 所其

library 中，有与多线程机制应用相关的类都是放在 System.Threading 命名空间中的。中提供 Thread 类用于创建线程，

ThreadPool 类用于管理线程池等等，此外还提供解决了线程执行安排，死锁，线程间通讯等实际问题的机制。如果你想在你的应用程序中使用多线程，就必须

包含这个类。 Thread 类有几个至关重要的方法，描述如下：

Start():启动线程

Sleep(int):静态方法，暂停当前线程指定的毫秒数

Abort():通常使用该方法来终止一个线程

Suspend()：该方法并不终止未完成的线程，它仅仅挂起线程，以后还可恢复。

Resume():恢复被 Suspend()方法挂起的线程的执行

下面我们就动手来创建一个线程，使用 Thread 类创建线程时，只需提供线程入口即可。线程入口使程序知道该让这个线程干什么事，在 C#中，线程入口是通

过 ThreadStart 代理（ delegate）来提供的，你可以把 ThreadStart 理解为一个函数指针，指向线程要执行的函数，当调用 Thread.Start()方法后，线程就开

始执行 ThreadStart 所代表或者说指向的函数。

在多线程的程序中，经常会出现两种情况。一种情况下，应用程序中的线程把大部分的时间花费在等待状态，等待某个事件发生，然后才能给予响应；而另外

一种情况则是线程平常都处于休眠状态，只是周期性地被唤醒。在 .net framework 里边，我们使用 ThreadPool 来对付第一种情况，使用 Timer 来对付第二种

情况。

ThreadPool 类提供一个由系统维护的线程池 — — 可以看作一个线程的容器，该容器需要 Windows 2000 以上版本的系统支持，因为其中某些方法调用了

只有高版本的 Windows 才有的 API 函数。你可以使用 ThreadPool.QueueUserWorkItem()方法将线程安放在线程池里，该方法的原型如下：

//将一个线程放进线程池，该线程的 Start()方法将调用 WaitCallback 代理对象代表的函数

public static bool QueueUserWorkItem(WaitCallback);

//重载的方法如下，参数 object 将传递给 WaitCallback 所代表的方法

public static bool QueueUserWorkItem(WaitCallback, object);

120

要注意的是，ThreadPool 类也是一个静态类，你不能也不必要生成它的对象，而且一旦使用该方法在线程池中添加了一个项目，那么该项目将是没有办法

取消的。在这里你无需自己建立线程，只需把你要做的工作写成函数，然后作为参数传递给 ThreadPool.QueueUserWorkItem()方法就行了，传递的方法就是依

靠 WaitCallback 代理对象，而线程的建立、管理、运行等等工作都是由系统自动完成的，你无须考虑那些复杂的细节问题，线程池的优点也就在这里体现出

来了，就好像你是公司老板——只需要安排工作，而不必亲自动手。

下面的例程演示了 ThreadPool 的用法。首先程序创建了一个 ManualResetEvent 对象，该对象就像一个信号灯，可以利用它的信号来通知其它线程，本例中当

线程池中所有线程工作都完成以后，从它

ManualResetEvent 的对象将被设置为有信号，而通知主线程继续运行。有几个重要的方法：Reset()，Set()，WaitOne()。

用（，该

初始化该对象时，户可以指定其默认的状态有信号 /无信号）在初始化以后，对象将保持原来的状态不变直到它的 Reset()或者 Set()方法被调用，Reset()

方法将其设置为无信号状态， Set()方法将其设置为有信号状态。 WaitOne()方法使当前线程挂起直到 ManualResetEvent 对象处于有信号状态，此时该线程将

被激活。然后，程序将向线程池中添加工作项，这些以函数形式提供的工作项被系统用来初始化自动建立的线程。当所有的线程都运行完了以后，

ManualResetEvent.Set()方法被调用，因为调用了 ManualResetEvent.WaitOne()方法而处在等待状态的主线程将接收到这个信号，于是它接着往下执行，完成

后边的工作。

142. 讲讲你对 Visual Studio 2005.NET 中的 CLR 编程的理解,它与 MFC 编程有什么区别（列

举 2 点即可）?

1、MFC 是基于 Windows 的，直接编译成本机二进制代码，可直接在 Windows 操作系统中执行，它是依赖于平台系统调用的（也就是 MFC 本身对 API 的包

装）

2、 .net 编程（就是你说的 CLR）是基于 .net framework 的，理论上说它是跨平台的（虽然目前只有 Windows 支持它，而且需要单独加装组件），编译后

的只是中间代码，不可直接执行。

143. HTTP module/HTTP handler

ASP.NET 对请求处理的过程：

这它（之将

当请求一个 *.aspx 文件的时候，个请求会被 inetinfo.exe 进程截获，判断文件的后缀 aspx）后，这个请求转交给 ASPNET_ISAPI.dll，ASPNET_ISAPI.dll

会通过 http 管道（ HttpPipeLine）将请求发送给 ASPNET_WP.exe 进程，在 ASPNET_WP.exe 进程中通过 HttpRuntime 来处理这个请求，处理完毕将结果返回客

户端。

inetinfo.exe 进程：是 www 服务的进程， IIS 服务和 ASPNET_ISAPI.DLL 都寄存在此进程中。

ASPNET_ISAPI.DLL：是处理 .aspx 文件的 win32 组件。其实 IIS 服务器是只能识别 .html 文件的，当 IIS 服务器发现被请求的文件是 .aspx 文件时，

IIS 服务器将其交给 aspnet_isapi.dll 来处理。

aspnet_wp.exe 进程： ASP.NET 框架进程，提供 .net 运行的托管环境， .net 的 CLR(公共语言运行时 )就是寄存在此进程中。

ASP.NET Framework 处理一个 Http Request 的流程：

HttpRequest-->inetinfo.exe-->ASPNET_ISAPI.dll-->ASPNET_WP.exe-->HttpRuntime-->HttpApplicationFactory-->HttpApplication-->HttpModule-

->HttpHandlerFactory-->HttpHandler-->HttpHandler.ProcessRequest()

这

ASP.NET 请求处理过程是基于管道模型的，个管道模型是由多个 HttpModule 和 HttpHandler 组成，ASP.NET 把 http 请求依次传递给管道中各个 HttpModule，

最终被 HttpHandler 处理，处理完成后，再次经过管道中的 HTTP 模块，把结果返回给客户端。我们可以在每个 HttpModule 中都可以干预请求的处理过程。

注意：在 http 请求的处理过程中，只能调用一个 HttpHandler，但可以调用多个 HttpModule。

当请求到达 HttpModule 的时候，系统还没有对这个请求真正处理，但是我们可以在这个请求传递到处理中心（ HttpHandler）之前附加一些其它信息，或者截

获的这个请求并作一些额外的工作，也或者终止请求等。在 HttpHandler 处理完请求之后，我们可以再在相应的 HttpModule 中把请求处理的结果进行再次加

工返回客户端。

HttpModule

HTTP 模块是实现了 System.Web.IhttpModule 接口的类。

IHttpModule 接口的声明：

public interface IHttpModule

{

121

void Init (HttpApplication context);

void Dispose ();

}

Init 方法：系统初始化的时候自动调用，这个方法允许 HTTP 模块向 HttpApplication 对象中的事件注册自己的事件处理程序。

Dispose 方法：这个方法给予 HTTP 模块在对象被 **收集之前执行清理的机会。此方法一般无需编写代码。

HTTP 模块可以向 System.Web.HttpApplication 对象注册下面一系列事件：

AcquireRequestState 当 ASP.NET 运行时准备好接收当前 HTTP 请求的对话状态的时候引发这个事件。

AuthenticateRequest 当 ASP.NET 运行时准备验证用户身份的时候引发这个事件。

AuthorizeRequest 当 ASP.NET 运行时准备授权用户访问资源的时候引发这个事件。

BeginRequest 当 ASP.NET 运行时接收到新的 HTTP 请求的时候引发这个事件。

Disposed 当 ASP.NET 完成 HTTP 请求的处理过程时引发这个事件。

EndRequest 把响应内容发送到客户端之前引发这个事件。

Error 在处理 HTTP 请求的过程中出现未处理异常的时候引发这个事件。

PostRequestHandlerExecute 在 HTTP 处理程序结束执行的时候引发这个事件。

PreRequestHandlerExecute 在 ASP.NET 开始执行 HTTP 请求的处理程序之前引发这个事件。在这个事件之后， ASP.NET 把该请求转发给适当

的 HTTP 处理程序。

PreSendRequestContent 在 ASP.NET 把响应内容发送到客户端之前引发这个事件。这个事件允许我们在内容到达客户端之前改变响应内容。

我们可以使用这个事件给页面输出添加用于所有页面的内容。例如通用菜单、头信息或脚信息。

PreSendRequestHeaders 在 ASP.NET 把 HTTP 响应头信息发送给客户端之前引发这个事件。在头信息到达客户端之前，这个事件允许我们改变

它的内容。我们可以使用这个事件在头信息中添加 cookie 和自定义数据。

ReleaseRequestState 当 ASP.NET 结束所搜有的请求处理程序执行的时候引发这个事件。

ResolveRequestCache 我们引发这个事件来决定是否可以使用从输出缓冲返回的内容来结束请求。这依赖于 Web 应用程序的输出缓冲时怎样

设置的。

UpdateRequestCache 当 ASP.NET 完成了当前的 HTTP 请求的处理，并且输出内容已经准备好添加给输出缓冲的时候，引发这个事件。这依赖

于 Web 应用程序的输出缓冲是如何设置的。

上面这么多的事件，我们看起来可能会有些眼晕，但没关系，下面一步一步地看。

HttpModule 生命周期示意图

下面是事件的触发顺序：

BeginRequest 和 PreRequestHandlerExecute 之间的事件是在服务器执行 HttpHandler 处理之前触发。

PostRequestHandlerExecute 和 PreSendRequestContent 之间的事件是在服务器执行 Handler 处理之后触发。

下面我们看一下如何使用 HttpModule 来实现我们日常的应用：

HttpModule 通过在某些事件中注册，把自己插入 ASP.NET 请求处理管道。当这些事件发生的时候， ASP.NET 调用对相应的 HTTP 模块，这样该

模块就能处理请求了。

1、向每个页面动态添加一些备注或说明性的文字：

有的网站每一个页面都会弹出一个广告或在每个页面都以注释形式（）加入网站的版权信息。如果在每个页面教编写这样的

JS 代码的话，对于大一点的网站，这种 JS 代码的编写与维护可是一个很繁琐枯燥的工作。

有了 HttpModule 我们就可以很简单地解决这个问题了。 HttpModule 是客户端发出请求到客户端接收到服务器响应之间的一段必经之路。

122

我们完全可以在服务器处理完请求之后，并在向客户端发送响应文本之前这段时机，把这段注释文字添加到页面文本之后。这样，每一个页面请求都会被附加

上这段注释文字。

这段代码究竟该在哪个事件里实现呢？ PostRequestHandlerExecute 和 PreSendRequestContent 之间的任何一个事件都可以，但我比

较喜欢在 EndRequest 事件里编写代码。

第一步：创建一个类库 ClassLibrary831。

第二步：编写一个类实现 IHttpModule 接口

class TestModule:IHttpModule

{

public void Dispose()

{

}

public void Init(HttpApplication context)

{

}

}

第三步：在 Init 事件中注册 EndRequest 事件，并实现事件处理方法

class TestModule:IHttpModule

{

public void Dispose(){}

public void Init(HttpApplication context)

{

context.EndRequest += new EventHandler(context_ EndRequest);

}

void context_EndRequest(object sender, EventArgs e)

{

HttpApplication ha = (HttpApplication)sender;

ha.Response.Write("");

}

}

第四步：在 Web.Conofig 中注册一下这个 HttpModule 模块

name：模块名称，一般是类名

type：有两部分组成，前半部分是命名空间和类名组成的全名，后半部分是程序集名称，如果类是直接放在 App_Code 文件夹中，那程序

名称是 App_Code。

运会

这样在 Web 站点是添加该类库的引用后，行每个页面，发现其源文件中都会加入 “ ” 这句话。同样的方法你也可以在其中加入 JS 代码。

2、身份检查

大家在作登录时，登录成功后，一般要把用户名放在 Session 中保存，在其它每一个页面的 Page_Load 事件中都检查 Session 中是否

存在用户名，如果不存在就说明用户未登录，就不让其访问其中的内容。

在比较大的程序中，这种做法实在是太笨拙，因为你几乎要在每一个页面中都加入检测 Session 的代码，导致难以开发和维护。下面

我们看看如何使用 HttpModule 来减少我们的工作量

由于在这里我们要用到 Session 中的内容，我们只能在 AcquireRequestState 和 PreRequestHandlerExecute 事件中编写代码，因为在

HttpModule 中只有这两事件中可以访问 Session。这里我们选择 PreRequestHandlerExecute 事件编写代码。

第一步：创建一个类库 ClassLibrary831。

第二步：编写一个类实现 IHttpModule 接口

class TestModule:IHttpModule

{

123

public void Dispose()

{

}

public void Init(HttpApplication context)

{

}

}

第三步：在 Init 事件中注册 PreRequestHandlerExecute 事件，并实现事件处理方法

class AuthenticModule:IHttpModule

{

public void Dispose(){}

public void Init(HttpApplication context)

{

context.PreRequestHandlerExecute += new EventHandler(context_PreRequestHandlerExecute);

}

void context_PreRequestHandlerExecute(object sender, EventArgs e)

{

HttpApplication ha = (HttpApplication)sender;

string path = ha.Context.Request.Url.ToString();

int n = path.ToLower().IndexOf("Login.aspx");

if (n == -1) //是否是登录页面，不是登录页面的话则进入 {}

{

if (ha.Context.Session["user"] == null) // 是否 Session 中有用户名，若是空的话，转向登录页。

{

ha.Context.Response.Redirect("Login.aspx?source=" + path);

}

}

}

}

第四步：在 Login.aspx 页面的 “ 登录 ” 按钮中加入下面代码

protected void Button1_Click(object sender, EventArgs e)

{

if(true) //判断用户名密码是否正确

{

if (Request.QueryString["source"] != null)

{

string s = Request.QueryString["source"].ToLower().ToString(); //取出从哪个页面转来的

Session["user"] = txtUID.Text;

Response.Redirect(s); //转到用户想去的页面

}

else

{

Response.Redirect("main.aspx"); //默认转向 main.aspx

}

}

}

第五步：在 Web.Conofig 中注册一下这个 HttpModule 模块

124

3、多模块的操作

如果定义了多个 HttpModule，在 web.config 文件中引入自定义 HttpModule 的顺序就决定了多个自定义 HttpModule 在处理一个 HTTP

请求的接管顺序。

HttpHandler

HttpHandler 是 HTTP 请求的处理中心，真正地对客户端请求的服务器页面做出编译和执行，并将处理过后的信息附加在 HTTP 请求信息流中再次返回

到 HttpModule 中。

HttpHandler 与 HttpModule 不同，一旦定义了自己的 HttpHandler 类，那么它对系统的 HttpHandler 的关系将是 “ 覆盖 ” 关系。

IHttpHandler 接口声明

public interface IHttpHandler

{

bool IsReusable { get; }

public void ProcessRequest(HttpContext context); // 请求处理函数

}

示例：把硬盘上的图片以流的方式写在页面上

class TestHandler : IHttpHandler

{

public void ProcessRequest(HttpContext context)

{

FileStream fs = new FileStream(context.Server.MapPath("worm.jpg"), FileMode.Open);

byte[] b = new byte[fs.Length];

fs.Read(b, 0, (int)fs.Length);

fs.Close();

context.Response.OutputStream.Write(b, 0, b.Length);

}

public bool IsReusable

{

get

{

return true;

}

}

}

Web.Config 配置文件

指 *－

Verb 属性：定了处理程序支持的 HTTP 动作。支持所有的 HTTP 动作 ;“ GET” －支持 Get 操作 ;“ POST” －支持 Post 操作 ;“ GET, POST”

－支持两种操作。

Path 属性：指定了需要调用处理程序的路径和文件名（可以包含通配符）。 “ *” 、 “ *.aspx” 、 “ showImage.aspx” 、 “ test1.aspx,test2.aspx”

Type 属性：用名字空间、类名称和程序集名称的组合形式指定处理程序或处理程序工厂的实际类型。 ASP.NET 运行时首先搜索 bin 目录中的 DLL，接着在

GAC 中搜索。

这样程序运行的效果是该网站的任何一个页面都会显示 worm.jpg 图片。如何只让一个页面（ default21.aspx）执行 HttpHandler 中的

125

ProcessRequest 方法呢？最简单的办法是在 Web.Config 文件中把 path 配置信息设为 default21.aspx。

根据这个例子大家可以考虑一下如何编写“验证码”了。

IHttpHandler 工厂

IHttpHandlerFactory 的作用是对 IHttpHandler 进行管理。工厂的作用请见

http://hi.baidu.com/grayworm/blog/item/4a832160f8c9de46eaf8f8c1.html "

IHttpHandlerFactory 接口的声明：

public interface IHttpHandlerFactory

{

IHttpHandler GetHandler (HttpContext context,string requestType,string url,string pathTranslated);

void ReleaseHandler (IHttpHandler handler);

}

GetHandler 返回实现 IHttpHandler 接口的类的实例， ReleaseHandler 使工厂可以重用现有的处理程序实例。

示例：两个用 IHttpHandlerFactory 来实现对不同 HttpHandler 的调用。

有两个 HttpHandler：将图片显示在页面上的 HttpHandler 和生成验证码的 Handler

//将图片显示在页面上的 Handler

class TestHandler : IHttpHandler

{

public void ProcessRequest(HttpContext context)

{

FileStream fs = new FileStream(context.Server.MapPath("worm.jpg"), FileMode.Open);

byte[] b = new byte[fs.Length];

fs.Read(b, 0, (int)fs.Length);

fs.Close();

context.Response.OutputStream.Write(b, 0, b.Length);

}

public bool IsReusable

{

get

{

return true;

}

}

}

//生成验证码的 Handler

class CodeHandler:IHttpHandler

{

public bool IsReusable

{

get

{

return true;

}

}

public void ProcessRequest(HttpContext context)

{

Image b = new Bitmap(50,20);

Graphics g = Graphics.FromImage(b);

SolidBrush sb = new SolidBrush(Color.White);

Font f = new Font("宋体 ", 12);

126

string str = "";

Random r = new Random();

for (int i = 0; i

这样 TestHandlerFactory 就会根据请求的不同页面执行不同的 HttpHandler 处理程序了。

HttpHandler 使用会话

如果要在处理程序中使用 Session，那必须把该 HttpHandler 实现 IRequiresSessionState 接口， ,IRequiresSessionState 接口是个空接口，它没

有抽象方法，只是一个标记。此处就不作例子验证了。

144. GAC 的理解及其作用.

GAC 全称是 Global Assembly 他例

Cache，的作用是可以存放一些有很多程序都要用到的公共 Assembly，如 System.Data、System.Windows.Forms 等等。

127

这样，很多程序就可以从 GAC 里面取得 Assembly，而不需要再把所有要用到的 Assembly 都拷贝到应用程序的执行目录下面。举例而言，如果没有 GAC，那么

这

势必每个 WinForm 程序的目录下就都要从 C:\WINDOWS\Microsoft.NET\Framework\v1.0.3705 下面拷贝一份 System.Windows.Forms.dll，样显然不如都从 GAC

里面取用方便，也有利于 Assembly 的升级和版本控制。

除了系统默认放置在 GAC 中的 Assembly 如 System.Windows.Forms 以外，我们也可以添加自己的 Assembly：

1）创建一个 strong-name 的 Assembly，例如 ToolbarComponent.dll

2）运行 gacutil -i ToolbarComponent.dll，把这个 Assembly 添加到 GAC

3）在程序中动态装载：

System.Reflection.Assembly ass=Assembly.Load("ToolbarComponent, Version=1.0.934.20434, Culture=neutral, PublicKeyToken=65f

45658c8d4927f");

MessageBox.Show("Is the assembly loaded from GAC? "+ass.GlobalAssemblyCache);

在上面的程序中，ToolbarComponent 就是从 GAC 装载而不是从程序的运行目录下的 dll 文件中装载，程序目录下不需要放置 ToolbarComponent.dll 程序也

能正常运行。另外， Assembly.Load()中的参数可以通过 "gacutil -l"查到。

另外，上面提到了 GAC 中的 Assembly 必须是 strong-name 的。创建 strong-name 的 Assembly 的步骤大致如下：

a) 在命令行运行 “ sn -k keyPair.snk” 创建一个密钥文件。这里的 sn.exe 也是 .NET 附带的一个工具。

b) 在 VS.NET 里面修改 “ AssemblyInfo.cs” 文件：

[assembly: AssemblyDelaySign(false)]

[assembly: AssemblyKeyFile("..\\..\\keyPair.snk")]

c) 编译项目，就能得到一个 strong-name 的 Assembly。

GAC 中的所有的 Assembly 都会存放在系统目录 "%winroot%\assembly 下面。放在系统目录下的好处之一是可以让系统管理员通过用户权限来控制 Assembly 的

访问。

145. firefox 与 IE 对 javascript 和 CSS 的区别

1. document.formName.item("itemName") 问题

说明 :IE 下 ,可以使用 document.formName.item("itemName") 或 document.formName.elements["elementName"];

Firefox 下 ,只能使用 document.formName.elements["elementName"].

解决方法 :统一使用 document.formName.elements["elementName"].

2.集合类对象问题

说明 :IE 下 ,可以使用 ()或 []获取集合类对象 ;Firefox 下 ,只能使用 []获取集合类对象 .

解决方法 :统一使用 []获取集合类对象 .

3.自定义属性问题

说明 :IE 下 ,可以使用获取常规属性的方法来获取自定义属性 ,也可以使用 getAttribute()获取自定义属性 ;Firefox 下 ,只能使用 getAttribute()获取自定义属

性.

解决方法 :统一通过 getAttribute()获取自定义属性 .

4.eval("idName")问题

说明 :IE 下 ,,可以使用 eval("idName")或 getElementById("idName")来取得 id 为 idName 的 HTML 对象 ;Firefox 下只能使用 getElementById("idName")来取得

id 为 idName 的 HTML 对象 .

解决方法 :统一用 getElementById("idName")来取得 id 为 idName 的 HTML 对象 .

5.变量名与某 HTML 对象 ID 相同的问题

说明 :IE 下 ,HTML 对象的 ID 可以作为 document 的下属对象变量名直接使用 ;Firefox 下则不能 .Firefox 下 ,可以使用与 HTML 对象 ID 相同的变量名 ;IE 下则不能。

解决方法 :使用 document.getElementById("idName") 代替 document.idName.最好不要取 HTML 对象 ID 相同的变量名 ,以减少错误 ;在声明变量时 ,一律加上 var,

以避免歧义.

6.const 问题

说明 :Firefox 下 ,可以使用 const 关键字或 var 关键字来定义常量 ;IE 下 ,只能使用 var 关键字来定义常量 .

解决方法 :统一使用 var 关键字来定义常量 .

7.input.type 属性问题

说明 :IE 下 input.type 属性为只读 ;但是 Firefox 下 input.type 属性为读写 .

8.window.event 问题

128

说明 :window.event 只能在 IE 下运行 ,而不能在 Firefox 下运行 ,这是因为 Firefox 的 event 只能在事件发生的现场使用 . Firefox 必须从源处加入 event 作参

数传递。 Ie 忽略该参数，用 window.event 来读取该 event。

解决方法:

IE&Firefox:

Submitted(event)"/> …

function Submitted(evt) {

evt=evt?evt:(window.event?window.event:null);

}

9.event.x 与 event.y 问题

说明 :IE 下 ,even 对象有 x,y 属性 ,但是没有 pageX,pageY 属性 ;Firefox 下 ,even 对象有 pageX,pageY 属性 ,但是没有 x,y 属性 .

解决方法 :使用 mX(mX = event.x ? event.x : event.pageX;) 来代替 IE 下的 event.x 或者 Firefox 下的 event.pageX.

10.event.srcElement 问题

说明 :IE 下 ,event 对象有 srcElement 属性 ,但是没有 target 属性 ;Firefox 下 ,even 对象有 target 属性 ,但是没有 srcElement 属性 .

解决方法 :使用 obj(obj = event.srcElement ? event.srcElement : event.target ;)来代替 IE 下的 event.srcElement 或者 Firefox 下的 event.target. 请

同时注意 event 的兼容性问题。

11.window.location.href 问题

说明 :IE 或者 Firefox2.0.x 下 ,可以使用 window.location 或 window.location.href;Firefox1.5.x 下 ,只能使用 window.location.

解决方法 :使用 window.location 来代替 window.location.href.

12.模态和非模态窗口问题

说明 :IE 下 ,可以通过 showModalDialog 和 showModelessDialog 打开模态和非模态窗口 ;Firefox 下则不能 .

解决方法 :直接使用 window.open(pageURL,name,parameters) 方式打开新窗口。

如果需要将子窗口中的参数传递回父窗口 ,可以在子窗口中使用 window.opener 来访问父窗口 . 例如： var parWin = window.opener;

parWin.document.getElementById("Aqing").value = "A qing";

13.frame 问题

以下面的 frame 为例：

(1)访问 frame 对象 :

IE:使用 window.frameId 或者 window.frameName 来访问这个 frame 对象 . frameId 和 frameName 可以同名。

Firefox:只能使用 window.frameName 来访问这个 frame 对象 .

另外，在 IE 和 Firefox 中都可以使用 window.document.getElementById("frameId")来访问这个 frame 对象 .

(2)切换 frame 内容 :

在 IE 和 Firefox 中都可以使用 window.document.getElementById("testFrame").src = "xxx.html" 或 window.frameName.location = "xxx.html" 来切换 frame

的内容.

如果需要将 frame 中的参数传回父窗口 (注意不是 opener,而是 parent frame)，可以在 frme 中使用 parent 来访问父窗口。例如：

parent.document.form1.filename.value="Aqing";

14.body 问题

Firefox 的 body 在 body 标签没有被浏览器完全读入之前就存在；而 IE 的 body 则必须在 body 标签被浏览器完全读入之后才存在 .

15. 事件委托方法

IE： document.body.onload = inject; //Function inject() 在这之前已被实现

Firefox： document.body.onload = inject();

16. firefox 与 IE 的父元素 (parentElement)的区别

IE： obj.parentElement

firefox： obj.parentNode

解决方法 : 因为 firefox 与 IE 都支持 DOM,因此使用 obj.parentNode 是不错选择 .

17.cursor:hand VS cursor:pointer

firefox 不支持 hand，但 ie 支持 pointer

解决方法 : 统一使用 pointer

129

18.innerText 在 IE 中能正常工作，但是 innerText 在 FireFox 中却不行 . 需用 textContent。

解决方法:

if(navigator.appName.indexOf("Explorer") > -1){

document.getElementById('element').innerText = "my text";

} else{

document.getElementById('element').textContent = "my text";

}

19. FireFox 中设置 HTML 标签的 style 时，所有位置性和字体尺寸的值必须后跟 px。这个 ie 也是支持的。

在使使

20. ie,firefox 以及其它浏览器对于 table 标签的操作都各不相同， ie 中不允许对 table 和 tr 的 innerHTML 赋值，用 js 增加一个 tr 时，用 appendChild

方法也不管用。

解决方法：

//向 table 追加一个空行：

var row = otable.insertRow(-1);

var cell = document.createElement("td");

cell.innerHTML = " ";

cell.className = "XXXX";

row.appendChild(cell);

21. padding 问题

padding 5px 4px 3px 1px FireFox 无法解释简写 ,

必须改成 padding-top:5px; padding-right:4px; padding-bottom:3px; padding-left:1px;

22. 消除 ul、 ol 等列表的缩进时

样式应写成 :list-style:none;margin:0px;padding:0px;

其中 margin 属性对 IE 有效， padding 属性对 FireFox 有效

23. CSS 透明

IE： filter:progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=60) 。

FF： opacity:0.6。

24. CSS 圆角

IE：不支持圆角。

FF： -moz-border-radius:4px，或者 -moz-border-radius-topleft:4px;-moz-border-

radius-topright:4px;-moz-border-radius-bottomleft:4px;-moz-border-radius- bottomright:4px;。

25. CSS 双线凹凸边框

IE： border:2px outset;。

FF： -moz-border-top-colors: #d4d0c8 white;-moz-border-left-colors: #d4d0c8 white;-moz-border-right-colors:#404040

#808080;-moz-border-bottom-colors:#404040 #808080;

26. 对 select 的 options 集合操作

枚举元素除了 []外， SelectName.options.item()也是可以的 , 另外 SelectName.options.length, SelectName.options.add/remove 都可以在两种浏览器上使

用。注意在 add 后赋值元素，否则会失败（本人试验如此）。

27. XMLHTTP 的区别

//mf

if (window.XMLHttpRequest) //mf

{

xmlhttp=new XMLHttpRequest()

xmlhttp.

xmlhttp.open("GET",url,true)

xmlhttp.send(null)

}

//ie

else if (window.ActiveXObject) // code for IE

{

130

xmlhttp=new ActiveXObject("Microsoft.XMLHTTP")

if (xmlhttp)

{

xmlhttp.

xmlhttp.open("GET",url,true)

xmlhttp.send()

}

}

}

28. innerHTML 的区别

Firefox 不支持 innerHTML, 解决办法可以如下

rng = document.createRange();

el = document.getElementById(elementid);

rng.setStartBefore(el);

htmlFrag = rng.createContextualFragment(content);

while (el.hasChildNodes()) //清除原有内容，加入新内容

el.removeChild(el.lastChild);

el.appendChild(htmlFrag);

29. img 的 src 刷新问题

在 IE 下可以用可以刷新图片，但在 FireFox 下不行。

主要是缓存问题，在地址后面加个随机数就解决了。编辑 onclick 事件代码如下： "this.src=this.src+'?'+Math.random()"

146. jQuery AJAX

jQuery 确实是一个挺好的轻量级的 JS 框架，能帮助我们快速的开发 JS 应用，并在一定程度上改变了我们写 JavaScript 代码的习惯。

废话少说，直接进入正题，我们先来看一些简单的方法，这些方法都是对 jQuery.ajax()进行封装以方便我们使用的方法，当然，如果要处理复杂的逻辑，还

是需要用到 jQuery.ajax()的 (这个后面会说到 ).

1. load ( url, [data], [callback] ) ：载入远程 HTML 文件代码并插入至 DOM 中。

url (String) : 请求的 HTML 页的 URL 地址。

data (Map) : (可选参数 ) 发送至服务器的 key/value 数据。

callback (Callback) : (可选参数 ) 请求完成时 (不需要是 success 的 )的回调函数。

这个方法默认使用 GET 方式来传递的，如果 [data]参数有传递数据进去，就会自动转换为 POST 方式的。jQuery 1.2 中，可以指定选择符，来筛选载入的

HTML 文档， DOM 中将仅插入筛选出的 HTML 代码。语法形如 "url #some > selector" 。

这个方法可以很方便的动态加载一些 HTML 文件，例如表单。

示例代码：

$(".ajax.load").load("http://www.cnblogs.com/QLeelulu/archive/2008/03/30/1130270.html .post",

function (responseText, textStatus, XMLHttpRequest){

this;//在这里 this 指向的是当前的 DOM 对象，即 $(".ajax.load")[0]

//alert(responseText);//请求返回的内容

//alert(textStatus);//请求状态： success， error

//alert(XMLHttpRequest);//XMLHttpRequest 对象

});

这里将显示结果。

注：不知道为什么 URL 写绝对路径在 FF 下会出错，知道的麻烦告诉下。下面的 get()和 post()示例使用的是绝对路径，所以在 FF 下你将会出错并不会看到

返回结果。还有 get()和 post()示例都是跨域调用的，发现传上来后没办法获取结果，所以把运行按钮去掉了。

2. jQuery.get ( url, [data], [callback] )：使用 GET 方式来进行异步请求

参数：

131

url (String) : 发送请求的 URL 地址 .

data (Map) : (可选 ) 要发送给服务器的数据，以 Key/value 的键值对形式表示，会做为 QueryString 附加到请求 URL 中。

callback (Function) : (可选 ) 载入成功时回调函数 (只有当 Response 的返回状态是 success 才是调用该方法 )。

这是一个简单的 GET 请求功能以取代复杂 $.ajax 。请求成功时可调用回调函数。如果需要在出错时执行函数，请使用 $.ajax。示例代码：

$.get("./Ajax.aspx", {Action:"get",Name:"lulu"}, function (data, textStatus){

//返回的 data 可以是 xmlDoc, jsonObj, html, text, 等等 .

this; // 在这里 this 指向的是 Ajax 请求的选项配置信息，请参考下图

alert(data);

//alert(textStatus);//请求状态： success， error 等等。

当然这里捕捉不到 error，因为 error 的时候根本不会运行该回调函数

//alert(this);

});

点击发送请求：

jQuery.get()回调函数里面的 this ，指向的是 Ajax 请求的选项配置信息：

3. jQuery.post ( url, [data], [callback], [type] ) ：使用 POST 方式来进行异步请求

参数：

url (String) : 发送请求的 URL 地址 .

data (Map) : (可选 ) 要发送给服务器的数据，以 Key/value 的键值对形式表示。

callback (Function) : (可选 ) 载入成功时回调函数 (只有当 Response 的返回状态是 success 才是调用该方法 )。

type (String) : (可选 )官方的说明是： Type of data to be sent。其实应该为客户端请求的类型 (JSON,XML,等等 )

这是一个简单的 POST 请求功能以取代复杂 $.ajax 。请求成功时可调用回调函数。如果需要在出错时执行函数，请使用 $.ajax。示例代码：

Ajax.aspx：

Response.ContentType = "application/json";

Response.Write("{result: '" + Request["Name"] + ",你好！ (这消息来自服务器 )'}");

jQuery 代码：

$.post("Ajax.aspx", { Action: "post", Name: "lulu" },

function (data, textStatus){

// data 可以是 xmlDoc, jsonObj, html, text, 等等 .

//this; // 这个 Ajax 请求的选项配置信息，请参考 jQuery.get()说到的 this

alert(data.result);

}, "json");

点击提交：

这里设置了请求的格式为 "json"：

132

如果你设置了请求的格式为 "json"，此时你没有设置 Response 回来的 ContentType 为： Response.ContentType = "application/json"; 那么你将无法捕捉

到返回的数据。

注意一下， alert(data.result); 由于设置了 Accept 报头为 “ json” ，这里返回的 data 就是一个对象，并不需要用 eval()来转换为对象。

4. jQuery.getScript ( url, [callback] ) : 通过 GET 方式请求载入并执行一个 JavaScript 文件。

参数

url (String) : 待载入 JS 文件地址。

callback (Function) : (可选 ) 成功载入后回调函数。

jQuery 1.2 版本之前， getScript 只能调用同域 JS 文件。 1.2 中，您可以跨域调用 JavaScript 文件。注意： Safari 2 或更早的版本不能在全局作用

域中同步执行脚本。如果通过 getScript 加入脚本，请加入延时函数。

这个方法可以用在例如当只有编辑器 focus()的时候才去加载编辑器需要的 JS 文件 .下面看一些示例代码：

加载并执行 test.js。

jQuery 代码 :

$.getScript("test.js");

加载并执行 AjaxEvent.js ，成功后显示信息。

jQuery 代码 :

$.getScript("AjaxEvent.js", function(){

alert("AjaxEvent.js 加载完成并执行完成 .你再点击上面的 Get 或 Post 按钮看看有什么不同？ ");

});

加载完后请重新点击一下上面的 Load 请求看看有什么不同。

jQuery Ajax 事件

Ajax 请求会产生若干不同的事件，我们可以订阅这些事件并在其中处理我们的逻辑。在 jQuery 这里有两种 Ajax 事件：局部事件和全局事件。

局部事件就是在每次的 Ajax 请求时在方法内定义的，例如：

$.ajax({

beforeSend: function(){

// Handle the beforeSend event

},

complete: function(){

// Handle the complete event

}

// ...

});

全局事件是每次的 Ajax 请求都会触发的，它会向 DOM 中的所有元素广播，在上面 getScript() 示例中加载的脚本就是全局 Ajax 事件。全局事件可以如下

定义：

$("#loading").bind("ajaxSend", function(){

$(this).show();

}).bind("ajaxComplete", function(){

$(this).hide();

});

133

或者：

$("#loading").ajaxStart(function(){

$(this).show();

});

我们可以在特定的请求将全局事件禁用，只要设置下 global 选项就可以了：

$.ajax({

url: "test.html",

global: false,// 禁用全局 Ajax 事件 .

// ...

});

下面是 jQuery 官方给出的完整的 Ajax 事件列表：

 ajaxStart (Global Event)

This event is broadcast if an Ajax request is started and no other Ajax requests are currently running.

beforeSend (Local Event)

This event, which is triggered before an Ajax request is started, allows you to modify the XMLHttpRequest object (setting add itional headers,

if need be.)

ajaxSend (Global Event)

This global event is also triggered before the request is run.

success (Local Event)

This event is only called if the request was successful (no errors from the server, no errors with the data).

ajaxSuccess (Global Event)

This event is also only called if the request was successful.

error (Local Event)

This event is only called if an error occurred with the request (you can never have both an error and a success callback with a request).

ajaxError (Global Event)

This global event behaves the same as the local error event.

complete (Local Event)

This event is called regardless of if the request was successful, or not. You will always receive a complete callback, even for synchronous

requests.

ajaxComplete (Global Event)

This event behaves the same as the complete event and will be triggered every time an Ajax request finishes.

 ajaxStop (Global Event)

This global event is triggered if there are no more Ajax requests being processed.

具体的全局事件请参考 API 文档。

好了，下面开始说 jQuery 里面功能最强的 Ajax 请求方法 $.ajax();

jQuery.ajax ( options ) : 通过 HTTP 请求加载远程数据

这个是 jQuery 的底层 AJAX 实现。简单易用的高层实现见 $.get, $.post 等。

$.ajax() 返回其创建的 XMLHttpRequest 对象。大多数情况下你无需直接操作该对象，但特殊情况下可用于手动终止请求。

注意：如果你指定了 dataType 选项，确保服务器返回正确的 MIME 信息，

请 (如 xml 返回 "text/xml")。误的 MIME 类型可能导致不可预知的错误。

错

见 Specifying the Data Type for AJAX Requests 。

当设置 datatype 类型为 'script' 的时候，所有的远程 (不在同一个域中 )POST 请求都回转换为 GET 方式。

$.ajax() 只有一个参数：参数 key/value 对象，包含各配置及回调函数信息。详细参数选项见下。

jQuery 1.2 中，您可以跨域加载 JSON 数据，使用时需将数据类型设置为 JSONP 。使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将

自动替换 ? 为正确的函数名，以执行回调函数。数据类型设置为 "jsonp" 时， jQuery 将自动调用回调函数。 (这个我不是很懂 )

参数列表：

参数名类型描述

134

url String (默认 : 当前页地址 ) 发送请求的地址。

type String (默认 : "GET") 请求方式 ("POST" 或 "GET")，默认为 "GET"。注意：其它 HTTP 请求方

法，如 PUT 和 DELETE 也可以使用，但仅部分浏览器支持。

timeout Number 设置请求超时时间（毫秒）。此设置将覆盖全局设置。

async Boolean (默认 : true) 默认设置下，所有请求均为异步请求。如果需要发送同步请求，请将此选项

设置为 false。意，步请求将锁住浏览器，户其它操作必须等待请求完成才可以执行。

注同用

beforeSend Function 如

发送请求前可修改 XMLHttpRequest 对象的函数，添加自定义 HTTP 头。XMLHttpRequest

对象是唯一的参数。

function (XMLHttpRequest) {

this; // the options for this ajax request

}

cache Boolean (默认 : true) jQuery 1.2 新功能，设置为 false 将不会从浏览器缓存中加载请求信息。

complete Function 请求完成后回调函数 (请求成功或失败时均调用 )。参数： XMLHttpRequest 对象，成功

信息字符串。

function (XMLHttpRequest, textStatus) {

this; // the options for this ajax request

}

contentType String (默认 : "application/x-www-form-urlencoded") 发送信息至服务器时内容编码类型。默

认值适合大多数应用场合。

data Object, 发送到服务器的数据。将自动转换为请求字符串格式。GET 请求中将附加在 URL 后。查看

String processData 选项说明以禁止此自动转换。必须为 Key/Value 格式。如果为数组，jQuery

将自动为不同值对应同一个名称。如 {foo:["bar1", "bar2"]} 转换为

'&foo=bar1&foo=bar2'。

dataType String 预期服务器返回的数据类型。如果不指定， jQuery 将自动根据 HTTP 包 MIME 信息返回

responseXML 或 responseText，并作为回调函数参数传递，可用值 :

"xml": 返回 XML 文档，可用 jQuery 处理。

"html": 返回纯文本 HTML 信息；包含 script 元素。

"script": 返回纯文本 JavaScript 代码。不会自动缓存结果。

"json": 返回 JSON 数据。

"jsonp": JSONP 格式。使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替

换 ? 为正确的函数名，以执行回调函数。

error Function (默认 : 自动判断 (xml 或 html)) 请求失败时将调用此方法。这个方法有三个参数：

XMLHttpRequest 对象，错误信息，（可能）捕获的错误对象。

function (XMLHttpRequest, textStatus, errorThrown) {

// 通常情况下 textStatus 和 errorThown 只有其中一个有值

this; // the options for this ajax request

}

global Boolean (默认 : true) 是否触发全局 AJAX 事件。设置为 false 将不会触发全局 AJAX 事件，如

ajaxStart 或 ajaxStop 。可用于控制不同的 Ajax 事件

ifModified Boolean (默认 : false) 仅在服务器数据改变时获取新数据。使用 HTTP 包 Last-Modified 头信息

判断。

processData Boolean (默认 : true) 默认情况下，发送的数据将被转换为对象 (技术上讲并非字符串 ) 以配合默认

内容类型 "application/x-www-form-urlencoded"。果要发送 DOM 树信息或其它不

如

135

希望转换的信息，请设置为 false。

success Function 请求成功后回调函数。这个方法有两个参数：服务器返回数据，返回状态

function (data, textStatus) {

// data could be xmlDoc, jsonObj, html, text, etc...

this; // the options for this ajax request

}

这里有几个 Ajax 事件参数：beforeSend ，success ，complete ，error 。我们可以定义这些事件来很好的处理我们的每一次的 Ajax 请求。注意一下，

这些 Ajax 事件里面的 this 都是指向 Ajax 请求的选项信息的 (请参考说 get() 方法时的 this 的图片 )。

请认真阅读上面的参数列表，如果你要用 jQuery 来进行 Ajax 开发，那么这些参数你都必需熟知的。

示例代码，获取博客园首页的文章题目：

$.ajax({

type: "get",

url: "http://www.cnblogs.com/rss",

beforeSend: function(XMLHttpRequest){

//ShowLoading();

},

success: function(data, textStatus){

$(".ajax.ajaxResult").html("");

$("item",data).each(function(i, domEle){

$(".ajax.ajaxResult").append(""+$(domEle).children("title").text()+"");

});

},

complete: function(XMLHttpRequest, textStatus){

//HideLoading();

},

error: function(){

//请求出错处理

}

});

147. 深入浅出 JSON

JSON 定义

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和编写，同时也易于机器解析和生成。它基于 ECMA262 语言规范（ 1999-12

中但（

第三版） JavaScript 编程语言的一个子集。 JSON 采用与编程语言无关的文本格式，是也使用了类 C 语言包括 C， C++， C#， Java， JavaScript， Perl，

Python 等）的习惯，这些特性使 JSON 成为理想的数据交换格式。

JSON 的结构基于下面两点

1. "名称 /值 "对的集合不同语言中，它被理解为对象 (object)，记录 (record)，结构 (struct)，字典 (dictionary)，哈希表 (hash table)，键列表 (keyed list)

等

2. 值的有序列表多数语言中被理解为数组 (array)

JSON 使用：

JSON 以一种特定的字符串形式来表示 JavaScript 对象。如果将具有这样一种形式的字符串赋给任意一个 JavaScript 变量，那么该变量会变成一个对象引

用，而这个对象就是字符串所构建出来的，好像有点拗口，我们还是用实例来说明。

这里假设我们需要创建一个 User 对象，并具有以下属性

 用户 ID

 用户名

 用户 Email

您可以使用以下 JSON 形式来表示 User 对象：

136

{"UserID":11, "Name":"Truly", "Email":"zhuleipro ◎ hotmail.com"};

然后如果把这一字符串赋予一个 JavaScript 变量，那么就可以直接使用对象的任一属性了。

完整代码:

var User = {"UserID":11, "Name":"Truly", "Email":"zhuleipro◎ hotmail.com"};

alert(User.Name);

实际使用时可能更复杂一点，比如我们为 Name 定义更详细的结构，使它具有 FirstName 和 LastName：

{"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro ◎ hotmail.com"}

完整代码:

var User = {"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro ◎ hotmail.com"};

alert(User.Name.FirstName);

现在我们增加一个新的需求，我们某个页面需要一个用户列表，而不仅仅是一个单一的用户信息，那么这里就需要创建一个用户列表数组。

下面代码演示了使用 JSON 形式定义这个用户列表：

[

{"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro ◎ hotmail.com"},

{"UserID":12, "Name":{"FirstName":"Jeffrey","LastName":"Richter"}, "Email":"xxx ◎ xxx.com"},

{"UserID":13, "Name":{"FirstName":"Scott","LastName":"Gu"}, "Email":"xxx2 ◎ xxx2.com"}

]

完整代码:

var UserList = [

{"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro ◎ hotmail.com"},

{"UserID":12, "Name":{"FirstName":"Jeffrey","LastName":"Richter"}, "Email":"xxx ◎ xxx.com"},

{"UserID":13, "Name":{"FirstName":"Scott","LastName":"Gu"}, "Email ":"xxx2◎ xxx2.com"}

];

alert(UserList[0].Name.FirstName);

事实上除了使用 "."引用属性外，我们还可以使用下面语句：

alert(UserList[0]["Name"]["FirstName"]); 或者 alert(UserList[0].Name["FirstName"]);

现在读者应该对 JSON 的使用有点认识了，归纳为以下几点：

 对象是属性、值对的集合。一个对象的开始于 “ {” ，结束于 “ }” 。每一个属性名和值间用 “ :” 提示，属性间用 “ ,” 分隔。

 数组是有顺序的值的集合。一个数组开始于 "["，结束于 "]"，值之间用 ","分隔。

 值可以是引号里的字符串、数字、 true、 false、 null，也可以是对象或数组。这些结构都能嵌套。

 字符串和数字的定义和 C 或 Java 基本一致。

本文通过一个实例演示，初步了解了 JSON 的强大用途。可以归结如下：

 JSON 提供了一种优秀的面向对象的方法，以便将元数据缓存到客户机上。

 JSON 帮助分离了验证数据和逻辑。

 JSON 帮助为 Web 应用程序提供了 Ajax 的本质。

148. 在 UI 上使用 BackgroundWorker

凡是 WinForm 的应用程序，如果他执行了一个的非常冗长的处理操作（比如文件查询），它在执行时会锁定用户界面，虽然主活动窗口一直在运行，但用

户无法与程序交互，无法移动窗体或改变窗体大小，所以用户感觉很不爽。如何做才能使得这个程序有响应。答案就是在后台线程中执行这个操作。

在这里已经有了多种方法来做这个事情：

137

(一 )委托异步调用

将具体耗时的操作作为一个委托，并用 BeginInvoke 来异步执行这个委托（ Invoke 是同步调用），并且可以为这个操作传入参数并且通过 EndInvoke 方

法获得返回返回值。

(二 )使用 ThreadPool

新建 .net FrameWork 中自带的 WaitCallback 委托，然后放到线程池中运行 ThreadPool.QueueUserWorkItem( callback ); 根据 WaitCallback 委托

的定义，可以传入一个 object 类型的参数。

但是不能精确的控制线程池中的线程。

(三 )使用 Thread

和 ThreadPool 相比，使用 Thread 的开销会比较大。但是它有它的优势，使用 Thread 类可以显式管理线程。只要有可能，就应该使用 ThreadPool

类来创建线程。然而，在一些情况下，您还是需要创建并管理您自己的线程，而不是使用 ThreadPool 类。在 .net 2.0 中，提供了一个新的委托

ParameterizedThreadStart 支持启动一个线程并传入参数，这是对原来的 ThreadStart 委托的改进。

说了这么多还没有说到今天的主角 BackgroundWorker，他也是一个在 2.0 中新增的类 ,可以用于启动后台线程 ,并在后台计算结束后调用主线程的方法 .

可以看出同样的功能使用委托的异步调用也可以实现，只是使用 BackgroundWorker 的话会更加的简便快捷，可以节省开发时间，并把你从创建自己的委托

以及对它们的调用中解救出来。真是这样的吗看看下面这个例子。其实我也是从 101Samples 中看到的例子。

先看看 BackgroundWorker 中的主要概念。

第一：主要的事件及参数。

DoWork— — 当执行 BackgroundWorker.RunWorkerAsync 方法时会触发该事件，并且传递 DoWorkEventArgs 参数 ;

ProgressChanged— — 操作处理中获得的处理状态变化，通过 BackgroundWorker.ReportProgress(int) 方法触发该事件，并且传递

ProgressChangedEventArgs,其中包含了处理的百分比 ;

当

RunWorkerCompleted— — 异步操作完成后会触发该事件，然如果需要在操作过程中结束可以执行 BackgroundWorker.CancelAsync 方法要求异步调用中止，

跳同

并且在异步委托操作中检测 BackgroundWorker.CancellationPending 属性如果为 true 的话，出异步调用，时将 DoWorkEventArgs.Cancel 属性设为 true，

这样当退出异步调用的时候，可以让处理 RunWorkerCompleted 事件的函数知道是正常退出还是中途退出。

第二：主要的方法。

BackgroundWorker.RunWorkerAsync— —

“ 起动 ” 异步调用的方法有两次重载 RunWorkerAsync(),RunWorkerAsync(object argument) ，第二个重载提供了一个参数，可以供异步调

用使用。（如果有多个参数要传递怎么办，使用一个类来传递他们吧 )。调用该方法后会触发 DoWork 事件，并且为处理 DoWork 事件的函数 DoWorkEventArg 事

件参数，其中包含了 RunWorkerAsync 传递的参数。在相应 DoWork 的处理函数中就可以做具体的复杂操作。

BackgroundWorker.ReportProgress — —

有时候需要在一个冗长的操作中向用户不断反馈进度，这样的话就可以调用的 ReportProgress(int percent),在调用 ReportProgress 方

法时，触发 ProgressChanged 事件。提供一个在 0 到 100 之间的整数，它表示后台活动已完成的百分比。你也可能提供任何对象作为第二个参数，允许你给

事件处理程序传递状态信息。作为传递到此过程的 ProgressChangedEventArgs 参数属性，百分比和你自己的对象（如果提供的话）均要被传递到

ProgressChanged 事件处理程序。这些属性被分别命名为 ProgressPercentage 和 UserState，并且你的事件处理程序可以以任何需要的方式使用它们。 (注

意：只有在 BackgroundWorker.WorkerReportsProgress 属性被设置为 true 该方法才可用 )。

BackgroundWorker.CancelAsync— —

但需要退出异步调用的时候，就调用的这个方法。但是样还不够，因为它仅仅是将 BackgroudWorker.CancellationPending 属性设置为 true。你需要在

具体的异步调用处理的时候，不断检查 BackgroudWorker.CancellationPending 是否为 true，如果是真的话就退出。 (注意：只有在

BackgroundWorker.WorkerSupportsCancellation 属性被设置为 true 该方法才可用 )。

贴出一段 101Samples 里面的代码，看一下就明白了：

public partial class MainForm : Form

{

private System.ComponentModel.BackgroundWorker backgroundCalculator;

public MainForm()

{

InitializeComponent();

backgroundCalculator = new BackgroundWorker();

backgroundCalculator.WorkerReportsProgress = true;

backgroundCalculator.WorkerSupportsCancellation = true;

backgroundCalculator.DoWork +=

138

new DoWorkEventHandler(backgroundCalculator_DoWork);

backgroundCalculator.ProgressChanged +=

new ProgressChangedEventHandler(backgroundCalculator_ProgressChanged);

backgroundCalculator.RunWorkerCompleted +=

new RunWorkerCompletedEventHandler(backgroundCalculator_RunWorkerCompleted);

updateStatus(String.Empty);

}

private int getNextPrimeAsync(int start, BackgroundWorker worker, DoWorkEventArgs e)

{

int percentComplete = 0;

start++;

while (!isPrime(start))

{

// Check for cancellation

if (worker.CancellationPending)

{

e.Cancel = true;

break;

}

else

{

start++;

percentComplete++;

worker.ReportProgress(percentComplete % 100);

}

}

return start;

}

void backgroundCalculator_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

{

if (e.Cancelled)

{

updateStatus("Cancelled.");

}

else if (e.Error != null)

{

reportError(e.Error);

}

else

{

reportPrime((int)e.Result);

}

calcProgress.Value = 0;

}

void backgroundCalculator_ProgressChanged(object sender, ProgressChangedEventArgs e)

{

updateProgress(e.ProgressPercentage);

}

void backgroundCalculator_DoWork(object sender, DoWorkEventArgs e)

139

{

int start = (int) e.Argument;

e.Result = getNextPrimeAsync(start, (BackgroundWorker)sender, e);

}

private void nextPrimeAsyncButton_Click(object sender, EventArgs e)

{

updateStatus("Calculating...");

int start;

Int32.TryParse(textBoxPrime.Text, out start);

if (start == 0)

{

reportError("The number must be a valid integer");

}

else

{

// Kick off the background worker process

backgroundCalculator.RunWorkerAsync(int.Parse(textBoxPrime.Text));

}

}

private void cancelButton_Click(object sender, EventArgs e)

{

if (backgroundCalculator.IsBusy)

{

updateStatus("Cancelling...");

backgroundCalculator.CancelAsync();

}

}

// Update the Status label

private void updateStatus(string status)

{

calcStatus.Text = status;

}

// Indicate progress using progress bar

private void updateProgress(int percentComplete)

{

calcProgress.Value = percentComplete;

}

}

BackgroundWorker 创建自己的委托并调用这个窗体的 Invoke 方法来运行它， BackgroundWorker 组件以一种优雅的方式来处理这个线程转换。

BackgroundWorker 组件允许你从后台线程中调用它的 ReportProgress 方法，该方法触发其 ProgressChanged 事件处理例程返回到窗体的线程中。你不必使

用 delegate/Invoke 方法自己处理这个线程转换，而是调用 ReportProgress，其余的事情交给组件来做。

149. 项目描述

Siebel Report

Novartis’ ETMS system is undergoing moving to Siebel System. These 24 Siebel reports retrieve data directly from Siebel database. The l inks

of 24 Siebel reports will be embedded in web pages of Siebel system. The project includes 24 reports and will use 3 tiers solu tion. Every report

140

will map to a page and an entity class. All entity classes will combine to be the business layer. Database layer includes all reporting stored

procedures and common stored procedures.

Followings techniques and tools are used in the project. Use ASP.NET 2.0 + Reporting Service (RDLC) to render

every report.

 ASP.NET 2.0

 Visual Studio 2005 with SP1

 Reporting Service (RDLC)

 SQLPlus

Waterfall software development life cycle model is followed during the process of Siebel Report development.

This development methodology contains the following stages:

 Requirements Gathering and Analysis

 System Design

 Coding and Unit Test

 System Test

 UAT (will be performed by Client)

Requirement Traceability Matrix (RTM) Document is used to make sure that specifications described in the FRS document are all covered completely.

This document is updated during each phase to help to verify and analyze that all the specifications are covered.

Object-Oriented design is employed in the system design. Requirements are converted from business model to individual components and finally

into class definition in the low level design.

He is responsible for the report design and sales module analysis and implemented.

CMS

Huaxia D&B is Shanghai Huaxia Dun & Bradstreet Business Information Consulting Co., Limited (HDBC), founded

in Dec 2006. It is the joint venture of D&B, the world leader in business information for more than 165 years,

and Huaxia Credit, a well recognized information provider in China.

Correspondents Management System (CMS) is a platform HDBC wants to implement to manage the activities of “Place

tickets to agents”, “Delivery from agents” and “Billing the tickets to agents”.

HDBC wants to build the system into a web application by using .NET technique and SQL Server 2005.

We gathered some high level requirements through meetings with the IT and Business team of HDBC. We then do

an proposal for an IT solution to the CMS.

It contains 6 main function modules:

 Place tickets

 Deliver tickets

 Billing of ticket

 Integrated with OPAL system

 Common data management

 System Reports

I am responsible for calculation module design and coding, report design.

DIT-C Tool

DIT-C Tool is an application which helps the clients of Huaxia D&B to transfer the standard DIT’s

XML data to specific customer-formatted XML file. Huaxia D&B wants to build it into a Desktop application

using .NET technique.

The running environment of this tool should be Windows XP/2000 and .Net framework 3.5 or above

should be pre-installed.

I am responsible for transfer tracking and logging module.

CareScore

141

Care score is an internal employee appraisal system for Huaxia D&B. This system is originally developed

under Access and written by VBA. This system allows the QAA to do the appraisal for BA or DEO based

on the Duns he or she gets. The BA/DEO leader and Manager should be able to review the appraisal result

reports for the BA/DEO. Currently the client wants to update the system to ASP.NET and SQL server 2000.

Care Score have Admin module, Report Module and Do Appraisal module. Admin module provides facility

to manage the user information and report type. The Do Appraisal module provides the facility to create

new appraisal for BA/DEO and edit existing data. Report module provides the ability to view and generate

BA summary report, BA Compare report, and DEO summary report and QAA performance report.

I am responsible for evaluation page implementing and designing report.

PRDBR

PRDB Rewrite project is a reengineering project. Nestle once used an Access based application called

Project Request Database (PRDB) to serve as a single repository for tracking and accelerate the approval

process of Projects and Enhancements. This existing application is re-engineered with .Net framework

2.0. It provide user friendly interface in order to fulfill all the functions and to ease the effort

for maintenance. This is a web application which uses SQL Server 2005 as the back end.

He is responsible for calculation module, report implementing and mail module.

150. ERP

ERP 是英文 Enterprise Resourse Planning 的缩写，中文意思是企业资源规划。它是一个以管理会计为核心的信息系统，识别和规划企业资源，从而获取客户

订单，完成加工和交付，最后得到客户付款。 ERP 将企业内部所有资源整合在一起，对采购、生产、成本、库存、分销、运输、财务、人力资源进行规划，从

而达到最佳资源组合，取得最佳效益。

151. 设计模式

创建型模式：

工厂方法定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂模式使一个类的实例化延迟到其子类。

抽象工厂提供一个创建一系列或相关依赖对象的接口，而无需指定他们具体的类。

建造者将一个复杂对象的构建与它的的表示分离，使得同样的构建过程可以创建不同的表示。将一个复杂对象的构建与它的表示分离，用同样的构建过程

创建不同的产品。

原型是用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新对象。建立相应数目的原型并克隆它们通常比每次用合适的状态手工实例化该类更

方便一些。

单例保证一个类仅有一个实例，并提供一个访问它的全局访问点。对一些类来说，一个实例是很重要的。一个全局变量可以使得一个对象被访问，但它不

能防止客户实例化多个对象。单例模式让类自身负责保存它唯一实例。这个类可以保证没有其他实例可以被创建，并且提供了一个访问该实例的方法。对唯一

的实例可以严格地控制客户怎样以及何时访问它。

创建型模式隐藏了这些类的实例是如何被创建和放在一起，整个系统关于这些对象所知道的是由抽象类所定义的接口。这样，创建型模式在创建了什么、

谁创建它、它是怎么被创建的，以及何时创建这些方面提供了很大的灵活性。创建型模式抽象了实例化的过程。他们帮助一个系统独立于如何创建、组合和表

示它的那些对象。创建型模式都会将关于该系统使用哪些具体的类的信息封装起来。

内聚性描述的是一个例程内部组成部分之间相互联系的紧密程度。而耦合性描述的是一个例程与其他例程之间联系的紧密程度。软件开发的目标应该是创

建这样的例程：内部完整，也就是高内聚，而与其他例程之间的联系则是小巧、直接、可见、灵活的，这就是松耦合。

结构型模式

适配器 (Adapter)将一个类的接口转换成客户希望的另一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的哪些类可以一起工作。

桥接 (Bridge)将抽象部分与它的实现部分分离，使它们都可以独立变化。

组合 (Composite)将对象组合成树形结构以表示 ‘ 部分 -整体 ’ 的层次结构，组合模式使得用户对单个对象的使用具有一致性。

装饰 (Decorator)动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更加灵活。

外观 (Facade)为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更容易使用。

享元 (Flyweight)为运用共享技术有效地支持大量细粒度的对象。

代理 (Proxy)为其他对象提供一种代理以控制对这个对象的访问。

代理与外观的主要区别在于，代理对象代表一个单一对象而外观对象代表一个子系统；代理的客户对象无法直接直接访问目标对象，由代理提供对单独的

目标对象的访问控制，而外观的客户对象可以直接访问子系统中的各个对象，但通常由外观对象提供对子系统各元件功能的简化的共同层次的调用接口。

142

代理是一种原来对象的代表，其他需要与这个对象打交道的操作都是和这个代表交涉。而适配器则不需要虚构出一个代表者，只需要为应付特定使用目的，

将原来的类进行一些组合。

行为型模式

观察者 (Observer)定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

模板方法 (TemplateMethod)定义一个操作的算法骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变一个算法结构即可以重定义该算法的某

些特定步骤。

命令 (Command)将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；可以对请求排队或记录请求日志，以及支持可撤销的操作。

状态 (State)允许一个对象在其内部状态改变时改变它的行为，让其看起来似乎修改了它的类。

职责链 (Chain of Responsiblilty)使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条

链传递该请求，直到有一个对象处理它为止。

解析器 (Interpreter)给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言的句子。

中介者 (Mediator)用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使耦合松散，而且可以独立地改变它们之间的

交互。

访问者 (Visitor)表示一个作用于某对象结构中的各个元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

策略 (Strategy)定义一系列的算法，把它们一个个封装起来，并且使他们可以相互替换，使算法可以独立于使用它的客户而变化。

152. 数据库索引

一、引言

对数据库索引的关注从未淡出我的们的讨论，那么数据库索引是什么样的？聚集索引与非聚集索引有什么不同？希望本文对各位同仁有一定的帮助。有不少存

疑的地方，诚心希望各位不吝赐教指正，共同进步。 [最近首页之争沸沸扬扬，也不知道这个放在这合适么，苦劳？功劳？ … … ]

二、 B-Tree

其例

我们常见的数据库系统，索引使用的数据结构多是 B-Tree 或者 B+Tree。如，MsSql 使用的是 B+Tree，所

Oracle 及 Sysbase 使用的是 B-Tree。以在最开始，

简单地介绍一下 B-Tree。

B-Tree 不同于 Binary Tree（二叉树，最多有两个子树），一棵 M 阶的 B-Tree 满足以下条件：

1）每个结点至多有 M 个孩子；

2）除根结点和叶结点外，其它每个结点至少有 M/2 个孩子；

3）根结点至少有两个孩子（除非该树仅包含一个结点）；

4）所有叶结点在同一层，叶结点不包含任何关键字信息；

5）有 K 个关键字的非叶结点恰好包含 K+1 个孩子；

另外，对于一个结点，其内部的关键字是从小到大排序的。以下是 B-Tree（ M=4）的样例：

对于每个结点，主要包含一个关键字数组 Key[]，一个指针数组（指向儿子） Son[]。在 B-Tree 内，查找的流程是：使用顺序查找（数组长度较短时）或折半

查找方法查找 Key[]数组，若找到关键字 K，则返回该结点的地址及 K 在 Key[]中的位置；否则，可确定 K 在某个 Key[i]和 Key[i+1]之间，则从 Son[i]所指的

子结点继续查找，直到在某结点中查找成功；或直至找到叶结点且叶结点中的查找仍不成功时，查找过程失败。

接着，我们使用以下图片演示如何生成 B-Tree（ M=4，依次插入 1~6）：

从图可见，当我们插入关键字 4 时，由于原结点已经满了，故进行分裂，基本按一半的原则进行分裂，然后取出中间的关键字 2，升级（这里是成为根结点）。

其它的依类推，就是这样一个大概的过程。

143

三、数据库索引

1．什么是索引

在数据库中，索引的含义与日常意义上的“索引”一词并无多大区别（想想小时候查字典），它是用于提高数据库表数据访问速度的数据库对象。

A）索引可以避免全表扫描。多数查询可以仅扫描少量索引页及数据页，而不是遍历所有数据页。

B）对于非聚集索引，有些查询甚至可以不访问数据页。

C）聚集索引可以避免数据插入操作集中于表的最后一个数据页。

D）一些情况下，索引还可用于避免排序操作。

当然，众所周知，虽然索引可以提高查询速度，但是它们也会导致数据库系统更新数据的性能下降，因为大部分数据更新需要同时更新索引。

2.索引的存储

一条索引记录中包含的基本信息包括：键值（即你定义索引时指定的所有字段的值） +逻辑指针（指向数据页或者另一索引页）。

当你为一张空表创建索引时，数据库系统将为你分配一个索引页，该索引页在你插入数据前一直是空的。此页此时既是根结点，也是叶结点。每当你往表中插

入一行数据，数据库系统即向此根结点中插入一行索引记录。当根结点满时，数据库系统大抵按以下步骤进行分裂：

A）创建两个儿子结点

B）将原根结点中的数据近似地拆成两半，分别写入新的两个儿子结点

C）根结点中加上指向两个儿子结点的指针

通常状况下，由于索引记录仅包含索引字段值（以及 4-9 字节的指针），索引实体比真实的数据行要小许多，索引页相较数据页来说要密集许多。一个索引页

可以存储数量更多的索引记录，这意味着在索引中查找时在 I/O 上占很大的优势，理解这一点有助于从本质上了解使用索引的优势。

3．索引的类型

A）聚集索引，表数据按照索引的顺序来存储的。对于聚集索引，叶子结点即存储了真实的数据行，不再有另外单独的数据页。

B）非聚集索引，表数据存储顺序与索引顺序无关。对于非聚集索引，叶结点包含索引字段值及指向数据页数据行的逻辑指针，该层紧邻数据页，其行数量与

数据表行数据量一致。

在一张表上只能创建一个聚集索引，因为真实数据的物理顺序只可能是一种。如果一张表没有聚集索引，那么它被称为 “ 堆集 ”（ Heap）。这样的表中的数据

行没有特定的顺序，所有的新行将被添加的表的末尾位置。

4．聚集索引

在聚集索引中，叶结点也即数据结点，所有数据行的存储顺序与索引的存储顺序一致。

144

1）聚集索引与查询操作

如上图，我们在名字字段上建立聚集索引，当需要在根据此字段查找特定的记录时，数据库系统会根据特定的系统表查找的此索引的根，然后根据指针查找下

一个，直到找到。例如我们要查询 “ Green” ，由于它介于 [Bennet,Karsen]，据此我们找到了索引页 1007，在该页中 “ Green” 介于 [Greane, Hunter]间，据

此我们找到叶结点 1133（也即数据结点），并最终在此页中找以了目标数据行。

此次查询的 IO 包括 3 个索引页的查询（其中最后一次实际上是在数据页中查询）。这里的查找可能是从磁盘读取 (Physical Read)或是从缓存中读取 (Logical

Read)，如果此表访问频率较高，那么索引树中较高层的索引很可能在缓存中被找到。所以真正的 IO 可能小于上面的情况。

2）聚集索引与插入操作

最简单的情况下，插入操作根据索引找到对应的数据页，然后通过挪动已有的记录为新数据腾出空间，最后插入数据。

如果数据页已满，则需要拆分数据页（页拆分是一种耗费资源的操作，一般数据库系统中会有相应的机制要尽量减少页拆分的次数，通常是通过为每页预留空

间来实现）：

A）在该使用的数据段（ extent）上分配新的数据页，如果数据段已满，则需要分配新段。

B）调整索引指针，这需要将相应的索引页读入内存并加锁。

C）大约有一半的数据行被归入新的数据页中。

D）如果表还有非聚集索引，则需要更新这些索引指向新的数据页。

特殊情况：

A）如果新插入的一条记录包含很大的数据，可能会分配两个新数据页，其中之一用来存储新记录，另一存储从原页中拆分出来的数据。

B）通常数据库系统中会将重复的数据记录存储于相同的页中。

C）类似于自增列为聚集索引的，数据库系统可能并不拆分数据页，页只是简单的新添数据页。

3）聚集索引与删除操作

删除行将导致其下方的数据行向上移动以填充删除记录造成的空白。

如果删除的行是该数据页中的最后一行，那么该数据页将被回收，相应的索引页中的记录将被删除。如果回收的数据页位于跟该表的其它数据页相同的段上，

那么它可能在随后的时间内被利用。如果该数据页是该段的唯一一个数据页，则该段也被回收。

对于数据的删除操作，可能导致索引页中仅有一条记录，这时，该记录可能会被移至邻近的索引页中，原索引页将被回收，即所谓的“索引合并”。

5．非聚集索引

非聚集索引与聚集索引相比：

A）叶子结点并非数据结点

B）叶子结点为每一真正的数据行存储一个 “ 键 -指针 ” 对

C）叶子结点中还存储了一个指针偏移量，根据页指针及指针偏移量可以定位到具体的数据行。

D）类似的，在除叶结点外的其它索引结点，存储的也是类似的内容，只不过它是指向下一级的索引页的。

聚集索引是一种稀疏索引，数据页上一级的索引页存储的是页指针，而不是行指针。而对于非聚集索引，则是密集索引，在数据页的上一级索引页它为每一个

数据行存储一条索引记录。

对于根与中间级的索引记录，它的结构包括：

A）索引字段值

B） RowId（即对应数据页的页指针 +指针偏移量）。在高层的索引页中包含 RowId 是为了当索引允许重复值时，当更改数据时精确定位数据行。

145

C）下一级索引页的指针

对于叶子层的索引对象，它的结构包括：

A）索引字段值

B） RowId

1）非聚集索引与查询操作

针对上图，如果我们同样查找“ Green”，那么一次查询操作将包含以下 IO：3 个索引页的读取 +1 个数据页的读取。同样，由于缓存的关系，真实的 IO 实际可

能要小于上面列出的。

2）非聚集索引与插入操作

如果一张表包含一个非聚集索引但没有聚集索引，则新的数据将被插入到最末一个数据页中，然后非聚集索引将被更新。如果也包含聚集索引，该聚集索引将

被用于查找新行将要处于什么位置，随后，聚集索引、以及非聚集索引将被更新。

3）非聚集索引与删除操作

如果在删除命令的 Where 子句中包含的列上，建有非聚集索引，那么该非聚集索引将被用于查找数据行的位置，数据删除之后，位于索引叶子上的对应记录也

将被删除。如果该表上有其它非聚集索引，则它们叶子结点上的相应数据也要删除。

如果删除的数据是该数所页中的唯一一条，则该页也被回收，同时需要更新各个索引树上的指针。

由于没有自动的合并功能，如果应用程序中有频繁的随机删除操作，最后可能导致表包含多个数据页，但每个页中只有少量数据。

6．索引覆盖

索引覆盖是这样一种索引策略：当某一查询中包含的所需字段皆包含于一个索引中，此时索引将大大提高查询性能。

包含多个字段的索引，称为复合索引。索引最多可以包含 31 个字段，索引记录最大长度为 600B。如果你在若干个字段上创建了一个复合的非聚集索引，且你

的查询中所需 Select 字段及 Where,Order By,Group By,Having 子句中所涉及的字段都包含在索引中，则只搜索索引页即可满足查询，而不需要访问数据页。

由于非聚集索引的叶结点包含所有数据行中的索引列值，使用这些结点即可返回真正的数据，这种情况称之为 “索引覆盖”。

在索引覆盖的情况下，包含两种索引扫描：

A）匹配索引扫描

B）非匹配索引扫描

1）匹配索引扫描

此类索引扫描可以让我们省去访问数据页的步骤，当查询仅返回一行数据时，性能提高是有限的，但在范围查询的情况下，性能提高将随结果集数量的增长而

增长。

针对此类扫描，索引必须包含查询中涉及的的所有字段，另外，还需要满足： Where 子句中包含索引中的 “ 引导列 ” （ Leading Column），例如一个复合索引

包含 A,B,C,D 四列，则 A 为 “ 引导列 ” 。如果 Where 子句中所包含列是 BCD 或者 BD 等情况，则只能使用非匹配索引扫描。

2）非配置索引扫描

正如上述，如果 Where 子句中不包含索引的导引列，那么将使用非配置索引扫描。这最终导致扫描索引树上的所有叶子结点，当然，它的性能通常仍强于扫描

所有的数据页。

146

153. Oracle 游标

一．概念：

游标：用来查询数据库，获取记录集合（结果集）的指针，可以让开发者一次访问一行结果集，在每条结果集上作操作。

二．分类：

1．静态游标：

分为显式游标和隐式游标。

2． REF 游标：

是一种引用类型，类似于指针。

三．详细内容：

1．显式游标：

CURSOR 游标名 (参数 ) [返回值类型 ] IS

Select 语句

生命周期：

a.打开游标 (OPEN)

解析，绑定。。。不会从数据库检索数据

b.从游标中获取记录 (FETCH INTO)

执行查询，返回结果集。通常定义局域变量作为从游标获取数据的缓冲区。

c.关闭游标 (CLOSE)

完成游标处理，用户不能从游标中获取行。还可以重新打开。

选项：参数和返回类型

set serveroutput on

declare

cursor emp_cur ( p_deptid in number) is

select * from employees where department_id = p_deptid;

l_emp employees%rowtype;

begin

dbms_output.put_line('Getting employees from department 30');

open emp_cur(30);

loop

fetch emp_cur into l_emp;

exit when emp_cur%notfound;

dbms_output.put_line('Employee id '|| l_emp.employee_id || ' is ');

dbms_output.put_line(l_emp.first_name || ' ' || l_emp.last_name);

end loop;

close emp_cur;

dbms_output.put_line('Getting employees from department 90');

open emp_cur(90);

loop

fetch emp_cur into l_emp;

exit when emp_cur%notfound;

dbms_output.put_line('Employee id '|| l_emp.employee_id || ' is ');

dbms_output.put_line(l_emp.first_name || ' ' || l_emp.last_name);

end loop;

close emp_cur;

end;

/

2．隐式游标：

不用明确建立游标变量，分两种：

147

a.在 PL/SQL 中使用 DML 语言，使用 ORACLE 提供的名为 SQL 的隐示游标

b.CURSOR FOR LOOP，用于 for loop 语句

a.举例：

declare

begin

update departments set department_name=department_name;

--where 1=2;

dbms_output.put_line('update '|| sql%rowcount ||' records');

end;

/

b.举例：

declare

begin

for my_dept_rec in ( select department_name, department_id from departments)

loop

dbms_output.put_line(my_dept_rec.department_id || ' : ' || my_dept_rec.department_name);

end loop;

end;

/

c.举例：

单独 select

declare

l_empno emp.EMPLOYEE_ID%type;

-- l_ename emp.ename%type;

begin

select EMPLOYEE_ID

into l_empno

from emp;

--where rownum =1;

dbms_output.put_line(l_empno);

end;

/

使用 INTO 获取值，只能返回一行。

游标属性：

%FOUND：变量最后从游标中获取记录的时候，在结果集中找到了记录。

%NOTFOUND：变量最后从游标中获取记录的时候，在结果集中没有找到记录。

%ROWCOUNT：当前时刻已经从游标中获取的记录数量。

%ISOPEN：是否打开。

Declare

Cursor emps is

Select * from employees where rownumschema->table 后，如果在现有的分区表上建立没有显式声明的聚集索引时，分

区表会自动变为非分区表。这一点很让我纳闷。如果你觉得我的非分区索引无法对起子分区，

你可以提醒我一下呀！没有任何的提醒，直接就变成了非分区表。不知道这算不算一个 bug。大家也可以试试。

153

分区表效率问题肯定是大家关心的问题。在我的试验中，如果按照分区字段进行的查询（过滤）效率会高于未分区表的相同语句。但是如果按照非分区字段进

行查询，效率会低于未分区表的相同语句。但是随着数据量的增大，这种成本差距会逐渐减小，趋于相等。（ 500 万数量级只相差 10%左右）

6、 CLR 类型

微软对 CLR 作了大篇幅的宣传，这是因为数据库产品终于融入 .net 体系中。最开始我们也是狂喜，感觉对象数据库的一些概念可以实现了。但是作了些试验，

发现使用 CLR 的存储过程或函数在达到一定的阀值的时候，系统性能会呈指数级下滑！这是非常危险的！只使用几个可能没有问题，当一旦大规模使用会造成

严重的系统性能问题！

其实可以做一下类比， Oracle 等数据库产品老早就支持了 java 编程，而且提供了 java 池参数作为用户配置接口。但是现在有哪些系统大批使用了 java 存储

过程？！连 Oracle 自己的应用都不用为什么？！还不是性能有问题！否则面向对象的数据库早就实现了！

建议使用 CLR 的地方一般是和应用的复杂程度或操作系统环境有很高的耦合度的场景。如你想构建复杂的算法，并且用到了大量的指针和高级数据模型。或者

是要和操作系统进行 Socket 通讯的场景。否则建议慎重！

7、索引视图

索引视图 2k 就有。但是 2005 对其效率作了一些改进但是 schema.viewname 的作用域真是太限制了它的应用面。还有一大堆的环境参数和种种限制都让人对它

有点却步。

8、语句和事务快照

语句级快照和事务级快照终于为 SQL Server 的并发性能带来了突破。个人感觉语句级快照大家应该应用。事务级快照，如果是高并发系统还要慎用。如果一

个用户总是被提示修改不成功要求重试时，会杀人的！

9、数据库快照

原理很简单，对要求长时间计算某一时间点的报表生成和防用户操作错误很有帮助。但是比起 Oracle10g 的闪回技术还是细粒度不够。可惜！

10、 Mirror

Mirror 可以算是 SQL Server 的 Data guard 了。但是能不能被大伙用起来就不知道了。

二、开发方面

1、 Ranking 函数集

其中最有名的应该是 row_number 了。这个终于解决了用临时表生成序列号的历史，而且 SQL Server2005 的 row_number 比 Oracle 的更先进。因为它把 Order

by 集成到了一起，不用像 Oracle 那样还要用子查询进行封装。但是大家注意一点。如下面的例子：

select ROW_NUMBER() OVER (order by aa)

from tbl

order by bb

会先执行 aa 的排序，然后再进行 bb 的排序。

可能有的朋友会抱怨集成的 order by，其实如果使用 ranking 函数 ,Order by 是少不了的。如果担心 Order by 会影响效率，可以为 order by 的字段建

立聚集索引，查询计划会忽略 order by 操作（因为本来就是排序的嘛）。

2、 top

可以动态传入参数，省却了动态 SQL 的拼写。

154

3、 Apply

对递归类的树遍历很有帮助。

4、 CTE

个人感觉这个真是太棒了！阅读清晰，非常有时代感。

5、 try/catch

代替了原来 VB 式的错误判断。比 Oracle 高级不少。

6、 pivot/unpivot

个人感觉没有 case 直观。而且默认的第三字段（还可能更多）作为 group by 字段很容易造成新手的错误。

三、 DBA 管理方面

1、数据库级触发器

记得在最开始使用 2k 的时候就要用到这个功能，可惜 2k 没有，现在有了作解决方案的朋友会很高兴吧。

2、多加的系统视图和实时系统信息

这些东西对 DBA 挑优非常有帮助，但是感觉粒度还是不太细。

3、优化器的改进

一直以来个人感觉 SQL Server 的优化器要比 Oracle 的聪明。 SQL2005 的更是比 2k 聪明了不少。（有次作试验发现有的语句在 200 万级时还比 50 万级的相

同语句要快 show_text 的一些提示没有找到解释。一直在奇怪。）

论坛例子：

http://community.csdn.net/Expert/topic/4543/4543718.xml?temp=.405987

4、 profiler 的新事件观察

这一点很好的加强了 profiler 的功能。但是提到 profiler 提醒大家注意一点。 windows2003 要安装 sp1 补丁才能启动 profiler。否则点击没有反应。

5、 sqlcmd

习惯敲命令行的朋友可能会爽一些。但是功能有限。适合机器跑不动 SQL Server Management Studio 的朋友使用。

四、遗憾

1、登陆的控制

始终遗憾 SQL Server 的登陆无法分配 CPU/内存占用等指标数。如果你的 SQL Server 给别人分配了一个只可以读几个表的权限，而这个家伙疯狂的死循环

进行连接查询，会给你的系统带来很大的负担。而 SQL Server 如果能像 Oracle 一样可以为登陆分配如： 5%的 cpu， 10%的内存。就可以解决这个漏洞。

2、数据库物理框架没有变动

undo 和 redo 都放在数据库得 transaction 中，个人感觉是个败笔。如果说我们在设计数据库的时候考虑分多个数据库，可能能在一定程度上避免 I/O 效率问

题。但是同样会为索引视图等应用带来麻烦。看看行级和事务级的快照数据放在 tempdb 中，就能感觉到目前架构的尴尬。

3、还是没有逻辑备份

备份方面可能还是一个老大难的问题。不能单独备份几个表总是感觉不爽。灵活备份的问题不知道什么时候才能解决。

155

4、 SSIS(DTS)太复杂了

SQL Server 的异构移植功能个人感觉最好了。（如果对比过 SQL Server 的链接服务器和 Oracle 的透明网关的朋友会发现 SQL Server 的

sp_addlinkedserver(openquery)异构数据库系列比 Oracle 真是强太多了。）

以前的 DTS 轻盈简单。但是现在的 SSIS 虽然功能强大了很多，但是总是让人感觉太麻烦。看看论坛中询问 SSIS 的贴子就知道。做的功能太强大了，往往会有

很多用户不会用了。

157. 用一条 SQL 语句查询出每门课都大于 80 分的学生姓名

name kecheng fenshu

张三语文 81

张三数学 75

李四语文 76

李四数学 90

王五语文 81

王五数学 100

王五英语 90

A: select distinct name from table where name not in (select distinct name from table where fenshub.Debit101ccur

************************************************************************************

160. 精妙 SQL 语句

说明：复制表 (只复制结构 ,源表名： a 新表名： b)

SQL: select * into b from a where 11

156

说明：拷贝表 (拷贝数据 ,源表名： a 目标表名： b)

SQL: insert into b(a, b, c) select d,e,f from a;

说明：显示文章、提交人和最后回复时间

SQL: select a.title,a.username,b.adddate from table a,(select max(adddate) addda te from table where table.title=a.title) b

说明：外连接查询 (表名 1： a 表名 2： b)

SQL: select a.a, a.b, a.c, b.c, b.d, b.f from a LEFT OUT JOIN b ON a.a = b.c

说明：日程安排提前五分钟提醒

SQL: select * from 日程安排 where datediff('minute',f 开始时间 ,getdate())>5

说明：两张关联表，删除主表中已经在副表中没有的信息

SQL:

delete from info where not exists ( select * from infobz where info.infid=infobz.infid )

原表:

courseid coursename score

-------------------------------------

1 java 70

2 oracle 90

3 xml 40

4 jsp 30

5 servlet 80

161.

Student(S#,Sname,Sage,Ssex) 学生表

Course(C#,Cname,T#) 课程表

SC(S#,C#,score) 成绩表

Teacher(T#,Tname) 教师表

问题：

1、查询 “ 001” 课程比 “ 002” 课程成绩高的所有学生的学号；

select a.S# from (select s#,score from SC where C#='001') a,(select s#,score

from SC where C#='002') b

where a.score>b.score and a.s#=b.s#;

2、查询平均成绩大于 60 分的同学的学号和平均成绩；

select S#,avg(score)

from sc

group by S# having avg(score) >60;

3、查询所有同学的学号、姓名、选课数、总成绩；

select Student.S#,Student.Sname,count(SC.C#),sum(score)

157

from Student left Outer join SC on Student.S#=SC.S#

group by Student.S#,Sname

4、查询姓 “ 李 ” 的老师的个数；

select count(distinct(Tname))

from Teacher

where Tname like '李 %';

5、查询没学过 “ 叶平 ” 老师课的同学的学号、姓名；

select Student.S#,Student.Sname

from Student

where S# not in (select distinct( SC.S#) from SC,Course,Teacher where SC.C#=Course.C# and Teacher.T#=Course.T# and Teacher.T name='叶

平 ');

6、查询学过 “ 001” 并且也学过编号 “ 002” 课程的同学的学号、姓名；

select Student.S#,Student.Sname from Student,SC where Student.S#=SC.S# and SC.C#='001'and exists( Select * from SC as SC_2 where SC_2.S#=SC.S#

and SC_2.C#='002');

7、查询学过 “ 叶平 ” 老师所教的所有课的同学的学号、姓名；

select S#,Sname

from Student

where S# in (select S# from SC ,Course ,Teacher where SC.C#=Course.C# and Teacher.T#=Course.T# and T eacher.Tname='叶平 ' group by S# having

count(SC.C#)=(select count(C#) from Course,Teacher where Teacher.T#=Course.T# and Tname=' 叶平 '));

8、查询课程编号 “ 002” 的成绩比课程编号 “ 001” 课程低的所有同学的学号、姓名；

Select S#,Sname from (select Student.S#,Student.Sname,score ,(select score f rom SC SC_2 where SC_2.S#=Student.S# and SC_2.C#='002') score2

from Student,SC where Student.S#=SC.S# and C#='001') S_2 where score2 60);

10、查询没有学全所有课的同学的学号、姓名；

select Student.S#,Student.Sname

from Student,SC

where Student.S#=SC.S# group by Student.S#,Student.Sname having count(C#) =60 THEN 1 ELSE 0 END)/COUNT(*) AS 及格百分数

FROM SC T,Course

where t.C#=course.C#

GROUP BY t.C#

ORDER BY 100 * SUM(CASE WHEN isnull(score,0)>=60 THEN 1 ELSE 0 END)/COUNT(*) DESC

20、查询如下课程平均成绩和及格率的百分数 (用 "1 行 "显示 ): 企业管理（ 001），马克思（ 002）， OO&UML （ 003），数据库（ 004）

SELECT SUM(CASE WHEN C# ='001' THEN score ELSE 0 END)/SUM(CASE C# WHEN '001' THEN 1 ELSE 0 END) AS 企业管理平均分

,100 * SUM(CASE WHEN C# = '001' AND score >= 60 THEN 1 ELSE 0 END)/SUM(CASE WHEN C# = '001' THEN 1 ELSE 0 END) AS 企业管理及格百

分数

,SUM(CASE WHEN C# = '002' THEN score ELSE 0 END)/SUM(CASE C # WHEN '002' THEN 1 ELSE 0 END) AS 马克思平均分

,100 * SUM(CASE WHEN C# = '002' AND score >= 60 THEN 1 ELSE 0 END)/SUM(CASE WHEN C# = '002' THEN 1 ELSE 0 END) AS 马克思及格百分

数

,SUM(CASE WHEN C# = '003' THEN score ELSE 0 END)/SUM(CASE C# WHEN '003' T HEN 1 ELSE 0 END) AS UML 平均分

,100 * SUM(CASE WHEN C# = '003' AND score >= 60 THEN 1 ELSE 0 END)/SUM(CASE WHEN C# = '003' THEN 1 ELSE 0 END) AS UML 及格百分数

,SUM(CASE WHEN C# = '004' THEN score ELSE 0 END)/SUM(CASE C# WHEN '004' THEN 1 ELSE 0 E ND) AS 数据库平均分

,100 * SUM(CASE WHEN C# = '004' AND score >= 60 THEN 1 ELSE 0 END)/SUM(CASE WHEN C# = '004' THEN 1 ELSE 0 END) AS 数据库及格百分

数

FROM SC

159

21、查询不同老师所教不同课程平均分从高到低显示

SELECT max(Z.T#) AS 教师 ID,MAX(Z.Tname) AS 教师姓名 ,C.C# AS 课程ＩＤ ,MAX(C.Cname) AS 课程名称 ,AVG(Score) AS 平均成绩

FROM SC AS T,Course AS C ,Teacher AS Z

where T.C#=C.C# and C.T#=Z.T#

GROUP BY C.C#

ORDER BY AVG(Score) DESC

22、查询如下课程成绩第 3 名到第 6 名的学生成绩单：企业管理（ 001），马克思（ 002）， UML （ 003），数据库（ 004）

[学生 ID],[学生姓名 ],企业管理 ,马克思 ,UML,数据库 ,平均成绩

SELECT DISTINCT top 3

SC.S# As 学生学号 ,

Student.Sname AS 学生姓名 ,

T1.score AS 企业管理 ,

T2.score AS 马克思 ,

T3.score AS UML,

T4.score AS 数据库 ,

ISNULL(T1.score,0) + ISNULL(T2.score,0) + ISNULL(T3.score,0) + ISNULL(T4.score,0) as 总分

FROM Student,SC LEFT JOIN SC AS T1

ON SC.S# = T1.S# AND T1.C# = '001'

LEFT JOIN SC AS T2

ON SC.S# = T2.S# AND T2.C# = '002'

LEFT JOIN SC AS T3

ON SC.S# = T3.S# AND T3.C# = '003'

LEFT JOIN SC AS T4

ON SC.S# = T4.S# AND T4.C# = '004'

WHERE student.S#=SC.S# and

ISNULL(T1.score,0) + ISNULL(T2.score,0) + ISNULL(T3.score,0) + ISNULL(T4.score,0)

NOT IN

(SELECT

DISTINCT

TOP 15 WITH TIES

ISNULL(T1.score,0) + ISNULL(T2.score,0) + ISNULL(T3.score,0) + ISNULL(T4.s core,0)

FROM sc

LEFT JOIN sc AS T1

ON sc.S# = T1.S# AND T1.C# = 'k1'

LEFT JOIN sc AS T2

ON sc.S# = T2.S# AND T2.C# = 'k2'

LEFT JOIN sc AS T3

ON sc.S# = T3.S# AND T3.C# = 'k3'

LEFT JOIN sc AS T4

ON sc.S# = T4.S# AND T4.C# = 'k4'

ORDER BY ISNULL(T1.score,0) + ISNULL(T2.score,0) + ISNULL(T3.score,0) + ISNULL(T4.score,0) DESC);

23、统计列印各科成绩 ,各分数段人数 :课程 ID,课程名称 ,[100-85],[85-70],[70-60],[ T2.平均成绩 ) as 名次 ,

S# as 学生学号 ,平均成绩

FROM (SELECT S#,AVG(score) 平均成绩

FROM SC

GROUP BY S#

) AS T2

ORDER BY 平均成绩 desc;

25、查询各科成绩前三名的记录 :(不考虑成绩并列情况 )

SELECT t1.S# as 学生 ID,t1.C# as 课程 ID,Score as 分数

FROM SC t1

WHERE score IN (SELECT TOP 3 sc ore

FROM SC

WHERE t1.C#= C#

ORDER BY score DESC

)

ORDER BY t1.C#;

26、查询每门课程被选修的学生数

select c#,count(S#) from sc group by C#;

27、查询出只选修了一门课程的全部学生的学号和姓名

select SC.S#,Student.Sname,count(C#) AS 选课数

from SC ,Student

where SC.S#=Student.S# group by SC.S# ,Student.Sname having count(C#)=1;

28、查询男生、女生人数

Select count(Ssex) as 男生人数 from Student group by Ssex having Ssex=' 男 ';

Select count(Ssex) as 女生人数 from Student group by Ssex having Ssex=' 女 '；

29、查询姓 “ 张 ” 的学生名单

SELECT Sname FROM Student WHERE Sname like ' 张 %';

30、查询同名同性学生名单，并统计同名人数

select Sname,count(*) from Student group by Sname having count(*)>1;;

31、 1981 年出生的学生名单 (注： Student 表中 Sage 列的类型是 datetime)

select Sname, CONVERT(char (11),DATEPART(year,Sage)) as age

from student

where CONVERT(char(11),DATEPART(year,Sage))='1981';

32、查询每门课程的平均成绩，结果按平均成绩升序排列，平均成绩相同时，按课程号降序排列

Select C#,Avg(score) from SC group by C# order by Avg(score),C# DESC ;

33、查询平均成绩大于 85 的所有学生的学号、姓名和平均成绩

select Sname,SC.S# ,avg(score)

from Student,SC

where Student.S#=SC.S# group by SC.S#,Sname having avg(score)>85;

161

34、查询课程名称为 “ 数据库 ” ，且分数低于 60 的学生姓名和分数

Select Sname,isnull(score,0)

from Student,SC,Course

where SC.S#=Student.S# and SC.C#=Course.C# and Course.Cname=' 数据库 'and score =70 AND SC.S#=student.S#;

37、查询不及格的课程，并按课程号从大到小排列

select c# from sc where scor e 80 and C#='003';

39、求选了课程的学生人数

select count(*) from sc;

40、查询选修 “ 叶平 ” 老师所授课程的学生中，成绩最高的学生姓名及其成绩

select Student.Sname,score

from Student,SC,Course C,Teacher

where Student.S#=SC.S# and SC.C#=C.C# and C.T#=Teacher.T# and Teacher.Tname=' 叶平 ' and SC.score=(select max(score)from SC where C#=C.C# );

41、查询各个课程及相应的选修人数

select count(*) from sc group by C#;

42、查询不同课程成绩相同的学生的学号、课程号、学生成绩

select distinct A.S#,B.score from SC A ,SC B where A.Score=B.Score and A.C# B.C# ;

43、查询每门功成绩最好的前两名

SELECT t1.S# as 学生 ID,t1.C# as 课程 ID,Score as 分数

FROM SC t1

WHERE score IN (SELECT TOP 2 score

FROM SC

WHERE t1.C#= C#

ORDER BY score DESC

)

ORDER BY t1.C#;

44、统计每门课程的学生选修人数（超过 10 人的课程才统计）。要求输出课程号和选修人数，查询结果按人数降序排列，查询结果按人数降序排列，若人数

相同，按课程号升序排列

select C# as 课程号 ,count(*) as 人数

from sc

group by C#

order by count(*) desc,c#

45、检索至少选修两门课程的学生学号

select S#

from sc

group by s#

having count(*) > = 2

46、查询全部学生都选修的课程的课程号和课程名

select C#,Cname

from Course

162

where C# in (select c# from sc group by c#)

47、查询没学过 “ 叶平 ” 老师讲授的任一门课程的学生姓名

select Sname from Student where S# not in (select S# from Course,Teacher,SC where Course.T#=Teacher.T# and SC.C#=course.C# an d Tname='

叶平 ');

48、查询两门以上不及格课程的同学的学号及其平均成绩

select S#,avg(isnull(score,0)) from SC where S# in (select S# from SC where score 2)group by S#;

49、检索 “ 004” 课程分数小于 60，按分数降序排列的同学学号

select S# from SC where C#='004'and score 5

3. 查询借阅了 "水浒 "一书的读者，输出姓名及班级

--实现代码：

SELECT * FROM CARD c

WHERE EXISTS(

SELECT * FROM BORROW a,BOOKS b

WHERE a.BNO=b.BNO

AND b.BNAME=N'水浒 '

AND a.CNO=c.CNO)

4. 查询过期未还图书，输出借阅者（卡号）、书号及还书日期

--实现代码：

SELECT * FROM BORROW

WHERE RDATE0

INSERT BORROW_SAVE SELECT i.*

FROM INSERTED i,BOOKS b

WHERE i.BNO=b.BNO

AND b.BNAME=N'数据库技术及应用 '

12. 建立一个视图，显示 "力 01"班学生的借书信息（只要求显示姓名和书名）

--实现代码：

CREATE VIEW V_VIEW

AS

SELECT a.NAME,b.BNAME

FROM BORROW ab,CARD a,BOOKS b

WHERE ab.CNO=a.CNO

AND ab.BNO=b.BNO

AND a.CLASS=N'力 01'

13. 查询当前同时借有 "计算方法 "和 "组合数学 "两本书的读者，输出其借书卡号，并按卡号升序排序输出

--实现代码：

SELECT a.CNO

FROM BORROW a,BOOKS b

WHERE a.BNO=b.BNO

AND b.BNAME IN(N'计算方法 ',N'组合数学 ')

GROUP BY a.CNO

HAVING COUNT(*)=2

ORDER BY a.CNO DESC

14. 假定在建 BOOKS 表时没有定义主码，写出为 BOOKS 表追加定义主码的语句

--实现代码：

ALTER TABLE BOOKS ADD PRIMARY KEY(BNO)

15.1 将 NAME 最大列宽增加到 10 个字符（假定原为 6 个字符）

165

--实现代码：

ALTER TABLE CARD ALTER COLUMN NAME varchar(10)

15.2 为该表增加 1 列 NAME（系名），可变长，最大 20 个字符

--实现代码：

ALTER TABLE CARD ADD 系名 varchar(20)

问题描述：

为管理岗位业务培训信息，建立 3 个表:

S (S#,SN,SD,SA) S#,SN,SD,SA 分别代表学号、学员姓名、所属单位、学员年龄

C (C#,CN ) C#,CN 分别代表课程编号、课程名称

SC ( S#,C#,G ) S#,C#,G 分别代表学号、所选修的课程编号、学习成绩

要求实现如下 5 个处理：

1. 使用标准 SQL 嵌套语句查询选修课程名称为 ’ 税收基础 ’ 的学员学号和姓名

2. 使用标准 SQL 嵌套语句查询选修课程编号为 ’ C2’ 的学员姓名和所属单位

3. 使用标准 SQL 嵌套语句查询不选修课程编号为 ’ C5’ 的学员姓名和所属单位

4. 使用标准 SQL 嵌套语句查询选修全部课程的学员姓名和所属单位

5. 查询选修了课程的学员人数

6. 查询选修课程超过 5 门的学员学号和所属单位

1. 使用标准 SQL 嵌套语句查询选修课程名称为 ’ 税收基础 ’ 的学员学号和姓名

--实现代码：

SELECT SN,SD FROM S

WHERE [S#] IN(

SELECT [S#] FROM C,SC

WHERE C.[C#]=SC.[C#]

AND CN=N'税收基础 ')

2. 使用标准 SQL 嵌套语句查询选修课程编号为 ’ C2’ 的学员姓名和所属单位

--实现代码：

SELECT S.SN,S.SD FROM S,SC

WHERE S.[S#]=SC.[S#]

AND SC.[C#]='C2'

3. 使用标准 SQL 嵌套语句查询不选修课程编号为 ’ C5’ 的学员姓名和所属单位

--实现代码：

SELECT SN,SD FROM S

WHERE [S#] NOT IN(

SELECT [S#] FROM SC

WHERE [C#]='C5')

4. 使用标准 SQL 嵌套语句查询选修全部课程的学员姓名和所属单位

--实现代码：

SELECT SN,SD FROM S

WHERE [S#] IN(

166

SELECT [S#] FROM SC

RIGHT JOIN C ON SC.[C#]=C.[C#]

GROUP BY [S#]

HAVING COUNT(*)=COUNT(DISTINCT [S#]))

5. 查询选修了课程的学员人数

--实现代码：

SELECT 学员人数 =COUNT(DISTINCT [S#]) FROM SC

6. 查询选修课程超过 5 门的学员学号和所属单位

--实现代码：

SELECT SN,SD FROM S

WHERE [S#] IN(

SELECT [S#] FROM SC

GROUP BY [S#]

HAVING COUNT(DISTINCT [C#])>5)

162. Covariance and Contravariance 委托中的协变和逆变

将方法签名与委托类型匹配时，协变和逆变可以提供一定程度的灵活性。协变允许方法具有的派生返回类型比委托中定义的更多。逆变允许方法具有的派生

参数类型比委托类型中的更少。

示例 1（协变）

说明

本示例演示如何将委托与具有返回类型的方法一起使用，这些返回类型派生自委托签名中的返回类型。由 SecondHandler 返回的数据类型是 Dogs

类型，它是由委托中定义的 Mammals 类型派生的。

class Mammals

{

}

class Dogs : Mammals

{

}

class Program

{

// Define the delegate.

public delegate Mammals HandlerMethod();

public static Mammals FirstHandler()

{

return null;

}

public static Dogs SecondHandler()

{

return null;

}

167

static void Main()

{

HandlerMethod handler1 = FirstHandler;

// Covariance allows this delegate.

HandlerMethod handler2 = SecondHandler;

}

}

示例 2（逆变）

说明

本示例演示如何将委托与具有某个类型的参数的方法一起使用，这些参数是委托签名参数类型的基类型。通过逆变，以前必须使用若干个不同处理程序的地方

现在只要使用一个事件处理程序即可。如，现在可以创建一个接收 EventArgs 输入参数的事件处理程序，然后，可以将该处理程序与发送 MouseEventArgs 类

型（作为参数）的 Button.MouseClick 事件一起使用，也可以将该处理程序与发送 KeyEventArgs 参数的 TextBox.KeyDown 事件一起使用。

代码

C#

复制代码

System.DateTime lastActivity;

public Form1()

{

InitializeComponent();

lastActivity = new System.DateTime();

this.textBox1.KeyDown += this.MultiHandler; //works with KeyEventArgs

this.button1.MouseClick += this.MultiHandler; //works with MouseEventArgs

}

// Event hander for any event with a n EventArgs or

// derived class in the second parameter

private void MultiHandler(object sender, System.EventArgs e)

{

lastActivity = System.DateTime.Now;

}