关于ado.net entity framework 性能比较网上也有很多，这里我只是初步的介绍下ado.net entity framework使用不同的方法查询数据的不同性能

第一部分：重复查询单个实体

第一种：Linq To Entitiess

代码如下：

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　for　(int　i　=　0;　i　<　1000;　i++)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　(from　c　in　context.Customers　where　c.CustomerID　==　"ALFKI"　select　c).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2-time1).ToString());
　　　　　　　　}

查询使用时间为6.2秒左右

第二种：使用Entity SQL

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　for　(int　i　=　0;　i　<　1000;　i++)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context.Customers.Where("it.CustomerID=@Id",　new　System.Data.Objects.ObjectParameter("Id",　"ALFKI")).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2-time1).ToString());
　　　　　　　　}
查询使用时间为6.2秒左右

第三种：使用EntityKey 来查询

　static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　for　(int　i　=　0;　i　<　1000;　i++)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context.GetObjectByKey(new　System.Data.EntityKey("NorthwindEntities.Customers",　"CustomerID",　"ALFKI"))　as　Customers;
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2-time1).ToString());
　　　　　　　　}

查询使用时间为1秒，没错是一秒

总结：

前两种方法查询所使用的时间都差不多为6.2秒，时间比较长，但是使用第三种方法查询数据仅仅使用了1秒，为什么会相差那么多，区别在于前两种方法每次查询都要从数据库中查找，1000次查询每次的查询时间都一样，但是第三种方法只有第一次是从数据库中查数据，后面的999次都是在context通过主键直接取数据，速度当然会快很多啦，EF4.0之前的实体当含有外键引用时是自动生成对象引用的，而EF4.0现在多了一个外键ID，这样我们可以很方便的通过外键来查询数据

第二部分：查询不同是实体
第一种：Linq To Entitiess

　static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　//先将Customers所有的主键查询出来
　　　　　　　　　　　　List<string>　keys　=　context.Customers.Select(c　=>　c.CustomerID).Distinct().ToList();
　　　　　　　　　　　　//和上面的context以作区别
　　　　　　　　　　　　NorthwindEntities　　context_　=　new　NorthwindEntities();
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　foreach　(var　key　in　keys)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context_.Customers.Where(c　=>　c.CustomerID　==　key).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2　-　time1).ToString());
　　　　　　　　}

查询使用时间0.68秒左右

第二种：使用Entity SQL

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　//先将Customers所有的主键查询出来
　　　　　　　　　　　　List<string>　keys　=　context.Customers.Select(c　=>　c.CustomerID).Distinct().ToList();
　　　　　　　　　　　　//和上面的context以作区别
　　　　　　　　　　　　NorthwindEntities　　context_　=　new　NorthwindEntities();
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　foreach　(var　key　in　keys)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context_.Customers.Where("it.CustomerID=@Id",　new　System.Data.Objects.ObjectParameter("Id",　key)).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2　-　time1).ToString());
　　　　　　　　}

查询使用时间0.5秒左右

第三种：使用EntityKey 来查询

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　//先将Customers所有的主键查询出来
　　　　　　　　　　　　List<string>　keys　=　context.Customers.Select(c　=>　c.CustomerID).Distinct().ToList();
　　　　　　　　　　　　//和上面的context以作区别
　　　　　　　　　　　　NorthwindEntities　　context_　=　new　NorthwindEntities();
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　foreach　(var　key　in　keys)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context_.GetObjectByKey(new　System.Data.EntityKey("NorthwindEntities.Customers",　"CustomerID",　key))　as　Customers;
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2　-　time1).ToString());
　　　　　　　　}

查询时间为0.18秒左右

总结：

通过比较第三种方法仍然比前两种来的快，查询效率更高

使用EntityKey来查询数据比其他两种方法来的更快，而且不是快一点点，而是相差有好几倍，这里的比较并没有使用存储过程来比较查询，但是从这里我们可以看出，在平常的应用中如果知道实体的主键尽量用主键来查询

  /**//// <summary>
    /// 外包业务访问类
    /// </summary>
    public class OutSourcingDAO
    {

        /**//// <summary>
        /// 增加
        /// </summary>
        /// <param name="bt"></param>
        /// <returns></returns>
        public int InsertGetIdentity(OutSourcing bt)
        {
            return new DAHelper(DataAccess.Create()).InsertGetIdentity(bt);
        }
        /**//// <summary>
        /// 更新
        /// </summary>
        /// <param name="bt"></param>
        /// <returns></returns>
        public int Update(OutSourcing bt)
        {
            return new DAHelper(DataAccess.Create()).Update(bt);
        }
        /**//// <summary>
        /// 删除
        /// </summary>
        /// <param name="bt"></param>
        /// <returns></returns>
        public int Delete(OutSourcing bt)
        {
            return new DAHelper(DataAccess.Create()).Delete(bt);
        }
    }
上面 OutSourcing 为与表相对应的实体类 ；DAHelper 为作者自己实现的一个包装类，可以对任意实体进行增加，修改，删除 查询等功能。
  再贴一段代码：

   public int ExecSql(string strSql)
        {
            try
            {
                this.OpenConnection();
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = strSql;
             
               return cmd.ExecuteNonQuery();
            }
            catch (System.Exception e)
            {
                throw this.CatchException(e);
            }
            finally
            {
                this.CloseConnection();
            }
        }
我最终通过调用 ExecSql  方法来与数据库交互，而该方法会自己打开数据库连接，执行语句，然后关闭连接。
在操作同一个数据库的时候，如果要高效的使用 TransactionScope，必须保证 SqlConnection 不改变，即用同一个 SqlConnection 来完成所需要的增加
删除，或修改。我想写这样的代码进行事务控制：

 public int UpdateTest(OutSourcing outSourcing, BusinessAccept businessAccept)
        {
            IDataAccess dac = DataAccess.Create();
            DAHelper myHelper = new DAHelper(dac);
            using (TransactionScope ts = new TransactionScope())
            {
                myHelper.Update(outSourcing);
                myHelper.Update(businessAccept);
               
                ts.Complete();
            }
        }
这样就需要，执行第一个操作时候打开数据库连接，执行，不关闭连接，然后执行第二个操作，执行完关闭。显然，我想让 TransactionScope 在
实行 Dispose() 方法的时候关闭数据库连接。using 代码块的本质上等同于 try{}finally{} 语句代码块。为什么不封装一下 TransactionScope 让它满足自己的要求呢？

/**//// <summary>
/// TransactionScope 包装类
/// </summary>
public sealed class Scope : IDisposable
{
    private TransactionScope m_TransactionScope = null;
    /**//// <summary>
    ///  测试访问类
    /// </summary>
    private DataAccessTest m_DataAccessTest = null;
    /**//// <summary>
    /// 实例化一个新的 TransactionScope
    /// </summary>
    /// <param name="dac"></param>
    public Scope(DataAccessTest dac)
    {
        this.m_DataAccessTest = dac;
        //告诉访问类 你已经使用了事务
        dac.SetScope(this);
        this.m_TransactionScope = new TransactionScope();

    }
    /**//// <summary>
    /// 发出事务结束命令
    /// </summary>
    public void Complete()
    {
        this.m_TransactionScope.Complete();
    }
    IDisposable 成员#region IDisposable 成员
    /**//// <summary>
    /// 当执行该方法的时候完成两件任务
    /// 1 关闭数据库连接
    /// 2 调用 TransactionScope 的 Dispose()方法
    /// </summary>
    void IDisposable.Dispose()
    {
        try
        {
            m_DataAccessTest.Close();
        }
        finally
        {
            m_TransactionScope.Dispose();
        }
    }

    #endregion
}

数据库访问类代码如下：

/**//// <summary>
/// 模拟数据库访问类
/// </summary>
public class DataAccessTest
{
    SqlConnection con = null;
    SqlCommand cmd = new SqlCommand();
    Scope scope = null;
    string strCon = "这里是数据库连接字符串。。。。。";

    public void SetScope(Scope scope)
    {
        this.scope = scope;
    }
    private void OpenConnection()
    {

        if (con == null || scope == null)
        {
            con = new SqlConnection(strCon);
            cmd.Connection = con;
            con.Open();
            Console.WriteLine(" 打开数据库连接;");
        }
    }

    private void CloseConnection()
    {
        this.cmd.Parameters.Clear();
        if (scope == null)
        {
            //
            con.Close();
            con.Dispose();
            Console.WriteLine(" 未使用事务 关闭数据库连接;");
        }
    }

    public int ExecuteSql(string strSql)
    {
        try
        {
            this.OpenConnection();
            cmd.CommandType = CommandType.Text;
            cmd.CommandText = strSql;
            Console.WriteLine("执行 Sql 语句。。。");

            return cmd.ExecuteNonQuery();
        }
        catch (System.Exception e)
        {
            throw e;
        }
        finally
        {
            this.CloseConnection();
        }
    }
 
    public void Close()
    {
        con.Close();
        con.Dispose();
        Console.WriteLine(" 关闭数据库连接->该方法由 Scope中的Dispose()方法调用 ");
    }
}
赶快写个方法测试一下吧！

   /**//// <summary>
        /// 测试
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                Console.WriteLine("下面是使用事务的输出。。。。。。。。");
                this.TestACT();
                Console.WriteLine("*********************下面是  未  使用事务的输出。。。。。。。。");
                this.TestNoACT();
            }
            catch (System.Exception ex)
            {
                Console.WriteLine("出现了异常？？？？？？？？？？？？");
                MessageBox.Show(ex.ToString());
            }

        }
        /**//// <summary>
        /// 使用事务
        /// </summary>
        public void TestACT()
        {
            DataAccessTest dac = new DataAccessTest();
            using (Scope scope = new Scope(dac))
            {
                string strSql1 = "INSERT INTO [tilva20].[dbo].[T_Test]([TestName])VALUES('a')";
                string strSql2 = "INSERT INTO [tilva20].[dbo].[T_Test]([TestName])VALUES('b')";
                dac.ExecuteSql(strSql1);
                dac.ExecuteSql(strSql2);

                scope.Complete();
            }
        }
        /**//// <summary>
        /// 不使用事务
        /// </summary>
        public void TestNoACT()
        {
                DataAccessTest dac = new DataAccessTest();
        
                string strSql1 = "INSERT INTO [tilva20].[dbo].[T_Test]([TestName])VALUES('a')";
                string strSql2 = "INSERT INTO [tilva20].[dbo].[T_Test]([TestName])VALUES('b')";
                dac.ExecuteSql(strSql1);
                dac.ExecuteSql(strSql2);
        }

查看一下输入的结果
下面是使用事务的输出。。。。。。。。
 打开数据库连接;
执行 Sql 语句。。。
执行 Sql 语句。。。
 关闭数据库连接->该方法由 Scope中的Dispose()方法调用
*********************下面是  未  使用事务的输出。。。。。。。。
 打开数据库连接;
执行 Sql 语句。。。
 未使用事务 关闭数据库连接;
 打开数据库连接;
执行 Sql 语句。。。
 未使用事务 关闭数据库连接;

输出结果和想像中的完全一样 数据库也正确（没任何原因不正确！）
最后 改变一下方法：

   /**//// <summary>
        /// 使用事务
        /// </summary>
        public void TestACT()
        {
            DataAccessTest dac = new DataAccessTest();
            using (Scope scope = new Scope(dac))
            {
                string strSql1 = "INSERT INTO [tilva20].[dbo].[T_Test]([TestName])VALUES('a')";
                string strSql2 = "INSERT INTO [tilva20].[dbo].[T_Test]([TestName])VALUES('b22222222222222222222222222222222222222222222222222222222222222222222222222222222222222')";
                dac.ExecuteSql(strSql1);
                dac.ExecuteSql(strSql2);

                scope.Complete();
            }
        }
熟悉数据库的肯定知道 “将截断字符串或二进制数据”吧！
输出结果为：
 下面是使用事务的输出。。。。。。。。
 打开数据库连接;
执行 Sql 语句。。。
执行 Sql 语句。。。
 关闭数据库连接->该方法由 Scope中的Dispose()方法调用
出现了异常？？？？？？？？？？？？
数据库一条记录没有增加 数据库连接已经关闭  测试结果完全满意！
对自己访问层稍做修改：
最终的代码为：

   public int UpdateTest(OutSourcing outSourcing, BusinessAccept businessAccept)
        {
            IDataAccess dac = DataAccess.Create();
            DAHelper myHelper = new DAHelper(dac);
            using (Scope ts=new Scope())
            {
                myHelper.Update(outSourcing);
                myHelper.Update(businessAccept);
               
                ts.Complete();
            }
        }

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/logicbiz/archive/2008/04/23/2317712.aspx

worksheetGrid.Shapes.AddPicture(PicturePath,
Microsoft.Office.Core.MsoTriState.msoFalse, Microsoft.Office.Core.MsoTriState.msoTrue,
picLeft, picTop, 155, 155);
MS要将OFFICE11的参考加入.才能引用的

调用方法：

<!--StartFragment-->MengXianhui.Utility.ExcelReport.InsertPictureToExcel ipt = new MengXianhui.Utility.ExcelReport.InsertPictureToExcel(); ipt.Open(); ipt.InsertPicture("B2", @"C:\Excellogo.gif"); ipt.InsertPicture("B8", @"C:\Excellogo.gif",120,80); ipt.SaveFile(@"C:\ExcelTest.xls"); ipt.Dispose();

<!--StartFragment-->using System; using System.Windows.Forms; using Excel = Microsoft.Office.Interop.Excel; namespace MengXianhui.Utility.ExcelReport {   class InsertPictureToExcel   {     /// <summary>     /// 打开没有模板的操作。     /// </summary>     public void Open( )     {       this.Open(String.Empty);     }     /// <summary>     /// 功能：实现Excel应用程序的打开     /// </summary>     /// <param name="TemplateFilePath">模板文件物理路径</param>     public void Open( string TemplateFilePath )     {       //打开对象       m_objExcel = new Excel.Application();       m_objExcel.Visible = false;       m_objExcel.DisplayAlerts = false;       if (m_objExcel.Version != "11.0")       {         MessageBox.Show("您的 Excel 版本不是 11.0 （Office 2003），操作可能会出现问题。");         m_objExcel.Quit();         return;       }       m_objBooks = (Excel.Workbooks)m_objExcel.Workbooks;       if (TemplateFilePath.Equals(String.Empty))       {         m_objBook = (Excel._Workbook)(m_objBooks.Add(m_objOpt));       }       else       {         m_objBook = m_objBooks.Open(TemplateFilePath, m_objOpt, m_objOpt, m_objOpt, m_objOpt,           m_objOpt, m_objOpt, m_objOpt, m_objOpt, m_objOpt, m_objOpt, m_objOpt, m_objOpt, m_objOpt, m_objOpt);       }       m_objSheets = (Excel.Sheets)m_objBook.Worksheets;       m_objSheet = (Excel._Worksheet)(m_objSheets.get_Item(1));       m_objExcel.WorkbookBeforeClose += new Excel.AppEvents_WorkbookBeforeCloseEventHandler(m_objExcel_WorkbookBeforeClose);     }     private void m_objExcel_WorkbookBeforeClose( Excel.Workbook m_objBooks, ref bool _Cancel )     {       MessageBox.Show("保存完毕！");     }     /// <summary>     /// 将图片插入到指定的单元格位置。     /// 注意：图片必须是绝对物理路径     /// </summary>     /// <param name="RangeName">单元格名称，例如：B4</param>     /// <param name="PicturePath">要插入图片的绝对路径。</param>     public void InsertPicture( string RangeName, string PicturePath )     {       m_objRange = m_objSheet.get_Range(RangeName, m_objOpt);       m_objRange.Select();       Excel.Pictures pics = (Excel.Pictures)m_objSheet.Pictures(m_objOpt);       pics.Insert(PicturePath, m_objOpt);     }     /// <summary>     /// 将图片插入到指定的单元格位置，并设置图片的宽度和高度。     /// 注意：图片必须是绝对物理路径     /// </summary>     /// <param name="RangeName">单元格名称，例如：B4</param>     /// <param name="PicturePath">要插入图片的绝对路径。</param>     /// <param name="PictuteWidth">插入后，图片在Excel中显示的宽度。</param>     /// <param name="PictureHeight">插入后，图片在Excel中显示的高度。</param>     public void InsertPicture( string RangeName, string PicturePath, float PictuteWidth, float PictureHeight )     {       m_objRange = m_objSheet.get_Range(RangeName, m_objOpt);       m_objRange.Select();       float PicLeft, PicTop;       PicLeft = Convert.ToSingle(m_objRange.Left);       PicTop = Convert.ToSingle(m_objRange.Top);       //参数含义：       //图片路径       //是否链接到文件       //图片插入时是否随文档一起保存       //图片在文档中的坐标位置（单位：points）       //图片显示的宽度和高度（单位：points）       //参数详细信息参见：http://msdn2.microsoft.com/zh-cn/library/aa221765(office.11).aspx       m_objSheet.Shapes.AddPicture(PicturePath, Microsoft.Office.Core.MsoTriState.msoFalse,         Microsoft.Office.Core.MsoTriState.msoTrue, PicLeft, PicTop, PictuteWidth, PictureHeight);     }     /// <summary>     /// 将Excel文件保存到指定的目录，目录必须事先存在，文件名称不一定要存在。     /// </summary>     /// <param name="OutputFilePath">要保存成的文件的全路径。</param>     public void SaveFile( string OutputFilePath )     {       m_objBook.SaveAs(OutputFilePath, m_objOpt, m_objOpt,         m_objOpt, m_objOpt, m_objOpt, Excel.XlSaveAsAccessMode.xlNoChange,         m_objOpt, m_objOpt, m_objOpt, m_objOpt, m_objOpt);       this.Close();     }     /// <summary>     /// 关闭应用程序     /// </summary>     private void Close( )     {       m_objBook.Close(false, m_objOpt, m_objOpt);       m_objExcel.Quit();     }     /// <summary>     /// 释放所引用的COM对象。注意：这个过程一定要执行。     /// </summary>     public void Dispose( )     {       ReleaseObj(m_objSheets);       ReleaseObj(m_objBook);       ReleaseObj(m_objBooks);       ReleaseObj(m_objExcel);       System.GC.Collect();       System.GC.WaitForPendingFinalizers();     }     /// <summary>     /// 释放对象，内部调用     /// </summary>     /// <param name="o"></param>     private void ReleaseObj( object o )     {       try       {         System.Runtime.InteropServices.Marshal.ReleaseComObject(o);       }       catch { }       finally { o = null; }     }     private Excel.Application m_objExcel = null;     private Excel.Workbooks m_objBooks = null;     private Excel._Workbook m_objBook = null;     private Excel.Sheets m_objSheets = null;     private Excel._Worksheet m_objSheet = null;     private Excel.Range m_objRange = null;     private object m_objOpt = System.Reflection.Missing.Value;   } }

Introduction

Generating Excel files from web pages or other applications is a major subject in many articles. I'd like to present here a solution that does not require MS Excel to be installed on the target computer. This article shows how to create Microsoft Excel Binary Interchange File Format (BIFF) without using Microsoft Excel. BIFF is the native file format for Excel data, and can be viewed and modified in Microsoft Excel 97 or later.

Approaches and problems

The technique that is most frequently used to transfer data to an Excel workbooks is Automation. With Automation, you can call methods and properties that are specific to Excel tasks, but this solution has many drawbacks. Some of them are described in the Microsoft Knowledge Base. Additionally, you have to manage the lifetime of the temporary XLS files created on the server. Also, it is slow, because Excel runs in a separate process.

ExcelWriter class

The solution presented here is to write directly to a stream in Excel binary file format. For this purpose, I created very small C# class called ExcelWriter.

Collapse Copy Code

/// <summary>
/// Produces Excel file without using Excel
/// </summary>
public class ExcelWriter
{
private Stream stream;
private BinaryWriter writer;
private ushort[] clBegin = { 0x0809, 8, 0, 0x10, 0, 0 };
private ushort[] clEnd = { 0x0A, 00 };
private void WriteUshortArray(ushort[] value)
{
for (int i = 0; i < value.Length; i++)
writer.Write(value[i]);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExcelWriter"/> class.
/// </summary>
/// <param name="stream">The stream.</param>
public ExcelWriter(Stream stream)
{
this.stream = stream;
writer = new BinaryWriter(stream);
}
/// <summary>
/// Writes the text cell value.
/// </summary>
/// <param name="row">The row.</param>
/// <param name="col">The col.</param>
/// <param name="value">The string value.</param>
public void WriteCell(int row, int col, string value)
{
ushort[] clData = { 0x0204, 0, 0, 0, 0, 0 };
int iLen = value.Length;
byte[] plainText = Encoding.ASCII.GetBytes(value);
clData[1] = (ushort)(8 + iLen);
clData[2] = (ushort)row;
clData[3] = (ushort)col;
clData[5] = (ushort)iLen;
WriteUshortArray(clData);
writer.Write(plainText);
}
/// <summary>
/// Writes the integer cell value.
/// </summary>
/// <param name="row">The row number.</param>
/// <param name="col">The column number.</param>
/// <param name="value">The value.</param>
public void WriteCell(int row, int col, int value)
{
ushort[] clData = { 0x027E, 10, 0, 0, 0 };
clData[2] = (ushort)row;
clData[3] = (ushort)col;
WriteUshortArray(clData);
int iValue = (value << 2) | 2;
writer.Write(iValue);
}
/// <summary>
/// Writes the double cell value.
/// </summary>
/// <param name="row">The row number.</param>
/// <param name="col">The column number.</param>
/// <param name="value">The value.</param>
public void WriteCell(int row, int col, double value)
{
ushort[] clData = { 0x0203, 14, 0, 0, 0 };
clData[2] = (ushort)row;
clData[3] = (ushort)col;
WriteUshortArray(clData);
writer.Write(value);
}
/// <summary>
/// Writes the empty cell.
/// </summary>
/// <param name="row">The row number.</param>
/// <param name="col">The column number.</param>
public void WriteCell(int row, int col)
{
ushort[] clData = { 0x0201, 6, 0, 0, 0x17 };
clData[2] = (ushort)row;
clData[3] = (ushort)col;
WriteUshortArray(clData);
}
/// <summary>
/// Must be called once for creating XLS file header
/// </summary>
public void BeginWrite()
{
WriteUshortArray(clBegin);
}
/// <summary>
/// Ends the writing operation, but do not close the stream
/// </summary>
public void EndWrite()
{
WriteUshortArray(clEnd);
writer.Flush();
}
}

Using the code

The ExcelWriter sample is a console application that writes an XLS file to the name and location specified. The XLS file that is created is simply an empty spreadsheet. Then, you can start to write cell values by calling the WriteCell method with the row number, column number, and a cell value as parameters:

Collapse Copy Code

namespace XLSExportDemo
{
class Program
{
static void Main(string[] args)
{
FileStream stream = new FileStream("demo.xls", FileMode.OpenOrCreate);
ExcelWriter writer = new ExcelWriter(stream);
writer.BeginWrite();
writer.WriteCell(0, 0, "ExcelWriter Demo");
writer.WriteCell(1, 0, "int");
writer.WriteCell(1, 1, 10);
writer.WriteCell(2, 0, "double");
writer.WriteCell(2, 1, 1.5);
writer.WriteCell(3, 0, "empty");
writer.WriteCell(3, 1);
writer.EndWrite();
stream.Close();
}
}
}

The picture below shows the final result of this sample:

The ExcelWriter class supports numeric and text values for the cells, and can be used for exporting data from the database to an XLS file, or for producing an XLS stream from a website on the fly.

I hope this article gives you a head start in working with Excel files from .NET and C#.

History

}

需要刷新判断功能时新页面只需继承该类就可,通过引用属性IsPageRefreshed识别"为真表示刷新,假则是正常提交",将数据库的操作写在
if(!IsPageRefreshed)
{
   数据库操作
}
即可,如果是刷新不会执行,代码中注释部分使用的是Session方式保存票证,因为session比较容易丢失且占内存,所以使用cookie,

摘要：代码生成器是您日常生活中的一部分，即使您没有意识到这一点。Pierre Couzy 说明了如何在项目中利用它们。

本页内容

简介
工具和示例
版本控制
小结

简介

假设您在一家由 DBA 统治一切的公司里工作：您不能生成只是“到 Oracle 那里去取一些记录”的应用程序。您只能依靠存储过程，因为在该级别存在安全层。

生成应用程序通常涉及到下列步骤：

1. 创建一批存储过程。

2. 创建能够与存储过程通信的 C# 类。

3. 创建将管理 Microsoft ASP.NET 表单或 Microsoft Windows 窗体或者形成另一个层的更高级别的类。

步骤 1 和步骤 2 是密切相关的：它们共享大量结构，它们消耗另一个步骤所产生的东西，等等。问题在于，您拥有两种不同的语言（在该示例中，为 PL-SQL 和 C#），并且无法从其中一种语言引用另一种语言。

您说这没有什么大不了的？团队中的第一个开发人员将使一切保持正常，因为他了解 .NET、PL/SQL 以及安全模型的本质。他可能将编写两个东西：首先是一组帮助器类，然后是一个有效的示例 — 于是，其他开发人员将使用这些帮助器类，复制/粘贴有效示例，并针对他们的需要进行修改。

如果您已经在软件行业中工作了足够长的时间，就会知道接下来将会发生什么事情：随着要求的增加，帮助器类将慢慢变大，并且其中一些将很快过时。当然，没有人敢于修改它们，因为这可能会毁坏较旧的项目。同时，开发人员将重用不再与新规则同步的有效示例，并且他们将没有办法了解哪些部分仍在使用，以及哪些部分可以毫无风险地丢弃。您将陷入一片混乱之中（复制/粘贴编程）。

有很多克服这一复杂性的办法，而我将介绍您可能已经忽视的一种有用的办法 — 代码生成器。其实您已经使用了它们，即使您没有意识到这一点：每当您创建一个新的 ASPX 页时，隐藏机制就会将它转换为 C# 或 Microsoft Visual Basic 类。当您在项目中引用 COM 组件、Web 服务甚至数据结构（类型化数据集）时，会发生相同的事情 — 有一个类被自动生成，它隐藏了您不希望了解的复杂性。

返回页首

工具和示例

您将遇到的第一批代码生成器只是一些隐藏复杂性的工具。它们不允许您解释如何生成代码，并且不让您随后更改生成的代码（它们将清除您进行的更新）。

例如，“Add Web Reference Wizard”甚至不向您显示插入到项目中的代码（除非您请求它显示）。

Windows 窗体设计器也是一个代码生成器。在这里，您可以查看代码，但最好不要动它。

     #region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.button1 = new System.Windows.Forms.Button();
this.SuspendLayout();

让我们更进一步地探讨该问题：代码生成器可以提供格式规范的主干，以供您随后添加自己的代码。您可能知道 Reflector，但您是否知道 Reflector 的一些外接程序 (http://www.dotnetwiki.org/Default.aspx?tabid=52) 包含代码生成器？它们使您可以执行以下工作：

当您按下“Generate”按钮时，将创建一个新文件：

// Generated by Refly
namespace MyTestNameSpace
{
using System;
/// <summary>Test fixture for the <see cref="SomeBusinessClass"/> class
///</summary>
/// <remarks />
[TestFixture()]
public class SomeBusinessClassTest
{
/// <summary />
/// <remarks />
private SomeBusinessClass _someBusinessClass = null;
/// <summary />
/// <remarks />
public virtual SomeBusinessClass SomeBusinessClass
{
get
{
return this._someBusinessClass;
}
}
/// <summary>Tests the EstimateSomeNumber method</summary>
/// <remarks>
///   <para>Test coverage (estimated): 100,0%</para>
///   <para>Target path:</para>
///   <code>/* 0 */ return 0x2a;
/// </code>
/// </remarks>
[Test()]
[Ignore()]
public virtual void EstimateSomeNumber0()
{
throw new System.NotImplementedException();
}
/// <summary>Tests the IsSomethingAlreadyInDataBase method</summary>
/// <remarks>
///   <para>Test coverage (estimated): 100,0%</para>
///   <para>Target path:</para>
///   <code>/* 0 */ return false;
/// </code>
/// </remarks>
[Test()]
[Ignore()]
public virtual void IsSomethingAlreadyInDataBase0()
{
throw new System.NotImplementedException();
}
/// <summary>Sets up the fixture</summary>
/// <remarks />
[SetUp()]
public virtual void SetUp()
{
throw new System.NotImplementedException();
}
/// <summary>Releases resource allocated in the fixture</summary>
/// <remarks />
[TearDown()]
public virtual void TearDown()
{
throw new System.NotImplementedException();
}
}
}

您不了解有关“单元测试”的任何内容，但是您仍然能够生成有效的测试类。与上一个示例的不同之处在于，这一次您必须在生成的类的内部编码。可是，我们仍然无法创建我们自己的模板。

下一个步骤是创建我们自己的代码生成器。我们需要的全部东西就是一种根据一组常用信息（例如，将要获得的列的名称、要用来请求信息的方式、要允许的事务种类等等）来生成文本文件（C#、PL-SQL 等等）的方式。当然，您无法生成所有东西，因此需要一个能够生成自定义主干的工具，而某个开发人员随后将添加特定的实现细节。

该工具可以是 Perl、Microsoft VBScript 或普通的旧式 ASP（就本文而言）— 毕竟，它是一种可以根据参数生成文本文件的很好的工具。您可能使用 ASP 生成 HTML 文件，但是它还适用于生成 Microsoft Excel 或 CSV、WML — 因此，为什么不用它来生成 T-SQL 或 C# 呢？

您的 ASP 文件可能如下所示：

<%@ Language=VBScript %>
<%if request("Generate").count = 0 then%>
<HTML><BODY>
<form method=post>
<P>Property name :<INPUT name=PropertyName></P>
<P>What is the type of your property ? <INPUT name=PropertyType></P>
<P>Read only <input type=checkbox name=ReadOnly value=true></P>
<P><INPUT type=submit value="Generate !" name=Generate></P>
</form>
</BODY></HTML>
<% else
dim PropertyName, PropertyType, ReadOnly, PropertyModifier
PropertyName = Request("PropertyName")
PropertyType = Request("PropertyType")
ReadOnly = (Request("ReadOnly")="true")
if ReadOnly then PropertyModifier = "ReadOnly" else PropertyModifier = ""
Response.ContentType = "text/plain"
%>
Private _<%=PropertyName%> as <%=PropertyType%>
Public <%=propertyModifier%> Property <%=PropertyName%> as <%=PropertyType%>
Get
Return _<%=PropertyName%>
End Get
<%if not ReadOnly then%>
Set (ByVal Value as <%=PropertyType%>)
_<%=PropertyName%> = Value
End Set
<%end if%>
End Property
<%end if%>

当您执行该文件时，您将获得如下所示的内容：

您还可以在 Internet 上找到代码生成器。我通常使用 CodeSmith；它是免费的并且易于理解，但是您可以找到很多其他的代码生成器。图 5 是一个屏幕截图，它显示了一种等待泛型的聪明方式；它生成一个强类型的哈希表。

这些工具通常接受两个输入 — 一个模板文件（像我们的 ASP 文件）和一个 XML 参数文件（像表单的内容），并产生一个新文件。

开发人员被赋予这些模板，并且他们通常通过同一组参数来使用两个不同的模板。这样，他们将相同的信息给予这两个模板，并且获得共享信息的一个 T-SQL 文件和一个 C# 文件，同时无需承担遗忘或键入错误的风险；这样就为您完成了此工作的乏味部分。

返回页首

版本控制

当然，在使用模板和自动生成的代码时，事情会变得复杂。在现实生活中，模板会演化（例如，您可能希望赋予 C# 类一种调用某些存储过程的异步方式）；如果是这样，那么您需要一种相应的办法，以应付开发人员在主干生成之后放入的实现。

为此，您必须确保开发人员添加的代码独立于您的模板所生成的代码。实现此目的最简单的技术是创建两个不同的类：一个用于生成的代码，另一个从第一个继承，但将不生成。

由于该技术所具有的继承机制，因此它在您生成 .NET 代码时非常适用；但是，如果您要生成其他种类的代码（VBScript、SQL），则将无法以这种方式工作。在那种情况下，您主要依靠自己来解决问题。我使用的机制很简单：我在生成的代码中提供了占位符（在 C# 中为区域；在 SQL 中为特定注释所围绕的块），并且当代码被重新生成时，只有这些区域中的代码被保留。传输自定义代码本身同样简单：模板始终接受 PreviousFile 参数。当该参数存在时，将分析以前的文件以获得自定义代码，并将其重新插入到当前的生成文件中。

如果没有办法恢复原样，则千万不要弄乱生成的代码：您将发现自己正在进行复制/粘贴编程。

返回页首

小结

下面是在使用代码生成器时需要记住的一些事情：

• 如果不打算对生成的代码进行修改，请预先声明。

• 不要忘记，开发人员没有时间了解生成代码的内部结构，因此请为他们提供帮助，并且尽可能详细地对入口点进行说明。

• 考虑进行版本控制，并明确说明您将允许人们做什么。或许您希望开发人员只在代码的特定区域中添加自定义代码，或者您希望他们从您的类继承。

• 模板的新版本应当始终能够重新生成旧版本所生成的代码。如果新版本需要比旧版本更多的代码以便正确工作，则请将需要代码的位置变得明显一些，并且插入一些能够生成错误的代码（在编译时 — 如果可能的话）。

• 如果您决定中断模板的版本控制机制（例如，通过添加在应用新版本时无法恢复原样的代码），请保留该模板和您使用的参数的副本。如果您需要为某个旧项目生成另一个类似的代码文件，并且您已经丢失了在开发该旧项目时使用的模板版本，则会发生很糟糕的事情。我只是将模板和参数与项目一起放在 SourceSafe 中。

• 在发布模板之前，对其进行彻底的测试。模板会在开发人员之间飞快地传播，因为他们无需多少知识就可以解决问题。如果更新生成的文件意味着丢失自定义，那么程序错误将很难查找，并且更加难以修复。

使用该方法能够走多远？简单说来，代码生成器使开发人员可以获得一个抽象级别。他不必将精力集中于技术过程（因为该过程已嵌入到模板中），并且可以考虑集成该过程。它使开发人员能够更好地理解客户需求，并使技术过程拥有更好的质量。Microsoft Visual Studio 已经广泛使用了这些技术，并且即将问世的版本已经添加了很多改进（引人注目的是一个类建模程序和不完整类机制，可用于将生成的代码与自定义代码分隔开）。

现实世界中的 .NET

Pierre Couzy 是一个专门研究分布式系统体系结构的培训师和顾问。作为 20 余部书籍的作者，他目前被 WinWise 聘为 ASP.NET 和 BizTalk 专家。他自 2003 年以来一直是地区主管，并且在法国的许多重要会议上发表了演讲。如果您要与他讨论法国爵士乐、桥牌（是的，就是那种简单的游戏）甚至计算机，请通过 Pierre.couzy@winwise.fr 与他联系。

目标

使用本单元以：

• 开发、实现并使用自定义 CAS 权限。

• 使用自定义代码访问权限来控制到由 DPAPI 提供的非托管加密功能的访问。

适用于

本单元适用于下列产品和技术：

• Microsoft® Windows® 2000 Server 和 Windows 2000 Professional、Windows Server™ 2003、Windows XP Professional 操作系统

• Internet Information Server (IIS)

• Microsoft .NET Framework 1.1

如何使用本单元

要从本单元受益最多：

• 您必须具备使用 Visual C# .NET 和 Visual Studio .NET 进行编程的经验。

• 请阅读“如何创建 DPAPI 库”。该单元演示了如何创建本单元所用的托管 DPAPI 包装程序集。

本页内容

摘要
须知
创建 EncryptionPermission 类
创建 EncryptionPermissionAttribute 类
在 GAC 中安装权限程序集
更新 DPAPI 托管包装代码
从中等信任的 Web 应用程序调用 DPAPI

摘要

.NET Framework 的代码访问安全性 (CAS) 功能可扩展。这使您能够实现自己的权限以控制到重要自定义功能的访问。

本单元主要说明如何创建自定义 CAS 权限以控制到托管数据保护 API (DPAPI) 包装代码的编程访问。该代码在以下站点的 MSDN 库文章“如何：创建 DPAPI 库”中进行阐述：http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnnetsec/html/SecNetHT07.asp。

返回页首

须知

代码访问安全性权限必须源自 System.Security.CodeAccessPermission，它可实现由 IPermission 接口定义的 Demand 方法，同时还可实现其他方法，如 IStackWalk 接口定义的 Assert、Deny 以及 PermitOnly 。

代码访问权限（不是身份权限）还可实现 IUnrestrictedPermission 接口，以指示该权限是不受限制的权限集的一部分。这意味着该权限会被自动授予任何具有完全信任的代码。本单元中使用的自定义 EncryptionPermission 的继承层次结构如图 1 所示。

自定义 EncryptionPermission 类维护以下状态：

• EncryptionPermissionFlag。确定被授予该权限的代码能够加密数据还是解密数据，或二者均可。

• StorePermissionFlag。确定被授予该权限的代码能够通过机器存储还是当前用户存储使用 DPAPI，或二者均可。

返回页首

创建 EncryptionPermission 类

EncryptionPermission 类是自定义权限实现，用于授权到非托管 DPAPI 功能的访问。

创建 CustomPermission 类

1. 创建新的 Visual C#^TM 开发工具“类库”项目 CustomPermission，并将 class1.cs 重命名为 EncryptionPermission.cs。

2. 向该程序集添加强名称，以便可将其安装在 GAC 中。使用 assemblyinfo.cs 中的以下属性：

   [assembly: AssemblyKeyFile(@"..\..\CustomPermissions.snk")]
       

3. 使用固定的程序集版本。

   [assembly: AssemblyVersion("1.0.0.1")]
       

4. 将以下 using 语句添加到 EncryptionPermission.cs 顶端。

   using System.Security;
       using System.Security.Permissions;
       

5. 将以下枚举类型添加到 CustomPermissions 命名空间。

   [Flags, Serializable]
       public enum EncryptionPermissionFlag
       {Encrypt = 0x01, Decrypt = 0x02}
       [Flags, Serializable]
       public enum StorePermissionFlag
       {User = 0x01, Machine = 0x02}
       

6. 利用 [Serializable] 属性向 EncryptionPermission 类添加序列化支持，然后将其从 CodeAccessSecurity 和 IUnrestrictedPermission 导出。.并且，密封该类，如下所示。

   [Serializable]
       public sealed class EncryptionPermission : CodeAccessPermission,
       IUnrestrictedPermission
       

7. 添加两个私有成员变量以维持权限状态。

   private EncryptionPermissionFlag _permFlag;
       private StorePermissionFlag _storePermFlag;
       

8. 用以下构造函数替换默认的构造函数。

   // It is convention for permission types to provide a constructor
       // that accepts the PermissionState enumeration.
       public EncryptionPermission(PermissionState state)
       {
       if (state.Equals(PermissionState.Unrestricted))
       {
       _permFlag = EncryptionPermissionFlag.Encrypt |
       EncryptionPermissionFlag.Decrypt;
       _storePermFlag = StorePermissionFlag.User | StorePermissionFlag.Machine;
       }
       else
       {
       _permFlag &= ~(EncryptionPermissionFlag.Encrypt |
       EncryptionPermissionFlag.Decrypt);
       _storePermFlag &= ~(StorePermissionFlag.User |
       StorePermissionFlag.Machine);
       }
       }
       // This constructor allows you to specify the encryption type (encrypt
       // or decrypt) by using the EncryptionPermissionFlag enumeration and the DPAPI
       // key store to use (user or machine) as defined by the StorePermissionFlag
       // enumeration.
       public EncryptionPermission(EncryptionPermissionFlag cipher,
       StorePermissionFlag store)
       {
       _permFlag = cipher;
       _storePermFlag = store;
       }
       public EncryptionPermission()
       {
       _permFlag &= ~EncryptionPermissionFlag.Encrypt |
       EncryptionPermissionFlag.Decrypt;
       _storePermFlag &= ~(StorePermissionFlag.User | StorePermissionFlag.Machine);
       }
       

9. 添加以下公共属性以允许使用者应用程序设置权限类状态。

   // Set this property to true to allow encryption.
       public bool Encrypt
       {
       set {
       if(true == value)
       {
       _permFlag |= EncryptionPermissionFlag.Encrypt;
       }
       else
       {
       _permFlag &= ~EncryptionPermissionFlag.Encrypt;
       }
       }
       get {
       return (_permFlag & EncryptionPermissionFlag.Encrypt).Equals(
       EncryptionPermissionFlag.Encrypt);
       }
       }
       // Set this property to true to allow decryption.
       public bool Decrypt
       {
       set {
       if(true == value)
       {
       _permFlag |= EncryptionPermissionFlag.Decrypt;
       }
       else
       {
       _permFlag &= ~EncryptionPermissionFlag.Decrypt;
       }
       }
       get {
       return (_permFlag & EncryptionPermissionFlag.Decrypt).Equals(
       EncryptionPermissionFlag.Decrypt);
       }
       }
       // Set this property to true to use the DPAPI machine key.
       public bool MachineStore
       {
       set {
       if(true == value)
       {
       _storePermFlag |= StorePermissionFlag.Machine;
       }
       else
       {
       _storePermFlag &= ~StorePermissionFlag.Machine;
       }
       }
       get {
       return (_storePermFlag & StorePermissionFlag.Machine).Equals(
       StorePermissionFlag.Machine);
       }
       }
       // Set this property to true to use the DPAPI user key.
       public bool UserStore
       {
       set {
       if(true == value)
       {
       _storePermFlag |= StorePermissionFlag.User;
       }
       else
       {
       _storePermFlag &= ~StorePermissionFlag.User;
       }
       }
       get {
       return (_storePermFlag & StorePermissionFlag.User).Equals(
       StorePermissionFlag.User);
       }
       }
       

10. 实现 IPermission.Copy。这会创建与当前权限实例完全相同的副本，并将其返回到调用方。

    public override IPermission Copy()
        {
        return  new EncryptionPermission(_permFlag, _storePermFlag);
        }
        

11. 实现 IPermission.Intersect。这会返回一个权限对象，该对象即当前权限和提供权限之间的交集。

    public override IPermission Intersect(IPermission target)
        {
        // An input of null indicates a permission with no state.
        // There can be no common state, so the method returns null.
        if (target == null)
        return null;
        if (!(target.GetType().Equals(this.GetType())))
        throw new ArgumentException(
        "Argument must be of type EncryptionPermission.");
        // Cast target to an EncryptionPermission.
        EncryptionPermission targetPerm = (EncryptionPermission)target;
        EncryptionPermissionFlag intersectEncryption = this._permFlag &
        targetPerm._permFlag;
        StorePermissionFlag intersectStore = this._storePermFlag &
        targetPerm._storePermFlag;
        return new EncryptionPermission(intersectEncryption, intersectStore);
        }
        

12. 实现 IPermission.Union。这会返回一个权限对象，该对象即当前权限和提供权限的并集。

    public override IPermission Union(IPermission target)
        {
        if (target == null)
        return Copy();
        if (!(target.GetType().Equals(this.GetType())))
        throw new ArgumentException(
        "Argument must be of type EncryptionPermission.");
        // Cast the target to an EncryptionPermission.
        EncryptionPermission targetPerm = (EncryptionPermission)target;
        EncryptionPermissionFlag unionEncryption = this._permFlag |
        targetPerm._permFlag;
        StorePermissionFlag unionStore = this._storePermFlag |
        targetPerm._storePermFlag;
        return new EncryptionPermission(unionEncryption, unionStore);
        }
        

13. 实现 IPermission.IsSubsetOf。该方法会返回一个布尔值，以指示当前权限是否是提供权限的子集。要成为子集，则当前权限中状态的每一项也必须位于目标权限内。

    public override bool IsSubsetOf(IPermission target)
        {
        // An input of null indicates a permission with no state.
        // The permission can only be a subset if it's in a similar empty state.
        bool canEncrypt, canDecrypt;
        bool canUseMachineStore, canUseUserStore;
        bool canTargetEncrypt, canTargetDecrypt;
        bool canTargetUseMachineStore, canTargetUseUserStore;
        canEncrypt = (this._permFlag &
        EncryptionPermissionFlag.Encrypt).
        Equals(EncryptionPermissionFlag.Encrypt);
        canDecrypt = (this._permFlag &
        EncryptionPermissionFlag.Decrypt).
        Equals(EncryptionPermissionFlag.Decrypt);
        canUseMachineStore = (this._storePermFlag &
        StorePermissionFlag.Machine).
        Equals(StorePermissionFlag.Machine);
        canUseUserStore = (this._storePermFlag &
        StorePermissionFlag.User).
        Equals(StorePermissionFlag.User);
        if (target == null)
        {
        if ((canEncrypt == false && canDecrypt == false) && (canUseMachineStore ==
        false  && canUseUserStore == false))
        return true;
        else
        return false;
        }
        if (!(target.GetType().Equals(this.GetType())))
        throw new ArgumentException(
        "Argument must be of type EncryptionPermission.");
        // Cast the target to an EncryptionPermission.
        EncryptionPermission targetPerm = (EncryptionPermission)target;
        canTargetEncrypt = (targetPerm._permFlag &
        EncryptionPermissionFlag.Encrypt).
        Equals(EncryptionPermissionFlag.Encrypt);
        canTargetDecrypt = (targetPerm._permFlag &
        EncryptionPermissionFlag.Decrypt).
        Equals(EncryptionPermissionFlag.Decrypt);
        canTargetUseMachineStore = (targetPerm._storePermFlag &
        StorePermissionFlag.Machine).
        Equals(StorePermissionFlag.Machine);
        canTargetUseUserStore = (targetPerm._storePermFlag &
        StorePermissionFlag.User).
        Equals(StorePermissionFlag.User);
        // Every value set (true) in this permission must be in the target.
        // The following code checks to see if the current permission is a subset
        // of the target. If the current permission has something that the target
        // does not have, it cannot be a subset.
        if(canEncrypt == true && canTargetEncrypt == false)
        return false;
        if(canDecrypt == true && canTargetDecrypt == false)
        return false;
        if(canUseMachineStore == true && canTargetUseMachineStore == false)
        return false;
        if(canUseUserStore == true && canTargetUseUserStore == false)
        return false;
        return true;
        }
        

14. 实现 ISecurityEncodable.ToXml 和 FromXml。这些方法将权限对象的实例转换为 XML 格式，反之亦然。这些方法用于支持序列化。例如，在将安全属性存储在程序集元数据中时使用这些方法。

    public override SecurityElement ToXml()
        {
        // Create a new element. The tag name must always be IPermission.
        SecurityElement elem = new SecurityElement("IPermission");
        // Determine the fully qualified type name (including the assembly name) of
        // the EncryptionPermission class. (The security system uses this name to
        // locate and load the class.)
        string name = typeof(EncryptionPermission).AssemblyQualifiedName;
        // Add attributes for the class name and protocol version.
        // The version must currently be 1.
        elem.AddAttribute("class", name);
        elem.AddAttribute("version", "1" );
        if (IsUnrestricted())
        {
        // Using the Unrestricted attribute is consistent with the
        // built-in .NET Framework permission types and helps keep
        // the encoding compact.
        elem.AddAttribute("Unrestricted", Boolean.TrueString);
        }
        else
        {
        // Encode each state field as an attribute of the Permission element.
        // To compact, encode only nondefault state parameters.
        elem.AddAttribute("Flags", this._permFlag.ToString());
        elem.AddAttribute("Stores", this._storePermFlag.ToString());
        }
        // Return the completed element.
        return elem;
        }
        // Converts a SecurityElement (or tree of elements) to a permission
        // instance.
        public override void FromXml(SecurityElement elem)
        {
        string attrVal = "";
        // Check for an unrestricted instance.
        attrVal = elem.Attribute("Unrestricted");
        if (attrVal != null)
        {
        if(attrVal.ToLower().Equals("true"))
        {
        this._permFlag = EncryptionPermissionFlag.Encrypt |
        EncryptionPermissionFlag.Decrypt;
        this._storePermFlag = StorePermissionFlag.Machine |
        StorePermissionFlag.User;
        }
        return;
        }
        //Turn off the permission and store flags.
        this._permFlag &= ~(EncryptionPermissionFlag.Encrypt |
        EncryptionPermissionFlag.Decrypt);
        this._storePermFlag &= ~(StorePermissionFlag.Machine |
        StorePermissionFlag.User);
        attrVal = elem.Attribute("Flags");
        if (attrVal != null)
        {
        if(!attrVal.Trim().Equals(""))
        {
        this._permFlag =
        (EncryptionPermissionFlag)Enum.Parse(typeof(EncryptionPermissionFlag),
        attrVal);
        }
        }
        attrVal = elem.Attribute("Stores");
        if (attrVal != null)
        {
        if(!attrVal.Trim().Equals(""))
        {
        this._storePermFlag =
        (StorePermissionFlag)Enum.Parse(typeof(StorePermissionFlag),
        attrVal);
        }
        }
        }
        

15. 实现 IUnrestrictedPermission.IsUnrestricted。如果权限实例处于不受限制的状态，则该方法返回 true。本例中，不受限制的 EncryptionPermission 实例允许代码使用 DPAPI 机器和用户存储来加密和解密数据。

    public bool IsUnrestricted()
        {
        bool canEncrypt, canDecrypt, canUseUserStore, canUseMachineStore;
        canEncrypt = (this._permFlag &
        EncryptionPermissionFlag.Encrypt).
        Equals(EncryptionPermissionFlag.Encrypt);
        canDecrypt = (this._permFlag &
        EncryptionPermissionFlag.Decrypt).
        Equals(EncryptionPermissionFlag.Decrypt);
        canUseUserStore = (this._storePermFlag &
        StorePermissionFlag.User).
        Equals(StorePermissionFlag.User);
        canUseMachineStore = (this._storePermFlag &
        StorePermissionFlag.Machine).
        Equals(StorePermissionFlag.Machine);
        return ((canEncrypt && canDecrypt) &&
        (canUseUserStore && canUseMachineStore));
        }
        

返回页首

创建 EncryptionPermissionAttribute 类

.NET Framework 使用与其合作伙伴权限类相关联的属性类来编码权限实例。您需要权限属性来支持声明性安全语法。

创建 EncryptionPermissionAttribute 类

1. 将一个新类文件添加到当前项目，EncryptionPermissionAttribute.cs。

2. 将以下 using 语句添加到新文件的顶端。

   using System.Security;
       using System.Diagnostics;
       using System.Security.Permissions;
       

3. 从 CodeAccessSecurityAttribute 导出属性类，并将其密封。

   public sealed class EncryptionPermissionAttribute :
       CodeAccessSecurityAttribute
       

4. 向该类添加序列化支持，并使用 AttributeUsage 属性来指示可以使用自定义权限属性的位置。

   [Serializable,
       AttributeUsage(AttributeTargets.Method |      // Can use on methods
       AttributeTargets.Constructor | // Can use on constructors
       AttributeTargets.Class |       // Can use on classes
       AttributeTargets.Struct |      // Can use on structures
       AttributeTargets.Assembly,     // Can use at the assembly level
       AllowMultiple = true,          // Can use multiple attribute
       // instances per program element
       // (class, method and so on)
       Inherited = false)]            // Can not be inherited
       

5. 向该类添加私有成员变量以镜像由关联的权限类维持的状态。

   // The following state fields mirror those used in the associated
       // permission type.
       private bool _encrypt = false;
       private bool _decrypt = false;
       private bool _machineStore = false;
       private bool _userStore = false;
       

6. 用以下构造函数替换默认的构造函数。

   // Pass the action code back to the base class.
       public EncryptionPermissionAttribute(SecurityAction action) : base(action)
       {
       }
       

7. 添加以下公共属性以镜像这些由关联的权限类提供的各项。

   public bool Encrypt
       {
       get {
       return _encrypt;
       }
       set {
       _encrypt = value;
       }
       }
       public bool Decrypt
       {
       get {
       return _decrypt;
       }
       set {
       _decrypt = value;
       }
       }
       public bool UserStore
       {
       get {
       return _userStore;
       }
       set {
       _userStore = value;
       }
       }
       public bool MachineStore
       {
       get {
       return _machineStore;
       }
       set {
       _machineStore = value;
       }
       }
       

8. 实现 SecurityPermissionAttribute.CreatePermission。该方法会创建一个权限对象，该对象随后被序列化并通过程序集的元数据中指定的 SecurityAction 枚举进行保留。

   public override IPermission CreatePermission()
       {
       // The runtime automatically provides a property to indicate
       // whether or not an unrestricted instance is required.
       if((Unrestricted) || ((_encrypt && _decrypt) &&
       (_userStore && _machineStore)))
       {
       return new EncryptionPermission(PermissionState.Unrestricted);
       }
       // Copy the state from the attribute to the permission object
       EncryptionPermissionFlag cipher = 0x0;
       StorePermissionFlag store = 0x0;
       if(_encrypt)
       cipher |= EncryptionPermissionFlag.Encrypt;
       if(_decrypt)
       cipher |= EncryptionPermissionFlag.Decrypt;
       if(_userStore)
       store |= StorePermissionFlag.User;
       if(_machineStore)
       store |= StorePermissionFlag.Machine;
       // Return the final permission.
       return new EncryptionPermission(cipher, store);
       }
       

9. 生成解决方案。

返回页首

在 GAC 中安装权限程序集

您必须对实现自定义安全权限的所有程序集授予完全信任。实际上，这意味着您需要在使用程序集的计算机上安装该程序集，以确保默认的安全策略授予其完全信任。My_Computer_Zone 内的代码由默认的策略授予完全信任。

在 GAC 中安装程序集是确保代码访问安全策略授予其完全信任的一种方法。GAC 是适合于权限程序集的位置，原因在于该程序集由本地计算机上的代码访问安全策略使用，并且它对于本地计算机上安装的所有 .NET Framework 应用程序均可用。

要在本地计算机的 GAC 中安装自定义权限程序集，请运行以下命令。

gacutil.exe /i custompermission.dll

返回页首

更新 DPAPI 托管包装代码

.NET Framework 类库目前并未公开 DPAPI 功能。要从 .NET Framework 应用程序调用 DPAPI，必须使用 P/Invoke。有关演示如何创建托管 DPAPI 包装程序集的代码的信息，请参阅“How To Create a DPAPI Library”。

不做进一步的修改，您只可从完全信任代码调用参考“如何……”方法文章中的托管 DPAPI 包装。若要能够从部分信任代码（例如，中等信任的 ASP.NET Web 应用程序）调用 DPAPI 包装，您必须将对非托管 DPAPI 函数的调用置于沙箱内方可。为此，需进行以下修改：

• 宣告 DPAPI 包装代码中的非托管代码权限。这意味着任何调用代码均不要求非托管代码权限。

• 通过要求自定义 EncryptionPermission 在包装内授权调用代码。根据 Demand/Assert 使用模式，Demand 调用在 Assert 调用前出现。有关安全使用 Assert 的详细信息，请参阅单元“Code Access Security in Practice”中的“Assert and RevertAssert”。

修改 DPAPI 托管包装

1. 通过“如何创建 DPAPI 库”中的以下指令构建 DPAPI 托管包装。

2. 向 CustomPermission 程序集添加引用。

3. 从托管包装库中打开 dataprotection.cs，并在该文件顶端现有的 using 语句下添加以下 using 语句。

   using System.Security;
       using System.Security.Permissions;
       using CustomPermissions;
       

4. 在 dataprotection.cs 中找到 Encrypt 方法，并在该 Encrypt 方法中的外部 try 块顶端添加以下代码。

   // Set the storeFlag depending on how the caller uses
       // the managed DPAPI wrapper.
       StorePermissionFlag storeFlag;
       if(Store.USE_MACHINE_STORE == store)
       {
       storeFlag = StorePermissionFlag.Machine;
       }
       else
       {
       storeFlag = StorePermissionFlag.User;
       }
       // Demand custom EncryptionPermission.
       (new EncryptionPermission(EncryptionPermissionFlag.Encrypt, storeFlag)).
       Demand();
       // Assert the unmanaged code permission.
       (new SecurityPermission(SecurityPermissionFlag.UnmanagedCode)).Assert();
       // Now use P/Invoke to call the unmanaged DPAPI functions.
       

5. 将以下 finally 块添加到该 Encrypt 方法中的外部 try 块。

   finally
       {
       CodeAccessPermission.RevertAssert();
       }
       

6. 找到 dataprotection.cs 中的 Decrypt 方法，并将以下代码添加到外部 try 块的顶端。

   StorePermissionFlag storeFlag;
       if(Store.USE_MACHINE_STORE == store)
       {
       storeFlag = StorePermissionFlag.Machine;
       }
       else
       {
       storeFlag = StorePermissionFlag.User;
       }
       // Demand custom EncryptionPermission.
       (new EncryptionPermission(EncryptionPermissionFlag.Decrypt, storeFlag)).
       Demand();
       // Assert the unmanaged code permission.
       (new SecurityPermission(SecurityPermissionFlag.UnmanagedCode)).Assert();
       

7. 将以下 finally 块添加到该 Decrypt 方法中的外部 try 块。

   finally
       {
       CodeAccessPermission.RevertAssert();
       }
       

返回页首

从中等信任的 Web 应用程序调用 DPAPI

要从中等信任的 Web 应用程序或任何部分信任的代码使用 DPAPI 托管包装，您必须配置代码访问安全策略以授予代码自定义 EncryptionPermission。

本步骤中，将创建测试 Web 应用程序，然后修改中等信任的 Web 应用程序的 ASP.NET 代码访问安全策略以授予其 EncryptionPermission。

创建测试 Web 应用程序

1. 将新的 C# ASP.NET Web 应用程序项目添加当前解决方案。

2. 向 Dataprotection.dll 程序集添加引用。

3. 将以下字段添加到 Webform1.aspx。

   • 一个用于要加密数据的输入字段。使用 ID txtDataToEncrypt。

   • 一个用于已加密数据的字段。使用 ID txtEncryptedData。

   • 一个用于已解密数据的字段。使用 ID txtDecryptedData。

   • 一个 Encrypt 按钮。使用 ID btnEncrypt。

   • 一个 Decrypt 按钮。使用 IDbtnDecrypt。

   • 一个用于错误消息的标签。使用 ID lblError。

4. 将以下 using 语句添加到现有 using 语句之下的 WebForm1.aspx.cs 顶端。

   using DataProtection;
       

5. 添加以下代码以用于 Encrypt 按钮单击事件处理程序。

   private void btnEncrypt_Click(object sender, System.EventArgs e)
       {
       DataProtector dp = new DataProtector(
       DataProtector.Store.USE_MACHINE_STORE );
       try
       {
       byte[] dataToEncrypt = Encoding.ASCII.GetBytes(txtDataToEncrypt.Text);
       // Not passing optional entropy in this example
       // Could pass random value (stored by the application) for added security
       // when using DPAPI with the machine store.
       txtEncryptedData.Text =
       Convert.ToBase64String(dp.Encrypt(dataToEncrypt,null));
       }
       catch(Exception ex)
       {
       lblError.ForeColor = Color.Red;
       lblError.Text = "Exception.<br>" + ex.Message;
       return;
       }
       lblError.Text = "";
       }
       

6. 添加以下代码以用于 Decrypt 按钮单击事件处理程序。

   private void btnDecrypt_Click(object sender, System.EventArgs e)
       {
       DataProtector dp = new DataProtector(DataProtector.Store.USE_MACHINE_STORE);
       try
       {
       byte[] dataToDecrypt = Convert.FromBase64String(txtEncryptedData.Text);
       // Optional entropy parameter is null.
       // If entropy was used within the Encrypt method, the same entropy
       // parameter must be supplied here.
       txtDecryptedData.Text =
       Encoding.ASCII.GetString(dp.Decrypt(dataToDecrypt,null));
       }
       catch(Exception ex)
       {
       lblError.ForeColor = Color.Red;
       lblError.Text = "Exception.<br>" + ex.Message;
       return;
       }
       lblError.Text = "";
       }
       

7. 通过将以下元素添加到 <system.web> 部分内应用程序的 Web.config 文件来配置 Web 应用程序以用于中等信任。

   <trust level="Medium" />
       

8. 生成解决方案。

修改中等信任策略

1. 使用 Visual Studio® .NET 或记事本打开中等信任策略文件。该策略文件位于以下位置。

   %windir%\Microsoft.NET\Framework\{version}\CONFIG\web_mediumtrust.config

2. 通过将以下 <SecurityClass> 元素添加到 <SecurityClasses> 元素来声明 EncryptionPermission。

   <SecurityClass Name="EncryptionPermission"
       Description="CustomPermission.EncryptionPermission,
       CustomPermission, Version=1.0.0.1,
       Culture=neutral,
       PublicKeyToken=951cd7d57a536a94"/>
       

   将 PublicKeyToken 属性值设为程序集指定的公钥标记。要提取自定义权限程序集的公钥标记，请使用以下命令。

   sn -T custompermission.dll

   注 使用大写 -T 开关项。

3. 找到在中等信任策略文件中的 ASP.NET 命名权限集，并添加以下权限元素。

   <IPermission class="EncryptionPermission"
       version="1" Flags="Encrypt,Decrypt"
       Stores="Machine,User">
       </IPermission>
       

   该权限授予中等信任的 Web 应用程序不受限制的 EncryptionPermission，原因在于它允许代码加密和解密数据，以及使用 DPAPI 机器和用户存储。以上元素演示了支持的语法。它等同于以下内容：
       

   <IPermission class="EncryptionPermission"
       version="1" Unrestricted="true" >
       </IPermission>
       

   通过仅使用相关的属性，您可以授予代码限制的权限。例如，要限制代码仅使用机器存储中的机器密钥解密数据，请使用以下元素。

   <IPermission class="EncryptionPermission"
       version="1" Flags="Decrypt"
       Stores="Machine">
       </IPermission>
       

4. 保存策略文件。

   现在您可以运行测试 Web 应用程序，并验证通过使用部分信任的 Web 应用程序的 DPAPI 可否加密和解密数据。

有关将高权限代码置于沙箱内和使用 ASP.NET 代码访问安全策略的详细信息，请参阅单元“Using Code Access Security with ASP.NET”。

适用范围：
Microsoft® ASP.NET

摘要：揭示能够以单一登录的方式登录多个 Web 应用程序的技术。本文还提供了示例代码，使您能够在完全使用单一登录的情况下创建强大的企业安全系统方面有一个良好的开端。

Download the code samples for this article（英文）。

本页内容

引言
单一登录解决方案概述
类和页面
表
AppLauncher Web 应用程序
Apps 类
在 Web 应用程序中检索令牌
增强您的单一登录系统
安装示例
结论
参考资料

引言

如果您的公司在运转方式上与其他绝大多数公司相同，那么您可能拥有许多用于支持公司业务的 Web 应用程序。绝大多数这种类型的应用程序需要采取安全措施，因为您肯定不希望用户随心所欲地进入任何 Web 应用程序。例如，只允许某些用户进入执行摘要决策支持系统，而其他用户则应只允许进入客户信息系统。有可能还有一些使用这些系统的外部用户，他们并不是您的 Microsoft® Windows® 域用户。可以通过安全机制强制每个用户登录系统，从而对此进行控制。但这样做的问题在于，访问不同系统时，每个系统都会不断地要求用户登录。对于仅仅具有五个 Web 应用程序的公司，如果某用户被允许访问其中的每一个程序，该用户会因为频繁地登录和注销而厌烦不已。所以必须找到一个更好的办法。

在阅读本文后，您将了解一种在企业中应用单一登录解决方案的方法。公司的内部用户可以使用 Windows 身份验证访问应用程序，而外部用户将被强制进行登录（参见图 1）。

本文所讨论的主题

单一登录 Web 应用程序

• 生成单一登录令牌

• 将用户映射至应用程序

• 基于窗体的身份验证

• Windows 中集成的身份验证

返回页首

单一登录解决方案概述

图 1 所示为内部用户和外部用户在登录到位于一个公司的 Intranet 上的网站时所执行的一系列步骤。在 50,000 英尺的级别上，这个系统仅有四个组件：通过 Windows 身份验证的网站、Active Directory、一个数据库服务器和一个或多个基于窗体进行身份验证的网站。

Intranet 解决方案

在图 1 的左上角可以看到内部用户使用浏览器浏览到特定的网站（第 1 步）。这个网站验证（第 2 步）用户的 Windows 凭据（通过 Active Directory）。如果用户是有效的 Windows 用户，则允许其进入该站点。通过身份验证后，将检索用户的标识，并调用包含指定用户能够运行的应用程序列表的数据库表（第 3 步）。这些应用程序将显示在 DataGrid 中，以供用户选择。

用户单击希望运行的应用程序后，将生成一个唯一的、只能使用一次的令牌（第 4 步）。此令牌和用户标识将被存储在另一个数据库表中。然后此令牌被传递给用户要运行的 Web 应用程序中的一个特定页面（通过查询行）。此特殊页面从查询行读取该令牌，然后验证在数据库表中是否存在此令牌（第 5 步）。如果令牌存在，它将在数据库中检索登录 ID，然后删除存储此令牌的记录。此操作能够防止其他人再次使用此令牌并将登录 ID 发送回 Web 应用程序。

在了解了 Web 应用程序中的用户标识后，您需要生成一个 ASP.NET 窗体身份验证票据，因为在 Intranet 中，所有的 Web 应用程序都将使用基于窗体的身份验证。此票据将被正在浏览站点中所有的安全页面的用户所使用。

Extranet 解决方案

想要访问 Web 应用程序的外部用户（您所在域之外的用户）将被定向到与内部用户不同的起始页面（参见图 2）。内部用户和外部用户被定向到的 Web 应用程序采取了基于窗体的身份验证的安全措施。当外部用户试图打开此 Web 应用程序中的任何页面时，他们将被自动重定向至登录页面。此登录页面与对内部用户进行身份验证的页面不同。用户必须输入其凭据，然后系统将调用同一个数据库，以确定该用户对此应用程序是否有效。如果有效，则将为此用户会话生成正常的基于窗体的身份验证 cookie。

返回页首

类和页面

您需要创建若干类和 Web 页面以支持企业级安全系统。图 2 显示了需要为此系统编写的每个类和 Web 页。本文稍后将讨论此图所显示的每个类。在此图之后，列出了每个类的说明信息以及您的系统中的 Web 页面主要功能。

Apps 类

此类用于检索指定用户的应用程序列表。它还将生成一个新令牌、根据给定的令牌检索用户的标识信息以及删除令牌。

AppToken 类

此类包含从 Apps 类的 VerifyLoginToken 方法返回令牌信息时所需的四个属性。表 2 说明了此类包含的四个属性。

AppUserRoles 类

此类用于检索试图登录应用程序的用户的信息。其中的一个方法根据给定的登录 ID 和应用程序键值检查登录是否有效。另一个方法返回给定用户的角色集。还有一个方法根据登录 ID 和应用程序键值返回 esUser 表的主键。

AppLauncher 应用程序中的 Default.aspx

此 Web 页类将检索通过了 IIS 身份验证的 Windows 用户，并返回允许这些用户访问的应用程序的列表。它将在 DataGrid 中显示此列表（图 3），并允许用户单击其中特定的应用程序。用户单击应用程序后，此页将生成一个新令牌，并将此令牌和用户 ID 存储到 esAppToken 表，然后调用此应用程序将令牌传递给该 Web 应用程序中的 AppLogin.aspx 页。

每个网站中的 AppLogin.aspx

只能从应用程序启动器调用此 Web 页类。若有任何其他的应用程序试图调用此页，它会将用户重定向至网站的 Default.aspx 页。因为每个 Web 应用程序都使用基于窗体的身份验证，所以此操作将强制 ASP.NET 将用户重定向至站点中的 Login.aspx 页。

如果使用令牌从应用程序启动器站点调用此页，那么此页将调用 Apps 类中的方法，以验证此令牌是否有效。如果令牌有效，则 Apps 类将返回一个 AppToken 对象，以便此页能够使用此对象中的信息创建基于窗体的身份验证的用户。

每个网站中的 Login.aspx

这是常规的 Web 登录页面，它要求用户输入凭据，并在数据库中检查这些凭据，以确保是有效用户；此外，如果是有效用户，则还将创建身份验证票据，并在用户进入站点时，重定向至用户请求的页面。

每个网站中的 Default.aspx

这是每个网站的主登陆页面。只有通过了 AppLogin 或 Login Web 页面的身份验证的用户才能够浏览此页以及站点中所有其他页。

返回页首

表

您还需要在数据库中创建若干表，用来支持此单一登录企业级安全系统。本文中的表所包含的字段不多，但就所述内容而言，已经足够。图 4 显示了需要在数据库中创建的每个表之间的关系。在图 4 之后，会看到这些表的列表，以及本解决方案中使用的每个表的说明信息。

esApps

此表包含企业中所有 Web 应用程序的列表。除应用程序的名称以外，表中还包含应用程序的详细说明信息以及应用程序的 URL。URL 是完整形式的 URL，并且应以 AppLogin.aspx 页结尾。应用程序启动器中的 default.aspx 页将负责在重定向至 Web 应用程序前向 URL 中添加字符串 “Token=<GeneratedToken>”。

esUsers

此表列出可以使用应用程序的所有用户。您需要为所有内部用户复制您的用户域登录 ID。您可能还希望为外部用户添加密码字段。

esAppsUsers

此表将 esUsers 表中的用户与 esApps 表中他们能够运行的应用程序关联起来。表中的数据只有 esUsers 表和 esApps 表的外键。

esAppRoles

此表包含每个应用程序的角色集。例如，一个应用程序可能包含“Admin”和“User”角色，而其他应用程序则可能包含“User”和“Supervisor”规则。

esAppUsersRoles

此表包含应用程序中每个用户的每一个角色的列表。在应用程序“HR”中，用户“Joe”可能是“Supervisor”，但在应用程序“Payroll”中，则可能是“Admin”和“User”。

esAppToken

esAppToken 包含由登录门户应用程序生成并传递给单个 Web 应用程序的令牌。这些记录在通常情况下应只存在两秒（或更短的时间），因为正被调用的 Web 应用程序在从此表中收集信息之后，会立即删除此令牌。这样可以防止他人再次使用此令牌。

返回页首

AppLauncher Web 应用程序

应用程序启动器解决方案（ 图 9）由通过 Windows 身份验证的站点和类库项目组成。此通过 Windows 身份验证的站点将直接读取线程中的用户域 ID，并利用此用户域 ID 在用户表中查找用户。我们看一下显示用户能够运行的应用程序的 Web 页。

AppLauncherxx 中的 Default.aspx

应用程序启动器网站只需要一个 Web 页：即 default.aspx。此 Web 页从页面的 User 对象中读取用户的 Windows 登录 ID，并加载数据库中为此用户定义的应用程序列表。以下是加载 default.aspx 页面时调用的 Page_Load 事件过程的代码。

// C#
private void Page_Load(object sender, System.EventArgs e)
{
// 显示用户名称
// 不带域前缀
lblLogin.Text = "Applications Available for: " +
Apps.LoginIDNoDomain(User.Identity.Name);
AppLoad();
}
' VB.NET
Private Sub Page_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
' 显示用户名称
' 不带域前缀
lblLogin.Text = "Applications Available for: " & _
Apps.LoginIDNoDomain(User.Identity.Name)
AppLoad()
End Sub

调用 Apps 类的静态方法 LoginIDNoDomain 是为了去除域前缀。如果登录 ID 为“Ken”的用户通过了名为“PDSA”的域的身份验证，那么 User.Identity.Name 属性将返回“PDSA\Ken”。而此方法则仅返回字符串“Ken”。

加载此用户能够运行的应用程序

AppLoad 方法使用 Apps 类的一个实例检索允许此用户运行的应用程序的 DataSet。本文后面的内容将显示 Apps 类中的 GetAppsByLoginID 方法。

// C#
private void AppLoad()
{
Apps app = new Apps();
try
{
// 为此用户加载应用程序
grdApps.DataSource =
app.GetAppsByLoginID(User.Identity.Name);
grdApps.DataBind();
}
catch (Exception ex)
{
lblMessage.Text = ex.Message;
}
}
' VB.NET
Private Sub AppLoad()
Dim app As New Apps
Try
' 为此用户加载应用程序
grdApps.DataSource = app.GetAppsByLoginID(User.Identity.Name)
grdApps.DataBind()
Catch ex As Exception
lblMessage.Text = ex.Message
End Try
End Sub

LinkButton 控件

default.aspx 页面的 DataGrid 控件显示指定用户的应用程序列表后（参见图 3），用户就可以选择其中的应用程序。DataGrid 中用于显示超级链接以供用户单击的控件即为 LinkButton。在 Web 页面中，LinkButton 定义如下：

<asp:LinkButton id=lnkApp runat="server"
AppID='<%# DataBinder.Eval(Container.DataItem, "iAppID") %>'
UserID='<%# DataBinder.Eval(Container.DataItem, "iUserID") %>'
CommandArgument='<%# DataBinder.Eval(Container.DataItem, "sURL") %>'
Text='<%# DataBinder.Eval(Container.DataItem, "sAppName") %>'>
</asp:LinkButton>

从上述代码可以看出，增添了一些 esApps 表的主键 (iAppID) 和 esUsers 表的主键 (iUserID) 的附加属性。这些属性以及 CommandArgument 中的 URL 提供了可存储到数据库中的足够的用户信息。稍后您会看到，我们将在 ItemCommand 事件过程中检索这些附加属性。

提示： 可以向服务器控件添加任何想要的属性。ASP.NET 将忽略这些属性，但是您可以使用服务器控件的 Attributes 属性检索它们的值。

ItemCommand 事件

用户单击 DataGrid 中的 LinkButton 控件后，将调用 ItemCommand 事件过程。在此方法中，需要创建 Apps 类的一个新实例，并检索 LinkButton 控件，以便获取属性，然后调用 Apps 类中的 CreateLoginToken 方法，以将此数据存储到数据库中的 esAppToken 表中。最后，从此方法检索出令牌后，此令牌将与 LinkButton 的 CommandArgument 属性中的 URL 连接，然后调用 Response.Redirect，以调用令牌所传递的 Web 应用程序。

// C#
private void grdApps_ItemCommand(object source,
System.Web.UI.WebControls.DataGridCommandEventArgs e)
{
Apps app = new Apps();
bool redirect = false;
string token = String.Empty;
LinkButton lb;
try
{
lb = (LinkButton) e.Item.Cells[0].Controls[1];
// 为此用户或应用程序创建令牌
token = app.CreateLoginToken(
lb.Text,
User.Identity.Name,
Convert.ToInt32(lb.Attributes["UserID"]),
Convert.ToInt32(lb.Attributes["AppID"]));
redirect = true;
}
catch (Exception ex)
{
redirect = false;
lblMessage.Text = ex.Message;
}
if (redirect)
{
// 重定向至生成的令牌中
// 传递的 Web 应用程序
Response.Redirect(e.CommandArgument.ToString() +
"?Token=" + token, false);
}
}
' VB.NET
Private Sub grdApps_ItemCommand(ByVal source As Object, _
ByVal e As System.Web.UI.WebControls.DataGridCommandEventArgs) _
Handles grdApps.ItemCommand
Dim app As New Apps
Dim boolRedirect As Boolean
Dim token As String
Dim lb As LinkButton
Try
lb = DirectCast(e.Item.Cells(0).Controls(1), LinkButton)
' 为此用户或应用程序创建令牌
token = app.CreateLoginToken(lb.Text, _
User.Identity.Name, _
Convert.ToInt32(lb.Attributes("UserID")), _
Convert.ToInt32(lb.Attributes("AppID")))
boolRedirect = True
Catch ex As Exception
boolRedirect = False
lblMessage.Text = ex.Message
End Try
If boolRedirect Then
' 重定向至生成的令牌中
' 传递的 Web 应用程序
Response.Redirect(e.CommandArgument.ToString() & _
"?Token=" & token, False)
End If
End Sub

您会注意到，在上面的代码中，检索了 e.Item 参数中的 LinkButton 控件。e.Item 用于引用您在 DataGrid 中单击的行。您可以在 LinkButton 所在的列后检索所单击的 LinkButton 控件的特定实例。在本例中，它在 Cells(0) 中。在此单元格中，可以在 Controls(1) 后取得该控件。该控件位于位置一 (1) 的原因是 DataGrid 中所使用的、允许我们将 LinkButton 置于单元格中的 ItemTemplate 被看作是元素零 (0)。

检索出 LinkButton 后，就可以使用 Attributes 属性检索在设置 LinkButton 时存储的 UserID 和 AppID。Attributes 属性是您向服务器控件添加的所有附加属性的集合，这些附加属性不是初始控件定义的组成部分。

修改 Web.Config

在 Web 应用程序对用户进行身份验证之前，必须将 Web.Config 文件中的 <authentication> 元素设置为“Windows”。此外，还必须拒绝 Web.config 中的 <authorization> 元素中的匿名用户。

<authorization>
<deny users="?" />
</authorization>

设置这两个元素可从浏览器强制服务器检索用户的 Windows 凭据。当然，只有当您在用户所登录的域中使用 Internet Explorer 时，它才会起作用。

最后一项要完成的工作是存储连接字符串，以便从数据库的表中获取。在本文的示例中，我只使用了 Web.config 中的 <appSettings> 部分存储连接字符串。

<appSettings>
<add key="eSecurityConnectString"
value="server=(local);Database=eSecurity;uid=myUserID;pwd=myPassword" />
</appSettings>

在本文中，我在 SQL Server™ 中创建了名为 eSecurity 的数据库，并创建了本文前面内容中所述的所有的表。本文的示例代码包含一个 SQL 脚本，可以运行此脚本以在 SQL Server 数据库中创建表。如果使用其他数据库系统，则需要根据您的数据库对脚本进行适当的修改。

返回页首

Apps 类

现在看一下在此企业级安全系统中用于实现主要功能的 Apps 类。AppLauncherData 程序集包含的三个类中的每一个类都可负责为用户加载应用程序、加载用户角色以及操作安全令牌。较好的做法是保留与数据库进行交互的功能，以及保留在用户界面层以外操作令牌的功能。这可以使您不必更改用户界面就可以修改令牌的创建方法，以及修改与数据库交互的方式。

Apps 类负责操作令牌以及为用户加载应用程序。我们看一下这个类的定义。

// C#
public class Apps
{
string mConnectString;
public Apps()
{
mConnectString = ConfigurationSettings.
AppSettings["eSecurityConnectString"];
}
...
}
' VB.NET
Public Class Apps
Private mConnectString As String
Public Sub New()
mConnectString = ConfigurationSettings. _
AppSettings("eSecurityConnectString")
End Sub
...
End Class

可以看到这个类首先使用从 Web.config 文件中检索出的连接字符串加载成员变量。

GetAppsByLoginID 方法

要为特定的用户加载应用程序，应将用户的登录 ID 传递给 GetAppsByLoginID 方法。此方法负责执行联接，以检索所有相关的信息。使用 SQL 联接需要从 esApps 和 esAppsUsers 表中获取信息。此外，还需要联接 esUsers 表，因为只需要检索特定用户的应用程序，而所有我们可用的信息只有用户的 Login ID，所以必须在 esUsers 表中查找用户的主键，以便联接到其他表。

注意： 本文使用动态 SQL 只是为了显示概念。在实际的企业级安全系统中，需要对所有的 SQL 调用使用存储过程。

// C#
public DataSet GetAppsByLoginID(string loginID)
{
DataSet ds = new DataSet();
SqlCommand cmd;
SqlDataAdapter da;
string sql;
sql = "SELECT esApps.iAppID, esAppsUsers.iUserID, ";
sql += " esApps.sAppName, esApps.sDesc, esApps.sURL ";
sql += " FROM esApps";
sql += " INNER JOIN esAppsUsers ";
sql += " ON esApps.iAppID = esAppsUsers.iAppID ";
sql += " INNER JOIN esUsers ";
sql += " ON esAppsUsers.iUserID = esUsers.iUserID ";
sql += " WHERE sLoginID = @sLoginID ";
sql = String.Format(sql, Apps.LoginIDNoDomain(loginID));
try
{
cmd = new SqlCommand(sql);
cmd.Parameters.Add(new
SqlParameter("@sLoginID", SqlDbType.Char));
cmd.Parameters["@sLoginID"].Value =
Apps.LoginIDNoDomain(loginID);
cmd.Connection = new SqlConnection(mConnectString);
da = new SqlDataAdapter(cmd);
da.Fill(ds);
return ds;
}
catch (Exception ex)
{
throw ex;
}
}
' VB.NET
Public Function GetAppsByLoginID(ByVal LoginID As String) _
As DataSet
Dim ds As New DataSet
Dim cmd As SqlCommand
Dim da As SqlDataAdapter
Dim sql As String
sql = "SELECT esApps.iAppID, esAppsUsers.iUserID, "
sql &= " esApps.sAppName, esApps.sDesc, esApps.sURL "
sql &= " FROM esApps"
sql &= " INNER JOIN esAppsUsers "
sql &= " ON esApps.iAppID = esAppsUsers.iAppID "
sql &= " INNER JOIN esUsers "
sql &= " ON esAppsUsers.iUserID = esUsers.iUserID "
sql &= " WHERE sLoginID = @sLoginID "
sql = String.Format(sql, Apps.LoginIDNoDomain(LoginID))
Try
cmd = New SqlCommand(sql)
cmd.Parameters.Add(New _
SqlParameter("@sLoginID", SqlDbType.Char))
cmd.Parameters("@sLoginID").Value = _
Apps.LoginIDNoDomain(LoginID)
cmd.Connection = New SqlConnection(mConnectString)
da = New SqlDataAdapter(cmd)
da.Fill(ds)
Return ds
Catch ex As Exception
Throw ex
End Try
End Function

CreateLoginToken 方法

用户单击在 DataGrid 中的应用程序后，必须生成一个新令牌。CreateLoginToken 方法负责执行此任务。

// C#
public string CreateLoginToken(string appName,
string loginID, int userID, int appID)
{
SqlCommand cmd = new SqlCommand();
SqlParameter param;
string token;
string sql;
// 生成新令牌
token = GenerateToken();
sql = "INSERT INTO esAppToken(sToken, sAppName, ";
sql += " sLoginID, iUserID, iAppID, dtCreated) ";
sql += " VALUES(@sToken, @sAppName, @sLoginID, ";
sql += "        @iUserID, @iAppID, @dtCreated) ";
param = new SqlParameter("@sToken", SqlDbType.Char);
param.Value = token;
cmd.Parameters.Add(param);
param = new SqlParameter("@sAppName", SqlDbType.Char);
param.Value = appName;
cmd.Parameters.Add(param);
param = new SqlParameter("@sLoginID", SqlDbType.Char);
param.Value = Apps.LoginIDNoDomain(loginID);
cmd.Parameters.Add(param);
param = new SqlParameter("@iUserID", SqlDbType.Int);
param.Value = userID;
cmd.Parameters.Add(param);
param = new SqlParameter("@iAppID", SqlDbType.Int);
param.Value = appID;
cmd.Parameters.Add(param);
param = new SqlParameter("@dtCreated", SqlDbType.DateTime);
param.Value = DateTime.Now;
cmd.Parameters.Add(param);
try
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
cmd.Connection = new SqlConnection(mConnectString);
cmd.Connection.Open();
cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (cmd.Connection.State != ConnectionState.Closed)
{
cmd.Connection.Close();
cmd.Connection.Dispose();
}
}
return token;
}
' VB.NET
Public Function CreateLoginToken(ByVal AppName As String, _
ByVal LoginID As String, ByVal UserID As Integer, _
ByVal AppID As Integer) As String
Dim cmd As New SqlCommand
Dim param As SqlParameter
Dim token As String
Dim sql As String
' 生成新令牌
token = GenerateToken()
sql = "INSERT INTO esAppToken(sToken, sAppName, "
sql &= " sLoginID, iUserID, iAppID, dtCreated) "
sql &= " VALUES(@sToken, @sAppName, @sLoginID, "
sql &= " @iUserID, @iAppID, @dtCreated)"
sql = String.Format(sql, token, AppName, _
Apps.LoginIDNoDomain(LoginID), UserID, AppID, _
DateTime.Now.ToString())
param = New SqlParameter("@sToken", SqlDbType.Char)
param.Value = token
cmd.Parameters.Add(param)
param = New SqlParameter("@sAppName", SqlDbType.Char)
param.Value = AppName
cmd.Parameters.Add(param)
param = New SqlParameter("@sLoginID", SqlDbType.Char)
param.Value = Apps.LoginIDNoDomain(LoginID)
cmd.Parameters.Add(param)
param = New SqlParameter("@iUserID", SqlDbType.Int)
param.Value = UserID
cmd.Parameters.Add(param)
param = New SqlParameter("@iAppID", SqlDbType.Int)
param.Value = AppID
cmd.Parameters.Add(param)
param = New SqlParameter("@dtCreated", SqlDbType.DateTime)
param.Value = DateTime.Now
cmd.Parameters.Add(param)
Try
cmd.CommandType = CommandType.Text
cmd.CommandText = sql
cmd.Connection = New SqlConnection(mConnectString)
cmd.Connection.Open()
cmd.ExecuteNonQuery()
Catch ex As Exception
Throw ex
Finally
If cmd.Connection.State <> ConnectionState.Closed Then
cmd.Connection.Close()
cmd.Connection.Dispose()
End If
End Try
Return token
End Function

要创建令牌，应调用 GenerateToken 方法。此方法独立于 CreateLoginToken 方法的原因是，它允许您更改以后要生成的令牌的类型。在本文的末尾，提出了有关的设想。此方法使用 Guid 类生成一个新的 GUID 作为令牌。

// C#
public string GenerateToken()
{
return System.Guid.NewGuid().ToString();
}
' VB.NET
Public Function GenerateToken() As String
Return System.Guid.NewGuid().ToString()
End Function

返回页首

在 Web 应用程序中检索令牌

要从应用程序启动器测试启动应用程序，应创建一个可从启动器调用的用于测试的 Web 应用程序（参见图 10）。这个用于测试的 Web 应用程序将使用前面所讨论的 AppLauncherDataxx 项目。

修改 Web.Config

要创建集成了单一登录系统的 Web 应用程序，首先需要修改 Web.config 文件，并创建 <appSettings> 区段，以存储连接字符串，从而与 eSecurity 数据库进行交互。还需要存储应用程序 ID 和应用程序名称，以供外部用户进入时使用。因为外部用户进入时，尚未创建令牌，这时需要知道用户选择的应用程序，以便在建立用户角色时加载要使用的 AppToken 对象。在本文后面的内容中，您会了解如何这样做。

<appSettings>
<add key="eSecurityConnectString"
value="server=(local);Database=
eSecurity;uid=mUserID;pwd=myPassword"></add>
<add key="eSecurityAppID" value="1"></add>
<add key="eSecurityAppName" value="Payroll"></add>
</appSettings>

您还需要设置 Web 应用程序，以使用基于窗体的身份验证。要进行此操作，请修改 <authentication> 元素，如下所示。

<authentication mode="Forms">
<forms name="AppTest" loginUrl="Login.aspx" />
</authentication>

最后，为了拒绝匿名用户访问，还需要修改 <authorization> 元素。

<authorization>
<deny users="?" />
</authorization>

AppLogin.aspx 页

请记住，从应用程序启动器调用的每个应用程序都会调用 AppLogin 页，并向此页传递生成的令牌。AppLogin 页会验证此令牌是否正确，从 esAppToken 表检索相关的信息，然后删除 esAppToken 中的记录，以使该令牌不被重复使用。

// C#
private void Page_Load(object sender, System.EventArgs e)
{
VerifyToken();
}
private void VerifyToken()
{
Apps app = new Apps();
AppToken al;
try
{
al = app.VerifyLoginToken(
Request.QueryString["Token"].ToString());
if(al.LoginID.Trim() == "")
{
// 非有效登录
// 将其重定向至默认页面
// 这将使用户转至登录页面
Response.Redirect("default.aspx");
}
else
{
// 创建窗体身份验证 Cookie
// 设置窗体身份验证变量
FormsAuthentication.Initialize();
FormsAuthentication.SetAuthCookie(
al.LoginID.ToString(), false);
// 设置应用程序令牌对象
Application["AppToken"] = al;
// 重定向至默认页面
Response.Redirect("default.aspx");
}
}
catch
{
// 通过默认页面将用户重定向至登录页面
Response.Redirect("default.aspx");
}
}
' VB.NET
Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
VerifyToken()
End Sub
Private Sub VerifyToken()
Dim app As New Apps
Dim al As AppToken
Try
al = app.VerifyLoginToken( _
Request.QueryString("Token").ToString())
If al.LoginID.Trim() = "" Then
' 非有效登录
' 将其重定向至默认页面
' 这将使用户转至登录页面
Response.Redirect("default.aspx")
Else
' 创建窗体身份验证 Cookie
' 设置窗体身份验证变量
FormsAuthentication.Initialize()
FormsAuthentication.SetAuthCookie( _
al.LoginID.ToString(), False)
' 设置应用程序令牌对象
Application("AppToken") = al
' 重定向至默认页面
Response.Redirect("default.aspx")
End If
Catch
' 通过默认页面将用户重定向至登录页面
Response.Redirect("default.aspx")
End Try
End Sub

在 VerifyLogin 方法中，首先检查令牌是否有效。这一操作通过调用 Apps 类中的 VerifyLoginToken 方法完成。此方法返回 AppToken 类的一个实例。如果此类的 LoginID 属性存在值，就表明此用户是有效用户。如果没有值，则令牌无效。在令牌无效的情况下，此方法将用户重定向到网站中的 default.aspx 页面。当然，如果打开了基于窗体的身份验证，用户会被强制重定向至 Login.aspx 页面，被请求重新登录。

调用 FormsAuthentication.Initialize 和 FormsAuthentication.SetAuthCookie 方法可以向外发送窗体验证 cookie。这会将内存中的 cookie 发送到浏览器。每次用户返回此站点时，ASP.NET 运行库都会检查此 cookie。

VerifyLoginToken 方法

此方法通过查询行接受生成的令牌，并对其进行检查，以确保令牌有效。此方法会转到 esAppToken 表检查此令牌。如果在表中找到此令牌，则将表中所有的值置于 AppToken 对象的各个属性中，然后从此方法返回该 AppToken 对象。

// C#
public AppToken VerifyLoginToken(string Token)
{
AppToken al = new AppToken();
DataSet ds = new DataSet();
SqlCommand cmd;
DataRow dr;
SqlDataAdapter da;
string sql;
sql = "SELECT iAppTokenID, sAppName, sLoginID, ";
sql += " iAppID, iUserID ";
sql += " FROM esAppToken";
sql += " WHERE sToken = @sToken ";
try
{
cmd = new SqlCommand(sql);
cmd.Parameters.Add(new
SqlParameter("@sToken", SqlDbType.Char));
cmd.Parameters["@sToken"].Value = Token;
cmd.Connection = new SqlConnection(mConnectString);
da = new SqlDataAdapter(cmd);
da.Fill(ds);
if (ds.Tables[0].Rows.Count > 0)
{
dr = ds.Tables[0].Rows[0];
al.LoginID = dr["sLoginID"].ToString();
al.AppName = dr["sAppName"].ToString();
al.AppKey = Convert.ToInt32(dr["iAppID"]);
al.LoginKey = Convert.ToInt32(dr["iUserID"]);
DeleteToken(Convert.ToInt32(dr["iAppTokenID"]));
}
}
catch (Exception ex)
{
throw ex;
}
return al;
}
' VB.NET
Public Function VerifyLoginToken(ByVal Token As String) As AppToken
Dim al As New AppToken
Dim ds As New DataSet
Dim cmd As SqlCommand
Dim dr As DataRow
Dim da As SqlDataAdapter
Dim sql As String
sql = "SELECT iAppTokenID, sAppName, sLoginID, "
sql &= " iAppID, iUserID "
sql &= " FROM esAppToken"
sql &= " WHERE sToken = @sToken "
Try
cmd = New SqlCommand(sql)
cmd.Parameters.Add(New _
SqlParameter("@sToken", SqlDbType.Char))
cmd.Parameters("@sToken").Value = Token
cmd.Connection = New SqlConnection(mConnectString)
da = New SqlDataAdapter(cmd)
da.Fill(ds)
If ds.Tables(0).Rows.Count > 0 Then
dr = ds.Tables(0).Rows(0)
al.LoginID = dr("sLoginID").ToString()
al.AppName = dr("sAppName").ToString()
al.AppKey = Convert.ToInt32(dr("iAppID"))
al.LoginKey = Convert.ToInt32(dr("iUserID"))
DeleteToken(Convert.ToInt32(dr("iAppTokenID")))
End If
Catch ex As Exception
Throw ex
End Try
Return al
End Function

基于角色的安全性

用户通过 Web 应用程序的验证后，将被重定向至 default.aspx 页面。因为已经向浏览器发送了身份验证 cookie，每次都会将此 cookie 发送回来。在向用户传送请求的页面之前，将调用 global.asax 文件中的 Application_AuthenticateRequest 方法。只有在这个方法中才能够建立要与此用户关联的任何角色。我不打算在这里显示此方法的用法，因为专门有文章对其进行讨论。您可以查看示例代码中使用此方法的例子。基于角色的安全性的代码十分简单。您完全可以改进此代码，使其能够使用缓存。它的目的只是告诉您如何着手去做。

返回页首

增强您的单一登录系统

本文介绍了创建企业级安全系统方面的很多内容。但若要介绍创建企业级安全系统的所有方面，则超出了本文的范围。例如，您还应当添加一系列的维护屏幕，以允许管理员添加用户，并且建立用户和应用程序之间的映射关系。也需要对这组屏幕采取安全措施，以便只有特定角色内的用户才能够打开它们。

系统另外一个需要增强的地方是自动添加不在系统中的域用户的能力。它能够帮助您向系统中添加用户，而不必手工输入用户信息，要么您也可以编写添加用户的应用程序。您一般会将这些用户指定为默认角色，以便只允许他们运行某些应用程序而不是全部应用程序。此外，如果以这种方式添加了新用户，管理员还应当收到电子邮件形式的通知信息。

因为这种安全系统依赖于生成的特定的令牌，而在创建令牌之后，会立即调用 Web 应用程序，所以如果应用程序未启动以响应请求，就可能出现问题。如果出现这种情况，那么令牌就会留在数据库中，从而导致潜在的安全性风险。所以还需要预先安排一项工作，用来删除超过指定时间长度的令牌。也可以创建自己特定的令牌，该令牌由令牌和创建此令牌的时间组成。这样就只需修改 VerifyLoginToken 方法，以检查时间，确保它小于指定的时间长度。

本文中使用的令牌为 GUID 类型，它强制您回调数据库，以检索用户的配置文件信息。本系统的一个较好的增强方案是使用基于 WS-Security 增强标准的令牌加密配置文件信息，并仅将其作为令牌由应用程序启动器传递给每个 Web 应用程序。这样能够避免每次往返数据库。

当然，你可能希望更改代码中的所有动态 SQL 调用，以使用存储过程和带参数的命令对象来避免遭受任何 SQL 流量注入攻击，彻底保证数据表的安全。对于命令对象，应使用存储过程和参数。

返回页首

安装示例

本文附带两个示例应用程序。它们都是 Web 应用程序。解决方案中还包含为每个 Web 应用程序提供的类库。示例具有 Microsoft Visual Basic® .NET 和 C# 两种版本，可以选择希望使用的版本。解决方案文件中还有一个 .SQL 文件，可用来帮助您在数据库中创建所需的表。.SQL 文件用于 SQL Server，但经过简单的修改，也可用于其他数据库系统。以下是安装示例应用程序应执行的步骤。

• 在 DBMS 中创建名为 eSecurity 的数据库。

• 执行 .SQL 文件，在 eSecurity 数据库中创建表。

• 将提供的 .ZIP 文件解压到文件夹中。

• 创建虚拟目录，使其指向希望使用的每个文件夹。例如，如果使用的是 VB.NET 版本的示例，那么请创建两个名称分别为 AppLauncherVB 和 AppTestVB 的虚拟目录，并使其指向这两个文件夹。

• 修改 .SLN 文件，使其指向您创建的虚拟目录文件夹。

返回页首

结论

Web 应用程序的单一登录系统有助于节省用户时间，并减轻在企业中因需要记忆登录 ID 和密码所带来的不便。此外，它还允许外部用户使用内部 Web 应用程序，而不必将这些用户添加到域中。实现这样一个系统只需创建几个简单的表和类。但要创建一个完全使用单一登录方式的可靠的企业级安全系统，还需要做许多工作，本文中的示例可以使您有一个良好的开端。

目标

本模块用于：

• 使用服务组件使 Web 应用程序调用要求客户端使用客户端证书进行身份验证的 Web 服务。

适用于：

本模块适用于下列产品和技术：

• Microsoft® Windows® XP 或 Windows 2000 Server（带 Service Pack 3）以及更高版本的操作系统

• Microsoft Internet 信息服务 5.0

• Microsoft 证书服务（如果需要生成自己的客户端证书）

• Microsoft .NET Framework 版本 1.0（带 Service Pack 2）

• Microsoft SQL Server™ 2000（带 Service Pack 2）以及更高版本

• Microsoft Visual C#® .NET 开发工具

本模块的使用方法

要最大程度的使用本模块：

• 必须有使用 Visual C# .NET 和 Microsoft Visual Studio_ .NET 开发系统的经验。

• 必须有使用 ASP.NET 开发 Web 应用程序的经验。

• 必须有开发和实现在 Enterprise Services (COM+) 上下文中运行的服务组件的经验。

• 必须有开发和实现 Windows 服务的经验。

• 必须了解如何使用 Windows 管理工具创建 Windows 用户帐户。

• 必须能够访问证书颁发机构 (CA)，如 Microsoft 证书服务（如果要生成新的客户端证书）。

• 如果不愿生成自己的证书，则必须决定从哪个商业 CA 申请一个客户端证书。某些 CA 将对此服务收费。

• 必须有一个安装了 SSL 证书的 Web 服务器。有关详细信息，请参阅“How To Set Up SSL on a Web Server”。

• 阅读模块“Security Model for ASP.NET Applications”，此模块介绍了客户端证书并将其与其他形式的身份验证进行比较。

本页内容

摘要
预备知识
创建一个简单的 Web 服务
将 Web 服务虚拟目录配置为需要客户端证书
创建运行服务组件的自定义帐户
为自定义帐户申请一个客户端证书
使用浏览器测试客户端证书
将客户端证书导出到文件
开发用于调用 Web 服务的服务组件
配置和安装服务组件
开发一个 Web 应用程序来调用服务组件
其他资源

摘要

客户端证书为 Web 应用程序提供了一种出色的身份验证机制。浏览器或其他客户端应用程序必须提供有效的证书才能被授予对应用程序的访问权，从而使客户端无需再提供用户名和密码。这就使得在创建由其他客户端应用程序访问的安全 Web 服务时，客户端证书非常有用。

本模块描述了如何调用一个配置为需要 Web 应用程序颁发客户端证书的 Web 服务。

返回页首

预备知识

在使用客户端证书时，您的应用程序还可从创建客户端应用程序和 Web 服务之间的安全信道（使用安全套接字层 [SSL]）中获益。这使您能够安全地将保密信息发送给 Web 服务，或从 Web 服务送回。SSL 确保了消息的完整性和保密性。

注 本模块中的信息还适用于 ASP.NET 和 IIS 宿主的远程组件。

为什么使用服务组件？

本模块中提供的解决方案使用了一个服务组件，该服务组件配置为使用自定义服务帐户在 Enterprise Services 服务器应用程序中运行。ASP.NET Web 应用程序调用服务组件，这会导致对 Web 服务的调用（传递一个客户端证书）。此解决方案的配置如图 1 所示。

这种安排确保了系统在与 Web 服务通信时有权访问用户配置文件。最初的 SSL 握手需要这种方式。

注 用于运行 Web 应用程序的 ASPNET 帐户具有“拒绝交互登录”特权，从而禁止使用此帐户进行交互式登录。因此，此帐户没有用户配置文件。不要向 ASPNET 帐户（或用于运行 Web 应用程序的任何帐户）授予交互登录功能。在配置帐户来运行 Web 应用程序时，应始终遵循最小特权原则，尽可能少地向帐户授予特权。有关详细信息，请参阅“How To Create a Custom Account to Run ASP.NET”。

为什么需要用户配置文件？

在您申请使用需要客户端证书的 Web 服务时，客户端和服务器之间会发生 SSL 握手。要交换的一些组件有服务器证书、客户端证书以及由客户端生成的“预主机密 (pre-master secret)”。稍后在协议中使用此机密来生成“主机密 (master secret)”。

为了让服务器验证证书的提交者是否确实是私钥的持有者，客户端必须使用私钥加密预主机密，并将已加密的预主机密发送给服务器。为了使系统获得客户端的私钥来对预主机密进行签名，系统必须从客户端的密钥存储区中获得私钥。密钥存储区位于客户端的配置文件中，必须加载此配置文件。

注 在本模块中，Web 服务计算机（它宿主 Web服务）被命名为“WSServer”，Web 服务客户端计算机（它宿主 ASP.NET Web 应用程序和服务组件）被命名为“WSClient”。

返回页首

创建一个简单的 Web 服务

要在 Web 服务宿主计算机上创建一个简单的 Web 服务，请执行下列操作：

1. 启动 Visual Studio .NET 并创建一个新的名为 SecureMath 的 Visual C# ASP.NET Web 服务应用程序。

2. 将 service1.asmx 重命名为 math.asmx。

3. 打开 math.asmx.cs 并将 Service1 类重命名为 math。

4. 将下列 Web 方法添加到 math 类。

    [WebMethod]
       public long Add(long operand1, long operand2)
       {
       return (operand1 + operand2);
       }
       

5. 在 Build 菜单上，单击 Build Solution 来创建 Web 服务。

返回页首

将 Web 服务虚拟目录配置为需要客户端证书

此过程使用 Internet 信息服务将 Web 服务的虚拟目录配置为用于 SSL 并需要证书。

此过程假定您在 Web 服务器上安装了有效的证书。有关安装 Web 服务器证书的详细信息，请参阅“How To Setup SSL on a Web Server”。

要将 Web 服务虚拟目录配置为需要客户端证书，请执行下列操作：

• 启动 Web 服务宿主计算机上的 Internet 信息服务。

• 导航到 SecureMath 虚拟目录。

• 右键单击 SecureMath，然后单击 Properties。

• 单击 Directory Security 选项卡。

• 在 Secure communications 下，单击 Edit。

  如果 Edit 不可用，最可能的原因是尚未安装 Web 服务器证书。

• 选择 Require secure channel (SSL) 复选框。

• 选择 Require client certificates 选项。

• 单击 OK，然后再次单击 OK。

• 在 Inheritance Overrides 对话框中，单击 Select All，然后单击 OK 关闭 SecureMath 属性对话框。

此操作将新的安全性设置应用到虚拟目录根下的所有子目录。

返回页首

创建运行服务组件的自定义帐户

此过程在 Web 服务客户端计算机上创建一个新的用户帐户，您将使用这个帐户运行调用 Web 服务的服务组件。

要创建运行服务组件的自定义帐户，请执行下列操作：

1. 用强密码在客户端计算机上创建一个新的用户帐户。清除 User must change password at next logon 复选框，然后选择 Password never expires 选项。

2. 将此帐户添加到 Administrators 组。

用于加载用户配置文件的帐户必须是本地计算机上的管理员。

返回页首

为自定义帐户申请一个客户端证书

在此过程中，您将使用新的自定义帐户登录到客户端计算机。然后，将发出要获得证书的申请。此过程假定您使用 Microsoft 证书服务。如果您没有使用 Microsoft 证书服务创建新证书，则在使用自定义帐户登录的同时，向您希望的 CA 发出要获得客户端证书的申请并安装证书。

此过程还假定已将 Microsoft 证书服务配置为自动颁发证书来响应证书申请。还可以将其配置为挂起请求，这要求管理员明确颁发证书。

要检查 Microsoft 证书服务设置，请执行下列操作：

1. 在 Microsoft 证书服务计算机上，单击 Administrative Tools 程序组中的 Certification Authority。

2. 展开 Certification Authority (Local)，右键单击证书颁发机构，然后单击 Properties。

3. 单击 Policy Module 选项卡，然后单击 Configure。

4. 检查默认操作。

下列过程假定已选中 Always issue the certificate。

要为自定义帐户请求一个客户端证书，请执行下列操作：

1. 注销客户端计算机并使用自定义帐户重新登录。

   此操作强制为自定义帐户创建用户配置文件。

2. 为了申请客户端证书，请浏览 CA。例如，如果您的 CA 位于 CAServer 计算机上，则浏览到下列位置。

   http://caserver/certsrv
       

3. 单击 Request a certificate，然后单击 Next。

4. 确保选中 User Certificate，然后单击 Next。

5. 单击 Submit。

   生成申请并发送到 CA 进行处理。

6. 在证书颁发且您收到来自 CA 服务器的响应后，单击 Install this certificate。

7. 确保颁发 CA 的证书作为受信任的根证书颁发机构安装在本地计算机上。

   要确认此操作，请执行下列步骤：

   1. 在任务栏上，单击 Start 按钮，然后单击 Run。

   2. 键入 mmc，然后单击 OK。

   3. 在 File 菜单上，单击 Add/Remove Snap-in。

   4. 单击 Add。

   5. 单击 Certificates，然后单击 Add。

   6. 单击 Computer account，然后单击 Next。

   7. 单击 Local Computer: (the computer this console is running on)，然后单击 Finish。

   8. 单击 Close，然后单击 OK。

   9. 在 MMC 管理单元的左侧窗格中，展开 Certificates (Local Computer)。

   10. 展开 Trusted Root Certification Authorities，然后单击 Certificates。

   11. 确认已列出了 CA 证书。

       如果未列出 CA，则执行下列步骤：

   12. 浏览到 http://caserver/certsrv。

   13. 单击 Retrieve the CA certificate or certificate revocation list，然后单击 Next。

   14. 单击 Install this CA certification path。

返回页首

使用浏览器测试客户端证书

在此过程中，您将浏览到 Web 服务，以便确认服务器证书或客户端证书没有问题。

要使用浏览器测试客户端证书，请执行下列操作：

• 使用 Internet Explorer 并导航到 https://server/SecureMath/Math.asmx。

  确保您指定了“https”，因为此站点配置为需要 SSL。

• Client Authentication 对话框应显示出来。选择客户端证书，然后单击 OK。

• 确认在浏览器内成功地显示了 Web 服务测试页。

  如果看到图 2 所示的对话框，则需要将证书颁发机构的证书安装到如前一过程中所述的 Trusted Root Certification Authorities 存储中。

  

  图 2. Security Alert 对话框

返回页首

将客户端证书导出到文件

此过程将客户端证书导出到文件。随后，当服务组件在需要将证书传递给 Web 服务时，将检索此文件。

要将客户端证书导出到文件，请执行下列操作：

1. 在 Internet Explorer 中，单击 Tools 菜单上的 Internet Options。

2. 单击 Content 选项卡。

3. 单击 Certificates。

4. 单击客户端证书，然后单击 Export。

5. 单击 Next 跳过“证书导出向导”的欢迎对话框。

6. 确保选中了 No, do not export the private key，然后单击 Next。

7. 确保选中了 DER encoded binary X.509 (.CER)，然后单击 Next。

   您必须使用此格式，因为 .NET Framework 不支持 Base-64 或 PKCS #7 格式。

8. 输入一个导出文件名。注意 .cer 导出文件的位置，因为在后续过程中将再次需要此位置。

9. 单击 Next，然后单击 Finish 导出此证书。

10. 关闭 Internet Explorer。

11. 注销此计算机并使用常规开发帐户重新登录。

返回页首

开发用于调用 Web 服务的服务组件

此过程创建了一个新的 Visual C# 类库应用程序以及用于调用 Web 服务的服务组件。此过程假定您正在使用客户端计算机。

要开发用于调用 Web 服务的服务组件，请执行下列操作：

1. 启动 Visual Studio.NET 并创建一个新的名为 WebServiceRequestor 的 Visual C# 类库项目。

2. 添加一个对 SecureMath Web 服务的 Web 引用。

   重要事项 在添加 Web 引用前，必须临时地将 Web 服务的虚拟目录重新配置为不需要客户端证书（尽管仍需要 SSL）。在成功添加 Web 引用后，将虚拟目录配置更改回需要客户端证书。

   实际上，如果站点需要客户端证书，则服务的发行商将 WSDL 作为独立的脱机文件使用，服务的使用者可以使用此文件来创建代理。

   在 Add Web Reference 对话框中，确保在指定 Web 服务位置时指定 https。如果失败，则会产生错误，因为 Web 服务虚拟目录配置为需要 SSL。

3. 添加一个到 System.EnterpriseServices 程序集的引用。

4. 将 class1.cs 重命名为 ProfileManager.cs。

5. 将下列类定义添加到 ProfileManager.cs（替换主干 class1 类）。ProfileManager 类使用 P/Invoke 调用 LoadUserProfile 和 UnloadUserProfile Win32 API。

   internal class ProfileManager
       {
       [DllImport("Userenv.dll", SetLastError=true,
       CharSet=System.Runtime.InteropServices.CharSet.Auto)]
       internal static extern bool LoadUserProfile(IntPtr hToken,
       ref PROFILEINFO lpProfileInfo);
       [DllImport("Userenv.dll", SetLastError=true,
       CharSet=System.Runtime.InteropServices.CharSet.Auto)]
       internal static extern bool  UnloadUserProfile(IntPtr hToken,
       IntPtr hProfile);
       [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi)]
       public struct PROFILEINFO
       {
       public int dwSize;
       public int dwFlags;
       public String lpUserName;
       public String lpProfilePath;
       public String lpDefaultPath;
       public String lpServerName;
       public String lpPolicyPath;
       public IntPtr hProfile;
       }
       }
       

6. 将另一个名为 MathServiceComponent.cs 的类文件添加到项目中。

7. 将下列 using 语句添加到 MathServiceComponent.cs 的现有 using 语句下。

   using System.Net;
       using System.Web.Services;
       using System.Security.Principal;
       using System.EnterpriseServices;
       using System.Runtime.InteropServices;
       using System.Security.Cryptography.X509Certificates;
       using WebServiceRequestor.WebReference1;
       

8. 添加下列类定义，它提供了一个公共 CallMathWebService 方法。在稍后的过程中，您将从客户端 ASP.NET Web 应用程序中调用此方法。

   注 在下列代码中，用在步骤 3“Create a Custom Account for Running the Serviced Componen”中创建的自定义帐户的名称替换用于加载用户配置文件的帐户名。

   // This class calls the web service that requires a certificate.
       public class MathServiceComponent : ServicedComponent
       {
       [DllImport("advapi32.dll", CharSet=CharSet.Auto, SetLastError=true)]
       private extern static bool DuplicateToken(IntPtr ExistingTokenHandle,
       int SECURITY_IMPERSONATION_LEVEL,
       ref IntPtr DuplicateTokenHandle);
       [DllImport("kernel32.dll", CharSet=CharSet.Auto)]
       private extern static bool CloseHandle(IntPtr handle);
       // Calls the Web service that requires client certificates
       // certFilepath points to the .cer file to use
       // url is the Web service url
       // operand1 and operand2 are the parameters to pass to the Web service
       public long CallMathWebService(String certFilepath,
       String url, int operand1, int operand2)
       {
       bool retVal = false;
       // Need to duplicate the token. LoadUserProfile needs a token with
       // TOKEN_IMPERSONATE and TOKEN_DUPLICATE.
       const int SecurityImpersonation = 2;
       IntPtr dupeTokenHandle = DupeToken(WindowsIdentity.GetCurrent().Token,
       SecurityImpersonation);
       if(IntPtr.Zero == dupeTokenHandle)
       {
       throw new Exception("Unable to duplicate token.");
       }
       // Load the profile.
       ProfileManager.PROFILEINFO profile = new ProfileManager.PROFILEINFO();
       profile.dwSize = 32;
       //TODO: Replace with custom account name created in step 3.
       profile.lpUserName = @"machinename\customaccountname";
       retVal = ProfileManager.LoadUserProfile(dupeTokenHandle, ref profile);
       if(false == retVal)
       {
       throw new Exception("Error loading user profile. " +
       Marshal.GetLastWin32Error());
       }
       // Instantiate the Web service proxy
       math mathservice = new math();
       mathservice.Url = url;
       String certPath = certFilepath;
       mathservice.ClientCertificates.Add(
       X509Certificate.CreateFromCertFile(certPath));
       long lngResult = 0;
       try
       {
       lngResult = mathservice.Add(operand1, operand2);
       }
       catch(Exception ex)
       {
       if(ex is WebException)
       {
       WebException we = ex as WebException;
       WebResponse webResponse = we.Response;
       throw new Exception("Exception calling method. " + ex.Message);
       }
       }
       ProfileManager.UnloadUserProfile(WindowsIdentity.GetCurrent().Token,
       profile.hProfile);
       CloseHandle(dupeTokenHandle);
       return lngResult;
       }
       private IntPtr DupeToken(IntPtr token, int Level)
       {
       IntPtr dupeTokenHandle = new IntPtr(0);
       bool retVal = DuplicateToken(token, Level, ref dupeTokenHandle);
       if (false == retVal)
       {
       return IntPtr.Zero;
       }
       return dupeTokenHandle;
       }
       } // end class
       

9. 在 Build 菜单上，单击 Build Solution。

返回页首

配置和安装服务组件

此过程将配置服务组件，生成强名称，将其安装到全局程序集缓存中并注册到 COM+。

1. 打开 assemblyinfo.cs 并将下列 using 语句添加到现有 using 语句下。

   using System.EnterpriseServices;
       

2. 将下列程序集级属性添加到 assemblyinfo.cs，将服务组件配置为在 COM+ 服务器应用程序中运行。

    [assembly: ApplicationActivation(ActivationOption.Server)]
       

3. 打开一个命令提示符窗口并更改为当前项目的目录。

4. 使用 sn.exe 实用工具来生成含有公共-私有密钥对的密钥文件。

   sn.exe -k WebServiceRequestor.snk
       

5. 返回到 Visual Studio .NET。

6. 定位到 assemblyinfo.cs 内的 [AssemblyKeyFile] 属性，并将其修改为引用项目目录内的密钥文件，如下所示。

    [assembly: AssemblyKeyFile(@"..\..\WebServiceRequestor.snk")]
       

7. 在 Build 菜单上，单击 Build Solution。

8. 返回到命令提示符，然后运行下列命令将程序集添加到全局程序集缓存。

   gacutil.exe /i bin\debug\webservicerequestor.dll
       

9. 运行下列命令来将此程序集注册到 COM+。

   regsvcs bin\debug\webservicerequestor.dll
       

10. 启动 Component Services（位于 Administrative Tools 程序组下）。

11. 展开 Component Services、Computers 和 My Computer 节点。

12. 展开 COM+ Applications 文件夹。

13. 右键单击 WebServiceRequestor，然后单击 Properties。

14. 单击 Identity 选项卡。

15. 选择 This user: 选项并输入对应于此前创建的自定义帐户的帐户详细信息。

    此操作将 COM+ 应用程序配置为使用自定义帐户来运行。

16. 单击 OK 关闭 Properties 对话框。

17. 关闭组件服务。

返回页首

开发一个 Web 应用程序来调用服务组件

此过程创建一个简单的 ASP.NET Web 应用程序，可将其用作客户端应用程序来调用 Web 服务（通过服务组件）。

要开发一个 Web 应用程序来调用服务组件，请执行下列操作：

1. 在 Web 服务客户端计算机上，创建一个新的名为 SecureMathClient 的 Visual C# ASP.NET Web 应用程序。

2. 添加一个对 System.EnterpriseServices 的引用。

3. 添加一个对 WebServiceRequestor 服务组件的引用。

   浏览到位于 bin\debug 文件夹内 WebServiceRequestor 项目目录下的 WebServiceRequestor.dll。

4. 打开 WebForm1.aspx.cs 并将下列 using 语句添加到现有的 using 语句下。

   using WebServiceRequestor;
       

5. 在 Designer 模式下查看 WebForm1.aspx 并使用下列 ID 创建一个如图 3 所示的窗体：

   • operand1

   • operand2

   • result

   • add

   

   图 3. Web 窗体控件排列

6. 双击 Add 创建一个按钮单击事件处理程序。

7. 将下列代码添加到事件处理程序中：

   注 将 certPath 字符串设置为在步骤 6“将客户端证书导出到文件”期间导出的证书文件的位置。

   将带有 HTTPS URL 的 url 字符串设置为 Web 服务。

   private void add_Click(object sender, System.EventArgs e)
       {
       // TODO: Replace with a valid path to your certificate
       string certPath = @"C:\CustomAccountCert.cer";
       // TODO: Replace with a valid URL to your Web service
       string url = "https://wsserver/SecureMath/math.asmx";
       MathServiceComponent mathComp = new MathServiceComponent();
       long addResult = mathComp.CallMathWebService( certPath,
       url,
       Int32.Parse(operand1.Text),
       Int32.Parse(operand2.Text));
       result.Text = addResult.ToString();
       }
       

8. 在 Build 菜单上，单击 Build Solution。

9. 运行此应用程序。输入要进行加法运算的两个数，然后单击 Add。

   Web 应用程序将调用服务组件，此服务组件使用 SSL 并传递客户端证书来调用 Web 服务。

目标

本模块用于：

• 获取并安装客户端证书。

• 创建一个需要客户端证书的 ASP.NET Web 应用程序。

适用于

本模块适用于下列产品和技术：

• Microsoft® Windows® XP 或 Windows 2000 Server（带 Service Pack 3）以及更高版本的操作系统。

• Microsoft Internet 信息服务 (IIS) 5.0

• Microsoft 证书服务（如果您需要生成自己的证书的话）

• Microsoft .NET Framework 版本 1.0（带 Service Pack 2）以及更高版本

• Microsoft Visual C#® .NET 开发工具

本模块的使用方法

要最大程度地利用本模块：

• 必须有使用 Visual C# .NET 和 Microsoft Visual Studio® .NET 开发系统的经验。

• 必须有使用 ASP.NET 开发 Web 应用程序的经验。

• 必须有配置 IIS 的经验。

• 必须能访问某个证书颁发机构 (CA)，如 Microsoft 证书服务（如果要生成新的客户端证书）。

• 如果您不想生成自己的证书，则必须决定要从哪个商业 CA 来申请客户端证书。某些 CA 将对此服务收费。

• 必须有一个安装了 SSL 证书的 Web 服务器。有关详细信息，请阅读“如何在 Web 服务器上建立 SSL”。

• 有关客户端证书与其他形式的身份验证的比较，请阅读模块“Security Model for ASP.NET Applications”。

本页内容

摘要
创建一个简单的 Web 应用程序
将 Web 应用程序配置为需要客户端证书
申请并安装客户端证书
验证客户端证书操作
其他资源

摘要

客户端证书为 Web 应用程序提供了一种出色的身份验证机制。浏览器或其他客户端应用程序必须提供有效的证书才能被授予对应用程序的访问权，从而使客户端无需再提供用户名和密码。这就使得在创建由其他客户端应用程序访问的安全的 Web 服务时，客户端证书非常有用。

本模块描述如何获取和安装客户端证书，并说明如何创建需要客户端证书的 Web 应用程序。

返回页首

创建一个简单的 Web 应用程序

在此过程中，您将创建一个简单的用于测试目的的 Web 应用程序。

要创建一个简单的 Web 应用程序，请执行下列操作：

1. 启动 Visual Studio .NET 并创建一个新的名为 SecureApp 的 Visual C# ASP.NET Web 应用程序。

2. 将标签控件从工具箱拖到 WebForm1.aspx Web 窗体，然后将其 ID 属性设置为 message。

3. 再将一个标签拖到 WebForm1.aspx，并将其 ID 属性设置为 certData。

4. 将下列代码添加到 Page_Load 事件过程中。

   string username;
       username = User.Identity.Name;
       message.Text = "Welcome " + username;
       HttpClientCertificate cert = Request.ClientCertificate;
       if (cert.IsPresent)
       {
       certData.Text = "Client certificate retrieved";
       }
       else
       {
       certData.Text = "No client certificate";
       }
       

5. 在 Build 菜单上，单击 Build Solution。

6. 启动 Internet Explorer 并导航到 http://localhost/SecureApp/WebForm1.aspx。

   应显示带有消息“Welcome”（不显示用户名，因为用户尚未进行身份验证）和“No client certificate”的页。

7. 关闭 Internet Explorer。

返回页首

将 Web 应用程序配置为需要客户端证书

此过程使用 Internet 信息服务 (IIS) 将 Web 应用程序的虚拟目录配置为需要证书。

此过程假定您在 Web 服务器上安装了有效的证书。有关安装 Web 服务器证书的详细信息，请参阅“如何在 Web 服务器上建立 SSL”。

要将 Web 应用程序的虚拟目录配置为需要证书，请执行下列操作：

1. 在 Web 服务主机上，启动 IIS。

2. 导航到 SecureApp 虚拟目录。

3. 右击 SecureApp，然后单击 Properties。

4. 单击 Directory Security 选项卡。

5. 在 Secure communications 下，单击 Edit。

   如果 Edit 不可用，最可能的原因是未安装 Web 服务器证书。

6. 选择 Require secure channel (SSL) 复选框。

7. 选择 Require client certificates 选项。

8. 单击 OK，然后再次单击 OK。

9. 在 Inheritance Overrides 对话框中，单击 Select All，然后单击 OK 关闭 SecureApp 属性对话框。

   此操作将新安全性设置应用到虚拟目录根下的所有子目录。

10. 要确认已正确配置了 Web 站点，请启动 Internet Explorer 并浏览（使用 HTTPS）到 https://localhost/SecureApp/webform1.aspx。

11. Internet Explorer 显示出一个 Client Authentication 对话框，要求您选择一个客户端证书。由于您尚未安装客户端证书，因此请单击 OK，并确认显示出一个通知您此页需要客户端证书的错误页。

12. 关闭 Internet Explorer。

返回页首

申请并安装客户端证书

此过程将安装客户端证书。您可以使用任何证书颁发机构的证书，也可以使用 Microsoft 证书服务生成自己的证书，如以下几部分所述。

此过程假定 Microsoft 证书服务已针对挂起申请进行了配置，它需要管理员显式颁发证书。它还可以配置为自动颁发证书来响应证书申请。

要检查证书申请状态设置，请执行下列操作：

1. 在 Microsoft 证书服务计算机上，从 Administrative Tools 程序组中选择 Certification Authority。

2. 展开 Certification Authority (Local)，右击证书颁发机构并单击 Properties。

3. 单击 Policy Module 选项卡，然后单击 Configure。

4. 检查默认操作。

   下面的过程假定已选中 Set the certificate request status to pending. Administrator must explicitly issue the certificate。

要申请客户端证书，请执行下列操作：

1. 启动 Internet Explorer 并导航到 http:// hostname/certsrv，其中 hostname 是安装 Microsoft 证书服务的计算机的名称。

2. 单击 Request a certificate，然后单击 Next。

3. 在 Choose Request Type 页上，单击 User Certificate，然后单击 Next。

4. 单击 Submit 来完成申请。

5. 关闭 Internet Explorer。

要颁发客户端证书，请执行下列操作：

1. 从 Administrative Tools 程序组中，启动 Certification Authority 工具。

2. 展开证书颁发机构，然后选择 Pending Requests 文件夹。

3. 选择刚提交的证书申请，指向 Action 菜单上的 All Tasks，然后单击 Issue。

4. 确认证书在 Issued Certificates 文件夹中显示出来，然后双击它以查看其内容。

5. 在 Details 选项卡上，单击 Copy to File 将此证书保存为 Base-64 编码的 X.509 证书。

6. 关闭此证书的属性窗口。

7. 关闭“证书颁发机构”工具。

要安装客户端证书，请执行下列操作：

1. 要查看证书，请启动 Windows Explorer，导航到上一过程中保存的 .cer 文件，然后双击此文件。

2. 单击 Install Certificate，然后单击 Certificate Import Wizard 的第一页上的 Next。

3. 选择 Automatically select the certificate store based on the type of certificate，然后单击 Next。

4. 单击 Finish 完成此向导。取消确认消息框，然后单击 OK 关闭证书。

返回页首

验证客户端证书操作

本过程验证您是否可以使用客户端证书来访问 SecureApp 应用程序。

要验证客户端证书操作，请执行下列操作：

• 启动 Internet Explorer 并导航到 https://localhost/SecureApp/webform1.aspx。

• 确认 Web 页是否成功显示出来。

本页内容

活动概述
活动摘要表

活动：Web 应用程序的威胁建模

目的：确定方案中的相关威胁和漏洞，以帮助您构建应用程序的安全设计。

输入：

• 主要用例和使用方案

• 数据流

• 数据架构

• 部署关系图

输出：

• 威胁列表

• 漏洞列表

活动概述

威胁建模的五个主要步骤如图 1 所示。应该通过重复执行步骤 2 至步骤 5 来逐步细化威胁模型。随着应用程序开发周期的向前推进，您会发现有关应用程序设计的更多内容，并能够添加更多细节。

威胁建模的五个步骤是：

• 步骤 1 ：确定安全目标。目标清晰有助于您将注意力集中在威胁建模活动上，以及确定后续步骤要做多少工作。

• 步骤 2 ：创建应用程序概述。逐条列出应用程序的重要特征和参与者有助于在步骤 4 中确定相关威胁。

• 步骤 3 ：分解应用程序。全面了解应用程序的结构可以使您更轻松地发现更相关、更具体的威胁。

• 步骤 4 ：确定威胁。使用步骤 2 和 3 中的详细信息来确定与您的应用程序方案和上下文相关的威胁。

• 步骤 5 ：确定漏洞。检查应用程序的各层以确定与威胁有关的弱点。使用漏洞类别来帮助您关注最常出现错误的区域。

返回页首

活动摘要表

表 1 归纳威胁建模活动，并展示每个步骤的输入和输出。

本文讨论了企业实施SOA时遇到的八个重要挑战的不同的解决方法，同时根据EDS与客户的经验给出了一些例子。

本页内容

介绍
架构组件
挑战
结论

介绍

你可能考虑过在你的企业中实施SOA。在这个实施过程中，会遇到复杂的挑战—包括那些仅对你的公司和产业存在的挑战。然而，通过一种灵活的路线图去控制实施SOA，你可以在遇到这些挑战时很快的面对并解决它们。

SOA是一个重要的新的架构范例，它支持中间层解决方案的模块化实现。尤其适用于当多个根据不同技术开发的应用软件在不同的平台上运行时，平台间相互交互的情况。

然而，SOA并不是一夜醒来就可以顺利实施的。企业首先必须朝着构建先进的组件和服务的方向努力。一个路线图和企业特有标准是必备的先决条件—以保证这个架构在企业系统化的实施。

这篇文章针对企业实施SOA将遇到的各种挑战提供了不同的解决方法。基于EDS与客户的实践给出了一些例子。同时，还在构造一个工具时根据EDS的经验进行调节，这个工具为企业网络服务的配置、管理和部署提供了便利。

返回页首

架构组件

图1显示了一个SOA架构的基本组件。这些组件包括：

• 服务提供者. 一个服务提供者是一个组件或组件集，在无状态方式下完成商业功能，接受预定义的输入和输出。

• 服务消费者. 一个服务消费者是一个组件集，有兴趣去使用一项或多项由服务提供者提供的服务。

• 服务仓库. 一个服务仓库包括对服务的描述。服务提供者在服务仓库中记录他们提供的服务，而服务消费者接受服务仓库来查找提供的服务有哪些。

图 1. SOA架构组件

返回页首

挑战

在企业实施SOA时，需要面对的关键挑战有八个。这些挑战在一个典型的工程部署计划中排列如下：

1. 服务识别.服务是什么？一个指定的服务能够提供什么样的商业功能？如何提供最佳粒度的服务？

2. 服务场所. 在企业内，哪里是服务场所的最佳位置？

3. 服务范围定义. 这些服务如何集合进逻辑领域？

4. 服务打包. 现存的原有主机系统提供的功能如何工程化包装为可再度使用的服务？

5. 服务协调. 这些复杂的服务如何协调？

6. 服务发送. 服务消费者提出的要求如何发送到适当的服务或服务领域？

7. 服务管理. 企业如何按步骤在管理和维持服务？

8. 服务通信标准采用. 企业如何长期采取一个特定的标准？

服务识别

挑战

构建SOA时，正确的识别服务和确定相应的服务提供者是一个关键的首要步骤。现今世界，在企业内部，类似的商业功能可以由多个系统提供。

方法

解决这个挑战有两个方法；服务合理化与服务合并。服务合理化是对所有提供特定商业功能的系统和应用平台进行一个仔细的分析。通过服务合理化，由少量访问系统实现的商业功能可以在海量访问系统平台。在流线型系统上使用这种方法，我们可以传送更多可靠的服务。

图2 . 服务合理化账号配置

图2提供了一个服务合理化的例子。大量的前台应用，比如在线银行、CRM与VRU，需要账号配置商业功能提供的相关信息。客户与账号库的信息记录系统应该支持账号配置商业功能。根据前台应用的特性调用这个功能，可以返回账号配置的各个子集。

在这个例子中，企业为客户增加在线与VRU访问的同时，减少了需要人类交互的CRM的使用。

服务合并

服务合并主要将所有各种服务合并成一种服务方式，这种方式支持多个个体服务表现出的用户界面的扩展。这种合并后重定义的服务可以被各个独立的应用系统稳定的提供。

图3 . 服务合并产品目录

图3说明了一个产品目录库如何被三个独立的服务访问。三个服务被用来寻找一个产品相关信息的预定义子集。在服务合并后，只有一个服务来提供全部产品目录。这个服务包括了各个独立服务在服务合并中提供的信息。服务消费者选择产品目录中感兴趣的部分。服务合并就这样成为一种高效率的方式帮助大量流线型服务支持同样的商业功能。

服务场所

挑战服务经常在一个特定记录系统上的特定商业实体集上执行。这个记录系统是服务执行的一个理想场所。然而，分布式架构解决方案将导致商业数据通过多个应用平台扩散，而同样商业实体将产生大量由记录系统产生的记录。两个系统间的数据同步就成为一个关键需求。这种情况下，哪里才是最佳服务场所呢？

方法

这里有三种方法来解决这个挑战；基于内容方法，基于服务库方法，与后端复制方法。

基于内容方法

这个方法将收到的服务请求发送到正确的记录系统。此解决方案支持服务消费者眼中服务场所透明化：算法确定服务消费者并不知道一个特定服务是在哪里提供的。给出一个请求时，记录系统支持服务被打包为一个逻辑体。

图4 . 基于内容方法

图4说明了一个基于内容方法的例子。在这个例子中，消费者的相关信息被按区域隔离开来。属于特定区域的消费者信息被储存在数据中心特定区域的库中。然而，任意区域的服务消费者都可以访问这些信息。接收到服务请求后，消费者配置服务执行一个商业规则来确定对消费者有用的信息在哪个特定区域中存储。然后，消费者配置服务再将这个请求发送到找到的区域。

基于服务库方法

上面描述了一个基于内容方法的变化，基于服务库方法显示在图5中。消费者配置服务执行与基于内容方法同样的商业规则时，协调服务配置的信息来指引服务请求到正确的区域。这种方法使得必要时改变服务请求发送逻辑更容易。通过改变服务配置信息，服务请求可以被很容易的发送到不同的区域，不用再改变消费者配置服务自身的商业规则。

图5 . 基于服务库方法

后端复制方法

这个方法协调内在的交互应用连接能力去访问包括指定信息的物理库。这样，各个记录系统可以像逻辑接口一样去访问分布在系统上的信息。这个服务可以在每个记录系统上执行。这些被操作的数据的物理位置对服务本身是透明的。图6说明了一个后段复制方法的情况。同样的消费者配置服务在靠近服务的记录系统被执行。当其他区域库的信息被请求时，存在于数据库的技术提供的的内在数据复制能力可以支持获取相关数据。

图6 . 后端复制方法

服务范围定义

挑战

将服务按照逻辑区域分类减少了组件的数量，从而简化了结构。因为一些结构上的原因，这些组可以被协调：负载平衡，存取控制，代理模拟，与纵向或横向的商业逻辑区分。然而，对于企业内的商业部门与技术中心来说，要在定义一个正确的服务范围上取得一致，经常有一系列的挑战。什么才是一个好的服务范围逻辑组呢？

方法

我们可以选择多个方法来定义服务范围。表格1显示了一个跨商业部门的应用和平台分类例子。这个例子将用来说明在这部分中讨论的每种方法的重要特征。

功能范围

功能范围以一个特定服务集合的商业功能为基础。最好安排企业内的商业过程所有者来定义和隔离商业功能以及对应的服务范围。通过这样分组，某一特定范围的商业过程所有者可以自己控制此范围内的服务。只要商业过程所有者确信在他们各自范围内的服务也被提供给了其他企业，他们就完全控制了对这个服务的架构和应用。

在上面的例子中，有三个功能服务范围：贷款，金融和保险。在这些领域内的服务必须跨越多个平台与后端应用来处理属于他们领域的请求。然而，这些商业处理在一个特定领域内使类似的，不管执行服务的是那些应用或平台。

1. 贷款. 贷款范围覆盖服务显然包含在放出和管理贷款给消费者和企业用户中。这个服务领域包括住房抵押贷款与购买其他价值等同于住房的商品的贷款。服务可能包括借贷、分期还款与利息计算。

2. 金融. 金融范围覆盖服务显然通过大量媒介与金融有联系，这些媒介包括网络，ATM，VRU和金融中心。服务可能包括开设一个账户，查询帐户余额与账户间的转帐。

3. 保险. 保险范围覆盖服务仅包括对保险产业的服务。服务可能包括保险费计算、医疗历史查找与投诉处理。

基于技术范围

跨越多个技术平台的功能服务范围使得保持与每一个技术平台同步的内在挑战时时存在。出售方努力用一种方式揭示工业标准来支持他们的解决方案并使得企业依赖于他们的架构，硬件和软件。基于技术的服务范围规范允许特定技术能力的高效使用。

在这个例子中，服务范围可以按照UNIX，Linux与Windows平台分类。基础服务比如错误记录，事务监控与时间处理是这类服务很好的处理对象。他们依赖于运行平台，但独立于驱动这个功能服务范围的商业过程。

基于应用范围

作为一种帮助企业面对更新现有系统需求的方法，企业应用集成的概念应运而生。现在，企业拥有大量前台应用系统，因此需要集成这些类似的系统，通过不同的方式处理、打包并提出同样的数据。

基于应用服务范围允许一个特定系统提供分组服务。这种方法使得管理和维持服务更加容易，因为一个领域内的系统对所有的服务都是一样的。

在上面的例子中，SAP，Siebel，PeopleSoft，IBM DB2与Oracle都是很好的基于应用范围的客户。这些范围中的一些典型服务列在下面。

SAP

• 账户支付—帐目核对

• 财政计算

PeopleSoft

• 增加雇员

• 更新补偿

Oracle

• 数据复制

• 基于账户信息的角色说明

服务打包

挑战

在SOA中，一个企业系统必须功能以服务为主。方便集成的构造系统可以很容易的做到这一点。面向结构的系统有一些困难。是一些集成电路应用构造了这些系统，系统包括了所有的商业规则与过程逻辑。这些信息被分配给多个多个连接程序的集合。

一个SOA支持独立的服务—没有任何其它服务的相关知识。结构化程序与特定上下文紧密联系在一起。这些结构化程序如何被再次打包围独立的服务？

方法

我们可以使用一个共有三个步骤地方法来应对这个挑战。这个方法包括在架构方案中定义逻辑商业领域、为这些商业领域分配程序集、并使两个程序集之间松耦合关联。这些步骤在下面详细说明：

1. 商业领域定义. 在这个步骤中，我们建立商业功能的逻辑域。我们可以使用程序调用规划图和过程流图来定义这些商业领域。我们也可以通过调节架构系统的程序间的关系来定义商业领域。[架构系统的程序往往是与其它程序有关。在这种程序到程序的关系中，有一些通用的商业方法。]

2. 程序分配. 在标准的商业领域，我们分配独立的程序到一个特定的领域。我们非常需要再分配那些没有讲自己关联到对应商业领域的程序，使在特定商业领域内排列更有规则。在前面讨论过的服务范围概念的引导下，这样一组程序集可以排列的更好。

3. 松耦合关联. 在这一点上，甚至即使这些程序已经在标准商业领域内排列过了，她们海狮需要彼此间相互关联。在最后这一步骤中，我们将原来的轻度耦合关联替换为一个更加松散的耦合。为了这样做，我们重新定义架构程序界面，这样其它的应用可以调节自己；程序提供同样输出并且接受同样输入，就像它们开始做的那样。这个重定义过程提供了一个非常好的机会来确保这些程序就像一个整体来服务企业，而不是单个程序独立服务企业—就像它们开始被创建时那样。这个方法同时也使现有架构系统朝着面向服务方向靠近，配置他们使它们在内部是结构系统，外部对服务用户来说是面向服务的。

服务协调

一个特定服务的存在是因为至少有一个服务消费者发出了这项服务的请求。然而，在一些情况下，一个服务不得不调用许多其它服务来满足服务消费者的原始请求。简单的情况导致一个特定服务扩展原始请求到一个或者更多其它服务上。然而，复杂的情况可以导致大量服务的递归调用，在一些极端的例子里，一些服务的内部依赖调用—可以导致死循环。

这里有一个例子。当一张机票被出售时，下面的服务需要被执行：

取得消费者

取得日程表

检查可用信息

提供费用

接受支付

构建协调能力使得每一服务在如此复杂情况下都能顺利执行

如图7所示。

图7 . 服务协调挑战

这些综合服务如何被协调？

商业过程管理方法

这种方法使独立的服务更简单：这些服务没有能力来协调其它为了满足请求而调用的服务。

替代性的，这种能力被放置于商业过程层。商业过程负责调用每一个子服务，这样来提供组合服务来满足消费者的原始请求。商业过程就成为一个组成服务的专业例子。

图8 . 商业过程管理方法

图8说明了这张机票购买的商业过程，包括每一个独立执行的逻辑步骤。这个商业过程通过一个简单的访问来查找服务，然后按顺序协调为适当步骤。

服务发送

挑战

SOA还要提供对消费者的地域透明性：服务消费者必须能够在任意服务范围内发送任意服务的请求。同时，在调用一个服务前访问服务库是一个减少时间的步骤。这些架构在保证可接受的系统性能水平的同时，如何提供地域透明性？

方法

我们能够用两种方法解决服务发送挑战。

智能服务

使用这种方法，我们为所有的服务建造各自的地域信息。这就消除了一些跳跃性的请求同时也导致了服务重载。考虑到服务以及服务所在场所的更新频率，这种方法有着持久性。另外，这种方法并不与松耦合的服务架构时刻一致。不过，他支持一个更高层次执行的解决方案。

发送

另一种方法是智能的移动将发送从一个发送组件移动到独立的服务。这些发送组件可以在两种层次：服务域和服务。

1. 服务域发送. 一个服务域发送在所有服务域的场所上是智能的。当接收到一个请求，它确定是否它能够仅靠自己支持的服务来满足这个请求。如果能，它处理这个请求。如果不能，它将这个请求传送到正确的可以满足这个请求的服务范围。

2. 服务发送. 一个服务发送在一个服务范围内被调用，在域内将请求发送到正确的服务。只有哪些可以在域内满足服务的请求被传递给服务发送。服务发送减少了各个服务上场所信息的负载。

服务域发送和服务发送对那些包括一定数量服务的服务域来说更加实用。对那些只有几个的服务，智能服务是一个可行的选择。

图9 . 服务域发送和服务发送

图9说明了一个域内服务域发送与服务发送的概念。

服务管理

挑战

不管一个企业以何种方式定义服务域，这里有几种哲学与技术上的方法来创建新的服务或修改现存的服务。谁来监控，定义和管理企业内这些对现存服务的改变？

方法

一个企业可以通过建立一个内部管理体来更有效的应对这个挑战。大量的管理模型都是可能的。下面讨论了一些。

中心管理

通过中心管理，企业内的管理体从各个服务域和各个没有直接依赖于各个服务域的部分得到说明。也必须从不同的商业部门和一些事件处理专家那里得到说明，这些专家可能在解决方案的关键技术组件上发表看法。中心管理体就像一个服务的删减后的完整回顾，也包括对现存服务的改变，在允许他们执行前。

图10 . 中心管理模型

如上面图10所示，中心管理体依赖于企业建立与执行SOA时的指导方针与标准。还依赖于通过这些标准与其他商业部门，架构小组和技术小组的交流。

分布式管理

通过分布式管理，每一个商业部门可以独立控制如何在自身组织内部提供服务。分布式管理要求一种功能性服务领域方法。一个服务架构委员会可以依旧提供高水平的指导方针的标准给服务执行，但是委员会不必批准商业部门内部对现有服务架构的调整。委员会可以建议与指导方针保持一致但不能强迫这样做。

图11 . 分布式管理模型

如图11 分布式管理模型所示，商业部门A与B都有权利来建立他们自己的独立的标准。然而适当的被动标准（架构和程序标准）都在适当的位置等候部门去遵守。

服务通信标准采用

挑战

对纵向工业来说，通信标准是不同的，这导致了基于一个数据元素集合和通信方式的标准。然而，在一个独立数据元素层次，这些标准是弹性的，企业能够适应它们来与企业特定商业限制保持一致。这样，同一企业内的不同的商业部门可以通过不同方式与统一标准保持一致。另外，这些标准还提供了客户数据元素的创建。

举例，IFX标准确定了多种方式对一个顾客：

• 〈客户唯一标识符〉内部数据库用来唯一标识消费者

• 〈客户登录标识符〉消费者登录使用的账号

两个域都是唯一的。企业采用IFX标准就必须决定使用每个域的时间和地点。有时，消费者甚至决定忽略这两个标识符，自己重新创建一个客户域，这个客户域对企业记录系统更适合！

如何使企业选择一个单独的标准成为可能？

元数据管理方法

企业内元数据库支持关键商业体的可靠描述。这些描述是分布在多个企业系统上信息的扩展集。数据字典也就是逻辑与物理数据模型是元数据库定义和维护的关键输入。

元数据管理组在前面讨论过的中心管理模型中应该是一个焦点集中的组。元数据管理必须在企业层次执行。换句话说，即使一个企业选择了分布式管理模型来维护服务，它也必须选择一个中心管理模型来支持元数据。

在上面的例子中，消费者的元数据包括一个简单形式的标识符，这个标识符是唯一的。另外，元数据要确保维持管理信息的描述，这些描述包括登录帐号和密码。因此，即使一个企业已经通过一个客户域为消费者选择了唯一标识符，这个客户域也必须在元数据库中被描述。

返回页首

结论

像一声春雷，SOA已经被IT界迅速接受，它帮助企业用模块化的方法搭建并部署服务。然而，架构的实际应用需要仔细的规划。感兴趣的企业必须首先确定他们适合长期应用和支持SOA。

通过开发并制定一个实现路线图，企业可以预先应对好一系列将遇到的挑战。每个企业都将面对一个独特的挑战集；相应的应对这些挑战的方法也就各自不同。这些挑战的影响—在执行中与执行后—还依赖于这些特定企业的环境。

关于作者

Easwaran G. Nadhan是EDS，Plano，Texas顾问中的关键人物。他有在软件产业设计并实现分布式解决方案的20年的经验。最近，他借助自己的经验帮助企业完成企业应用集成，同时实现了SOA。这篇文章中的例子以EDS提供服务的实践经验为基础。可以写信与Nadhan联系easwaran.nadhan@eds.com

摘要： Dino Esposito 一直在编写有关 ASP.NET 控件开发的系列教程，并在以下第四部分中介绍了如何使用和创建复合控件。

随本文提供了 Visual Basic 和 C# 两种源代码。请从 此处 下载。

本页内容

简介
复合控件的要点是什么？
复合控件的常见方案
复合控件的呈现引擎
用于解决设计时问题的 CompositeControl
生成数据绑定复合控件
结论

简介

复合控件只不过是普通的 ASP.NET 控件，还不属于要论及的另一种类型的 ASP.NET 服务器控件。既然这样，为什么在各书籍和文档中总要留出专门的章节来论述复合控件呢？ASP.NET 复合控件有什么特别之处呢？

顾名思义，复合控件是将多个其他控件聚集在某单一顶部和单一 API 下的控件。如果某个自定义控件由一个标签和一个文本框组成，就可以说该控件是一个复合控件。“复合”一词表明该控件本质上是由其他构成组件在运行时组合而成。复合控件所暴露的方法集和属性集通常（但不是必须）由构成组件的方法和属性提供，并加入一些新成员。复合控件也可以引发自定义事件，还可以处理并激起子控件所引起的事件。

复合控件在 ASP.NET 中如此特别并不是因为其有可能成为服务器控件新类型的代表。更确切的说是因为它在呈现时获得了 ASP.NET 运行时的支持。

复合控件是一个功能强大的工具，可以生成丰富复杂的组件，这些组件产生自活动对象的相互作用而不是某些字符串生成器对象的标记输出。复合控件以构成控件树的形式呈现，每个构成控件都有其自己的生命周期和事件，并且所有构成控件都联合构成一个全新的 API，并按需要尽可能地抽象化。

在本文中，我将论述复合控件的内部体系结构，以阐明它在多种情况下为您带来的好处。接下来，我将生成一个复合列表控件，与我在以前文章中所述控件的功能集相比，此控件的功能集更为丰富。

返回页首

复合控件的要点是什么？

前一段时间，我曾经自己尝试在 ASP.NET. 中研究复合控件。我从 MSDN 文档学习理论和实践知识，并也设计出一些不错的控件。但是，只有当我有一次在纯属偶然的情况下看到以下示例时，我才真正领悟到复合控件的要点（和优点）。设想一下由两个其他控件（Label 和 TextBox）的组合生成的迄今为止最简单（也是最常见）的控件。以下介绍了一种编写这种控件的可行方法。我们将其命名为 LabelTextBox。

public class LabelTextBox :WebControl, INamingContainer
{
public string Text {
get {
object o = ViewState["Text"];
if (o == null)
return String.Empty;
return (string) o;
}
set { ViewState["Text"] = value; }
}
public string Title {
get {
object o = ViewState["Title"];
if (o == null)
return String.Empty;
return (string) o;
}
set { ViewState["Title"] = value; }
}
protected override void CreateChildControls()
{
Controls.Clear();
CreateControlHierarchy();
ClearChildViewState();
}
protected virtual void CreateControlHierarchy()
{
TextBox t = new TextBox();
Label l = new Label();
t.Text = Text;
l.Text = Title;
Controls.Add(l);
Controls.Add(t);
}
}

该控件具备两个公共属性（Text 和 Title）以及一个呈现引擎。这两个属性保存在视图状态中，并分别表示 TextBox 和 Label 的内容。该控件对于 Render 方法没有替换方法，并通过 CreateChildControls 替换方法来生成其自己的标记。我马上就会详述呈现阶段的例行过程。CreateChildControls 的代码首先清除子控件的集合，然后为当前控件输出的构成控件生成控件树。CreateControlHierarchy 是一种特定于控件的方法，不要求必须标记为受保护和虚拟。但请注意，大多数自带复合控件（例如 DataGrid）只是通过一个类似的虚拟方法来暴露用于生成控件树的逻辑。

CreateControlHierarchy 方法会根据需要实例化多个构成组件，然后合成最终输出。完成之后，各控件将被添加到当前控件的 Controls 集合。如果希望控件的输出结果是一个 HTML 表，则可以创建一个 Table 控件，并相应添加含有各自内容的行和单元格。所有行、单元格和所含控件都是最外部表的子项。这时，您只需将 Table 控件添加到 Controls 集合中即可。在上述代码中，Label 和 TextBox 是 LabelTextBox 控件的直接子项并直接添加到集合中。控件的呈现状态和运行状态都很正常。

单纯从性能上看，创建控件的暂态实例不如呈现一些纯文本的效率高。让我们考虑一种无需子控件就能编写上述控件的替代方法。这次让我们将其命名为 TextBoxLabel。

public class LabelTextBox :WebControl, INamingContainer
{
:
protected override void Render(HtmlTextWriter writer)
{
string markup = String.Format(
"<span>{0}</span><input type=text value='{1}'>",
Title, Text);
writer.Write(markup);
}
}

该控件具备同样的两个属性（Text 和 Title）并替换了 Render 方法。正如您所看到的那样，其实现过程相当简单并且代码运行速度也略胜一筹。您可以通过在字符串生成器中合成文本并为浏览器输出最终标记来取代合成子控件的这种方法。同样，此时控件的呈现状态良好。但我们真的可以说它的运行状态也同样良好吗？图 1 显示了在示例页中运行的两个控件。

在页面中启用跟踪功能并重新运行。当页面显示在浏览器中时，将其向下滚动并查看控件树。它将如下所示：

复合控件由构成组件的活动实例组成。ASP.NET 运行时会发现这些子控件，并可以在处理已发布数据时同它们进行直接通信。其结果是，子控件可以自己处理视图状态并自动激起事件。

对于基于标记合成的控件，情况则不同。如图中所示，该控件是一个带有空 Controls 集合的代码基本单位。如果标记在页面中注入交互元素（文本框、按钮、下拉式菜单），则 ASP.NET 在不涉及控件本身的情况下无法处理回发数据及事件。

尝试在两个文本框中输入一些文本并单击图 1 中的“刷新”按钮，这样就可以发生一个回发。第一个控件（即复合控件）在经过回发后会正确保留所分配的文本。使用 Render 方法的第二个控件在经过回发后会丢失新文本。为什么会这样呢？其中兼有两个原因。

第一个原因是，在上述标记中我没有为 <input> 标记命名。这样，它的内容就不会回发。请注意，必须使用 name 属性来为元素命名。让我们对 Render 方法做如下修改。

protected override void Render(HtmlTextWriter writer)
{
string markup = String.Format(
"<span>{0}</span><input type=text value='{1}' name='{2}'>",
Title, Text, ClientID);
writer.Write(markup);
}

注入客户端页面的 <input> 元素现在与服务器控件使用相同的 ID。页面回发时，ASP.NET 运行时可发现一个与已发布字段的 ID 相匹配的服务器控件。但它并不知道如何处理该控件。要使 ASP.NET 将所有的客户端更改都应用于服务器控件，该控件必须实现 IPostBackDataHandler 接口。

包含 TextBox 的复合控件无需担心回发问题，因为所嵌入的控件会使用 ASP.NET 自动解决该问题。呈现 TextBox 的控件需要与 ASP.NET 进行交互，以确保可以正确处理回发值并正常引发事件。以下代码表明了如何扩展 TextBoxLabel 控件以使其完全支持回发。

bool LoadPostData(string postDataKey, NameValueCollection postCollection)
{
string currentText = Text;
string postedText = postCollection[postDataKey];
if (!currentText.Equals(postedText, StringComparison.Ordinal))
{
Text = postedText;
return true;
}
return false;
}
void IPostBackDataHandler.RaisePostDataChangedEvent()
{
return;
}

返回页首

复合控件的常见方案

复合控件是适合用于构建复杂组件的工具，在复合控件中，多个子控件聚合到一起，并在彼此之间以及与外部之间进行交互。呈现控件则只用于只读式控件聚合，其输出不包括交互元素（例如下拉框或文本框）。

如果您对事件处理和回发数据感兴趣，我强烈建议您选择复合控件。如果使用子控件，则生成复杂的控件树会更加轻松，而且最终结果也更清晰简洁。此外，只有需要提供附加功能时才需要处理回发接口。

呈现控件不但需要实现附加接口，还要将含有属性值的标记静态部分缝合到一起。

复合控件的优点还表现在可以呈现多个同类项，这与在 DataGrid 控件中的情况类似。将每个构成项作为活动对象启用使您可以引发创建事件并以编程方式访问它们的属性。在 ASP.NET 2.0 中，对于要完全实现实际的数据绑定复合控件（上述控件只是随便的举例）所需的样板代码，绝大部分都隐藏在新基类的折叠部分中：CompositeDataBoundControl。

返回页首

复合控件的呈现引擎

在深入探讨 ASP.NET 2.0 编码技术之前，让我们回顾一下复合控件的内部例行过程。我们提到过，复合控件的呈现是集中围绕 CreateChildControls 方法进行的，该方法从 Control 基类继承而来。您可能会认为，要使服务器控件呈现其内容，替换 Render 方法是必不可少的一步。正如我们先前所看到的，如果 CreateChildControls 被替换，则并不总是需要执行这一步。但是，何时在控件调用栈中调用 CreateChildControls 呢？

如图中所示，在页面第一次显示时，会在预呈现阶段调用 CreateChildControls。

特别是，请求处理代码（在 Page 类中）在将 PreRender 事件引发至页面和每个子控件之前会直接调用 EnsureChildControls。换言之，如果控件树还未完全生成，则不会呈现任何控件。

以下代码段例示了 EnsureChildControls（在 Control 基础上定义的另一种方法）的伪代码。

protected virtual void EnsureChildControls()
{
if (!ChildControlsCreated)
{
try {
CreateChildControls();
}
finally {
ChildControlsCreated = true;
}
}
}

此方法可能会在页面和控件的生命周期内反复调用。为避免控件重复，ChildControlsCreated 属性被设为 true。如果此属性返回 true，则该方法会立即退出。

当页面回发时，ChildControlsCreated 会在周期前期调用。如图 4 所示，它在已发布数据处理阶段调用。

当 ASP.NET 页面开始处理从客户端发布的数据时，它会尝试查找一个其 ID 与已发布字段的名称相匹配的服务器控件。在执行此步骤期间，页面代码会调用 Control 类中的 FindControl 方法。反之，该方法需要确保在进行操作之前控件树已完全生成，因此它调用 EnsureChildControls 并按需要生成控件层次结构。

那么要在 CreateChildControls 方法内部执行的代码是怎样的呢？尽管没有正式的指南可供遵循，但通常认为 CreateChildControls 至少必须完成以下任务：清除 Controls 集合，生成控件树，并清除子控件的视图状态。并不严格要求必须从 CreateChildControls 方法内部设置 ChildControlsCreated 属性。实际上，ASP.NET 页面框架始终通过 EnsureChildControls（此方法可自动设置布尔标记）来调用 CreateChildControls。

返回页首

用于解决设计时问题的 CompositeControl

随 ASP.NET 2.0 一同提供了一个名为 CompositeControl 的基类。因此，新的非数据绑定复合控件应该从该类派生而不是从 WebControl 派生。在开发控件方面，CompositeControl 的用法变动不大。您仍然需要替换 CreateChildControls 并按先前所述方式编码。那么 CompositeControl 的作用是什么？让我们先从其原型着手：

public class CompositeControl :WebControl,
INamingContainer,
ICompositeControlDesignerAccessor

使用该类就无需再用 INamingContainer 装饰控件，但这实际上并不是很重要，因为接口只是一个标记并且不包含任何方法。更为重要的是，该类实现了一个名为 ICompositeControlDesignerAccessor 的全新接口。

public interface ICompositeControlDesignerAccessor
{
void RecreateChildControls();
}

此接口由复合控件的标准设计器用于在设计时重建控件树。以下是 CompositeControl 中方法的默认实现过程。

void ICompositeControlDesignerAccessor.RecreateChildControls()
{
base.ChildControlsCreated = false;
EnsureChildControls();
}

简言之，如果您从 CompositeControl 派生复合控件，就不会遇到设计时的故障，而且无需采用技巧和妙计就可以使控件在运行时和设计时都能正常运行。

要充分理解此接口的重要性，可试以寄存某 LabelTextBox 复合控件的示例页为例，并将其转换为设计模式。控件在运行时工作正常，但在设计时却不可见。

如果只是用 CompositeControl 替换 WebControl，则控件在运行时仍然保持正常工作，而在设计时也会运行良好。

返回页首

生成数据绑定复合控件

大多数复杂的服务器控件都已绑定数据（也可能已经模板化），并且由各种子控件构成。这些控件保留了一个构成项（通常为表的行或单元格）的列表。该列表在经过回发后会保存在视图状态中，并且从绑定数据生成或从视图状态重建。该控件还在视图状态中保存其构成项的数量，以便在页面中其他控件引起回发时可以正确重建表结构。我将用 DataGrid 控件举例说明。

DataGrid 由一列行构成，每一行都代表绑定数据源中的一个记录。每个网格行都通过一个 DataGridRow 对象（从 TableRow 派生的一个类）表示。在各网格行创建完成并被添加到最终网格表时，诸如 ItemCreated 和 ItemDataBound 之类的相应事件将被引发至页面。当通过数据绑定创建 DataGrid 时，其行数由绑定项数和页面大小决定。如果带有 DataGrid 的页面回发会怎样？

这种情况下，如果是由 DataGrid 自身引起的回发（例如，用户单击以进行排序或标页），则新页面会再次通过数据绑定来呈现 DataGrid。这是显而易见的，因为 DataGrid 需要刷新数据进行显示。如果是主页回发，则情况就不同了，因为单击了页面上的另一个控件（例如某按钮）。这种情况下，DataGrid 不绑定到数据并且必须从视图状态进行重建。（如果禁用了视图状态，就是另外一种情况了，这时只能通过数据绑定显示网格。）

数据源不保存在视图状态中。作为复合控件，DataGrid 包含子控件，其中每个子控件都将自己的状态保存到视图状态并从视图状态恢复。DataGrid 只需跟踪在所有行和所包含控件从视图状态恢复之前它所必须重复执行的次数。此次数与所显示绑定项的数量一致，并且必须作为控件状态的一部分存储到视图状态中。在 ASP.NET 1.x 中，您必须自己学习并实现此模式。在 ASP.NET 2.0 中，从新类 CompositeDataBoundControl 派生您的复合控件就可以了。

让我们尝试使用一种显示可扩展数据绑定新闻标题行的网格类控件。在此过程中，我们将再度使用在前文中论及的 Headline 控件。

public class HeadlineListEx :CompositeDataBoundControl
{
:
}

HeadlineListEx 控件包含了一个收集了所有绑定数据项的 Items 集合属性。该集合为公共集合，并且可在与多数列表控件一起运行时通过编程方式填充。对典型数据绑定的支持是通过一对属性（DataTextField 和 DataTitleField）实现的。这两个属性表明了数据源中将用于填充新闻标题和文本的字段。Items 集合被保存到视图状态中。

要将 HeadlineListEx 控件转换为真正的复合控件，您首先需要从 CompositeDataBoundControl 将其派生出来，然后再替换 CreateChildControls。有意思的是，你会注意到 CreateChildControls 是重载方法。

override int CreateChildControls()
override int CreateChildControls(IEnumerable data, bool dataBinding)

第一个重载方法替换了在 Control 类中定义的方法。第二个重载方法是每个复合控件都必须替换的一种抽象方法。实际上，复合控件的开发工作简化为两大主要任务：

• 替换 CreateChildControls。

• 实现 Rows 集合属性以跟踪控件的所有构成项。

Rows 属性不同于 Items，因为它不保存在视图状态中，且具有与请求相同的生存期，并引用帮助程序对象而不是绑定数据项。

public virtual HeadlineRowCollection Rows
{
get
{
if (_rows == null)
_rows = new HeadlineRowCollection();
return _rows;
}
}

Rows 集合在控件生成时填充。让我们看一下 CreateChildControls 的替换方法。该方法采用了两个参数：绑定项和一个布尔标记，其中布尔标记用于指明该控件是通过数据绑定创建还是通过视图状态创建。（请注意示例程序文件中的程序员注释使用的是英文，本文中将其译为中文是为了便于参考。）

override int CreateChildControls(IEnumerable dataSource, bool dataBinding)
{
if (dataBinding)
{
string textField = DataTextField;
string titleField = DataTitleField;
if (dataSource != null)
{
foreach (object o in dataSource)
{
HeadlineItem elem = new HeadlineItem();
elem.Text = DataBinder.GetPropertyValue(o, textField, null);
elem.Title = DataBinder.GetPropertyValue(o, titleField, null);
Items.Add(elem);
}
}
}
// 开始生成控件层次结构
Table t = new Table();
Controls.Add(t);
Rows.Clear();
int itemCount = 0;
foreach(HeadlineItem item in Items)
{
HeadlineRowType type = HeadlineRowType.Simple;
HeadlineRow row = CreateHeadlineRow(t, type,
item, itemCount, dataBinding);
_rows.Add(row);
itemCount++;
}
return itemCount;
}

在数据绑定的情况下，首先要填充 Items 集合。遍历绑定集合，提取数据，然后填充 HeadlineItem 类的新建实例。接下来，遍历 Items 集合（该集合中可能包含以编程方式添加的附加项），并在控件中创建行。

HeadlineRow CreateHeadlineRow(Table t, HeadlineRowType rowType,
HeadlineItem dataItem, int index, bool dataBinding)
{
// 为最外部表创建新行
HeadlineRow row = new HeadlineRow(rowType);
// 为子控件创建单元格
TableCell cell = new TableCell();
row.Cells.Add(cell);
Headline item = new Headline();
cell.Controls.Add(item);
// 此时引发 HeadlineRowCreated 事件
// 将此行添加到所创建的 HTML 表
t.Rows.Add(row);
// 处理数据对象绑定
if (dataBinding)
{
row.DataItem = dataItem;
Headline ctl = (Headline) cell.Controls[0];
ctl.Text = dataItem.Text;
ctl.Title = dataItem.Title;
// 此时引发 HeadlineRowDataBound 事件
}
return row;
}

CreateHeadlineRow 方法会创建并返回 HeadlineRow 类（从 TableRow 派生而来）的一个实例。在这种情况下，此行会包含一个由 Headline 控件填充的单元格。在其他情况下，您可以更改此部分代码以根据需要添加多个单元格并相应填充内容。

重要的是，要将所需完成的任务分为两个不同的步骤：创建和数据绑定。首先，创建行的布局，引发行创建事件（如果有），并最后将其添加到父表中。接下来，如果要将控件绑定到数据，则设置对绑定数据敏感的子控件属性。完成操作后，则引发一个行数据绑定事件（如果有）。

请注意，该模式更准确描述了 ASP.NET 自带复合控件的内部体系结构。

可以使用以下代码来引发事件。

HeadlineRowEventArgs e = new HeadlineRowEventArgs();
e.DataItem = dataItem;
e.RowIndex = index;
e.RowType = rowType;
e.Item = row;
OnHeadlineRowDataBound(e);

请注意，只在要引发数据绑定事件时才设置 DataItem 属性。事件数据结构被任意设置为以下形式。如果您认为有必要，尽可以对其进行更改。

public class HeadlineRowEventArgs :EventArgs
{
public HeadlineItem DataItem;
public HeadlineRowType RowType;
public int RowIndex;
public HeadlineRow Item;
}

若要实际引发一个事件，通常的做法是使用一个如下定义的受保护方法。

protected virtual void OnHeadlineRowDataBound(HeadlineRowEventArgs e)
{
if (HeadlineRowDataBound != null)
HeadlineRowDataBound(this, e);
}

若要声明此事件，可在 ASP.NET 2.0 中使用新的一般事件处理程序委托。

public event EventHandler<HeadlineRowEventArgs> HeadlineRowDataBound;

在示例页中，一切均照常执行。您可在控件标记上定义处理程序并将某方法写入代码文件。示例如下。

<cc1:HeadlineListEx runat="server" ID="HeadlineListEx1"
DataTextField="notes" DataTitleField="lastname"
DataSourceID="MySource" OnHeadlineRowDataBound="HeadlineRowCreated" />

HeadlineRowCreated 事件处理程序的代码显示如下。

protected void HeadlineRowCreated(object sender, HeadlineRowEventArgs e)
{
if (e.DataItem.Title.Contains("Doe"))
e.Item.BackColor = Color.Red;
}

通过挂接数据绑定事件，所有含有 Doe 的项都将以红色背景呈现。

返回页首

结论

复合控件是通过将其他控件聚合在某一公用 API 顶下创建而成的控件。复合控件将保留自己子控件的活动实例，并且不仅限于呈现这些实例。通过检查页面跟踪输出中的控件树部分，您就可以很容易看到这一点。使用复合控件可以带来几点好处，例如可以简化对事件和回发的处理。在 ASP.NET 1.x 中生成复杂的数据绑定控件有点棘手，需要您深入了解一些实现细节。在引进 CompositeDataBoundControl 基类的情况下，这种复杂性在 ASP.NET 中基本可以迎刃而解。最后，如果在 ASP.NET 2.0 中需要非数据绑定的复合控件，则可以使用 CompositeControl 基类。对于数据绑定复合控件，则可以改为考虑 CompositeDataBoundControl。无论是哪种情况，您都必须提供一个 CreateChildControls 的有效替换方法，这是所有复合控件的核心，用于创建子控件层次结构。

作者简介

Dino Esposito 是 Solid Quality Learning 顾问，并且是 "Programming Microsoft ASP.NET 2.0" (Microsoft Press, 2005)（英文）的作者。Dino 居住在意大利，经常就世界范围的行业事件发表评论。请通过 cutting@microsoft.com 或者加入博客 http://weblogs.asp.net/despos 与其联系。

本页内容

	引言
	简化和缩短窗体代码
	开始：从反射中检索属性列表
	将对象属性值绑定到控件
	用已知属性设置未知控件的值
	反转过程：BindControlsToObject
	性能和 FormBinding 方案的扩展
	结论
	参考资料

<script runat="server">
protected void Page_Load(Object Src, EventArgs E) {
if (!IsPostBack) {
Document document =
Documents.GetDocument(Request.QueryString["DocumentID"]);
Title.Text = document.Title;
Active.Checked = document.Active;
CreatedDate.Text = document.CreatedDate.ToString();
AuthorID.FindByValue(document.AuthorID.ToString()).Selected =
true;
// ... 等等
HtmlBody.Text = document.HtmlBody;
}
}
protected void SaveButton_Click(Object Src, EventArgs E) {
Document document =
Documents.GetDocument(Request.QueryString["DocumentID"]);
document.Title = Title.Text;
document.Active = Active.Checked;
document.CreatedDate = Convert.ToDateTime(CreatedDate.Text);
document.AuthorID = Convert.ToInt32(AuthorID.SelectedItem.Value);
// ... 等等
document.HtmlBody = HtmlBody.Text;
Documents.Update(document);
}
</script>

返回页首

简化和缩短窗体代码

在以上代码中，对每个控件进行显式转换，并将其设置为窗体控件的正确属性。根据属性和窗体控件的数量，这部分代码可能会变长并难以管理。代码还应包含类型转换的错误更正和 ListControl，这将进一步增加复杂性。即使窗体是由代码生成工具（例如 Eric J. Smith 的优秀的 CodeSmith）生成的，当需要任何自定义逻辑关系时，很容易引入错误。

使用反射，可以仅使用单行代码便将业务对象的所有属性绑定到相应的窗体控件，从而减少代码的行数并增强可读性。完成反射系统的建立后，以上代码将简化为：

protected void Page_Load(Object Src, EventArgs E) {
if (!IsPostBack) {
Document document =
Documents.GetDocument(Request.QueryString["DocumentID"]);
FormBinding.BindObjectToControls(document);
}
}
protected void Save_Click(Object Src, EventArgs E) {
Document document =
Documents.GetDocument(Request.QueryString["DocumentID"]);
FormBinding.BindControlsToObject(document);
Documents.Update(document);
}

此代码可用于所有标准的 ASP.NET 控件（TextBox、DropDownList、CheckBox 等）和许多第三方控件（例如 Free TextBox 和 Calendar Popup）。无论有多少业务对象属性和窗体控件，这一行代码都能提供所需的全部功能，只要窗体控件的 ID 与业务对象属性名相匹配。

返回页首

开始：从反射中检索属性列表

首先，我们需要检查业务对象的属性，并查找与业务对象属性名具有相同 ID 的 ASP.NET 控件。以下代码构成了绑定查找的基础：

public class FormBinding {
public static void BindObjectToControls(object obj,
Control container) {
if (obj == null) return;
Type objType = obj.GetType();
PropertyInfo[] objPropertiesArray =
objType.GetProperties();
foreach (PropertyInfo objProperty in objPropertiesArray) {
Control control =
container.FindControl(objProperty.Name);
if (control != null) {
// 处理控件 ...
}
}
}
}

在以上代码中，方法 BindObjectsToControls 接受了业务对象 obj 和一个容器控件。容器控件通常是当前 Web 窗体的 Page 对象。如果所用版本是会在运行时更改控件嵌套顺序的 ASP.NET 1.x MasterPages，您将需要指定窗体控件所在的 Content 控件。这是在 ASP.NET 1.x 中，FindControl 方法对嵌套控件和命名容器的处理方式导致的。

在以上代码中，我们获取了业务对象的 Type，然后使用该 Type 来获取 PropertyInfo 对象的数组。每个 PropertyInfo 对象都包含关于业务对象属性以及从业务对象获取和设置值的能力的信息。我们使用 foreach 循环检查具有与业务对象属性名 (PropertyInfo.Name) 对应的 ID 属性的 ASP.NET 控件的容器。如果找到控件，则尝试将属性值绑定到该控件。

返回页首

将对象属性值绑定到控件

过程中的大部分操作是在此阶段执行的。我们需要用对象的属性值来填充找到的控件。一种实现方法是为每种控件类型创建一个 if ... else 语句。派生自 ListControl（DropDownList、RadioButtonList、CheckBoxList 和 ListBox）的所有控件都具有可以统一访问的公用接口，所以可以将它们编组在一起。如果找到的控件是 ListControl，我们可以将其作为 ListControl 进行转换，然后设置选定项：

Control control = container.FindControl(objProperty.Name);
if (control != null) {
if (control is ListControl) {
ListControl listControl = (ListControl) control;
string propertyValue = objProperty.GetValue(obj,
null).ToString();
ListItem listItem =
listControl.Items.FindByValue(propertyValue);
if (listItem != null) listItem.Selected = true;
} else {
// 处理其他控件类型
}
}

不幸的是，其他控件类型并不从父类中派生。以下几个公用控件都具有 .Text 字符串属性：TextBox、Literal 和 Label。但该属性不是从公用父类中派生出来的，所以需要分别转换每种控件类型。我们还需要转换其他控件类型，例如 Calendar 控件，以便使用适当的属性（在 Calendar 的例子中，是 SelectedDate 属性）。要包含所有标准的 ASP.NET 窗体控件，并访问窗体控件的正确属性并不需要太多的代码行。

if (control is ListControl) {
ListControl listControl = (ListControl) control;
string propertyValue = objProperty.GetValue(obj,
null).ToString();
ListItem listItem = listControl.Items.FindByValue(propertyValue);
if (listItem != null) listItem.Selected = true;
} else if (control is CheckBox) {
if (objProperty.PropertyType == typeof(bool))
((CheckBox) control).Checked = (bool)
objProperty.GetValue(obj, null);
} else if (control is Calendar) {
if (objProperty.PropertyType == typeof(DateTime))
((Calendar) control).SelectedDate = (DateTime)
objProperty.GetValue(obj, null);
} else if (control is TextBox) {
((TextBox) control).Text = objProperty.GetValue(obj,
null).ToString();
} else if (control is Literal)(
//... 等等。还可用于标签等属性。
}

此方法完整地涵盖了标准的 ASP.NET 1.x 控件。从这个角度来看，我们拥有了功能齐全的 BindObjectToControls 方法。但在起作用的同时，此方法的应用范围会受到限制，因为它仅考虑内置的 ASP.NET 1.x 控件。如果要支持新的 ASP.NET 2.0 控件，或者要使用任何第三方控件，我们必须在 FormBinding 项目中引用控件的程序集，并将控件类型添加到 if ... else 列表。

此问题的解决方案是第二次使用反射，以查看各个控件的属性，并找出控件是否具有与业务对象的属性类型对应的属性类型。

返回页首

用已知属性设置未知控件的值

如上所述，有些控件共享字符串属性 .Text，大多数窗体控件以实质相同的方式使用此属性。该属性用于获取和设置用户输入的数据。有大量控件还使用了其他一些公用属性和属性类型。以下是这些属性中的一些：称为 .SelectedDate 的 DateTime 属性，它在许多日历和日期选取器控件中使用；称为 .Checked 的布尔属性，它在布尔型控件中使用；称为 .Value 的字符串属性，它常见于隐藏控件。这四个属性（string Text、string Value、bool Checked 和 DateTime SelectedDate）是最常见的控件属性。如果可以将系统设计成无论何种控件类型，都绑定到这些属性，那么我们的绑定方法将适用于使用那四个属性的任何控件。

在以下代码中，我们将第二次使用反射（这一次是对窗体控件使用，而不是对业务对象使用），以确定它是否具有任何常用属性。如果有，则尝试将业务对象的属性值设置为控件的属性。作为示例，我们将对整个 PropertyInfo 数组进行迭代，并查找称为 .Text 的字符串属性。如果控件具有该属性，则将数据从业务对象发送到该控件的属性。

if (control is ListControl) {
// ...
} else {
// 获取控件的类型和属性
//
Type controlType = control.GetType();
PropertyInfo[] controlPropertiesArray =
controlType.GetProperties();
// 查找 .Text 属性
//
foreach (PropertyInfo controlProperty
in controlPropertiesArray) {
if (controlPropertiesArray.Name == "Text" &&
controlPropertiesArray.PropertyType == typeof(String)) {
// 设置控件的 .Text 属性
//
controlProperty.SetValue(control,
(String) objProperty.GetValue(obj, null), null);
}
}
}

如果找到 .Text，则使用 PropertyInfo 类的 GetValue 方法从业务对象的属性中检索值。然后，使用控件的 .Text 属性的 SetValue 方法。在此，我们还使用 Type 命令将控件的属性设置为 typeof(String)，并使用 (String) 符号显式转换来自属性的值。

为了使 BindObjectToControls 方法完整，我们还需要处理其他公用属性，即 .Checked、.SelectedDate 和 .Value。在以下代码中，我们将控件属性搜索打包到称为 FindAndSetControlProperty 的辅助方法中，以简化代码。

if (control is ListControl) {
// ...
} else {
// 获取控件的属性
//
Type controlType = control.GetType();
PropertyInfo[] controlPropertiesArray =
controlType.GetProperties();
bool success = false;
success = FindAndSetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Checked", typeof(bool) );
if (!success)
success = FindAndSetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"SelectedDate", typeof(DateTime) );
if (!success)
success = FindAndSetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Value", typeof(String) );
if (!success)
success = FindAndSetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Text", typeof(String) );
}
private static void FindAndSetControlProperty(object obj,
PropertyInfo objProperty, Control control,
PropertyInfo[] controlPropertiesArray, string propertyName,
Type type) {
// 在整个控件属性中进行迭代
foreach (PropertyInfo controlProperty in
controlPropertiesArray) {
// 检查匹配的名称和类型
if (controlPropertiesArray.Name == "Text" &&
controlPropertiesArray.PropertyType == typeof(String)) {
// 将控件的属性设置为
// 业务对象属性值
controlProperty.SetValue(control,
Convert.ChangeType(
objProperty.GetValue(obj, null), type) , null);
return true;
}
}
return false;
}

以上属性检查的顺序很重要，因为有些控件具有以上属性中的多个，但我们只想设置一个。例如，CheckBox 控件既有 .Text 属性也有 .Checked 属性。在此示例中，我们希望使用 .Checked 属性而不是 .Text 属性，所以将 .Checked 放在属性搜索顺序的首位。任何情况下，如果找到具有正确名称和类型的控件属性，则尝试将控件的属性设置为业务对象属性的值。

从这个角度来看，我们拥有了功能齐全的 BindObjectToControls 方法。利用该方法，我们可以在 ASPX 窗体上的任何地方，使用任何类和控件的任意组合进行调用，而这确实有效。现在，我们需要创建在提交窗体时进行反转的方法。我们需要从表示用户输入的控件中检索新值，而不是将控件属性的值设置为业务对象的值。

返回页首

反转过程：BindControlsToObject

在 BindControlsToObject 方法中，我们将以同样的方式开始，即从业务对象中检索属性的列表，然后使用 FindControl 方法找到具有与对象属性相匹配的 ID 的控件。如果找到控件，则检索值并将该值返回给业务对象。此部分还将包含 ListControl 的单独代码，因为这些控件具有公用接口。我们将使用另一种辅助方法来搜索并检索控件中的值，然后将该值返回给业务对象。

public static void BindControlsToObject(object obj,
Control container) {
Type objType = obj.GetType();
PropertyInfo[] objPropertiesArray = objType.GetProperties();
foreach (PropertyInfo objProperty in objPropertiesArray) {
if (control is ListControl) {
ListControl listControl = (ListControl) control;
if (listControl.SelectedItem != null)
objProperty.SetValue(obj,
Convert.ChangeType(list.SelectedItem.Value,
objProperty.PropertyType), null);
} else {
// 获取控件的属性
//
Type controlType = control.GetType();
PropertyInfo[] controlPropertiesArray =
controlType.GetProperties();
bool success = false;
success = FindAndGetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Checked", typeof(bool) );
if (!success)
success = FindAndGetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"SelectedDate", typeof(DateTime) );
if (!success)
success = FindAndGetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Value", typeof(String) );
if (!success)
success = FindAndGetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Text", typeof(String) );
}
}
}
private static void FindAndGetControlProperty(object obj,
PropertyInfo objProperty, Control control, PropertyInfo[]
controlPropertiesArray, string propertyName, Type type) {
// 在整个控件属性中进行迭代
foreach (PropertyInfo controlProperty in
controlPropertiesArray) {
// 检查匹配的名称和类型
if (controlPropertiesArray.Name == "Text" &&
controlPropertiesArray.PropertyType == typeof(String)) {
// 将控件的属性设置为
// 业务对象属性值
try {
objProperty.SetValue(obj,
Convert.ChangeType(
controlProperty.GetValue(control, null),
objProperty.PropertyType) , null);
return true;
} catch {
// 无法将来自窗体控件
// 的数据转换为
// objProperty.PropertyType
return false;
}
}
}
return true;
}

完成这两种方法后，我们的窗体语法将得到简化，如以上简化和缩短窗体代码中所述。每个属性和控件的类型转换与错误更正都是自动进行的。这两种方法（BindObjectToControls 和 BindControlsToObject）为开发人员创建窗体提供了很大的灵活性。它们还可以用于处理以下这些常见方案：

•	如果将新属性添加到业务对象，并且需要在窗体上访问该新属性，那么开发人员只需将控件添加到页面，并将控件的 ID 设置为新属性的名称，FormBinding 方法将处理剩下的一切。
•	如果开发人员需要更改用于特定属性的控件的类型，例如从 TextBox 更改为第三方的 HTML 编辑器控件，他/她仅需要确保新控件具有以上属性之一（例如 .Text ），窗体将以与之前完全一致的方式进行工作。
•	全部使用 TextBox 控件也可以快速生成窗体，但输入仍将转换为适用于业务对象属性的正确类型。例如，可以用 TextBox 控件来代替 Calendar 控件或第三方的日期选取器控件。只要用户输入 DateTime 字符串作为值，便会将 TextBox 的 .Text 属性中的值转换为 DateTime，就如同它是日历控件上的 SelectedDate 属性一样。如果以后将 TextBox 更改为日期选取器控件，逻辑关系将保持不变。
•	通过将所有控件更改为 Literal 控件，开发人员还可以快速创建“视图”页面。Literal 的 .Text 属性将被设置为业务对象属性的值，就如同它是 TextBox 一样。
•	在实际方案中，窗体还包含其他数据类型和自定义配置。用于处理这些特定操作的代码可以放置在对 BindObjectToControls 和 BindControlsToObject 的调用之后。

返回页首

性能和 FormBinding 方案的扩展

有些开发人员可能想知道，使用反射引起的性能下降是否值得。在我的测试中，使用了具有七种属性（int DocumentID、bool Active、DateTime Created、int CategoryID、String Title、string Author 和 String htmlText）的对象，BindObjectToControls 用时约 1/3 毫秒，BindControlsToObject 用时大约 1 毫秒。这些值是通过循环运行 1000 次 BindObjectToControls 和 BindControlsToObject 方法得到的。对于常见的“添加”和“编辑”窗体方案，这样的性能应不会引起任何重大的问题，而且确实能够提高开发速度和灵活性。

尽管此方法几乎适用于每种窗体，但有时可能需要修改以上代码。在某些方案中，开发人员要使用的控件可能并不使用以上属性之一作为其主要接口。在此情形中，需要更新 FormBinding 方法，以包括该属性和类型。

返回页首

结论

这两种 FormBinding 方法（BindObjectToControls 和 BindControlsToObject）可用于极大地简化窗体代码，并为 ASP.NET 窗体的开发提供了最大的灵活性。对它们的使用使我获益良多，希望您的团队同样能够从中受益。

返回页首

参考资料

•	ASP.NET Unleashed
•	Programming Microsoft ASP.NET

namespace JustinsWebControls
{
    /// <summary>
    /// Enhanced version of the GridView control.
    /// Supports: Column sort direction images, row selecting/highlighting, prev/numeric/next paging.
    /// </summary>
    [DefaultProperty("SelectedValue")]
    [ToolboxData("<{0}:GridView runat=server></{0}:GridView>")]
    public class GridView : System.Web.UI.WebControls.GridView
    {
        /// <summary>
        /// Color of the row being hovered over.
        /// </summary>
        public string HighlightColor
        {
           get
           {
              if (ViewState["highlightColor"] == null)
              {
                 ViewState["highlightColor"] = false;
              }
              return (string)ViewState["highlightColor"];
           }

           set
           {
              ViewState["highlightColor"] = value;
           }
        }

        /// <summary>
        /// Turns the selection highlighting on or off.
        /// </summary>
        public bool EnableSelection
        {
           get
           {
              if (ViewState["enableSelection"] == null)
              {
                 ViewState["enableSelection"] = false;
              }
              return (bool)ViewState["enableSelection"];
           }

           set
           {
              ViewState["enableSelection"] = value;
           }
        }

        /// <summary>
        /// Turns on JustinsWeb sanctioned pager.
        /// </summary>
        public bool EnableNextPrevNumericPager
        {
           get
           {
              if (ViewState["enableJustinsWebPager"] == null)
              {
                 ViewState["enableJustinsWebPager"] = false;
              }
              return (bool)ViewState["enableJustinsWebPager"];
           }

           set
           {
              this.AllowPaging = value;
              ViewState["enableJustinsWebPager"] = value;
           }
        }

       /// <summary>
        /// Get/Set alternative to the inherited SortDirection field that is always accurate.
       /// </summary>
       public SortDirection SortDirectionAlt
       {
          get
          {
             if (ViewState["sortDirection"] == null)
             {
                ViewState["sortDirection"] = SortDirection.Ascending;
             }
             return (SortDirection)ViewState["sortDirection"];
          }

          set
          {
             ViewState["sortDirection"] = value;
          }
       }

       /// <summary>
       /// Get/Set alternative to the inherited SortExpression field that is always accurate.
       /// </summary>
       public string SortExpressionAlt
       {
          get
          {
             if (ViewState["sortExpressionAlt"] == null)
             {
                ViewState["sortExpressionAlt"] = "";
             }
             return (string)ViewState["sortExpressionAlt"];
          }

          set
          {
             ViewState["sortExpressionAlt"] = value;
          }
       }

       /// <summary>
       /// When using GridView in certain ways the SortDirection and SortExpression
       /// properties are sometimes left blank or never changed. When using this control,
       /// the Alt properties remedy this situation.
       /// </summary>
       /// <param name="e"></param>
       protected override void OnSorting(GridViewSortEventArgs e)
       {
          //Handle setting up of sorting info
          if(!String.IsNullOrEmpty(this.SortExpression))
          {
             SortExpressionAlt = e.SortExpression;
             SortDirectionAlt = e.SortDirection;
          }
          else
          {
             if (SortExpressionAlt == e.SortExpression)
             {
                if (SortDirectionAlt == SortDirection.Ascending)
                {
                   SortDirectionAlt = SortDirection.Descending;
                }
                else
                {
                   SortDirectionAlt = SortDirection.Ascending;
                }
             }
             else
             {
                SortDirectionAlt = SortDirection.Ascending;
             }

             this.SortExpressionAlt = e.SortExpression;
          }

          base.OnSorting(e);
       }

       protected override void InitializePager(GridViewRow row, int columnSpan, PagedDataSource pagedDataSource)
       {
          if (this.EnableNextPrevNumericPager)
          {
             base.PagerTemplate = new NextPrevNumericPagerTemplate(this.PageIndex, this.PageCount);
          }
          base.InitializePager(row, columnSpan, pagedDataSource);
       }

        /// <summary>
        /// Adds custom effects to the GridView at runtime.
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRowCreated(GridViewRowEventArgs e)
        {
            base.OnRowCreated(e);
            if (e.Row.RowType == DataControlRowType.DataRow)
            {
               //If row selection is enabled then add mouse over scripts to enable on client.
               if (EnableSelection)
               {
                  EnableEnhancedSelectForRow(e);
               }
            }
            else if (e.Row.RowType == DataControlRowType.Header && ShowSortDirection)
            {
               //this.SortDirection
               foreach (TableCell headerCell in e.Row.Cells)
               {
                  if (headerCell.HasControls())
                  {
                     AddSortImageToHeaderCell(headerCell);
                  }
               }
            }
        }

       private void AddSortImageToHeaderCell(TableCell headerCell)
       {
          // search for the header link
          LinkButton lnk = (LinkButton)headerCell.Controls[0];
          if (lnk != null)
          {
             // inizialize a new image
             System.Web.UI.WebControls.Image img = new System.Web.UI.WebControls.Image();
             // setting the dynamically URL of the image
             img.ImageUrl = (this.SortDirectionAlt == SortDirection.Ascending ? this.SortAscImageUrl : this.SortDescImageUrl);
             // checking if the header link is the user's choice
             if (this.SortExpressionAlt == lnk.CommandArgument)
             {
                // adding a space and the image to the header link
                headerCell.Controls.Add(new LiteralControl(" "));
                headerCell.Controls.Add(img);
             }
          }
       }

       private void EnableEnhancedSelectForRow(GridViewRowEventArgs e)
       {
          e.Row.Attributes.Add("onmouseover", RowOnMouseOverScript());
          e.Row.Attributes.Add("onmouseout", RowOnMouseOutScript());

          foreach (TableCell cell in e.Row.Cells)
          {
             // if no link are presen the cell,
             // we add the functionnality to select the row on the cell with a click
             if (!Recurser.ContainsLink(cell))
             {
                AddPostBackEventToCell(e, cell);
             }
          }
       }

       private void AddPostBackEventToCell(GridViewRowEventArgs e, TableCell cell)
       {
          // here we add the command to postback when the user click somewhere in the cell
          cell.Attributes.Add("onclick",
              Page.ClientScript.GetPostBackEventReference(this,
              "Select$" + e.Row.RowIndex.ToString()));
          cell.Style.Add(HtmlTextWriterStyle.Cursor, "pointer");
          cell.Attributes.Add("title", "Select");
       }

        /// <summary>
        /// Get or Set Image location to be used to display Ascending Sort order.
        /// </summary>
        [
        Description("Image to display for Ascending Sort"),
        Category("Misc"),
        Editor("System.Web.UI.Design.UrlEditor", typeof(System.Drawing.Design.UITypeEditor)),
        DefaultValue(""),
        ]
        public string SortAscImageUrl
        {
           get
           {
              object o = ViewState["SortImageAsc"];
              return (o != null ? o.ToString() : "");
           }
           set
           {
              ViewState["SortImageAsc"] = value;
           }
        }

      
        /// <summary>
        /// Get or Set Image location to be used to display Ascending Sort order.
        /// </summary>
        [
        Description("Sets whether or not we show the sort arrows in the GridView."),
        Category("Misc"),
        Editor("System.Web.UI.Design.UrlEditor", typeof(System.Drawing.Design.UITypeEditor)),
        DefaultValue("false"),
        ]
       public bool ShowSortDirection
        {
           get
           {
              object o = ViewState["ShowSortDirection"];
              return (o != null ? Convert.ToBoolean(o) : false);
           }
           set
           {
              ViewState["ShowSortDirection"] = value;
           }
        }

        /// <summary>
        /// Gets or Sets whether we show the sort arrow in the GridView after the header text or before.
        /// </summary>
        [
        Description("Sets whether we show the sort arrow in the GridView after the header text or before."),
        Category("Misc"),
        Editor("System.Web.UI.Design.UrlEditor", typeof(System.Drawing.Design.UITypeEditor)),
        DefaultValue("false"),
        ]
        public bool ShowSortImageBeforeHeaderText
        {
           get
           {
              object o = ViewState["ShowSortImageBeforeHeaderText"];
              return (o != null ? Convert.ToBoolean(o) : false);
           }
           set
           {
              ViewState["ShowSortImageBeforeHeaderText"] = value;
           }
        }

        /// <summary>
        /// Get or Set Image location to be used to display Ascending Sort order.
        /// </summary>
        [
        Description("Image to display for Descending Sort"),
        Category("Misc"),
        Editor("System.Web.UI.Design.UrlEditor", typeof(System.Drawing.Design.UITypeEditor)),
        DefaultValue(""),
        ]
        public string SortDescImageUrl
        {
           get
           {
              object o = ViewState["SortImageDesc"];
              return (o != null ? o.ToString() : "");
           }
           set
           {
              ViewState["SortImageDesc"] = value;
           }
        }

        /// <summary>
        /// Highlights the background of the row that the mouse is currently hovering over.
        /// </summary>
        /// <returns></returns>
        protected string RowOnMouseOverScript()
        {
            return "this.style.backgroundColor = '" + HighlightColor + "';";
        }

        /// <summary>
        /// Removes highlighting created by RowOnMouseOverScript.
        /// </summary>
        /// <returns></returns>
        protected string RowOnMouseOutScript()
        {
            return "this.style.backgroundColor = '';";
        }
    }

    /// <summary>
    ///
    /// </summary>
    public static class Recurser
    {
        /// <summary>
        /// this method check if a control or one of its children
        /// has the type of the types given by recursivity
        /// </summary>
        /// <param name="control">control to check</param>
        /// <param name="types">type to find</param>
        /// <returns>the first occurence of control which has one of the given types</returns>
        public static Control ContainsControlType(Control control, params Type[] types)
        {
            // may be we could loop throug the controls first and then the types
            // to gain somme speed of process
            // but I wanted to ensure the same process for any control,
            // for the first one like its children (cause the first one could have a given type)
            foreach (Type type in types)
            {
                if (control.GetType().Equals(type))
                    return control;
                else
                    // begin recursivity
                    foreach (Control ctrl in control.Controls)
                    {
                        Control tmpCtrl = ContainsControlType(ctrl, type);
                        if (tmpCtrl != null)
                            return tmpCtrl;
                    }
            }
            // if no controls had the given type in the current control we return false
            return null;
        }

        /// <summary>
        /// Check if there is more thant 0 links controls in a control or if this control is a link
        /// </summary>
        /// <param name="control">control to check in</param>
        /// <returns>true if there is any links</returns>
        public static bool ContainsLink(Control control)
        {
            bool ret = false;
            // search a link in the cell
            Control ctrl = ContainsControlType(control, typeof(HyperLink), typeof(LinkButton), typeof(DataBoundLiteralControl), typeof(TextBox), typeof(DropDownList));
            // if a control is returned, we have to check the case of the literal which could contain no links
            if (ctrl != null)
            {
                if (ctrl.GetType().Equals(typeof(DataBoundLiteralControl)))
                {
                    DataBoundLiteralControl dblc = (DataBoundLiteralControl)ctrl;
                    // here I check if the text contains a href or onclick attribute
                    // I assume that there this text should not be used to be displayed
                    if (dblc.Text.Contains("href") || dblc.Text.Contains("onclick"))
                        ret = true;
                }
                else ret = true;
            }
            return ret;
        }
    }

   /// <summary>
   /// Pager Template that conforms to JustinsWeb's user experience standards for functionality.
   /// </summary>
   public class NextPrevNumericPagerTemplate : ITemplate
   {
      int _pageIndex;

      int _pageNumber
      {
         get
         {
            return _pageIndex + 1;
         }
         set
         {
            _pageIndex = value - 1;
         }
      }

      int _pageCount;

      /// <summary>
      /// Constructor for template.
      /// </summary>
      /// <param name="pageIndex">Current page index.</param>
      /// <param name="pageCount">Total count of all pages.</param>
      public NextPrevNumericPagerTemplate(int pageIndex, int pageCount)
      {
         _pageIndex = pageIndex;
         _pageCount = pageCount;
      }

      /// <summary>
      /// Called when pager is instantiated in the provided control.
      /// </summary>
      /// <param name="container"></param>
      public void InstantiateIn(Control container)
      {
         int pagerStartIndex = startPageIndex(_pageIndex, _pageCount);
         int pagerEndIndex = endPageIndex(_pageIndex, _pageCount);

         createResultsSummary(container);

         createPrevButton(container);
         createSpacer(container);

         createPrevEllipsisIfNeeded(container, pagerStartIndex);
         createCorrectPageButtons(container, pagerStartIndex, pagerEndIndex);
         createNextEllipsisIfNeeded(container, pagerEndIndex);

         createNextButton(container);
      }

      /// <summary>
      /// Creates the ... that allows you to jump forward to more pages in the pager.
      /// </summary>
      /// <param name="container"></param>
      /// <param name="pagerEndIndex"></param>
      private void createNextEllipsisIfNeeded(Control container, int pagerEndIndex)
      {
         if (pageNumber(pagerEndIndex) < _pageCount)
         {
            createEllipsisButton(container, pagerEndIndex + 1);
         }
      }

      private void createPrevEllipsisIfNeeded(Control container, int pagerStartIndex)
      {
         if (pageNumber(pagerStartIndex) > 1)
         {
            createEllipsisButton(container, pagerStartIndex - 1);
         }
      }

      private void createCorrectPageButtons(Control container, int pagerStartIndex, int pagerEndIndex)
      {
         for (int i = pagerStartIndex; i <= pagerEndIndex; i++)
         {
            createCorrectPageButton(container, i);
         }
      }

      private static void createNextButton(Control container)
      {
         LinkButton nextButton = new LinkButton();
         nextButton.CommandName = "Page";
         nextButton.CommandArgument = "Next";
         nextButton.Text = "Next >";
         container.Controls.Add(nextButton);
      }

      private static void createPrevButton(Control container)
      {
         LinkButton prevButton = new LinkButton();
         prevButton.CommandName = "Page";
         prevButton.CommandArgument = "Prev";
         prevButton.Text = "< Prev";
         container.Controls.Add(prevButton);
      }

      private void createResultsSummary(Control container)
      {
         Label resultsSummary = new Label();
         resultsSummary.CssClass = "PagerResultsSummary";
         resultsSummary.Text = "Page " + _pageNumber + " of " + _pageCount;
         container.Controls.Add(resultsSummary);
      }

      private void createCorrectPageButton(Control container, int pageIndexOnButton)
      {
         if (_pageIndex == pageIndexOnButton)
         {
            createNumericPageLabel(container, pageIndexOnButton);
         }
         else
         {
            createNumericPageButton(container, pageIndexOnButton);
         }

         createSpacer(container);
      }

      private void createNumericPageButton(Control container, int pageIndex)
      {
         LinkButton pageButton;
         pageButton = new LinkButton();
         pageButton.Text = pageNumber(pageIndex).ToString();
         pageButton.CommandName = "Page";
         pageButton.CommandArgument = pageNumber(pageIndex).ToString();
         container.Controls.Add(pageButton);
      }

      private void createNumericPageLabel(Control container, int pageIndex)
      {
         Label currentPageLabel;
         currentPageLabel = new Label();
         currentPageLabel.CssClass = "SelectedPageButton";
         currentPageLabel.Text = pageNumber(pageIndex).ToString();
         container.Controls.Add(currentPageLabel);
      }

      private void createEllipsisButton(Control container, int goToIndex)
      {
         LinkButton pageButton;
         pageButton = new LinkButton();
         pageButton.Text = "...";
         pageButton.CommandName = "Page";
         pageButton.CommandArgument = pageNumber(goToIndex).ToString();
         container.Controls.Add(pageButton);

         createSpacer(container);
      }

      private static void createSpacer(Control container)
      {
         Literal spacer = new Literal();
         spacer = new Literal();
         spacer.Text = "&nbsp;";

         container.Controls.Add(spacer);
      }

      /// <summary>
      /// Finds the starting page index to display on the pager. (Will need conversion to page number)
      /// </summary>
      /// <param name="currentPageIndex"></param>
      /// <param name="totalPageCount"></param>
      /// <returns></returns>
      private int startPageIndex(int currentPageIndex, int totalPageCount)
      {
         int startingPageToDisplay = 0;
         startingPageToDisplay = currentPageIndex - 4;
        
         if ((pageIndex(totalPageCount) - currentPageIndex) < 5)
         {
            startingPageToDisplay = pageIndex(totalPageCount) - 9;
         }
         if (startingPageToDisplay < 0)
         {
            startingPageToDisplay = 0;
         }
         return startingPageToDisplay;
      }

      /// <summary>
      /// Finds the ending page index to display on the pager. (Will need conversion to page number)
      /// </summary>
      /// <param name="currentPageIndex"></param>
      /// <param name="totalPageCount"></param>
      /// <returns></returns>
      private int endPageIndex(int currentPageIndex, int totalPageCount)
      {
         int endingPageToDisplay = currentPageIndex + 5;
         int maxEndingPageIndex = (9 > pageIndex(totalPageCount)) ? pageIndex(totalPageCount) : 9;

         if (endingPageToDisplay > totalPageCount - 1)
         {
            endingPageToDisplay = totalPageCount - 1;
         }
         else if (currentPageIndex < 5)
         {
            endingPageToDisplay = maxEndingPageIndex;
         }
         return endingPageToDisplay;
      }

      /// <summary>
      /// Converts a given page index to a page number.
      /// </summary>
      /// <param name="pageIndex"></param>
      /// <returns></returns>
      private int pageNumber(int pageIndex)
      {
         return pageIndex + 1;
      }

      /// <summary>
      /// Converts a given page number to a page index.
      /// </summary>
      /// <param name="pageNumber"></param>
      /// <returns></returns>
      private int pageIndex(int pageNumber)
      {
         return pageNumber - 1;
      }

   }

}

Live Demo | Download

Scenario

I am sure everyone is pretty familiar with Master/Details style of editing data, but just in case - here is how my page works.  The grid shows 12 rows of customer data.  The far right column in the grid contains a hyperlink that when clicked brings the detail view of the row into focus so the corresponding row can be edited.  The detail view is a popup control and contains a Save and Close buttons.  When close is clicked, the detail popup is dismissed and the user goes back to viewing the main grid.  When they click Save, some simple validation checks are run (all are RequiredFieldValidators for this sample) and the new data values are persisted, and finally the detail popup is dismissed and the main grid is refreshed so that it displays the changes.

Controls

There are quite a few controls that work together for this sample.  Here is a listing of the controls and the role they play.

Customer GridView

The Customer Grid is just a regular GridView.  I have used BoundFields to bind to the data and I am using a TemplateField for rendering the 'Edit' anchor. 

When 'Edit' is clicked, I want to show the detail view popup.  To accomplish this I set the CommandName of the 'Edit' button to Select - this will cause the SelectedIndexChanged event to fire on the server.  Inside this event handler, I force the DetailView to databind, passing the datasource it is bound to the ID that corresponds to the row the user clicked.  Finally, I let the UpdatePanel the DetailView is contained in that it needs to update its contents and invoke the Show server side method of my ModalPopupExtender which will cause the popup to be displayed when the partial page is reloaded on the client.

Here are the 2 events handlers that I am using to accomplish this bit of work.  The top event handler fires when 'Edit' is clicked and the explicit call to DataBind forces the DetailView's corresponding ObjectDataSource's Selecting event to fire.  In this handler I use the SelectedIndex of the GridView to fetch the ID the data source needs. 

Customer DetailsView

The DetailsView for the individual customer records is also pretty simple - except because I have included RequiredFieldValidators I wasn't able to use the BoundFields and instead I had to explicitly define the EditItemTemplate for each of the fields.

Just below the DetailsView, I have 2 buttons that interact with the ModalPopupExtender.  The Close button dismissed the popup without posting back or committing any changes.  The Save button does post back, moves the data out of the DetailsView and back to the ObjectDataSource, hides the ModalPopupExtender and finally causes the main GridView to refresh so it displays the changes.

Here is the logic I have wired to the Save button's click handler.

Apply a Yellow Fade to the Updated Row in the GridView

And while this has been pretty much nuts and bolds functionality thus far, I couldn't resist trying to spice it up by applying a yellow fade to the row in the main grid that was updated.  To implement this feature, I needed a way to send a bit of information back from the server that let me know what row in the grid was updated.  So my approach was to use the ScriptManager's RegisterDataItem method to accomplish this.  Here is the doc from MSDN:

Sends custom data to a control during partial-page rendering, and indicates whether the data is in JavaScript Object Notation (JSON) format.

Just what I need - so after the Save button is clicked, back in the server side event handler, I call RegisterDataItem and pass the index of the updated row to the GridView.  Then after the partial refresh has occurred back on the client, I extract the row index from the DataItem's collection, use it to find the row that changed and give it a custom CSS class.

So I added the following call to my Save button handler to register the index of the row that was changed.

And then added the following JavaScript to my page to track down the corresponding TR element in the rendered table and apply the updated CSS class to the row.

And like magic I get a yellow background applied to the row that was edited.  The background color stays in place for 1.5 seconds then my timeout handler fires and removes it.  A poor man's animation, but the plumbing is in place for me to improve upon.  Below are the screen shots of how it looks.

性能问题应该从系统设计时期开始考虑，并延续到系统的生命期终止之时。

具有可伸缩性的系统是指当系统的负载增加一倍，系统需要的资源也同样增加一倍。说起来简单，但在现实环境中确难以做到。由于管理并发用户的开销的增长、锁事务的增长、一致性读负载的增加、操作系统负载的增加、低效的SQL或索引设计导致的过高的I/O等等因素，会导致系统资源的消耗的增长远大于一倍。

破坏可伸缩性的因素：

1.低效的应用程序设计、实施和配置

2.硬件部分的规模不合适

3.软件部分的限制

4.硬件部分的限制  

系统的结构可分为硬件和软件两部分：

硬件部分包括：CPU、内存、I/O子系统和网络模块。

软件部分包括：管理用户接口、实现商业逻辑、管理用户请求和资源分配、管理数据和事务。  

在设计系统时，应该考虑以下几个问题：

系统将支持多少用户？

用户的交互方式是什么？

用户所处的位置？

网络的速度怎样？

用户将访问多少数据？有多少数据是只读访问？