我觉得如果想成为一名优秀的开发者，不仅要积极学习时下流行的新技术，比如WCF、Asp.Net MVC、AJAX等，熟练应用一些已经比较成熟的技术，比如Asp.Net、WinForm。还应该有着牢固的计算机基础知识，比如数据结构、操作系统、 编译原理、网络与数据通信等。有的朋友可能觉得这方面的东西过于艰深和理论化，望而却步，但我觉得假日里花上一个下午的时间，研究一种算法或者一种数据结 构，然后写写心得，难道不是一件乐事么？所以，我打算将一些常见的数据结构和算法总结一下，不一定要集中一段时间花费很大精力，只是在比较空闲的时间用一 种很放松的心态去完成。我最不愿意的，就是将写博客或者是学习技术变为一项工作或者负担，应该将它们视为生活中的一种消遣。人们总是说坚持不易，实际上当 你提到“坚持”两个字之时，说明你已经将这件事视为了一种痛苦，你的内心深处并不愿意做这件事，所以才需要坚持。你从不曾听人说“我坚持玩了十年的电子游 戏”，或者“坚持看了十年动漫、电影”、“坚持和心爱的女友相处了十年”吧？我从来不曾坚持，因为我将其视为一个爱好和消遣，就像许多人玩网络游戏一样。

好了，闲话就说这么多吧，我们回到正题。因为这方面的著作很多，所以这里只给出简单的描述和实现，供我本人及感兴趣的朋友参考。我会尽量用C#和C++两种语言实现，对于一些不好用C#表达的结构，仅用C++实现。

本文将描述四种最简单的排序方法，插入排序、泡沫排序、选择排序、希尔排序，我在这里将其称为“简单排序”，是因为它们相对于快速排序、归并排序、堆排序、分配排序、基数排序从理解和算法上要简单一些。对于后面这几种排序，我将其称为“高级排序”。

简单排序

开始之前先声明一个约定，对于数组中保存的数据，统一称为记录，以避免和“元素”，“对象”等名称相混淆。对于一个记录，用于排序的码，称为关键码。 很显然，关键码的选择与数组中记录的类型密切相关，如果记录为int值，则关键码就是本身；如果记录是自定义对象，它很可能包含了多个字段，那么选定这些 字段之一为关键码。凡是有关排序和查找的算法，就会关系到两个记录比较大小，而如何决定两个对象的大小，应该由算法程序的客户端（客户对象）决定。对 于.NET来说，我们可以创建一个实现了IComparer<T>的类（对于C++也是类似）。关于IComparer<T>的 更多信息，可以参考这篇文章《基于业务对象的排序》。最后，为了使程序简单，对于数组为空的情况我并没有做处理。

1.插入排序

算法思想

插入排序使用了两层嵌套循环，逐个处理待排序的记录。每个记录与前面已经排好序的记录序列进行比较，并将其插入到合适的位置。假设数组长度为n，外 层循环控制变量i由1至n-1依次递进，用于选择当前处理哪条记录；里层循环控制变量j，初始值为i，并由i至1递减，与上一记录进行对比，决定将该元素 插入到哪一个位置。这里的关键思想是，当处理第i条记录时，前面i-1条记录已经是有序的了。需要注意的是，因为是将当前记录与相邻的上一记录相比较，所以循环控制变量的起始值为1（数组下标），如果为0的话，上一记录为-1，则数组越界。

现在我们考察一下第i条记录的处理情况：假设外层循环递进到第i条记录，设其关键码的值为X，那么此时有可能有两种情况：

1. 如果上一记录比X大，那么就交换它们，直到上一记录的关键码比X小或者相等为止。
2. 如果上一记录比X小或者相等，那么之前的所有记录一定是有序的，且都比X小，此时退出里层循环。外层循环向前递进，处理下一条记录。

算法实现(C#)

public class SortAlgorithm {
    // 插入排序
    public static void InsertSort<T, C>(T[] array, C comparer)
        where C:IComparer<T>
    {          
        for (int i = 1; i <= array.Length - 1; i++) {
            //Console.Write("{0}: ", i);
            int j = i;
            while (j>=1 && comparer.Compare(array[j], array[j - 1]) < 0) {
                swap(ref array[j], ref array[j-1]);
                j--;
            }
            //Console.WriteLine();
            //AlgorithmHelper.PrintArray(array);
        }
    }

// 交换数组array中第i个元素和第j个元素
    private static void swap<T>(ref T x,ref T y) {
        // Console.Write("{0}<-->{1} ", x, y);
        T temp = x;
        x = y;
        y = temp;
    }
}

上面Console.WriteLine()方法和AlgorithmHelper.PrintArray()方法仅仅是出于测试方 便，PrintArray()方法依次打印了数组的内容。swap<T>()方法则用于交换数组中的两条记录，也对交换数进行了打印（这里我 注释掉了，但在测试时可以取消对它们的注释）。外层for循环控制变量i表示当前处理第i条记录。

public class AlgorithmHelper {
    // 打印数组内容
    public static void PrintArray<T>(T[] array) {
        Console.Write("   Array:");
        foreach (T item in array) {
            Console.Write(" {0}", item);
        }
        Console.WriteLine();
    }
}

// 获得Comparer，进行比较
public class ComparerFactory {
    public static IComparer<int> GetIntComparer() {
        return new IntComparer();
    }

public class IntComparer : IComparer<int> {
        public int Compare(int x, int y) {
            return x.CompareTo(y);
        }
    }
}

上面这段代码我们创建了一个ComparerFactory类，它用于获得一个IntComparer对象，这个对象实现了 IComparer<T>接口，规定了两个int类型的关键码之间比较大小的规则。如果你有自定义的类型，比如叫MyType，只需要在 ComparerFactory中再添加一个类，比如叫MyTypeComparer，然后让这个类也实现IComparer<T>接口，最 后再添加一个方法返回MyTypeComparer就可以了。

输出演示(C#)

接下来我们看一下客户端代码和输出：

static void Main(string[] args) {
    int[] array = {42,20,17,13,28,14,23,15};
    //int[] array = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
    AlgorithmHelper.PrintArray(array);

SortAlgorithm.InsertSort
        (array, ComparerFactory.GetIntComparer());
}

算法实现(C++)

// 对int类型进行排序
class IntComparer{
    public:
        static bool Smaller(int x, int y){
            return x<y;
        }
        static bool Equal(int x, int y){
            return x==y;
        }
        static bool Larger(int x, int y){
            return x>y;
        }
};

// 插入排序
template <class T, class C>
void InsertSort(T a[], int length){
    for(int i=1;i<=length-1;i++){
        int j = i;
        while(j>=1 && C::Smaller(a[j], a[j-1])){
            swap(a[j], a[j-1]);
            j--;
        }
    }
}

2.冒泡排序

算法思想

如果你从没有学习过有关算法方面的知识，而需要设计一个数组排序的算法，那么很有可能设计出的就是泡沫排序算法了。因为它很好理解，实现起来也很简 单。它也含有两层循环，假设数组长度为n，外层循环控制变量i由0到n-2递增，这个外层循环并不是处理某个记录，只是控制比较的趟数，由0到n-2，一 共比较n-1趟。为什么n个记录只需要比较n-1趟？我们可以先看下最简单的两个数排序：比如4和3，我们只要比较一趟，就可以得出3、4。对于更多的记 录可以类推。

数组记录的交换由里层循环来完成，控制变量j初始值为n-1（数组下标），一直递减到1。数组记录从数组的末尾开始与相邻的上一个记录相比，如果上 一记录比当前记录的关键码大，则进行交换，直到当前记录的下标为1为止（此时上一记录的下标为0）。整个过程就好像一个气泡从底部向上升，于是这个排序算 法也就被命名为了冒泡排序。

我们来对它进行一个考察，按照这种排序方式，在进行完第一趟循环之后，最小的一定位于数组最顶部（下标为0）；第二趟循环之后，次小的记录位于数组 第二（下标为1）的位置；依次类推，第n-1趟循环之后，第n-1小的记录位于数组第n-1（下标为n-2）的位置。此时无需再进行第n趟循环，因为最后 一个已经位于数组末尾（下标为n-1）位置了。

算法实现(C#)

// 泡沫排序
public static void BubbleSort<T, C>(T[] array, C comparer)
    where C : IComparer<T>
{
    int length = array.Length;

for (int i = 0; i <= length - 2; i++) {
        //Console.Write("{0}: ", i + 1);
        for (int j = length - 1; j >= 1; j--) {
            if (comparer.Compare(array[j], array[j - 1]) < 0) {
                swap(ref array[j], ref array[j - 1]);
            }
        }
        //Console.WriteLine();
        //AlgorithmHelper.PrintArray(array);
    }
}

输出演示(C#)

static void Main(string[] args) {
    int[] array = {42,20,17,13,28,14,23,15};
    AlgorithmHelper.PrintArray(array);

SortAlgorithm.BubbleSort
        (array, ComparerFactory.GetIntComparer());
}

算法实现(C++)

// 冒泡排序
template <class T, class C>
void BubbleSort(T a[], int length){
    for(int i=0;i<=length-2;i++){
        for(int j=length-1; j>=1; j--){
            if(C::Smaller(a[j], a[j-1]))
                swap(a[j], a[j-1]);
        }
    }
}

3.选择排序

算法思想

选择排序是对冒泡排序的一个改进，从上面冒泡排序的输出可以看出，在第一趟时，为了将最小的值13由数组末尾冒泡的数组下标为0的第一个位置，进行了多次交换。对于后续的每一趟，都会进行类似的交换。

选择排序的思路是：对于第一趟，搜索整个数组，寻找出最小的，然后放置在数组的0号位置；对于第二趟，搜索数组的n-1个记录，寻找出最小的（对于 整个数组来说则是次小的），然后放置到数组的第1号位置。在第i趟时，搜索数组的n-i+1个记录，寻找最小的记录（对于整个数组来说则是第i小的），然 后放在数组i-1的位置（注意数组以0起始）。可以看出，选择排序显著的减少了交换的次数。

需要注意的地方是：在第i趟时，内层循环并不需要递减到1的位置，只要循环到与i相同就可以了，因为之前的位置一定都比它小（也就是第i小）。另外里层循环是j>i，而不是j>=i，这是因为i在进入循环之后就被立即保存到了lowestIndex中。

算法实现(C#)

public static void SelectionSort<T, C>(T[] array, C comparer)
    where C : IComparer<T>
{
    int length = array.Length;
    for (int i = 0; i <= length - 2; i++) {
        Console.Write("{0}: ", i+1);
        int lowestIndex = i;        // 最小记录的数组索引
        for (int j = length - 1; j > i; j--) {
            if (comparer.Compare(array[j], array[lowestIndex]) < 0)
                lowestIndex = j;
        }
        swap(ref array[i], ref array[lowestIndex]);
        AlgorithmHelper.PrintArray(array);
    }
}

输出演示(C#)

static void Main(string[] args) {
    int[] array = {42,20,17,13,28,14,23,15};
    AlgorithmHelper.PrintArray(array);

SortAlgorithm.SelectionSort
        (array, ComparerFactory.GetIntComparer());
}

算法实现(C++)

// 选择排序
template <class T, class C>
void SelectionSort(T a[], int length) {
    for(int i = 0; i <= length-2; i++){
        int lowestIndex = i;
        for(int j = length-1; j>i; j--){
            if(C::Smaller(a[j], a[lowestIndex]))
                lowestIndex = j;
        }
        swap(a[i], a[lowestIndex]);
    }
}

4.希尔排序

希尔排序利用了插入排序的一个特点来优化排序算法，插入排序的这个特点就是：当数组基本有序的时候，插入排序的效率比较高。比如对于下面这样一个数组：

int[] array = { 1, 0, 2, 3, 5, 4, 8, 6, 7, 9 };

插入排序的输出如下：

可以看到，尽管比较的趟数没有减少，但是交换的次数却明显很少。希尔排序的总体想法就是先让数组基本有序，最后再应用插入排序。具体过程如下：假设有数组int a[] = {42,20,17,13,28,14,23,15}，不失一般性，我们设其长度为length。

第一趟时，步长step = length/2 = 4，将数组分为4组，每组2个记录，则下标分别为(0,4)(1,5)(2,6)(3,7)；转换为数值，则为{42,28}, {20,14}, {17,23}, {13,15}。然后对每个分组进行插入排序，之后分组数值为{28,42}, {14,20}, {17,23}, {13,15}，而实际的原数组的值就变成了{28,14,17,13,42,20,23,15}。这里要注意的是分组中记录在原数组中的位置，以第2个 分组{14,20}来说，它的下标是(1,5)，所以这两个记录在原数组的下标分别为a[1]=14;a[5]=20。

第二趟时，步长 step = step/2 = 2，将数组分为2组，每组4个记录，则下标分别为(0,2,4,6)(1,3,5,7)；转换为数值，则为{28,17,42,23}, {14,13,20,15}，然后对每个分组进行插入排序，得到{17,23,28,42}{13,14,15,20}。此时数组就成了 {17,13,23,14,28,15,42,20}，已经基本有序。

第三趟时，步长 step=step/2 = 1，此时相当进行一次完整的插入排序，得到最终结果{13,14,15,17,20,23,28,42}。

算法实现(C#)

// 希尔排序
public static void ShellSort<T, C>(T[] array, C comparer)
    where C : IComparer<T>
{
    for (int i = array.Length / 2; i >= 1; i = i / 2) {
        Console.Write("{0}: ", i);
        for (int j = 0; j < i; j++) {
            InsertSort(array, j, i, comparer);
        }
        Console.WriteLine();
        AlgorithmHelper.PrintArray(array);
    }
}

// 用于希尔排序的插入排序
private static void InsertSort<T, C>
    (T[] array, int startIndex, int step, C comparer)
    where C : IComparer<T>
{
    for (int i = startIndex + step; i <= array.Length - 1; i += step) {
        int j = i;
        while(j>= step && comparer.Compare(array[j], array[j - step]) <0 ){
            swap(ref array[j], ref array[j - step]);
            j -= step;
        }
    }
}

注意这里插入排序InsertSort()方法的参数，startIndex是分组的起始索引，step是步长，可以看出，前面的插入排序只是此处step=1,startindex=0的一个特例。

输出演示(C#)

static void Main(string[] args) {
    int[] array = {42,20,17,13,28,14,23,15};
    AlgorithmHelper.PrintArray(array);

SortAlgorithm.ShellSort
        (array, ComparerFactory.GetIntComparer());
}

算法实现(C++)

// 希尔排序
template<class T, class C>
void ShellSort(T a[], int length){
    for(int i = length/2; i >= 1; i = i/2 ){
        for(int j = 0; j<i; j++){
            InsertSort<T, C>(&a[j], length-1, i);
        }
    }
}

// 用于希尔排序的插入排序
template<class T, class C>
void InsertSort(T a[], int length, int step){
    for(int i = step; i<length; i+= step){
        int j = i;
        while(j>=step && C::Smaller(a[j], a[j-step])){
            swap(a[j], a[j-step]);
            j-=step;
        }
    }
}

对于上面三种算法的代价，插入排序、冒泡排序、选择排序，都是Θ(n²)，而希尔排序略好一些，是Θ（n^1.5），关于算法分析，大家感兴趣可以参考相关书籍。这里推荐《数据结构与算法分析(C++版)第二版》和《算法I~IV（C++实现）——基础、数据结构、排序和搜索》，都很不错，我主要也是参考这两本书。

感谢阅读，希望这篇文章可以给你带来帮助

引言

最近花了一些时间，将微软Asp.Net官方的Ajax视频全部看了一遍，地址是http://www.asp.net/learn/ajax-videos/，视频大多都很短，8至15分钟的居多，有讲述AjaxControlToolkit中控件用法的，也有讲述Asp.Net Ajax常见的应用场景和技巧的。

本文介绍了使用Asp.Net Ajax做开发时两种最常见的与服务端进行交互（客户端请求服务端执行逻辑，服务端返回结果）的开发模式。第一种我姑且称为UpdatePanel模式，第二种称为Web Service（WCF Service）模式。

开始前的一些准备

对于这些文章，我假设大家都已经安装好了Asp.Net Ajax Extension 和 Asp.Net Ajax Control ToolKit 这两个组件。其中Asp.Net Ajax Extension已经包含在了.Net Framework 3.5中，而Ajax Control Toolkit可以去这个位置下载：http://www.codeplex.com/AjaxControlToolkit/Release/ProjectReleases.aspx?ReleaseId=16488 。因为我使用的是VS2008，所以Ajax Extension无需安装，而Ajax Control Toolkit我安装到了GAC（Global Assembly Cache，全局程序集缓存）中，因此文章所附代码的Bin目录不会包含任何的dll组件。如果你想运行代码，可以像我一样将Ajax Control Toolkit安装到GAC中，或者针对自己的情况（VS2005或者VS2008，私有程序集部署还是GAC部署）对代码进行一些简单的修改和配置。

如果你想安装到GAC中，假设你将AjaxControlToolkit.dll拷贝到了“C:\”下，那么可以打开“VS2008命令提示符”，然后输入下面的命令，按回车：

gacutil -i C:\AjaxControlToolkit.dll

除此以外，还有两点需想要说明。如果你想要在页面的CodeBehind中使用AjaxControlToolkit中定义的类型，那么需要在Web.config中进行一下配置，假设你和我一样采用的是GAC部署，那么Web.Config的设置为：

<system.web>
    <compilation debug="false">
        <assemblies>
            <add assembly="AjaxControlToolkit, Version=3.0.20820.37372, Culture=neutral, PublicKeyToken=28F01B0E84B6D53E"/>
            <!- 其余略 -->
    </compilation>
</system.web>

在VS2008(VS2005)中，你可以将AjaxControlToolkit安装到工具箱（Toolbox）中，但是在安装好以后，当你向页面拖放一个控件时，控件默认的前缀是cc1，并且会在页面顶部自动生成一行控件的声明，类似于这样：

// 自动在页面顶部产生的声明
<%@ Register Assembly="AjaxControlToolkit, Version=3.0.20820.37372, Culture=neutral, PublicKeyToken=28f01b0e84b6d53e" Namespace="AjaxControlToolkit" TagPrefix="cc1" %>
// 页面中控件的样式
<cc1:AutoCompleteExtender> ... </cc1:AutoCompleteExtender>

这样让人感觉页面很不清爽，除此以外，cc1也没有任何的含义。为了解决这个问题，我们也可以在Web.Config进行一下设置：

<system.web>
    <pages>
        <controls>
            <add assembly="AjaxControlToolkit, Version=3.0.20820.37372, Culture=neutral, PublicKeyToken=28f01b0e84b6d53e" namespace="AjaxControlToolkit" tagPrefix="ajaxControlToolkit" />
            <!-- 其余略 -->
        </controls>
    </pages>
<system.web>

如果你和我一样经过上面三个步骤的设置的话，那么在Web站点Bin目录中不会有任何的程序集，另外页面顶部也不会再有控件的声明，同时，拖放控件到页面中时，它的代码将是这样子的：

<ajaxControlToolkit:AutoCompleteExtender> ... </ ajaxControlToolkit:AutoCompleteExtender>

本文以及所有Asp.Net Ajax相关的文章，都假设你采用了和我相同的配置。

Asp.Net Ajax - UpdatePanel模式

现在考虑一个最简单的范例，页面上放置一个Label控件、一个Button控件，当我们点击Button控件的时候，将Label控件的文本更新 为当前时间，这里的关键是更新时间的代码位于服务端，而非使用Javascript在客户端来完成。尽管这里服务端的代码仅仅是更新一下时间，但在实际中 却可以执行任何的服务端操作。

UpdatePanel是是大家熟悉的一种方式了，即是在页面拖放一个UpdatePanel，将需要用Ajax方式进行更新的控件放在 UpdatePanel之内，在本例中是Label控件。可以将Button控件也放置在UpdatePanel之内，也可以不放置。如果 UpdatePanel内不放置Button控件，则需要设置UpdatePanel的Triggers节点，其中包括一个ControlID属性和 EventName属性，用于指定哪个控件的哪个事件可以触发了一个PostBack。本例中ControlID自然是Button的ID，而 EventName则为Click。也就是说当Button的Click事件触发时，进行PostBack操作。下面是aspx页面的主要代码：

<asp:ScriptManager ID="ScriptManager1" runat="server">
 </asp:ScriptManager>

当前时间：
 <asp:UpdatePanel ID="UpdatePanel1" runat="server">
     <ContentTemplate>
         <asp:Label ID="Label1" runat="server" Text="[未设置]"></asp:Label>
     </ContentTemplate>
    <Triggers>
        <asp:AsyncPostBackTrigger ControlID="Button1" EventName="Click" />
     </Triggers>
 </asp:UpdatePanel>
 <br />
 <asp:Button ID="Button1" runat="server" οnclick="Button1_Click" Text="更新时间" />

而在后置代码中，我们只需要像平常的Asp.Net开发一样，编写Button控件的Click事件处理程序就可以了：

protected void Button1_Click(object sender, EventArgs e) {
     Label1.Text = DateTime.Now.ToLongTimeString();
 }

OK，现在一切都已经就绪了，如果你运行这个页面，并且点击Button，会看到Label的值变为了最新的时间，而且没有因为PostBack所产生的页面闪动，即是人们常说的无刷新更新页面。 这可能是实现一个Asp.Net Ajax的最简单范例了。但是它的问题是什么呢？当我们点击Button的时候，在服务端执行了一个完整的Asp.Net 页面生命周期，和你不使用UpdatePanel更新页面没有任何的区别。可以做一个测试，在页面在拖放一个Label，ID为Label2，然后在 Page_Load中写入下面代码：

protected void Page_Load(object sender, EventArgs e) {
    if (!IsPostBack) {
        Label2.Text = DateTime.Now.ToLongTimeString();
    } else {
        Label2.Text = DateTime.Now.ToLongTimeString();
    }
}

然后在Page_Load一行设置断点，接下来运行调试，会发现每次你点击Button按钮的时候，都会运行else{...}中的语句，说明每次页面都会执行Page_Load方法。这说明使用这种方式时，服务器端的开销是比较大的。这 里还可以发现一个有趣的现象，尽管服务器执行了为Label2.Text赋值的语句，但是页面上Label2却并没有更新。如果想要更新它，那么需要将它 也放置到UpdatePanel中，这里我们可以在页面上重新拖放一个UpdatePanel，然后把Label2放置进去。然后我们再点击 Button，会发现Label1和Label2都进行了更新。这里又引出了一个有趣的问题：回想一下前面，我们只为第一个UpdatePanel设置了Triggers节点，而并没有为后来新添的UpdatePanel设置Triggers节点，但是对一个UpdatePanel的更新也会影响到另一个。 有的时候这种情况是我们所需要的，但更多时候不是，我们可能希望对于Label2的更新由其他控件的其他事件触发。此时，可以将第二个 UpdatePanel的UpdateMode属性设为“Conditional”，就避免了受到其他UpdatePanel提交的影响，这个值默认为 “Always”。

下面是此时Aspx页面的代码：

<!-- 上面相同 -->
<hr /><br />
<asp:UpdatePanel ID="UpdatePanel2" runat="server" UpdateMode="Conditional">
 <ContentTemplate>
     <asp:Label ID="Label2" runat="server" Text="[未设置]"></asp:Label>
 </ContentTemplate>
</asp:UpdatePanel>

以上这些就是一种最常见的Asp.Net Ajax开发模式了，我们看到它如何实现，也看到了它的缺陷：每次客户端的操作，都会在服务端执行一次完整的页面生命周期，加重了服务器的负担，同时客户端和服务端的通信过程中也会传递完整的http协议内容，增大了网络流量。我们也应该看到它的优点：实现起来非常的简单，操作上基本等同于通常的Asp.Net开发，所使用的控件也为Asp.Net服务器控件（Server Control，这里相对于HTML控件而言）。

Asp.Net Ajax - Web Service模式

还有一种方式就是Web Service模式了，客户端不再提交页面，而只是发送Web Service请求，并对收到应答进行处理。由于这里采用了异步方式，所以客户端在发送WebService请求之后无需等待。采用这种方式服务端不会执 行生命周期，往返的数据量也减到了最小。但缺点就是需要手动编写一些代码。我们来一步步看下如何完成，因为WCF是下一代Windows平台通信的基础， 集成了Web Service和Remoting这两大技术，所以我们采用WCF来创建服务。

首先选择“添加新项”，然后选择“启用了AJAX的WCF服务”，输入名称SimpleService，这样会在站点中添加一个 SimpleService.svc文件，在App_Code中创建一个SimpleService.cs，还会在Web.Config中添加相关的配 置。我们只需要改动一下App_Code中的SimpleService.cs下的代码：

public class SimpleService
{
    [OperationContract]
    public string GetCurrentDate(string clientValue) {
        string rtn = "Server Time :" + DateTime.Now.ToLongTimeString() + "<br />";
        rtn += "Client Value(round trip): " + clientValue;
        return rtn;
    }
}

SimpleService还用一些特性修饰了，我将它取消掉了以节省空间。方法接受一个字符串clientValue，然后获取服务器时间，最后 返回clientValue。这段代码看上去没有什么特别之处，但是注意到我在Client Value旁加了一个括号，写着“round trip”，对于Ajax程序来说，这个值由客户端发送，最后再返还给客户端，进行了一趟由客户端到服务端，再到客户端的周游。

为了要让javascript可以调用这个Web服务，我们需要在aspx页面中对它进行注册，拖放也一个ScriptManager到页面上，然后向下面这样进行设置：

<asp:ScriptManager ID="ScriptManager1" runat="server">
    <Services>
        <asp:ServiceReference Path="~/SimpleService.svc" />
    </Services>
</asp:ScriptManager>

接下来我们新建一个Pattern2.aspx页面，在上面拖放三个HTML标记。一个span，一个input(Button)，一个 input(Text)。注意，是客户端HTML标记，不含有runat="server"的，从这里已经可以看到一个很大的不同，我们使用的是客户端 HTML控件。接着在input(Button)上双击，会自动生成Javascript脚本，此时aspx页面的主要代码如下：

<input id="txtSample" type="text" style="width:120px" /><br />         
<span id="spnTime">[未设置]</span><br />
<br />
<input id="Button1" type="button" value="更新时间" οnclick="return Button1_onclick()" />

最关键是接下来要编写的javascript代码，我先将它贴出来，然后再进行解释：

<script language="javascript" type="text/javascript">
function Button1_onclick() {
    var context = "Callback Values";                // 传给回调函数
    var clientValue = $get("txtSample").value;      // 获得TextBox的值
    SimpleService.GetCurrentDate(clientValue, OnComplete, OnFailed, context);  
    return true;
}

function OnComplete(args, context){
    alert(context);
    var span = $get("spnTime");
    span.innerHTML = args;
}

function OnFailed(args){
    alert("更新日期失败！");
}
</script>

首先看这个Button1_onclick()方法，我们先声明了一个context，这个content很类似于在C#的委托变量上调用 BeginInvoke()方法时的最后一个参数，这个值用于传递给回调函数，以方便进行一些处理。接着我们获取了input(Text)中输入的值，保 存在了clientValue中。然后调用了Web服务，其中第一个参数就是上面定义的GetCurrentDate()时的参数，我们传入了 clientValue，第二个参数是OnComplete是成功时的回调函数，第三个是OnFailed是失败时的回调函数，最后一个参数我们传递了 context，可以将它交由回调函数处理。因为是异步操作，所以没有在这里获取GetCurrentDate()方法返回值，而是通过回调函数 OnComplete的参数对返回值进行了传递。

接下来看OnComplete()函数，其实我们最需要搞清楚的就是它的两个参数：第一个args即为Web服务方法 GetCurrentDate()的返回值；而第二个参数，即为调用GetCurrentDate()时传递的最后一个参数。在方法内部，我们使用 alert()显示了context的值，随后将Web服务的返回值显示在了span中。OnFailed()仅仅是提示用户更新失败。

接下来在页面上点击Button，应该可以看到下面的效果：

我们再次在Page_Load的位置设置断点，然后启动调试，会发现当我们使用这种方式时，点击Button服务端并没有再次执行页面生命周期，而 参与客户端/服务端往返的数据也是最少量的（仅往返必需数据），因此，虽然采用这种方式我们需要编写一定量的javascript代码，但是却能够显著地 提高站点的性能。

总结

这篇文章简单的讲述了使用Asp.Net Ajax进行开发时常见的两种方式，使用UpdatePanel + 服务器控件；或者是使用 Web Service + HTML标记 + Javascript，并且这两种方式的实现方式和效果做了简要的说明。

感谢阅读，希望这篇文章能给你带来帮助！