博客园_独孤伤

浅谈C#中标准Dispose模式的实现

2012-02-12T10:48:00Z

C#程序中的Dispose方法，一旦被调用了该方法的对象，虽然还没有垃圾回收，但实际上已经不能再使用了。所以使用上要仔细考虑细节。

AD：

需要明确一下C#程序（或者说.NET）中的资源。简单的说来，C#中的每一个类型都代表一种资源，而资源又分为两类：

托管资源：由CLR管理分配和释放的资源，即由CLR里new出来的对象；

非托管资源：不受CLR管理的对象，windows内核对象，如文件、数据库连接、套接字、COM对象等；

毫无例外地，如果我们的类型使用到了非托管资源，或者需要显式释放的托管资源，那么，就需要让类型继承接口IDisposable。这相当于是告诉调用者，该类型是需要显式释放资源的，你需要调用我的Dispose方法。

不过，这一切并不这么简单，一个标准的继承了IDisposable接口的类型应该像下面这样去实现。这种实现我们称之为Dispose模式：

public class SampleClass : IDisposable
{
//演示创建一个非托管资源
private IntPtr nativeResource = Marshal.AllocHGlobal(100);
//演示创建一个托管资源
private AnotherResource managedResource = new AnotherResource();
private bool disposed = false;
/// <summary>
/// 实现IDisposable中的Dispose方法
/// </summary>
public void Dispose()
{
//必须为true
Dispose(true);
//通知垃圾回收机制不再调用终结器（析构器）
GC.SuppressFinalize(this);
}
/// <summary>
/// 不是必要的，提供一个Close方法仅仅是为了更符合其他语言（如C++）的规范
/// </summary>
public void Close()
{
Dispose();
}
/// <summary>
/// 必须，以备程序员忘记了显式调用Dispose方法
/// </summary>
~SampleClass()
{
//必须为false
Dispose(false);
}
/// <summary>
/// 非密封类修饰用protected virtual
/// 密封类修饰用private
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
// 清理托管资源
if (managedResource != null)
{
managedResource.Dispose();
managedResource = null;
}
}
// 清理非托管资源
if (nativeResource != IntPtr.Zero)
{
Marshal.FreeHGlobal(nativeResource);
nativeResource = IntPtr.Zero;
}
//让类型知道自己已经被释放
disposed = true;
}
public void SamplePublicMethod()
{
if (disposed)
{
throw new ObjectDisposedException("SampleClass", "SampleClass is disposed");
}
//省略
} }

在Dispose模式中，几乎每一行都有特殊的含义。

在标准的Dispose模式中，我们注意到一个以~开头的方法：

/// <summary>
/// 必须，以备程序员忘记了显式调用Dispose方法
/// </summary>
~SampleClass()
{
//必须为false
Dispose(false);
}

这个方法叫做类型的终结器。提供终结器的全部意义在于：我们不能奢望类型的调用者肯定会主动调用Dispose方法，基于终结器会被垃圾回收器调用这个特点，终结器被用做资源释放的补救措施。

一个类型的Dispose方法应该允许被多次调用而不抛异常。鉴于这个原因，类型内部维护了一个私有的布尔型变量disposed：

private bool disposed = false;

在实际处理代码清理的方法中，加入了如下的判断语句：

if (disposed)
{
return;
}
//省略清理部分的代码，并在方法的最后为disposed赋值为true
disposed = true;

这意味着类型如果被清理过一次，则清理工作将不再进行。

应该注意到：在标准的Dispose模式中，真正实现IDisposable接口的Dispose方法，并没有实际的清理工作，它实际调用的是下面这个带布尔参数的受保护的虚方法：

/// <summary>
/// 非密封类修饰用protected virtual
/// 密封类修饰用private
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
//省略代码
}

之所以提供这样一个受保护的虚方法，是为了考虑到这个类型会被其他类继承的情况。如果类型存在一个子类，子类也许会实现自己的Dispose模式。受保护的虚方法用来提醒子类必须在实现自己的清理方法的时候注意到父类的清理工作，即子类需要在自己的释放方法中调用base.Dispose方法。
还有，我们应该已经注意到了真正撰写资源释放代码的那个虚方法是带有一个布尔参数的。之所以提供这个参数，是因为我们在资源释放时要区别对待托管资源和非托管资源。

在供调用者调用的显式释放资源的无参Dispose方法中，调用参数是true：

public void Dispose()
{
//必须为true
Dispose(true);
//其他省略
}

这表明，这个时候代码要同时处理托管资源和非托管资源。

在供垃圾回收器调用的隐式清理资源的终结器中，调用参数是false：

~SampleClass()
{
//必须为false
Dispose(false);
}

这表明，隐式清理时，只要处理非托管资源就可以了。

那么，为什么要区别对待托管资源和非托管资源。在认真阐述这个问题之前，我们需要首先弄明白：托管资源需要手动清理吗？不妨先将C#中的类型分为两类，一类继承了IDisposable接口，一类则没有继承。前者，我们暂时称之为非普通类型，后者我们称之为普通类型。非普通类型因为包含非托管资源，所以它需要继承IDisposable接口，但是，这个包含非托管资源的类型本身，它是一个托管资源。所以说，托管资源需要手动清理吗？这个问题的答案是：托管资源中的普通类型，不需要手动清理，而非普通类型，是需要手动清理的（即调用Dispose方法）。

Dispose模式设计的思路基于：如果调用者显式调用了Dispose方法，那么类型就该按部就班为自己的所以资源全部释放掉。如果调用者忘记调用Dispose方法，那么类型就假定自己的所有托管资源（哪怕是那些上段中阐述的非普通类型）全部交给垃圾回收器去回收，而不进行手工清理。理解了这一点，我们就理解了为什么Dispose方法中，虚方法传入的参数是true，而终结器中，虚方法传入的参数是true。

注意：我们提到了需要及时释放资源，却并没有进一步细说是否需要及时让引用等于null这一点。有一些人认为等于null可以帮助垃圾回收机制早点发现并标识对象是垃圾。其他人则认为这没有任何帮助。下一篇我们再细说这一点。

原文链接：http://www.cnblogs.com/luminji/archive/2011/03/29/1997812.html

【编辑推荐】

本文链接

.NET 中的委托

2012-02-12T07:00:00Z

1.1.1 定义

　　委托是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值，如下面的示例所示：

//Code in C#

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

与委托的签名（由返回类型和参数组成）匹配的任何方法都可以分配给该委托。

简单理解Delegate委托（或代理）是一种数据类型：它的变量可以引用到某一个符合要求的方法上，通过委托可以间接地调用该方法。

其实.NET的委托类似于C语言的函数指针，区别在于.NET委托是类型安全的，这说明，C中的函数指针只不过是一个指向存储单元的指针，我们无法说出这个指针实际指向什么。

1.1.2 委托使用

使用委托的四部曲：
定义一种委托类型
委托执行时要调用方法
定义一个委托实例
委托实例的调用

我们先定义一种委托类型如下：

//自定义一种委托类型

publicdelegatevoid StringProcessor(string input);

然后我们再定义5中候选的委托方法如下：

void PrintString(string x)

void PrintInteger(int x)

void PrintTwoStrings(string x, string y)

int GetStringLength(string x)

void PrintObject(object x)

复制代码

大家猜猜看哪个和上面提供的委托类型签名匹配（签名匹配：参数类型，参数个数和返回类型匹配）。激动时刻到了马上公布答案，和委托类型匹配的方法是PrintString和PrintObject，如果有不明白的请细细考虑一下委托匹配的条件—签名匹配。

图1委托成功输出

现在对委托有了一定的认识，接下来我们将介绍委托最经常使用的地方—事件。

我们将从发送器和接受器的角度讨论事件，例如在UI编程中，鼠标单击或键盘按键，发送器就是.NET的CLR，注意事件发送器并不知道接收器是谁，这符合面向对象的原则，而且某个事件接收器有个方法处理该事件，这个时候就要委托，如前面所讲事件发送器对事件接收器一无所知，通过委托作为一个中介，接收器把事件处理方法注册到事件中，这样就实现了由发送器->委托->接收器的过程了。

我们可以这样认为：委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。

1.1.3 自定义委托

前面话有点难以理解，接下来我们通过具体的例子分析一下何谓委托，该如何实现委托。现在不是很喜欢搞多国语言化的吗？看看如何让我们的程序会说多种语言吧！

///<summary>
/// the English speaker.
///</summary>
///<param name="name">The name.</param>
publicvoid EnglishSpeaker(string name)
{
Console.WriteLine(
string.Format("Hello my name is {0} and I am English speaker.\n", name));
}

///<summary>
/// the Chineses speaker.
///</summary>
publicvoid ChineseSpeaker(string name)
{
Console.WriteLine(
string.Format("您好我的名字叫{0},我是讲普通话的。\n", name));
}

复制代码

好啦现在我们有两个方法分别是说普通话和英语，现在我们的程序会说普通话和英语啦。现在我们考虑究竟什么时候讲普通话什么时候讲英语，那不简单我们加个判断就OK啦，是的我们可以通过switch或者if else就可以实现啦。

///<summary>
/// 根据上下文调用不同的方法
///</summary>
///<param name="name">string</param>
///<param name="lang">enum</param>
privatestaticvoid Say(string name, Language lang)
{
switch (lang)
{
case Language.Chinese:
Program.ChineseSpeaker(name);
break;
case Language.English:
Program.EnglishSpeaker(name);
break;
default :
break;
}
}

复制代码

但假设我们现在又要增加新的语言西班牙语，同样我们可以增加西班牙语，但我们必须修改switch语句增加判断，这不符合OOP中的OCP(对扩展开放，对修改关闭原则),这时候委托该登场。

///<summary>
/// Define speak delegate.
///</summary>
///<param name="name"></param>
privatedelegatevoid SpeakDelegate(string name);

复制代码

首先我们定义了一种委托类型SpeakDelegate，然后我们通过修改Say方法看看该如何使用委托变量。

///<summary>
/// The base say function.
///</summary>
///<param name="name">The name.</param>
///<param name="speaker">The speaker.</param>
privatestaticvoid Say(string name, SpeakDelegate speaker)
{
///Inoke the speaker function.
speaker(name);
}

复制代码

现在我们的参数已经不是枚举类型了，而是一个委托类型变量，而且实现的具体代码也没有了switch语句了，比之前简单了许多。现在大家知道如何去调用Say方法吧！没错我们只需传递一个name和一个具体实现函数名就OK了。

///传递函数名进行委托方法绑定
Program.Say("钧航", ChineseSpeaker);
Program.Say("JK.Rush", EnglishSpeaker);

复制代码

自定义委托相信大家都会了，接下来我将介绍一下.NET中委托实现，由于许多使用委托的例子都是事件，所以下面的例子也采用事件。但请大家要注意“可以使用委托，但却没有定义事件”的情况(例如：回调函数)。

1.1.4 .NET中的事件委托

举一个简单的例子，.NET中经常使用的控件Button，当我们把Button 控件 drap and drop到界面，然后双击界面的Button我们发现程序中自动生成了一个响应Button的事件方法，然后我们给事件方法添加Code之后，当我们点击该Button就响应该方法了，但我们没有看到代码中有任何的委托和事件之类的定义，其实这些.NET都已经做好了。我们可以查看如下文件。

图2事件委托实现

如上图所示我们打开Designer文件，事件委托的实现都在这里实现了。

其中，EventHandler就是一个代理类型，可以认为它是一个“类”，是所有返回类型为void，具备两个参数分别是object sender和EventArgs e，第一个参数表示引发事件的控件，或者说它表示点击的那个按钮。通过以下的代码我们细细解析一下。

privatevoid button1_Click(object sender, EventArgs e)
{
//获取被点击Button的实例
Button objBotton = sender as Button;
if (objBotton !=null)
{
objBotton.Text ="Hello you click me.";
objBotton.AutoSize =true;
}
else
{
//Exception Handle.
}
}

复制代码

图3点击产生效果

OK现在明白了sender就是传递一个被点击对象的实例，第二个参数名叫e的EventArgs参数，用于表示附加的事件关联的事件信息。当点击按钮时，没有附加任何关联的事件信息，如上的点击事件，第二参数并不表示任何有用的信息。但什么时候会用到呢？

我们先介绍一下EventArgs这个的类型。其实这个类并没有太多的功能，它主要是作为一个基类让其他类去实现具体的功能和定义，当我们搜索EventArgs发现很多类是继承于它的。

publicclass EventArgs
{
// Fields
publicstaticreadonly EventArgs Empty;

// Methods
static EventArgs();
public EventArgs();
}

复制代码

举其中的ImageClickEventArgs为例，它继承于EventArgs，而且还添加了自己的字段用来基类X和Y的坐标值（这是一个ImageButton被点击时候响应的），然后获取该按钮的X和Y坐标。

publicsealedclass ImageClickEventArgs : EventArgs
{
// Fields
publicint X;
publicint Y;

// Methods
public ImageClickEventArgs(int x, int y)
{
this.X = x;
this.Y = y;
}
}

复制代码

//ImageButton点击响应时间
protectedvoid ibtnTest_Click(object sender, ImageClickEventArgs e)
{
this.lblCX.Text = e.X.ToString();
this.lblCY.Text = e.Y.ToString();
}

复制代码

图4获取ImageClickEventArgs关联点击坐标

前面提到其他事件关联信息类型都是通过继承EventArgs实现的，所以说我们自己也可以自定义一个事件关联信息类型，如下我们只需继承EventArgs就OK了。

///<summary>
/// 自定义事件关联类
///</summary>
publicclass ColorChangedEventArgs : EventArgs
{
private Color color;

///<summary>
/// Initializes a new instance of the <see cref="ColorChangedEventArgs"/> class.
///</summary>
///<param name="c">The c.</param>
public ColorChangedEventArgs(Color c)
{
color = c;
}

///<summary>
/// Gets the color of the get.
///</summary>
///<value>
/// The color of the get.
///</value>
public Color GetColor
{
get { return color; }
}

}

复制代码

1.1.5自定义事件委托

多播委托

前面使用的每个委托都只包含一个方法调用。调用一个委托就调用一个方法调用。如果要通过一个委托调用多个方法，那就需要使用委托的多播特性。如果调用多播委托，就可以按委托添加次序连续调用多个方法。为此，委托的签名就必须返回void；否则，就只能得到委托调用的最后一个方法的结果，接下来看看多播实现。

namespace Multi_Delegate
{
delegatevoid StringProcessor();
publicclass Person
{
privatestring _Name;
public Person(string name)
{
this._Name = name;
}

publicvoid Say()
{
Console.WriteLine("Hello my name is {0}, what's your name.\n", this._Name);
}

publicvoid Reply()
{
Console.WriteLine("Hello my name is {0} and nice to meet you.\n", this._Name);
}
}

class Program
{
staticvoid Main(string[] args)
{
Person Jack =new Person("Jack");
Person Oliver =new Person("Oliver");
StringProcessor sp =null;
//绑定多播方法调用
sp += Jack.Say;
sp += Oliver.Reply;
sp();
Console.ReadKey();
}
}
}

复制代码

也许有人觉得很简单，实现的确简单明了，就是通过“+”把方法调用绑定到委托变量中，如果我们用“-”就可以移除绑定到委托变量方法了。

事件

前面一直没有解释什么是事件，现在让我用一句话解释事件和委托的关系吧！

事件和委托关系就像是属性和字段的关系，为了刚好的实现OOP的编程原则，事件对委托进行了封装。

现在我们修改前面的代码，使用事件对委托进行封装。

/// 使用事件对委托进行封装
///</summary>
publicclass Say
{
///<summary>
/// 封装委托字段
///</summary>
publicstaticevent SpeakDelegate speakDelegate;

///<summary>
/// 调用委托具体实现方法
///</summary>
///<param name="name"></param>
publicstaticvoid SayManager(string name)
{
speakDelegate(name);
}
}

///<summary>
/// 客户端调用委托
///</summary>
///<param name="args"></param>
staticvoid Main(string[] args)
{
Say.speakDelegate += Program.ChineseSpeaker;
Say.speakDelegate += Program.EnglishSpeaker;
Say.SayManager("Jackson");
Console.ReadKey();
}

复制代码

图5自定义委托

现在让我们看看编译后Say类就可以充分证明我们的结论：事件是对委托封装。

图6自定义事件编译后的代码

大家看到在编译后的代码中出现了一个私有的委托变量，然后接下是一个公用事件委托变量，这进一步说明了事件是对委托的封装。

图7自定义事件编译后MSIL代码

1.1.6事件委托实现观察者模式

前面我们介绍按钮事件响应是从发送者和接收者的角度出发的，现在我们以设计模式中的观察者模式为例。

图8GoF观察者架构

namespace GoFObserver
{
///<summary>
/// 充当Subject角色
///</summary>
publicclass GofTelecom
{
publicdelegatevoid GofNews();
publicstaticevent GofNews NewEvent;

///<summary>
/// 发布通知方法
///</summary>
///<returns></returns>
publicstaticbool Notify()
{
if (NewEvent !=null)
{
NewEvent();
returnfalse;
}
returntrue;
}
}

publicinterface IObserver
{
void Update();
}

///<summary>
/// 观察者
///</summary>
publicclass Programmer : IObserver
{

#region IObserver 成员

publicvoid Update()
{
Console.WriteLine("I am a greenhand programmer.\n");
}

#endregion

}

///<summary>
/// 观察者
///</summary>
publicclass Architect : IObserver
{
#region IObserver 成员

publicvoid Update()
{
Console.WriteLine("OH...I am a top banana.\n");
}

#endregion
}

publicclass Program
{
staticvoid Main(string[] args)
{
IList<IObserver> objObserver =new List<IObserver>();
objObserver.Add(new Programmer());
objObserver.Add(new Architect());
foreach (IObserver ob in objObserver)
{
GofTelecom.NewEvent += ob.Update;
}

if (!GofTelecom.Notify())
{
Console.WriteLine("Notify successful.\n");
}
else
{
Console.WriteLine("Notify failed.\n");
}
Console.ReadKey();
}
}
}

复制代码

[作者]：JK_Rush
[出处]：http://www.cnblogs.com/rush/
[本文基于]: 署名-非商业性使用 3.0 许可协议发布，欢迎转载，演绎，但是必须保留本文的署名 JK_Rush （包含链接），且不得用于商业目的。如您有任何疑问或者授权方面的协商，请与我联系。

本文链接

.NET 中的泛型 101

2012-02-11T15:09:00Z

1.1.1 摘要

图1 C# 泛型介绍

在接触泛型之前，我们编程一般都是使用具体类型（char, int, string等）或自定义类型来定义我们变量，如果我们有一个功能很强的接口，而且我们想把它提取或重构成一个通用的接口，使得该接口不仅仅适用于已定义数据类型，而是适用于更多数据类型，从而方便以后的扩展。

泛型提供上述功能的实现，泛型其实就是提供一个数据类型的抽象层，因为它泛所以抽象，方便了我们代码的重构和提取，我们无需hard-code接口中的数据类型，而是通过一个抽象泛型类型来指定数据类型，所以泛型可以提取出一个通用的接口。接下来让我们通过具体的例子说明什么是泛型。

1.1.2 正文

1.1.1.1 没有泛型的C# 1.0

相信许多人都使用过栈或者其他经典数据结构，而且对于栈的FILO都是娴熟于心了。假设现在要我们定义一个栈，用来存放具体数据类型，例如：int 数据，OK让我们来实现自定义栈。

/// <summary>
/// A custom stack1.
/// </summary>
public class CustomStack1
{
    private int _stackPointer = 0;
    private int[] _stackArray;

    public void Push(int item)
    {
        ////Concrete implemention.
    }

    public int Pop()
    {
        ////Concrete implemention.
    }
}

为了简洁没有完全遵守OOP的原则，这里没有使用属性和给出方法的具体实现，现在我们有了第一版可以存放int数据类型的栈。但如果需求改变保存数据类型增加string。那么我们可以怎样实现呢？没错我们只要增加一个类型为string的栈就OK了。

/// <summary>
/// A custom stack2.
/// </summary>
public class CustomStack2
{
    private int _stackPointer = 0;
    private string[] _stackArray;

    public void Push(int item)
    {
        ////Concrete implemention.
    }

    public string Pop()
    {
        ////Concrete implemention.
    }
}

很快我们就完成了第二版本的栈了，这看上去的确很简单而且实现起来很快只不过是ctrl + c和ctrl + v，但我们的代码真的那么简单好维护吗？想想其实危机四伏。我们能不能一开始就把保存的数据类型定义成为一个通用的类型呢（抽象数据类型）？----邪恶的object。

/// <summary>
/// A custom stack.
/// </summary>
public class CustomStack
{
    private int _stackPointer = 0;
    private object[] _stackArray;

    public void Push(object item)
    {
        ////Concrete implemention.
    }

    public object Pop()
    {
        ////Concrete implemention.
    }
}

现在我们实现了第三版的栈了，看上去我们好像找到了通用的解决方法，想想我们要注意一点是如果我们保存和取出数据类型为值类型时，值类型要进行boxing和unboxing操作（《.NET值类型和引用类型101》），而且还有进行数据类型检测。如果数据量不大我们可能察觉不到性能变化，但数据量大hehehe…。这就是为什么我们要使用泛型的原因之一，但更重要的原因是在进行boxing和unboxing时，我们需要提供更多信息给编译器，编译时再根据我们提供的信息进行类型检测。

1.1.1.2 C#中的泛型

现在我们知道了.NET为什么要提供泛型，现在让我们学习什么是泛型和怎样实现吧！在C# 2.0中提供了泛型这一机制，但这可不是什么新奇的技术，因为早在C++和Java都提供泛型机制。

C#中提供五种泛型分别是：classes, structs, interfaces, delegates, and methods。

泛型类

也许有人说没有使用过C++的模板或Java的泛型，而且不了解C#中的泛型，真的是这样吗？其实我们经常都在使用泛型，相信很多人都使用过Dictionary<TKey,TValue>，没错这就是C#中提供的泛型字典，接下来我们将介绍自定义泛型类CustomStack。

图2泛型类

/// <summary>
/// A custom generic stack.
/// </summary>
public class CustomStack<T>
{
    private int _stackPointer = 0;
    private T[] _stackArray;

    public void Push(T item)
    {
        ////Concrete implemention.
    }

    public T Pop()
    {
        ////Concrete implemention.
    }
}

前面给出了泛型类CustomStack实现，我们发现只需在类名后添加<T>，并且把具体数据类型改为抽象的泛型类型T，现在我们就定义了一个简单泛型类，我们可以通过以下对比一下非泛型和泛型实现的区别。

图3非泛型和泛型类定义

通过上图我们发现泛型类CustomStack和非泛型类CustomStack在实现上没有太大的区别，我们只需把具体类型换成T就OK了，接下来我们将进入泛型的进阶学习。

泛型委托

关于委托大家可以阅读《.NET 中的委托》和《.NET中的委托和事件(续)》，现在让我们学习一下泛型委托。

图4泛型委托的定义

上图给出了泛型委托的定义，我们要注意Type parameters包括泛型参数和返回类型。随着C#3.0 Linq特性的引用，泛型委托的使用得到了极大地扩展，让我们通过具体代码讲讲如何使用泛型委托。

首先我们定义一个泛型委托，然后再定义一个Calc类，接着在Calc里定义两个方法分别是Add() 和Divide() 如下：

/// <summary>
/// Define generic delegate.
/// </summary>
public delegate TR CalcMethod<T1, T2, TR>(T1 x, T2 y);


public class Calc
{
    static private double sum;

    /// <summary>
    /// Gets or sets the sum.
    /// </summary>
    /// <value>
    /// The sum.
    /// </value>
    static public double Sum
    {
        get { return sum; }
        set { sum = value; }
    }

    /// <summary>
    /// Adds the specified x.
    /// </summary>
    /// <param name="x">The x.</param>
    /// <param name="y">The y.</param>
    /// <returns></returns>
    static public string Add(int x , int y)
    {
        Sum = x + y;
        return Sum.ToString();
    }

    /// <summary>
    /// Divides the specified x.
    /// </summary>
    /// <param name="x">The x.</param>
    /// <param name="y">The y.</param>
    /// <returns></returns>
    static public string Divide(int x, int y)
    {
        if (y == 0)
        {
            return "除数不能为零";
        }
        Sum = x * 1.0 / y;
        return Sum.ToString();
    }

}

接下来我们需要定义一个委托变量，而后将委托变量和具体调用方法绑定就OK了。

////Initialize engeric delegate instance to Add method.
CalcMethod<int, int, string> calcMethod =
    new CalcMethod<int, int, string>(Calc.Add);

类型约束

前面例子我们并没有对泛型类型进行限制，由于T是一个抽象类型，有时我们必须限制T是哪种类型，例如我们可以定义CustomStack<int>，CustomStack<double>或CustomStack<string>类型的栈，但有时我们必须限制泛型类型。这时我们需要使用类型约束，引入关键字----where。

C#中提供五种类型约束（类名，接口名，引用类型，值类型和构造函数），我们可以通过使用不同的类型约束来限定泛型类型。

类型约束	约束描述
ClassName	T只能是该类或继承该类的子类
InterfaceName	T只能是该接口或实行该接口的类型
struct	T是任意值类型
class	T是任意引用类型（如classes, arrays, delegates, and interfaces等）
new()	T是包含公有无参构成函数的任意类型

表1类型约束

通过表1我们初步地了解不同类型约束之间的区别，现在让我们通过具体的例子来看看它们使用范围和区别。

假设我们定义了一个泛型结构体struct RefSample<T> where T : class，现在考考大家以下例子符合类约束的有（提示值类型和引用类型区别）：

A．  RefSample<IDisposable>

B．  RefSample<string>

C． RefSample<int[]>

D． RefSample<Guid>

E．  RefSample<int>

激动人心的时刻又到了现在让我们快快公布答案吧！答案是ABC，因为该泛型的约束是引用类型约束，如果大家还不清楚请看一下引用类型约束的定义。

通过类约束例子，我们举一反三值类型约束就是约束类型为值类型。

OK接下来让我们介绍构造函数约束。在介绍构造函数约束之前，让我们回顾一下符合构造函数约束的条件：任意值类型，任意非静态非抽象无明确定义构造函数的类和任意非抽象有明确定义无参构造函数的类。这句话很别扭，让我们通过具体例子讲解一下。

//// Define generic method
//// Which has constructor type constraints
public T CreateInstance<T>() where T : new() 
{
return new T(); 
}

CreateInstance<int>();
CreateInstance<object>();
CreateInstance<string>();

现在我们定义了一个泛型方法并且添加构造函数约束，调用CreateInstance<int>() 和 CreateInstance<object>() 成功，但调用CreateInstance<string>() 失败，这由于String类没有提供无参构造函数。也许有人会问：“我们很难判断每种类型是否包含默认构无参造函数”，确确是这样但我们可以记住的是C#规定值类型提供默认无参构造函数。

组合约束

前面的泛型例子都是只使用一种类型约束，但有时候我们要使用多种类型约束，这时我们就可以使用组合约束，在使用约束的时我们要注意约束的先后次序，约束次序如下：

图5约束次序

通过上图我们发现ClassName，class和struct是主要约束，接口名是第二约束，最后是构造函数约束。OK现在我们对组合约束有了初步地了解，那么让我们通过以下例子加深理解。

A. class Sample<T> where T : class, struct

B. class Sample<T> where T : Stream, class

C. class Sample<T> where T : new(), Stream

D. class Sample<T> where T : IDisposable, Stream

E. class Sample<T> where T : XmlReader, IComparable, IComparable

F. class Sample<T,U> where T : struct where U : class, T

G. class Sample<T,U> where T : Stream, U : IDisposable

上面给出错误使用组合约束的例子（注：A~E单类型组合约束，FG多类型组合约束），请大家指出约束错误的原因，如果不清楚错误的原因大家回忆一下约束定义。

1.1.3 总结

本文注意介绍了C# 中泛型的基础知识给出自己的总结，而且这不是C# 泛型的全部，如果大家在看完本文之后希望进一步学习泛型这才是我的目的。

泛型的优点：

编译时进行类型检测，减少运行时异常InvalidCastException。
泛型使用强数据类型。如我们实例一个CustomStack<CustomStruct>对象objStack，通过调用Push()方法成功把CustomStruct压入栈中，而objStack.Push(“Stack”)失败。
值类型无需进行boxing和unboxing操作。例如前面的泛型Push()和Pop()方法存放和取出值类型时无需进行boxing和unboxing操作。
减少代码量。如：我们定义一个泛型栈，就不用像前面例子那样分别定义int和string类型的栈。
程序性能提高，因为无需类型转换，从而减少类型检测。
使用泛型减少内存消耗。因为无需进行boxing操作，不用重新分配堆空间。
代码可读性更强。

很多人喜欢将C# ，C++ 和Java中的泛型进行对比，而且也有很多相关的讨论，在这里我也给出自己的想法，我觉得C++ 的泛型功能的确比C# 和Java都要强大。

本文链接

走进单元测试三：实战单元测试

2012-02-11T08:08:00Z

前两篇文章讲解了一些关于单元测试的基本理论知识，接下来我们应该理论联系实践，在实践中体会单元测试带给我们的便利！

　　环境：VS2008,2010版本！

　　关于怎么在VS中创建单元测试，园子里已经有很多这样的文章了，请参考以下链接：　　

　　 http://www.cnblogs.com/heqichang/archive/2011/09/30/2196779.html

http://www.cnblogs.com/TerryFeng/archive/2009/05/24/1488333.html

http://www.cnblogs.com/zhijianliutang/archive/2011/12/15/2288423.html

目录：

　　1.前言

　　　　一个完整的测试必须符合以下几点：　　　　

A) 考虑到各种情况，准备测试所需要的各种数据，这一步是测试的关键所在！

B) 调用要测试的方法！

C) 验证被测试方法的行为跟预期的是否一致！

D) 完成验证测试之后清理各种资源！

2.单元测试框架

　　测试框架的DLL文件名为： Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll

在VS自动创建单元测试项目就会自动引用这个DLL了！

　　　　测试类的基本结构如图：　　　　

　　　　基本的测试类结构就是这样的！

　　3.断言(Assert)

　　　　在单元测试代码里断言是无处不在的，我们应该合理的使用断言来验证数据！

　　　　它是一个静态类，主要有下面几种方法用来验证函数的结果跟我的预期是否一致！

　　　　① Assert.AreEqual

　　　　　　主要是验证函数产生的影响值或返回的值跟预期是否一致，这个方法不适合验证返回的数据集以及集合之类的数据，主要针对字符串，数字等等的单一类型，它还有个泛型重载，这个是比较好的，建议多使用，它还有第三个参数，是一个string型的message，基本上不会用到！

　　　　　　 ☆ Note：不要把参数的含义搞混，第一个参数是你的期望值(Except)，第二个参数是函数返回或影响程序产生的实际值(Actual)，不要把两个颠倒过来，因为如果运行正确没有什么大碍，如果运行产生错误，有的时候就会看错掉，造成判断失误，要注意了，这是一个规范！

　　　　　　例子：

　 Assert.AreEqual<string>("a", "a", "cheng xu yuan");

　　　　② Assert.AreNotEqual　　　　

　　　　　　没什么要讲的，情况跟上面相反，主要是验证实际值跟期望值不相等的情况！

　　　　③ Assert.AreSame

　　　　　　判断实际值跟预期值的类型是否一致！

　　　　④ Assert.AreNotSame

　　　　　　跟上面正好相反，测试类型不一致！

　　　　⑤ Assert.IsNotNull，Assert.IsNull，Assert.IsTrue，Assert.IsFalse

　　　　　　看这些方法名就知道什么意思了！

　　　　⑥ Assert.IsInstanceOfType，Assert.IsNotInstanceOfType

　　　　　　判断指定的对象是否是指定的类型！

　　　　⑦ Assert.Fail

　　　　　　迫使断言失败，不管前面的断言是否都成功了，但测试结果是错误的，因为我强制断言失败了！

　　　　总结：一个好的测试案例，里面的断言至少是大于一个的，这样才能验证数据的准确性，保证验证数据的严谨性！

　　　　例：如果实际值是个DataSet一般测试流程为：①判断是否为“null” → ②判断是否为“Empty”(验证是否有数据) →③ 接下来再验证数据的一致性，所以验证DataSet的基本流程就是这样的！　　　

 1 　　　　/// <summary>
 2 　　　　 /// Modify.
 3　　　　  /// </summary>
 4         [TestMethod()]
 5         [RollBack()]
 6         public void UpdateBondAssessApplicationConfiguration_ModifyData_DataUpdated() //注意命名规范，下一篇会着重讲解！
 7         {
 8             AssessApplicationConfigurationDataSet assessConfigurationDataSet = target.GetBondAssessApplicationConfiguration();
 9             assessConfigurationDataSet.CM_LookupConfiguration[0].Description = "This is my modify";
10             AssessApplicationConfigurationDataSet actual = target.UpdateBondAssessApplicationConfiguration(assessConfigurationDataSet);
11             AssessApplicationConfigurationDataSet newAssessAppDataSet = target.GetBondAssessApplicationConfiguration();
12 
13             Assert.IsNotNull(actual);                                                                       //第一步 验证是否为Null
14             Assert.IsTrue(actual.CM_LookupConfiguration.Rows.Count > 0);                                    //第二步 验证是否为Empty
15             Assert.IsTrue(newAssessAppDataSet.CM_LookupConfiguration[0].Description == "This is my modify");//第三步 验证数据的一致性
16             Assert.IsTrue(CompareToTable(newAssessAppDataSet.CM_LookupConfiguration, actual.CM_LookupConfiguration));
17         }

复制代码

　　4.测试异常 → ExpectedException(异常属性)

　　　　当代码中有抛出异常的情况时，我们应该对这个异常的准确性进行测试，首先要捕获这个异常，然后再跟我预期定义的异常进行比较就行了！

　　　　在VS自带的测试框架中提供了处理异常的测试！

这个异常属性有两个构造函数重载：

　　　　第一个参数：函数中出现异常的类型 → [ExpectedException(typeof(NullReferenceException))]

　　　　第二个参数：异常所提示的信息(Message) → [ExpectedException(typeof(NullReferenceException),"Don't is null.")]

　　　总结：在测试一些非法数据，边界值，异常测试是非常有用的，一旦发现异常，后面的一切断言和代码将跳过，然后系统将会把异常和你预期的异常进行比对，一致则表示通过，反之有错误！　　　　

 1 　　　　 /// <summary>
 2 　　　　 /// Is null.
 3 　　　　 /// </summary>
 4         [TestMethod()]
 5         [RollBack()]
 6         [ExpectedException(typeof(NullReferenceException))]  //第一种只定义了异常类型！
 7         public void UpdateLookupChequeNumberRegion_UpdateChequeNumberRegionAndDataSetIsNull_ThrowException()
 8         {
 9             LookupChequeNumberRegionDataSet actual = target.UpdateLookupChequeNumberRegion(null);
10         }
11 
12         /// <summary>
13 　　　　 /// Add.
14 　　　　 /// </summary>
15         [TestMethod()]
16         [RollBack()]　　　　　　　　　　　　//第二种定义了预期的异常类型还定义了异常信息！
17         [ExpectedException(typeof(BusinessException), "The category and code combination you have entered already exist. Please enter a different category and code combination.")]
18         public void UpdatePolicyConsideration_AddPolicyTheCODEIsSame_ThrowException()
19         {
20             string newGUID = Guid.NewGuid().ToString();
21             CodeTableDataSet expectedDataSet = target.GetPolicyConsideration();
22             expectedDataSet.T_IC_CODE.AddT_IC_CODERow(GetNewRow(expectedDataSet, null, ref newGUID));
23             CodeTableDataSet actual = target.UpdatePolicyConsideration(expectedDataSet);
31         }

复制代码

　　5.忽视测试 → Ignore属性

　　　　添加这个属性表明现在这个测试案例在运行时将不会被执行，跳过此方法！　　　　

 1 　　　　 [TestMethod()]
 2         [Ignore()]        //运行单元测试时将忽视这个测试案例
 3         public void GetBondDebt_InputValidClientID_RecordFound()
 4         {
 5             int clientCoreID = GetClientIDForSomeCondition();
 6             DebtDataSet actual = target.GetBondDebt(clientCoreID);
 7 
 8             Assert.IsNotNull(actual);
 9             Assert.IsTrue(actual.Debt.Rows.Count > 0);
10             Assert.IsTrue(CompareToDataSetAndList(actual, clientCoreID));
11         }

复制代码

　　6.数据驱动测试

　　　　在上一篇提到过当你的数据量很大的时候，有一种解决方案是采用数据驱动测试，把我们需要用来测试的数据放在文件中，然后运行测试，让测试代码去读取文件中的数据！

　　　　其实它也有一定的局限性，所以在合理的场合中合理的使用将减轻我们的工作量，这个判断只能给为看官去判断了！

　　　　当前支持Sql Server ，Oracle，CSV，XML等等文件，下面我就介绍下CSV和XML文件的使用方法！

　　　　也可以参照园子里面的博文：

　　　　http://www.cnblogs.com/zhijianliutang/archive/2011/12/15/2289398.html

　　　　http://www.cnblogs.com/heqichang/archive/2011/10/08/2202441.html

　　　　①CSV作为数据文件

　　　　　　我们写一个简单不能再简单的的加法运算方法来作为示例：　

1 　　　　 public int Add(int numberOne, int numberTwo)
2           {
3             int one = numberOne;
4             int two = numberTwo;
5             int three = numberOne + numberTwo;
6             return three;
7           }

复制代码

　　　　　　a) 首先要创建连接字符串，具体步骤如下：　　　　　　　　

　　　　　　　　I，　　

　　　　　　　　II，

　　　　　　　　III，

　　　　　　　　通过上面步骤的操作，就会进入选择文件的界面，按照提示即可完成，当然前提你的数据文件要准备好，完成之后会出现如下代码：　　　　　　

 1 　　　 /// <summary>
 2 　　　　 ///Add 的测试
 3 　　　　 ///</summary>
 4         [DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV",
 5                     "|DataDirectory|\\number.csv",
 6                     "number#csv",
 7                     DataAccessMethod.Sequential),  //这个是连接字符串，你也可以手动写，不要按照上面步骤操作，当然要写对单词和“注意文件的路径”！
 8         DeploymentItem("MyTest\\number.csv"),
 9         TestMethod()]
10         public void AddTest1()
11         {
12             Program target = new Program();
13             int numberOne = Convert.ToInt32(this.testContextInstance.DataRow["One"]);　　//获取数据！
14             int numberTwo = Convert.ToInt32(this.testContextInstance.DataRow["Two"]); ;
15             int expected = Convert.ToInt32(this.testContextInstance.DataRow["Except"]);
16             int actual = target.Add(numberOne, numberTwo);
17             Assert.AreEqual(expected, actual);
18         }

复制代码

　　　　　　点击运行你的测试，程序会通过你设置的路径去文件里面一行一行的读取数据，然后验证数据，如果其中有一行数据报错，那么整个测试也就是失败了，所以保证数据的正确性很重要！

　　　　　　注意：CSV默认会以Excel的方式打开，但是它里面的数据摆放有一个规则，就是以逗号的形式呈现，所以我还是建议大家使用记事本来添加数据！

　　　　②使用XML作为数据文件

　　　　　　其实使用方法跟上面的一样，尤其注意的是你XML文件里面数据的格式！　　　　　　

 1 　　　　<table>　//一定要设置根节点，如果不设置在文件选择的时候会报错！　　　
 2             <my>
 3                 <price>1</price>
 4                 <number>1</number>
 5                 <total>1</total>
 6             </my>
 7             <my>
 8                 <price>2</price>
 9                 <number>2</number>
10                 <total>4</total>
11             </my>
12         </table>

复制代码

　　　　　　注意：怎么来获取数据呢？Convert.ToInt32(this.testContextInstance.DataRow["price"]) 通过这样的方式来获取数据，还有在选择文件时，要确认是否选中了一个数据源文件，这个不要疏忽了！

　　　　③使用数据库作为数据文件很简单，配置一下连接字符串，设置一下路径就好了，在此就不讲解了！

　　7.单元测试的利器 → “Mole”技术

　　　　首先想感谢下项目组的Tian Mi大哥是他把这项技术带给我们的，谢谢他的无私奉献！

　　　　园子里面也有一篇精华文章，讲解了基本用法，链接为：http://www.cnblogs.com/hwade/archive/2010/11/26/Moles.html

　　　　“Mole”文件的下载地址：http://www.kuaipan.cn/index.php?ac=file&oid=29568238492847207

　　　　①应用环境：

　　　　　　所属模块依赖于系统的其它模块，依赖于系统的一些配置环境，还有就是调用第三方接口或服务等等的场景！

　　　　　　在这样的场景下我们的测试是不能直接调用第三方接口或服务的，所以我们要制造一个虚拟的环境，当我们去调用接口时，Mole技术会拦截我们调用的方法，从而转向我们自己制造的虚拟环境，那么就不会直接调用第三方接口和服务了！

　　　　②基本的操作流程不讲解了，如果你看了http://www.cnblogs.com/hwade/archive/2010/11/26/Moles.html这篇文章就明白了，我就将一些在写测试时遇到的几个小问题！

　　　　③如果“Moles”结束后，项目编译的时候报错，具体的错误我也不怎么知道了，但是我在网上搜了很久才找到答案的！

　　　　　　步骤：点击你的Moles文件，你会发现他是个XML配置文件，修改它的属性就好了，如：　　　　　　

1 　　　　　　<Moles  xmlns="http://schemas.microsoft.com/moles/2010/"  DisableCache="true" >  //增加一个DisableCache = "true"这个属性，如果遇到问题，基本都是这个问题，这样解决就Ok了！
2   　　　　　　<Assembly Name="Foundation.FinanceManagement.BusinessService"  />
3 　　　　　　</Moles>

复制代码

　　　　③有“Ref”参数的方法应该怎么写？

　　　　　　如果参数中ref参数，那么就不能按一般的方式写了，应该这样写：　　

　　　　④Moles的基本语法

　　　　　　Moles的内部原理没有明白，只懂的怎么去用它，基本的语法可以模仿上面的写法！

　　　　　　因为你把一个DLL Moles之后并编译之后会生成一个新的DLL，这里面就是虚拟环境场所，而且类名称都是以“M”开头的！

　　　　　　语法：命名空间 + Moles + M + 你Moles掉的类名 + Allinstance + 选择你要拦截的方法名 = (instance(必填参数，如果方法没参数，也必要添个)) =>

　　　　　　　　　{

　　　　　　　　　　　　//里面写你的逻辑，制造你自己的虚拟环境，如果方法有返回值，可以自己指定返回值的！

　　　　　　　　　};

　　好了，关于在实践中的单元测试就这么多了，其实最重要的还是你考虑测试的角度要多样化，就是考虑问题要全面，还有代码的简洁性，重构，封装等等，下一篇将是对这方面的着重讨论！

　　下一篇：走进单元测试四：测试背后的思考和总结！

　　链接：走进单元测试一：初认Unit Test

　　　　走进单元测试二：测试需要从哪些方面着手

本文链接

在.NET环境中实现每日构建(Daily Build)--NAnt篇

2012-02-10T04:03:00Z

前言

关于每日构建这个话题，也已经有很多很好的文章讨论了。本文的写作过程中也参考了这些文章。本文之所以继续这个题目，是因为在查阅了网上的资源后，发现没有一个比较通用的过程。所以本文就主要讨论了利用NAnt构建一个通用日编译的方案。利用这个方案，日编译的维护者可以不需要对每个要编译的方案都要做很多维护。只要定义一个属性文件就可以了。

关键词： Daily Build, NAnt

1. 简介

1.1. 每日构建的优点：

每日构建（Daily Build）也可称为持续集成（Continuous Integration），强调完全自动化的、可重复的创建过程，其中包括每天运行多次的自动化测试。每日构建的作用日益显得重要。它让开发者可以每天进行系统集成，从而减少了开发过程中的集成问题。

持续集成可以减少集成阶段"捉虫"消耗的时间，从而最终提高生产力。它使得绝大多数bug在引入的同一天就可以被发现。而且，由于一天之中发生变动的部分并不多，所以可以很快找到出错的位置。

1.2. 每日构建完成的任务

实现自动化每日构建需要做以下几部分的工作：

l 使创建过程完全自动化，让任何人都可以只输入一条命令就完成系统的创建。

l 使测试完全自动化，让任何人都可以只输入一条命令就运行一套完整的系统测试。

l 确保所有人都可以得到最新、最好的可执行文件。

2. 每日构建所使用的工具

在.NET环境下建立每日构建可以使用一系列开源工具：

Nant: 完成代码的自动编译，自动运行测试工具。http://nant.sourceforge.net/builds/

NantContrib：自动从源码库中获取源代码。http://nantcontrib.sourceforge.net/nightly/builds/

NUnit2Report:将NUnit测试工具产生的XML报告转换为HTML报告形式。http://NUnit2Report.sourceforge.net

VSS：Visual Source Safe，微软源码管理工具

Draco.NET: 用于自动检测VSS中源代码变动情况，调用Nant完成自动编译

http://sourceforge.net/projects/draconet/

下载所需的工具后，按照如下步骤进行安装：

在服务器上安装VSS源码管理工具

安装下载的Draco Server 和 Draco Web,修改安装后的Draco Web目录下的web.config文件，设置正确的Draco Server安装路径

将NAnt、NAntContrib、NUnit2Report压缩包解压，将三个Bin目录中的内容复制到一个公用目录，比如D:\DailyBuildTools，然后将该路径加入系统的Path路径列表中，具体为“控制面板-〉系统属性-〉环境变量-〉Path”

3. NAnt自动脚本

NAnt脚本实现了每日构建的主体功能，它具体分为下面几部分

l 定义每日构建所需的一些环境变量，比如从VSS上下载的源码的保存目录，发布目录等

l 清除旧的代码并从VSS源码库中下载最新源代码

l 编译源代码并运行测试代码集

l 将编译后的目标代码拷贝到发布目录进行发布

为了尽可能少的改动NAnt的脚本文件，简化日常维护的工作量，我们把一些对所有项目都基本相同的过程抽取出来，如环境变量定义，清除旧代码获取新代码，编译源代码，对目标代码进行发布的过程都可以写成通用的脚本，而一个具体项目的每日构建脚本则调用通用过程完成

本文采取的目录体系如下所示：

D：\DailyBuild\

<project1>\Source:存放<project1>源代码的目录

<project1>\Build:存放<project1>编译后的目标代码的目录

<project1>\Publish:存放<project1>的WEB发布文件的目录

<project1>\log:存放<project1>的日志文件

3.1. Nant的基础知识

l Nant脚本代码文件的基本结构

<?xml version="1.0" encoding="gb2312"?>

……

</target>

……

</target>

</project>

说明：encoding="gb2312"使得脚本文件可以支持中文

<project>标签定义了项目属性，一个脚本文件只能有一个项目定义

default="prebuild"说明该项目缺省从prebuild任务开始执行

<target>标签定义了一项任务，任务是Nant脚本具体执行动作的最小单元

depends="namecheck,clean "说明该任务执行前需要namecheck和clean任务先执行

description描述了该任务的一些说明性信息

l 定义变量

<property name="<变量名>" value="$<变量值>"/>

如上所示，定义变量使用<property>标签，name属性定义了变量的名称,value属性定义变量的值，其中name属性可以使用字母、数字、点号、下划线等符号，而value属性可以使用字符串或是已经定义的变量，Nant内建的函数等，

要使用已经定义的变量，可以用${<变量名>}，要使用内建函数，可以使用${<函数名称>}

如: <property name="solution.basedir" value="${core.basedir}\${solution.name}"/>

使用了已定义变量core.basedir和solution.name来定义变量solution.basedir;

使用了NAnt内建函数directory::get-current-directory()来定义curdir变量

3.2. 定义环境变量

定义环境变量的脚本代码写在Common。Config文件里

主要有以下几类信息的定义：

l 每日构建所在的根目录

说明：${directory::get-current-directory()}内建函数获取当前文件所在路径信息

l 被编译的解决方案的目录结构，和前面提到的目录体系一致

说明：以上代码是定义了要编译的解决方案的目录结构信息，其中${solution.name}是由外部传入的解决方案的名称，后面的代码将根据该名称在日编译的根目录下生成和solution.name指定的名称同名的目录，并在该目录下生成source,buld,log等子目录

l VSS源代码管理系统的基本信息

说明：定义了和VSS源码管理系统相关的一些信息，其中VSS数据库所在位置可以是网络路径，也可以是本地路径

l <编译时的一些参数

3.3. 建立目录结构，获取源代码

脚本代码写在CheckSource.build.xml文件里

l 包含在Common.config文件里定义的公共变量

l 检查是否存在solution.name变量

</ifnot>

</if>

</target>

说明：${property::exists('<变量名>')}是NAnt内建函数，用于测试某变量是否存在

${string::get-length(<字符串变量>)==0}测试字符串的长度是否为0

<ifnot test=<逻辑表达式> … </ifnot>:如果test表达式值为假，执行<ifnot>标签内的代码

<if test=<逻辑表达式> … </if>:如果test表达式值为假，执行<if>标签内的代码

l 建立解决方案的目录结构

</target>

说明:delete和mkdir标签内的failonerror属性表示即使操作文件夹的过程中出现了错误，也忽略错误向下执行

l 获取源代码：

从VSS上获取解决方案<solution.name>的源代码

</ifnot>

<vssget

user="${vss.username}"

password="${vss.password}"

localpath="${solution.source}"

recursive="true"

replace="true"

dbpath="${vss.dbpath}"

path="${vss.basepath}${vss.projectpath}"

</target>

说明：<vssget>标签是NAntContrib的语法，用来从VSS源码管理器上下载源代码，user和password属性表示登录VSS服务器的信息；Localpath属性是指下载的源代码存放的路径；recursive="true"表示递归获取代码；replace="true"表示如果本地有重复文件，则进行覆盖；dbpath定义VSS的srcsafe.ini文件的路径信息，包括srcsafe.ini文件名；path定义了要获取的源代码在VSS数据库中的路径，一般都是以$/为根目录。

3.4. 编译源代码

l 编译命令

编译解决方案的命令为

</webmap>

</solution>

其中solutionfile属性表明了要编译的解决方案文件的路径信息，即以"sln"为扩展名的文件，

configuration属性表明要编译的是发行版还是调试版，取值为"Release"或"Debug"

outputdir表明了编译后的动态链接库或可执行文件存放的目录

solution中的嵌套标签<webmap>用于当解决方案含有WEB项目的情况，有几个WEB项目，就有几项<map>标签，map标签中的url属性为WEB项目的*.csproj文件的WEB路径，path则为该*.csproj文件所在磁盘上的物理路径，例如，解决方案中有WEB项目exam，则map标签为 <map url="http://localhost/exam/exam.csproj" path="c:\exam\exam.csproj"

l 根据解决方案名称获取解决方案文件的路径信息

<in>

<items>

</items>

</in>

<do>

</do>

</foreach>

说明：<foreach>标签是NAnt中处理循环的命令,item="File"说明foreach进行循环处理的对象是文件，<include>中的name变量表示要查找的文件信息，"**\"表示查找路径包括子目录。Foreach的属性property="<变量名>"表示查找到的文件路径信息保存在该变量中，可以在<do>标签中引用.foreach每查找到一项符合条件的Item，都会执行<do>标签中的代码，以上代码执行的结果就是查找到指定名称的解决方案文件，供后面编译代码使用

l 获取解决方案中WEB项目的路径信息

如果解决方案中含有WEB项目，则其编译命令和不含WEB项目的解决方案编译有所区别，所以要区别对待。如果解决方案含有多个WEB项目，则可以让用户将多个WEB项目的名称放在一个变量中，如solution.webprojects，以逗号或分号或空格做分隔符。然后将项目名称分别提取出来，根据Web项目的个数决定solution命令的形式，代码如下

<!--将solution.webprojects中用",",";"或" "分隔的Web工程名提取出来，

分别设为webproject1,webproject2 -->

</if>

</ifnot>

</foreach>

</if>

以上代码中foreach标签的属性item="String" in="${solution.webprojects}" delim=";, " property="project"表明循环对象是字符串，对in所代表的字符串

如果设定solution.webprojects="webprj1;webprj2”，则以上代码执行的结果是定义了两个变量webproject1 ="webproj1"和webproject2 ="webproj2"

l 查找WEB工程名

根据前面从solution.webprojects中提取出来的webproj1和webproj2变量，查找该WEB工程的文件名

<in>

<items>

</items>

</in>

<do>

</do>

</foreach>

</if>

同理可以处理存在第二个WEB工程项目的情况，设置webproject2.file变量

l 编译解决方案

最后是编译解决方案，分别根据无WEB项目，有2个WEB项目，有一个WEB项目的三种情况处理

下面仅列出有两个WEB项目的情况

<solution

solutionfile="${solution.file}"

configuration="${build.configuration}"

outputdir="${solution.build}"

<map

url="http://localhost/${webproject1}/${webproject1}.csproj"

path="${webproject1.file}"

<map

url="http://localhost/${webproject2}/${webproject2}.csproj"

path="${webproject2.file}"

</webmap>

</solution>

</if>

3.5. 运行测试代码

l 测试命令

NAnt中关于测试的命令是<NUnit2>标签

<formatter type="Xml" usefile="true"

extension=".xml" outputdir="…"

</nunit2>

说明：<formatter>标签中，type="Xml"表明了根据测试结果生成XML结构化信息，usefile="true"表明使用文件保存测试结果，extension=".xml"表明生成的文件扩展名为xml，outputdir指出了文件将被保存到哪个目录

Test标签中的assemblyname表明了被测试的dll程序集的路径信息，haltonfailure="false"表明即使测试没有通过仍然继续执行脚本文件

这样在测试命令完成后，会在outputdir指出的目录下生成一个XML形式的报告文件，为了增加测试结果的可读性，可以使用另一个工具NUnit2Report，将测试结果转换为直观的HTML文件。具体命令如下

<nunit2report out="<文件名>" todir="<输出目录" >

</fileset>

</nunit2report>

说明：includes标签用来搜索符合条件的XML文件，转换出来的HTML文件保存为out指出的文件名，todir指出了HTML文件将保存的目录信息

<formatter type="Xml" usefile="true"

extension=".xml" outputdir="${solution.build}" />

</nunit2>

</fileset>

</nunit2report>

</foreach>

</if>

3.6. 进行WEB发布

WEB发布主要针对有WEB工程项目的解决方案，其实现原理为利用NAnt的拷贝命令，将WEB工程下除了源代码，资源代码，VSS信息文件外的其他文件和编译后的程序集拷贝到发布目录，最后设置WEB虚拟路径以供WEB访问的过程。

设置WEB虚拟路径的命令为

<mkiisdir dirpath="<物理路径>" vdirname="<虚拟路径>"/>

说明:设WEB项目发布在C:\Intepub\wwwroot\Exam，访问该WEB项目用地址http://127.0.0.1/Example/default.aspx，则<物理路径>为"C:\Intepub\wwwroot\Exam"，虚拟路径为"Example"（此处略去详细代码）。

下载示例代码

引用自：http://dragon.cnblogs.com/archive/2005/07/29/203189.html

本文链接

Private Protect Partial Internal Public 区别

2012-02-07T05:40:00Z

摘自：MSDN

The situation is similar to personal secrets (shared only with friends), family secrets (shared with friends and children), and nonsecrets (shared with anybody), respectively.

A Partial:It is possible to split the definition of a class or a struct, or an interface over two or more source files. Each source file contains a section of the class definition, and all parts are combined when the application is compiled.

please see the following example code:

public partial class CoOrds
{
private int x;
private int y;

public CoOrds(int x, int y)
{
this.x = x;
this.y = y;
}
}

public partial class CoOrds
{
public void PrintCoOrds()
{
System.Console.WriteLine("CoOrds: {0},{1}", x, y);
}

}

class TestCoOrds
{
static void Main()
{
CoOrds myCoOrds = new CoOrds(10, 15);
myCoOrds.PrintCoOrds();
}
}

A private: member of a class is accessible only by members and friends of the class.

See the following example code:

using System;

class Employee
{
private string name = "FirstName, LastName";
private double salary = 100.0;

public string GetName()
{
return name;
}

public double Salary
{
get { return salary; }
}
}

class MainClass
{
static void Main()
{
Employee e = new Employee();

// The data members are inaccessible (private), so
// then can't be accessed like this:
// string n = e.name;
// double s = e.salary;

// 'name' is indirectly accessed via method:
string n = e.GetName();

// 'salary' is indirectly accessed via property
double s = e.Salary;
}
}

A protected: member of a class is accessible by members and friends of the class and by members and friends of derived classes, provided they access the base member via a pointer or a reference to their own derived class.

please see the following example code:

using System;
class A
{
protected int x = 123;
}

class B : A
{
static void Main()
{
A a = new A();
B b = new B();

// Error CS1540, because x can only be accessed by
// classes derived from A.
// a.x = 10;

// OK, because this class derives from A.
b.x = 10;
}
}
  A public: member of a class is accessible by everyone.

See the following example code:
using System;
class Point
{
public int x;
public int y;
}

class MainClass
{
static void Main()
{
Point p = new Point();
// Direct access to public members:
p.x = 10;
p.y = 15;
Console.WriteLine("x = {0}, y = {1}", p.x, p.y);
}
}

A Property: Member is a generic term that refers to a field, property, or method of a class. A field is a variable, a property is a bit of data, and a method is a function/subroutine. For example:

public class BankAccount
{
private int _balance;
public int Balance
{
get { return _balance; }
set { _balance = value; }
}
public void Deposit(int depositAmount)
{
// I can reference _balance here because I'm inside the class that defined it
_balance = _balance + depositAmount;
}
}

The above C# code represents a class. _balance (field), Balance (property), and Deposit (method) are all "members" of the class.
Think of a class as a blueprint. A blueprint isn't a house, it's the definition of what the house will look like when you build it. You "build" an object from a class by "new"ing it.

public class Bank
{
public void Main()
{
// ba represents an object created from the class BankAccount
BankAccount ba = new BankAccount();

// This won't compile because _balance is private so it is not accessible outside the class
ba._balance = 10;

// This works fine because Balance is public, so it is accessible from this code that
// exists outside of the class definition for BankAccount
ba.Balance = 10;
}
}

本文链接

asp.net夜话之十一：web.config详解

2012-02-02T02:38:00Z

在开发中经常会遇到这样的情况，在部署程序时为了保密起见并不将源代码随项目一同发布，而我们开发时的环境与部署环境可能不一致（比如数据库不一样），如果在代码中保存这些配置这些信息部署时需要到用户那里更改代码再重新编译，这种部署方式非常麻烦。
在.net中提供了一种便捷的保存项目配置信息的办法，那就是利用配置文件，配置文件的文件后缀一般是.config，在asp.net中配置文件名一般默认是web.config。每个web.config文件都是基于XML的文本文件，并且可以保存到Web应用程序中的任何目录中。在发布Web应用程序时web.config文件并不编译进dll文件中。如果将来客户端发生了变化，仅仅需要用记事本打开web.config文件编辑相关设置就可以重新正常使用，非常方便。
本篇要讲述的知识如下：
配置文件的查找优先级

配置文件节点说明
配置文件的操作

配置文件的查找优先级
在.net提供了一个针对当前机器的配置文件，这个文件是machine.config，它位于%windir%/Microsoft.NET/Framework/v2.0.50727/CONFIG/文件下（%windir%是系统分区下的系统目录，在命令行模式下输入%windir%然后回车就能查看当前机器的系统目录，在Windows2003及WindowsXP中%windir%是系统分区下的windows目录，在Windows2000中%windir%是系统分区下的WinNT目录，在笔者机器上这个系统目录是C:/WINDOWS）。这个文件里面定义了针对当前机器的WinForm程序和asp.net应用程序的配置。下面是machine.config文件的内容：

在这个文件夹下还有一个web.config文件，这个文件包含了asp.net网站的常用配置。下面是这个web.config文件的内容：

asp.net网站IIS启动的时候会加载配置文件中的配置信息，然后缓存这些信息，这样就不必每次去读取配置信息。在运行过程中asp.net应用程序会监视配置文件的变化情况，一旦编辑了这些配置信息，就会重新读取这些配置信息并缓存。
当我们要读取某个节点或者节点组信息时，是按照如下方式搜索的：
(1)如果在当前页面所在目录下存在web.config文件，查看是否存在所要查找的结点名称，如果存在返回结果并停止查找。
(2)如果当前页面所在目录下不存在web.config文件或者web.config文件中不存在该结点名，则查找它的上级目录，直到网站的根目录。
(3)如果网站根目录下不存在web.config文件或者web.config文件中不存在该节点名则在%windir%/Microsoft.NET/Framework/v2.0.50727/CONFIG/web.config文件中查找。
(4)如果在%windir%/Microsoft.NET/Framework/v2.0.50727/CONFIG/web.config文件中不存在相应结点，则在%windir%/Microsoft.NET/Framework/v2.0.50727/CONFIG/machine.config文件中查找。
(5)如果仍然没有找到则返回null。
所以如果我们对某个网站或者某个文件夹有特定要求的配置，可以在相应的文件夹下创建一个web.config文件，覆盖掉上级文件夹中的web.config文件中的同名配置即可。这些配置信息的寻找只查找一次，以后便被缓存起来供后来的调用。在asp.net应用程序运行过程中，如果web.config文件发生更改就会导致相应的应用程序重新启动，这时存储在服务器内存中的用户会话信息就会丢失（如存储在内存中的Session）。一些软件（如杀毒软件）每次完成对web.config的访问时就会修改web.config的访问时间属性，也会导致asp.net应用程序的重启。

配置文件节点说明
web.config文件是一个XML文件，它的根结点是<configuration>，在<configuration>节点下的常见子节点有：<configSections>、<appSettings>、<connectionStrings>和<system.web>。其中<appSettings>节点主要用于配置一些网站的应用配置信息，而<connectionStrings>节点主要用于配置网站的数据库连接字符串信息。
<system.web>节点主要是网站运行时的一些配置，它的常见节点有如下：
<appSettings>节点
<appSettings>节点主要用来存储asp.net应用程序的一些配置信息，比如上传文件的保存路径等，以下是一个例子：

<appSettings>
<add key="ImageType" value=".jpg;.bmp;.gif;.png;.jpeg"/>
<add key="FileType" value=".jpg;.bmp;.gif;.png;.jpeg;.pdf;.zip;.rar;.xls;.doc"/>
</appSettings>

对于<appSettings>节点中的值可以按照key来进行访问，以下就是一个读取key值为“FileType”节点值的例子：

string fileType=ConfigurationManager.AppSettings["FileType "];

<connectionStrings>节点
<connectionStrings>节点主要用于配置数据库连接的，我们可以<connectionStrings>节点中增加任意个节点来保存数据库连接字符串，将来在代码中通过代码的方式动态获取节点的值来实例化数据库连接对象，这样一旦部署的时候数据库连接信息发生变化我们仅需要更改此处的配置即可，而不必因为数据库连接信息的变化而需要改动程序代码和重新部署。
以下就是一个<connectionStrings>节点配置的例子：

<connectionStrings>
<add name="AspNetStudyConnectionString1" connectionString="Data Source=(local);Initial Catalog=AspNetStudy;User ID=sa;Password=sa"/>
</connectionStrings>

在代码中我们可以这么实例化数据库连接对象：

//读取web.config节点配置
string connectionString = ConfigurationManager.ConnectionStrings["AspNetStudyConnectionString1"].ConnectionString;
//实例化SqlConnection对象
SqlConnection connection = new SqlConnection(connectionString);

这样做的好处是一旦开发时所用的数据库和部署时的数据库不一致，仅仅需要用记事本之类的文本编辑工具编辑connectionString属性的值就行了。

<compilation>节点
<compilation>节点配置 ASP.NET 使用的所有编译设置。默认的debug属性为“true”，即允许调试，在这种情况下会影响网站的性能，所以在程序编译完成交付使用之后应将其设为“false”。

<authentication>节点
设置asp.net身份验证模式，有四种身份验证模式，它们的值分别如下：
Mode 说明
Windows 使用Windows身份验证，适用于域用户或者局域网用户。
Forms 使用表单验证，依靠网站开发人员进行身份验证。
Passport 使用微软提供的身份验证服务进行身份验证。
None 不进行任何身份验证。

<authentication>节点
<authentication>节点控制用户对网站、目录或者单独页的访问，必须配合<authentication>节点一起使用。

<customErrors>节点
<customErrors>节点用于定义一些自定义错误信息的信息。此节点有Mode和defaultRedirect两个属性，其中defaultRedirect属性是一个可选属性，表示应用程序发生错误时重定向到的默认URL，如果没有指定该属性则显示一般性错误。Mode属性是一个必选属性，它有三个可能值，它们所代表的意义分别如下：
Mode 说明
On 表示在本地和远程用户都会看到自定义错误信息。
Off 禁用自定义错误信息，本地和远程用户都会看到详细的错误信息。
RemoteOnly 表示本地用户将看到详细错误信息，而远程用户将会看到自定义错误信息。
这里有必要说明一下本地用户和远程用户的概念。当我们访问asp.net应用程时所使用的机器和发布asp.net应用程序所使用的机器为同一台机器时成为本地用户，反之则称之为远程用户。在开发调试阶段为了便于查找错误Mode属性建议设置为Off，而在部署阶段应将Mode属性设置为On或者RemoteOnly，以避免这些详细的错误信息暴露了程序代码细节从而引来黑客的入侵。
下面我们添加一个页面CustomErrorsDemo.aspx，在它的Page_Load事件里抛出一个异常，代码如下：

using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
public partial class CustomErrorsDemo : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
throw new Exception("故意抛出的异常。");
}
}

我们先配置<customErrors>如下：

<customErrors mode="RemoteOnly">
<error statusCode="403" redirect="NoAccess.htm" />
<error statusCode="404" redirect="FileNotFound.htm" />
</customErrors>

这时本地运行CustomErrorsDemo.aspx的效果如下：

远程访问时看到的效果：

如果我们将customErrors的Mode属性设置为“On”本地运行和远程访问都会看到如下效果：

如果将customErrors的Mode属性设置为“Off”本地运行和远程访问都会看到如下效果：

<error>子节点
在<customErrors>节点下还包含有<error>子节点，这个节点主要是根据服务器的HTTP错误状态代码而重定向到我们自定义的错误页面，注意要使<error>子节点下的配置生效，必须将<customErrors>节点节点的Mode属性设置为“On”。下面是一个例子：

<customErrors mode="On" defaultRedirect="GenericErrorPage.htm">
<error statusCode="403" redirect="403.htm" />
<error statusCode="404" redirect="404.htm" />
</customErrors>

在上面的配置中如果用户访问的页面不存在就会跳转到404.htm页面，如果用户没有权限访问请求的页面则会跳转到403.htm页面，403.htm和404.htm页面都是我们自己添加的页面，我们可以在页面中给出友好的错误提示。

<httpHandlers>节点
<httpHandlers>节点用于根据用户请求的URL和HTTP谓词将用户的请求交给相应的处理程序。可以在配置级别的任何层次配置此节点，也就是说可以针对某个特定目录下指定的特殊文件进行特殊处理。

下面是与machine.config文件同一目录下的web.config文件中的<httpHandlers>节点配置：

<httpHandlers>
<add path="*.rules" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.xoml" verb="*" type="System.ServiceModel.Activation.HttpHandler, System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" validate="false"/>
<add path="trace.axd" verb="*" type="System.Web.Handlers.TraceHandler" validate="true"/>
<add path="WebResource.axd" verb="GET" type="System.Web.Handlers.AssemblyResourceLoader" validate="true"/>
<add path="*.axd" verb="*" type="System.Web.HttpNotFoundHandler" validate="true"/>
<add path="*.aspx" verb="*" type="System.Web.UI.PageHandlerFactory" validate="true"/>
<add path="*.ashx" verb="*" type="System.Web.UI.SimpleHandlerFactory" validate="true"/>
<add path="*.asmx" verb="*" type="System.Web.Services.Protocols.WebServiceHandlerFactory, System.Web.Services, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" validate="false"/>
<add path="*.rem" verb="*" type="System.Runtime.Remoting.Channels.Http.HttpRemotingHandlerFactory, System.Runtime.Remoting, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" validate="false"/>
<add path="*.soap" verb="*" type="System.Runtime.Remoting.Channels.Http.HttpRemotingHandlerFactory, System.Runtime.Remoting, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" validate="false"/>
<add path="*.asax" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.ascx" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.master" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.skin" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.browser" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.sitemap" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.dll.config" verb="GET,HEAD" type="System.Web.StaticFileHandler" validate="true"/>
<add path="*.exe.config" verb="GET,HEAD" type="System.Web.StaticFileHandler" validate="true"/>
<add path="*.config" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.cs" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.csproj" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.vb" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.vbproj" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.webinfo" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.licx" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.resx" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.resources" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.mdb" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.vjsproj" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.java" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.jsl" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.ldb" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.ad" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.dd" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.ldd" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.sd" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.cd" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.adprototype" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.lddprototype" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.sdm" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.sdmDocument" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.mdf" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.ldf" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.exclude" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.refresh" verb="*" type="System.Web.HttpForbiddenHandler" validate="true"/>
<add path="*.svc" verb="*" type="System.ServiceModel.Activation.HttpHandler, System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" validate="false"/>
<add path="*" verb="GET,HEAD,POST" type="System.Web.DefaultHttpHandler" validate="true"/>
<add path="*" verb="*" type="System.Web.HttpMethodNotAllowedHandler" validate="true"/>
</httpHandlers>

从上面的配置中可以看出，针对*.mdf、*.ldf文件的Get或者Post请求都会交给System.Web.HttpForbiddenHandler来处理，处理的结果就是用户不能查看或者下载相关的文件。如果我们某个文件夹下的文件或者某个类型的文件不允许用户下载，可以在</httpHandlers>节点中增加相应的子节点。
下面我们以一个例子来说明<httpHandlers>节点的用法，在我们的asp.net应用程序中建立一个IPData目录，在IPData目录中创建一个IPData.txt文件，然后在Web.config中添加以下配置：

<httpHandlers>
<add path="IPData/*.txt" verb="*" type="System.Web.HttpForbiddenHandler"/>
</httpHandlers>

上面的代码的作用是禁止访问IPData目录下的任何txt文件。
然后新建一个页面，在页面中添加一个超级链接，链接到该目录下IPData.txt文件，代码如下：

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="HttpHandlersDemo.aspx.cs" Inherits="HttpHandlersDemo" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>httpHandlers节点的例子</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<a href="IPData/IPData.txt" title="打开IPData/IPData.txt">打开IPData/IPData.txt</a>
</div>
</form>
</body>
</html>

运行这个页面的效果如下：

当前web.config文件的<customErrors>节点配置如下：
<customErrors mode="On" defaultRedirect="GenericErrorPage.htm">
<error statusCode="403" redirect="403.htm" />
<error statusCode="404" redirect="404.htm" />
</customErrors>
如果存在403.htm和404.htm页面，点击超级链接之后会出现如下效果：

我们从上图中可以看到当<customErrors>节点的Mode属性为“On”时，因为被禁止访问IPData文件夹下的所有txt文件，所以会跳转到自定义的没有权限提示页面，即403.htm。

<httpRuntime>节点
<httpRuntime>节点用于对 ASP.NET HTTP 运行库设置。该节可以在计算机、站点、应用程序和子目录级别声明。
例如下面的配置控制用户最大能上传的文件为40M（40*1024K），最大超时时间为60秒，最大并发请求为100个。

<httpRuntime maxRequestLength="40960" executionTimeout="60" appRequestQueueLimit="100"/>

<pages>节点
<pages>节点用于表示对特定页设置，主要有三个属性，分别如下：
属性名说明
buffer 是否启用了 HTTP 响应缓冲。
enableViewStateMac 是否应该对页的视图状态运行计算机身份验证检查 (MAC)，以放置用户篡改，默认为false，如果设置为true将会引起性能的降低。
validateRequest 是否验证用户输入中有跨站点脚本攻击和SQL注入式漏洞攻击，默认为true，如果出现匹配情况就会发 HttpRequestValidationException 异常。对于包含有在线文本编辑器页面一般自行验证用户输入而将此属性设为false。
下面就是一个配置节点的例子：

<pages buffer="true" enableViewStateMac="true" validateRequest="false"/>

<sessionState>节点
<sessionState>节点用于配置当前asp.net应用程序的会话状态配置。以下就是一个常见配置：

<sessionState cookieless="false" mode="InProc" timeout="30" />

上面的节点配置是设置在asp.net应用程序中启用Cookie，并且指定会话状态模式为在进程中保存会话状态，同时还指定了会话超时为30分钟。
<sessionState>节点的Mode属性可以是以下几种值之一：
属性值说明
Custom 使用自定义数据来存储会话状态数据。
InProc 默认值。由asp.net辅助进程来存储会话状态数据。
Off 禁用会话状态。
SQLServer 使用进程外SQL Server数据库保存会话状态数据。
StateServer 使用进程外 ASP.NET 状态服务存储状态信息。
一般默认情况下使用InProc模式来存储会话状态数据，这种模式的好处是存取速度快，缺点是比较占用内存，所以不宜在这种模式下存储大型的用户会话数据。

<globalization>节点：
用于配置应用程序的全球化设置。此节点有几个比较重要的属性，分别如下：
属性名说明
fileEncoding 可选属性。设置.aspx、.asmx 和 .asax 文件的存储编码。
requestEncoding 可选属性。设置客户端请求的编码，默认为UTF-8.
responseEncoding 可选属性。设置服务器端响应的编码，默认为UTF-8.
以下就是asp.net应用程序中的默认配置：

<globalization fileEncoding="utf-8" requestEncoding="utf-8" responseEncoding="utf-8"/>

配置文件的读写操作
虽然web.config文件是一个XML文件，但是由于权限的原因它在部署中不能像操作普通XML文件那样进行修改，在.net中提供了一个类用于对web.config进行修改。
下面是针对web.config修改通用类的代码：

using System;
using System.Configuration;
using System.Web;
using System.Web.Configuration;
/// <summary>
/// ConfigurationOperator 的摘要说明
/// </summary>
public class ConfigurationOperator:IDisposable
{
private Configuration config;
public ConfigurationOperator():this(HttpContext.Current.Request.ApplicationPath)
{
}
public ConfigurationOperator(string path)
{
config = WebConfigurationManager.OpenWebConfiguration(path);
}
/// <summary>
/// 设置应用程序配置节点，如果已经存在此节点，则会修改该节点的值，否则添加此节点
/// </summary>
/// <param name="key">节点名称</param>
/// <param name="value">节点值</param>
public void SetAppSetting(string key, string value)
{
AppSettingsSection appSetting = (AppSettingsSection)config.GetSection("appSettings");
if (appSetting.Settings[key] == null)//如果不存在此节点，则添加
{
appSetting.Settings.Add(key, value);
}
else//如果存在此节点，则修改
{
appSetting.Settings[key].Value = value;
}
}
/// <summary>
/// 设置数据库连接字符串节点，如果不存在此节点，则会添加此节点及对应的值，存在则修改
/// </summary>
/// <param name="key">节点名称</param>
/// <param name="value">节点值</param>
public void SetConnectionString(string key, string connectionString)
{
ConnectionStringsSection connectionSetting = (ConnectionStringsSection)config.GetSection("connectionStrings");
if (connectionSetting.ConnectionStrings[key] == null)//如果不存在此节点，则添加
{
ConnectionStringSettings connectionStringSettings = new ConnectionStringSettings(key, connectionString);
connectionSetting.ConnectionStrings.Add(connectionStringSettings);
}
else//如果存在此节点，则修改
{
connectionSetting.ConnectionStrings[key].ConnectionString = connectionString;
}
}
/// <summary>
/// 保存所作的修改
/// </summary>
public void Save()
{
config.Save();
config = null;
}
public void Dispose()
{
if (config != null)
{
config.Save();
}
}
}

把上面的代码存放到App_Code文件夹下，我们在项目中就可以直接使用了。
我们通过一个例子演示如果使用这个通用类对web.config进行设置。新建一个aspx页面，下面是前台代码：

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="ConfigModifyDemo.aspx.cs" Inherits="ConfigModifyDemo" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>在部署后修改web.config的例子</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<table border="0" cellpadding="0" cellspacing="0">
<tr><td>类型</td><td>名称</td><td>值</td></tr>
<tr><td>
程序配置</td><td>
<asp:TextBox ID="txtKey" runat="server"></asp:TextBox>
<asp:RequiredFieldValidator ID="RequiredFieldValidator2" runat="server" ControlToValidate="txtKey"
ErrorMessage="*" Display="Dynamic"></asp:RequiredFieldValidator></td><td>
<asp:TextBox ID="txtAppSetting" runat="server"></asp:TextBox></td></tr>
<tr><td>
数据库连接</td><td>
<asp:TextBox ID="txtConnectionName" runat="server"></asp:TextBox>
<asp:RequiredFieldValidator ID="RequiredFieldValidator1" runat="server" ErrorMessage="*" ControlToValidate="txtConnectionName" Display="Dynamic"></asp:RequiredFieldValidator></td><td style="height: 24px">
<asp:TextBox ID="txtConnectionString" runat="server"></asp:TextBox></td></tr>
<tr><td>
<asp:Button ID="btnModify" runat="server" OnClick="btnModify_Click" Text="修改" /></td><td></td><td></td></tr>
</table>
</div>
</form>
</body>
</html>

编写后台代码有时可能需要增加对配置文件读写操作类所在dll的引用，如下：

下面是后台代码：

using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Web.Configuration;//注意添加这个命名空间
public partial class ConfigModifyDemo : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
}
protected void btnModify_Click(object sender, EventArgs e)
{
string appSetting = txtAppSetting.Text;//appSetting子节点值
string connectionString = txtConnectionString.Text;//连接字符串
string key = txtKey.Text;//appSetting子节点Key
string connectionName = txtConnectionName.Text;//连接Name
ConfigurationOperator op = new ConfigurationOperator();
op.SetAppSetting(key, appSetting);
op.SetConnectionString(connectionName, connectionString);
op.Save();
}
}

下面是运行界面：

我们在上面的表单中填入如下信息：

假设此时web.config文件相关节点的内容如下：

<appSettings>
</appSettings>
<connectionStrings>
<add name="Conn" connectionString="Data Source=(local);Initial Catalog=AspNetStudy;Persist Security Info=True;User ID=sa;Password=sa" />
</connectionStrings>

我们点击“修改”按钮之后的文件内容如下：

<appSettings>
<add key="country" value="china" />
</appSettings>
<connectionStrings>
<add name="Conn" connectionString="Data Source=(local);Initial Catalog=Study;User ID=sa;Password=sa"
providerName="System.Data.SqlClient" />
</connectionStrings>

从执行结果可以看出我们的程序确实能做到修改和添加web.config中的节点的功能。需要注意的是，在利用了某些版本控制软件之后（如Microsoft Visual SourceSafe），版本控制软件可能会将web.config设置为只读属性，就会出现不能设置的情况，我们需要手动将web.config的只读属性去掉才能设置web.config文件。在实际部署项目的时候就不会存在这个问题。

总结：web.config是asp.net应用程序中一个很重要的配置文件，通过web.config文件可以方便我们进行开发和部署asp.net应用程序。此外还能对程序进行一些灵活的控制。在本篇中详细讲述了各节点的作用。因为在部署asp.net应用程序后因为权限原因不能按照XML方式进行修改web.config文件，所以在本篇中还提供了一个针对<appSettings>节点和<connectionStrings>节点设置的通用类，读者朋友可以根据实际项目需要对这个通用类进行完善和补充。
下一篇笔者将带领大家进入到asp.net的内部，了解一下asp.net的内部运行机制，这对于我们更加灵活地控制asp.net应用程序是非常有帮助的。
2008-11-5 01：47
周公（周金桥）

最近事情比较多，忙不过来了，可能发表时间会比较长，不过也好能有时间让我再思考一下我的表述方式。

注意，因为个人空间大小和下载速度受限，所以以后不再提供从本人主机上的下载地址，可以到www.verycd.com下载。地址是：http://www.verycd.com/topics/2730883/

Asp.net夜话系列文章：

引用自：http://blog.csdn.net/zhoufoxcn/article/details/3265141

本文链接

在web.config和app.config文件中增加自定义配置节点

2012-02-02T02:37:00Z

有经验的开发人员都知道在开发.NET应用时可以利用配置文件保存一些常用并且有可能变化的信息，例如日志文件的保存路径、数据库连接信息等等，这样即使生产环境中的参数信息与开发环境不一致也只需要更改配置文件而不用改动源代码再重新编译，极其方便。并且我们一般还约定，在<appSettings>节点保存应用程序的配置信息，在<connectionStrings>中保存数据库连接字符串信息（详见本博客《asp.net夜话之十一：web.config详解》）。
上面的这些方法和约定足以让我们在大部分开发中获得方便，但是在有些情况下有些配置信息可以按组分类存放，如果采用上面的方法不仅不直观，而且读取起来也不是太方便，幸好在.NET里就提供了这样的方法。如果有使用过Log4Net或者Enyim.Caching的朋友，肯定对下面的配置不会陌生：

<sectionGroup name="enyim.com"><section name="memcached" type="Enyim.Caching.Configuration.MemcachedClientSection, Enyim.Caching" /></sectionGroup>

或：

<configSections><section name="log4net" type="System.Configuration.IgnoreSectionHandler"/></configSections>

在出现上面配置的配置文件中，我们就会找到名称为"enyim.com"或者"log4net"的节点，尽管它们本不属于config文件的默认节点，但是通过上面的配置之后程序运行并不会报错。这样一来，相关配置信息也可以很好分类保存起来。
在这里周公演示一个简单的例子，这个例子来源于周公的一个从2006年起就开始开发的自用软件（因为没有美化所以没有免费发布），在这个应用程序的connfig文件中我增加了一些特有的配置，所以新增了一个自己的节点，app.config文件内容如下：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<section name="SoftwareSettings" type="ImageAssistant.Configuration.SoftwareSettings, ImageAssistant" />
</configSections>
<SoftwareSettings>
<LoadSettings>
<add key="LoadBmp" value="true"/>
<add key="LoadJpg" value="true"/>
<add key="LoadGif" value="true"/>
<add key="LoadPng" value="false"/>
</LoadSettings>
<PathSettings SavePath="C:/ResizeImages/" SearchSubPath="true"/>
</SoftwareSettings>
<appSettings>
<add key="LoadBmp" value="true"/>
<add key="LoadJpg" value="true"/>
<add key="LoadGif" value="true"/>
<add key="LoadPng" value="false"/>
<add key="IncludeSubPath" value="true"/>
</appSettings>
</configuration>

在config文件中我们使用<section name="SoftwareSettings" type="ImageAssistant.Configuration.SoftwareSettings, ImageAssistant" />告诉应用程序对于配置文件中的SoftwareSettings节点，其对应的类是ImageAssistant程序集中ImageAssistant.Configuration.SoftwareSettings类，并且在<SoftwareSettings>节点中我们还看到有<LoadSettings>节点和<PathSettings>节点，其中<LoadSettings>是一个节点集合，还包含有多个子节点，为了表示清楚这些关系我们需要添加四个类：SoftwareSettings、LoadSettingsCollection、LoadSettingsElement及PathSettingElement。为了发布方便，周公将这四个类的代码放在一个物理文件中，代码如下（注意添加对System.Configuration.dll的引用）：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
//作者：zhoufoxcn（周公）
//日期：2011-03-08
//blog：http://blog.csdn.net/zhoufoxcn 或http://zhoufoxcn.blog.51cto.com
//版权声明：本文允许非商业用途，但必须保证不得去掉本文中的任何链接，违者必究。
namespace ImageAssistant.Configuration
{
public sealed class LoadSettingsCollection : ConfigurationElementCollection
{
private IDictionary<string, bool> settings;
protected override ConfigurationElement CreateNewElement()
{
return new LoadSettingsElement();
}
protected override object GetElementKey(ConfigurationElement element)
{
LoadSettingsElement ep = (LoadSettingsElement)element;
return ep.Key;
}
protected override string ElementName
{
get
{
return base.ElementName;
}
}
public IDictionary<string, bool> Settings
{
get
{
if (settings == null)
{
settings = new Dictionary<string, bool>();
foreach (LoadSettingsElement e in this)
{
settings.Add(e.Key, e.Value);
}
}
return settings;
}
}
public bool this[string key]
{
get
{
bool isLoad = true;
if (settings.TryGetValue(key, out isLoad))
{
return isLoad;
}
else
{
throw new ArgumentException("没有对'" + key + "'节点进行配置。");
}
}
}
}
public class LoadSettingsElement : ConfigurationElement
{
[ConfigurationProperty("key", IsRequired = true)]
public string Key
{
get { return (string)base["key"]; }
set { base["key"] = value; }
}
[ConfigurationProperty("value", IsRequired = true)]
public bool Value
{
get { return (bool)base["value"]; }
set { base["value"] = value; }
}
}
public class PathSettingElement : ConfigurationElement
{
/// <summary>
///
/// </summary>
[ConfigurationProperty("SavePath", IsRequired = true)]
public string SavePath
{
get { return (string)base["SavePath"]; }
set { base["SavePath"] = value; }
}
/// <summary>
///
/// </summary>
[ConfigurationProperty("SearchSubPath", IsRequired = false, DefaultValue = true)]
public bool SearchSubPath
{
get { return (bool)base["SearchSubPath"]; }
set { base["SearchSubPath"] = value; }
}
}
/// <summary>
/// 对应config文件中的
/// </summary>
public sealed class SoftwareSettings : ConfigurationSection
{
/// <summary>
/// 对应SoftwareSettings节点下的LoadSettings子节点
/// </summary>
[ConfigurationProperty("LoadSettings", IsRequired = true)]
public LoadSettingsCollection LoadSettings
{
get { return (LoadSettingsCollection)base["LoadSettings"]; }
}
/// <summary>
/// 对应SoftwareSettings节点下的PathSettings子节点，非必须
/// </summary>
[ConfigurationProperty("PathSettings", IsRequired = false)]
public PathSettingElement PathSetting
{
get { return (PathSettingElement)base["PathSettings"]; }
set { base["PathSettings"] = value; }
}
}
}

在上面的代码中可以看到ConfigurationProperty这个属性，这是表示对应的属性在config文件中的属性名，IsRequired表示是否是必须的属性，还有DefaultValue表示属性的默认值。初次之外，我们还要注意以下关系：
SoftwareSettings：根节点，继承自ConfigurationSection。
LoadSettingsCollection：子节点集合，继承自ConfigurationElementCollection。
LoadSettingsElement：子节点，继承自ConfigurationElement。
PathSettingElement：子节点，继承自ConfigurationElement。
编写了如下代码之后，我们又该如何使用上面的类呢？其实很简单，如下：

class Program
{
static void Main(string[] args)
{
SoftwareSettings softSettings = ConfigurationManager.GetSection("SoftwareSettings") as SoftwareSettings;
foreach (string key in softSettings.LoadSettings.Settings.Keys)
{
Console.WriteLine("{0}={1}", key, softSettings.LoadSettings[key]);
}
Console.WriteLine("SavePath={0},SearchSubPath={1}", softSettings.PathSetting.SavePath, softSettings.PathSetting.SearchSubPath);
Console.ReadLine();
}
}

这个程序的运行结果如下：
LoadBmp=True
LoadJpg=True
LoadGif=True
LoadPng=False
SavePath=C:/ResizeImages/,SearchSubPath=True

总结：在上面的config文件中通过<appSettings>也达到了类似的效果，但是通过自定义节点我们可以方便地读取相关的应用程序配置，同时也便于维护。如果在开发过程中遇到本文中类似的情况，不妨采取本文所述的方式。本文示例源代码可以到这里下载。

周公
2011-03-08

引用自：http://blog.csdn.net/zhoufoxcn/article/details/6233171

另外一篇：http://wendang.baidu.com/view/cd907368af1ffc4ffe47acae.html?from=related

本文链接

使用NUnit做单元测试（总结版）

2012-01-16T07:40:00Z

【按：有关于NUnit的详细介绍请见：《NUnit2.0详细使用方法》http://confach.cnblogs.com/archive/2005/06/20/177817.aspx 本文是个人心得和简要总结】

一、本文摘要：

●什么单元测试
●什么是NUnit
●NUnit的下载以及安装
●NUnit的启动
●NUnit的最简单使用
●验证设计的功能是否实现
●SetUp/TearDown 属性
●TestFixtureSetUp/TestFixtureTearDown
●Category属性
●Explicit属性
●输出

二、什么单元测试

单元测试，就是局部测试，对于web应用程序或者Windows应用程序来说，都是由很多“局部”组成的。如果是一个具体的Web Page，那么可以通常运行、浏览页面看到具体的结果，但是如果是一个类，测试起来可能就会有一些麻烦，尤其是在类反复继承之后，想要查看程序运行过程中某个类的具体实现结果和实现过程，往往就不那么容易了。
vs IDE当中包含调试(Debug)和跟踪(Trace)的功能，但是它们也有一些局限，往往都是要对程序的整体进行测试，通过层层调用才能运行到某个类。
所以使用单元测试对局部进行测试就会有更好的结果了。
使用单元测试可以很轻松的实现：

静态类测试
静态方法测试
类的实例化测试
类的方法测试

三、什么是NUnit？

单元测试通过有两种办法：一个是微软在VS提供的单元测试，另一个是NUnit，前者可能更复杂也更全面（我只实践过一次，发现复杂是肯定有的），后者更简洁明了。

四、NUnit的下载以及安装

和普通的软件没有什么区别，略。
下载地址：http://www.nunit.org/

五、NUnit的启动

有两种方法，一个是单独启动（通过开始菜单快捷方式），这个时候需要指定已经编译好的dll路径；另一个是集成在VS中启动。

后者适合单独开发类库的时候使用，否则，在一个解决方案中既有类库，也有Web应用程序，还得反复切换“启动项目”。

单独启动的时候，指定好已经编译的DLL，按下"RUN"按钮，测试成功就会以绿色方式显示，失败就会显示红色，黄的部分则是通过Category指令跳过。

六、最简单使用

◆在项目（库类）中添加NUnit的引用。

NUnit.Framework 有针对 .net framwork 1.1和2.0两个版本，引用的时候需要注意

◆新建一个类

需要说明的是
i)NUnit通过创建这个类的实例，和运行这个实例的方法来完成测试。它和原始的、想测试的目标类，并不相同。假如写好一个类classA，想要对classA进行测试，那么现在新建的这个类就是Test_For_ClassA
ii)为了便于叙述，文中使用命名约定：“原始类”和“测试类”

◆并且使用Using指令把"NUnit.Framework;"命名空间包含进来

注意大小写，在添加引用的时候是全小写的，但是命名空间却不是。

◆在类名称前面加上指令：[TestFixtureSetUp]，这个类必须是public

◆添加一个public void 方法，在这个方法前面加上 [Test]指令。后文管这种方法叫做“测试方法”

◆ Shift+F6或者F6生成

◆通过开始菜单快捷方式启动NUnit

◆通过“文件”菜单》“打开”，浏览并找到刚才生成的dll

◆按下Run按钮，NUnit显示绿色的进度条，表明测试成功。

以上就是NUnit的最简单使用，这里其实什么也没有测试，只是演练一下NUnit这个单元测试工具的使用。下面进一步介绍NUnit的使用方法。

七、验证设计的功能是否实现

7.1基本的测试

◆例如：类的实例化

新建一个测试类，添加一个“测试方法”，在这个方法中添加原始类的实例化代码，这时候可以使用各种构造函数，例如（这里使用范例代码不能运行）：

class a = new class();
class b = new class("abc");

使用NUnit测试。如果“测试方法”测试通过显示绿色的进度条，那就证明类的构造函数通过了测试。

◆例如：类的void方法

在“测试方法”中实例化原始类，然后再运运行相应的方法，例如（这里使用范例代码不能运行）：

class a = new class();

a.go();

7.2详细测试：断言

以上的测试都是简单的验证原始类的某些代码运行过程中是否出现异常。对于复杂的类来说，这些远远不够，对于原始类的属性和有返回值的方法可以使用NUnit提供的Assert(断言)来测试。例如：

原始类：

public class tag
{
    public int Count;
    public tag(string html)
    {
        prase(html);
    }
    public void prase(string str)
    {
Count = 0;
        //中间包含具体的解析代码，解析过程中统计标签的数量，略
        return ;
    }
}

测试类：

[TestFixture]
public class TestTag
{

[Test]
    public void T1()
    {
        tag t = new tag("<i>abc</i>");
        Assert.AreEqual(1, t.Count);
    }
}

NUnit在测试的时候，就会比较t.Count是否和1相等，相等则通过测试，并且通过绿色表示出来。
需要说明的是，Assert.AreEqual只是针对值类型判断是否相等。其它的断言，请查看中文帮助：http://www.36sign.com/nunit/assertions.html

还有一些情况不能通过异常和或者断言来判断，那么有两个选择：
A 自己在测试类当中写私有的类业判断

B 在控制台中输出相关的信息。

八、SetUp/TearDown 指令

简单说，就是多个测试中包含的“重合”的代码，可以放到[SetUp]指令指导定的代码当中。每个[Test]方法都会在运行之前先运行[SetUp]运行结束再运行[TearDown]。

九、TestFixtureSetUp/TestFixtureTearDown 指令

这一组指令和前面的指令类似，但是又有些不同，主要的区别在于，这一组指令通常用来打开、释放某些共同的资源（例如数据库连接）

十、Category指令

跳过的测试

十一、Explicit指令

在7.1中是验证代码能否正常运行，如果不出现异常那么就通过测试了。在这里Explicit指令是故意验证，代码当中会不会出现某一具体的异常。

十二、输出

根据测试的需要，可以在NUnit测试的过程种在控制台输出测试类中指定的信息。

能过在NUnit工具的“Text Output”选项卡可以看到测试过程中输出的信息。

例如：

[TestFixtureSetUp]
        public void Init()
        {
             Console.WriteLine("开始测试并且初始化。");
        }

PS:关于输出,我封装了一个类TestBase，除了输出文本以外，还可以输出DataTable的内容。具体请见下面的链接。

http://www.cnblogs.com/xpnew/admin/EditPosts.aspx?postid=1795867

流浪是注定的宿命；
漂泊是无尽的轮回。

引用自 :　http://www.cnblogs.com/xpnew/archive/2010/08/09/1795867.html

本文链接

通过16道练习学习Linq和Lambda

2012-01-16T03:52:00Z

1、查询Student表中的所有记录的Sname、Ssex和Class列。
select sname,ssex,class from student
Linq:
    from s in Students
    select new {
        s.SNAME,
        s.SSEX,
        s.CLASS
    }
Lambda:
    Students.Select( s => new {
        SNAME = s.SNAME,SSEX = s.SSEX,CLASS = s.CLASS
    })

2、查询教师所有的单位即不重复的Depart列。
select distinct depart from teacher
Linq:
    from t in Teachers.Distinct()
    select t.DEPART
Lambda:
    Teachers.Distinct().Select( t => t.DEPART)

3、查询Student表的所有记录。
select * from student
Linq:
    from s in Students
    select s
Lambda:
    Students.Select( s => s)

4、查询Score表中成绩在60到80之间的所有记录。
select * from score where degree between 60 and 80
Linq:
    from s in Scores
    where s.DEGREE >= 60 && s.DEGREE < 80
    select s
Lambda:
    Scores.Where(
        s => (
                s.DEGREE >= 60 && s.DEGREE < 80
             )
    )

5、查询Score表中成绩为85，86或88的记录。
select * from score where degree in (85,86,88)
Linq:
In
    from s in Scores
    where (
            new decimal[]{85,86,88}
          ).Contains(s.DEGREE)
    select s
Lambda:
    Scores.Where( s => new Decimal[] {85,86,88}.Contains(s.DEGREE))
Not in
    from s in Scores
    where !(
            new decimal[]{85,86,88}
          ).Contains(s.DEGREE)
    select s
Lambda:
    Scores.Where( s => !(new Decimal[]{85,86,88}.Contains(s.DEGREE)))

    Any()应用：双表进行Any时，必须是主键为(String)
    CustomerDemographics CustomerTypeID（String）
    CustomerCustomerDemos (CustomerID CustomerTypeID) (String)
    一个主键与二个主建进行Any(或者是一对一关键进行Any)
    不可，以二个主键于与一个主键进行Any

    from e in CustomerDemographics
    where !e.CustomerCustomerDemos.Any()
    select e

    from c in Categories
    where !c.Products.Any()
    select c

6、查询Student表中"95031"班或性别为"女"的同学记录。
select * from student where class ='95031' or ssex= N'女'
Linq:
    from s in Students
    where s.CLASS == "95031"
       || s.CLASS == "女"
    select s
Lambda:
    Students.Where(s => ( s.CLASS == "95031" || s.CLASS == "女"))

7、以Class降序查询Student表的所有记录。
select * from student order by Class DESC
Linq:
    from s in Students
    orderby s.CLASS descending
    select s
Lambda:
    Students.OrderByDescending(s => s.CLASS)

8、以Cno升序、Degree降序查询Score表的所有记录。
select * from score order by Cno ASC,Degree DESC
Linq:(这里Cno ASC在linq中要写在最外面)
    from s in Scores
    orderby s.DEGREE descending
    orderby s.CNO ascending
    select s
Lambda:
    Scores.OrderByDescending( s => s.DEGREE)
          .OrderBy( s => s.CNO)

9、查询"95031"班的学生人数。
select count(*) from student where class = '95031'
Linq:
    (    from s in Students
        where s.CLASS == "95031"
        select s
    ).Count()
Lambda:
    Students.Where( s => s.CLASS == "95031" )
                .Select( s => s)
                    .Count()

10、查询Score表中的最高分的学生学号和课程号。
select distinct s.Sno,c.Cno from student as s,course as c ,score as sc
where s.sno=(select sno from score where degree = (select max(degree) from score))
and c.cno = (select cno from score where degree = (select max(degree) from score))
Linq:
    (
        from s in Students
        from c in Courses
        from sc in Scores
        let maxDegree = (from sss in Scores
                        select sss.DEGREE
                        ).Max()
        let sno = (from ss in Scores
                where ss.DEGREE == maxDegree
                select ss.SNO).Single().ToString()
        let cno = (from ssss in Scores
                where ssss.DEGREE == maxDegree
                select ssss.CNO).Single().ToString()
        where s.SNO == sno && c.CNO == cno
        select new {
            s.SNO,
            c.CNO
        }
    ).Distinct()
操作时问题？执行时报错： where s.SNO == sno（这行报出来的）运算符"=="无法应用于"string"和"System.Linq.IQueryable<string>"类型的操作数
解决：
原：let sno = (from ss in Scores
                where ss.DEGREE == maxDegree
                select ss.SNO).ToString()
Queryable().Single()返回序列的唯一元素；如果该序列并非恰好包含一个元素，则会引发异常。
解：let sno = (from ss in Scores
                where ss.DEGREE == maxDegree
                select ss.SNO).Single().ToString()

11、查询'3-105'号课程的平均分。
select avg(degree) from score where cno = '3-105'
Linq:
    (
        from s in Scores
        where s.CNO == "3-105"
        select s.DEGREE
    ).Average()
Lambda:
    Scores.Where( s => s.CNO == "3-105")
            .Select( s => s.DEGREE)
                .Average()

12、查询Score表中至少有5名学生选修的并以3开头的课程的平均分数。
select avg(degree) from score where cno like '3%' group by Cno having count(*)>=5
Linq:
        from s in Scores
        where s.CNO.StartsWith("3")
        group s by s.CNO
        into cc
        where cc.Count() >= 5
        select cc.Average( c => c.DEGREE)
Lambda:
    Scores.Where( s => s.CNO.StartsWith("3") )
            .GroupBy( s => s.CNO )
              .Where( cc => ( cc.Count() >= 5) )
                .Select( cc => cc.Average( c => c.DEGREE) )
Linq: SqlMethod
like也可以这样写:
    s.CNO.StartsWith("3") or SqlMethods.Like(s.CNO,"%3")

13、查询最低分大于70，最高分小于90的Sno列。
select sno from score group by sno having min(degree) > 70 and max(degree) < 90
Linq:
    from s in Scores
    group s by s.SNO
    into ss
    where ss.Min(cc => cc.DEGREE) > 70 && ss.Max( cc => cc.DEGREE) < 90
    select new
    {
        sno = ss.Key
    }
Lambda:
    Scores.GroupBy (s => s.SNO)
               .Where (ss => ((ss.Min (cc => cc.DEGREE) > 70) && (ss.Max (cc => cc.DEGREE) < 90)))
                   .Select ( ss => new {
                                        sno = ss.Key
                                     })

14、查询所有学生的Sname、Cno和Degree列。
select s.sname,sc.cno,sc.degree from student as s,score as sc where s.sno = sc.sno
Linq:
    from s in Students
    join sc in Scores
    on s.SNO equals sc.SNO
    select new
    {
        s.SNAME,
        sc.CNO,
        sc.DEGREE
    }
Lambda:
    Students.Join(Scores, s => s.SNO,
                          sc => sc.SNO,
                          (s,sc) => new{
                                            SNAME = s.SNAME,
                                            CNO = sc.CNO,
                                            DEGREE = sc.DEGREE
                                          })

15、查询所有学生的Sno、Cname和Degree列。
select sc.sno,c.cname,sc.degree from course as c,score as sc where c.cno = sc.cno
Linq:
    from c in Courses
    join sc in Scores
    on c.CNO equals sc.CNO
    select new
    {
        sc.SNO,c.CNAME,sc.DEGREE
    }
Lambda:
    Courses.Join ( Scores, c => c.CNO,
                             sc => sc.CNO,
                             (c, sc) => new
                                        {
                                            SNO = sc.SNO,
                                            CNAME = c.CNAME,
                                            DEGREE = sc.DEGREE
                                        })

16、查询所有学生的Sname、Cname和Degree列。
select s.sname,c.cname,sc.degree from student as s,course as c,score as sc where s.sno = sc.sno and c.cno = sc.cno
Linq:
    from s in Students
    from c in Courses
    from sc in Scores
    where s.SNO == sc.SNO && c.CNO == sc.CNO
    select new { s.SNAME,c.CNAME,sc.DEGREE }

主要参考文章链接：http://www.cnblogs.com/RuiLei/archive/2008/11/09/1329905.html

本文链接