博客园_hystar的.Net世界

（翻译）Entity Framework技巧系列之十四 - Tip 56

2011-07-11T12:51:00Z

提示56. 使用反射提供程序编写一个OData Service

在TechEd我收到一大堆有关将数据作为OData暴露的问题。

到目前为止你大概知道可以使用数据服务与Entity Framework将数据库中的数据暴露为一个OData服务。你可能还知道你可以在数据服务中使用一个自定义的数据服务提供程序来由任意地方暴露任意数据。

但是你了解数据服务反射提供程序吗？

事实上反射提供程序的使用非常简单。

我将创建一个OData服务暴露一些内存中的数据来展示这有多么容易。

首先你需要一些数据，这部分数据如何：

[EntityPropertyMapping("Name",
SyndicationItemProperty.Title,
SyndicationTextContentKind.Plaintext,
false)]
[EntityPropertyMapping("Odds",
SyndicationItemProperty.Summary,
SyndicationTextContentKind.Plaintext,
false)]
public class Team {
public static List<Team> Teams = new List<Team>{
         new Team {ID = 1, Name = "New Zealand", Odds = "1:1000"},
         new Team {ID = 2, Name = "Paraquay", Odds = "1:50"},
         …     };

    public int ID{get;set;}
    public string Name {get;set;}
    public string Odds { get; set; }
}

[DataServiceKey("Name")]
[EntityPropertyMapping("Name",
SyndicationItemProperty.Title,
SyndicationTextContentKind.Plaintext,
false)]
public class Group
{
    public static List<Group> Groups = new List<Group>{
      new Group {
         Name = "A",
         Teams = new List<Team>{
            Team.Teams[0],
             Team.Teams[1],
             Team.Teams[2],
             Team.Teams[3]
         }
       },
new Group {
         Name = "B",
         Teams = new List<Team>{
             Team.Teams[4],
             Team.Teams[5],
             Team.Teams[6],
             Team.Teams[7]
          }
       },
      …
    };
    public string Name {get;set;}
    public List<Team> Teams {get;set;}
}

注意[DataServiceKey]与[EntityPropertyMapping]特性的使用：

Ÿ [DataServiceKey]通知Data Services那个（些）属性是键。这个仅当

Ÿ [EntityPropertyMapping]通知Data Services将属性映射到一个标准的atom元素。这不是必须得-但这是一个最佳实践-它使浏览器中最终的源数据更易读。

下一步你需要一个类来扮演数据源。数据服务将暴露所有的IQueryable属性为源数据，并且推断出所有这些源数据暴露的类型所用到的类型。

所以如果我想要两个源，以暴露来自世界杯团体和小组，我将这样做：

public class WorldCupData
{
public IQueryable<Team> Teams{
get{
return Team.Teams.AsQueryable();
}
}
public IQueryable<Group> Groups{
get{
return Group.Groups.AsQueryable();
}
}
}

现在所有需要做的就是创建Data Service，并暴露出我们的数据集。只需向Web应用中添加一个WCF数据服务，并将自动生成的代码修改成如下这样：

public class WorldCup : DataService<WorldCupData>
{
// This method is called only once to initialize service-wide policies.
public static void InitializeService(DataServiceConfiguration config) {
config.SetEntitySetAccessRule("*", EntitySetRights.AllRead);
config.SetEntitySetPageSize("*", 100);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
}
}

完成后如下这样：

一些需要注意的点：

这个服务是只读的。如果你想要使它可写，你需要实现IDataServiceUpdateProvider接口。

在这个例子中，数据来自内存中的数组，然而如果你的数据源支持IQueryable接口，你的数据可以来自任何地方。

是的我知道这些数据都是错的，我正在新奥尔良到丹佛的西南航空的航班上，在没有互联网的情况下完成这些。谢天谢地这里有一个真实的世界杯OData Service。

编码愉快。

本文链接

再谈ASP.NET 7 - 跨应用、跨服务器的表单验证

2011-06-11T11:11:00Z

很多情况下，我们想要在同一台服务器上两个不同的应用程序共享相同的Forms验证信息，即在一个应用程序通过验证后，其它应用可以共享这个验证状态，从而不用再次登陆，实现一个单点登录的效果

使用Forms验证下产生的cookie是被加密的，每个程序都会默认生成独立的解密和校验码，所以我们也很难再不同的应用间共享加密的cookie。要想使共享变得可能，我们需要通过配置文件（服务器端）手动指定加密密钥和验证码。

machineKey默认配置如下：

<machineKey decryption="Auto" validation="SHA1"

decryptionKey="Auto Generate, IsolateApps" validationKey="Auto Generate, IsolateApps"/>

Ø decryption属性：用于指定Forms验证下cookie的加密算法，取值有Auto，AES或3DES，默认为Auto (ASP.NET会根据Web服务器的性能选择最佳加密算法)。

Ø validation属性：用于指定对验证cookie进行Hash与加密的算法，可取值为AES，MD5，SHA1和3DES。

Ø descryptionKey属性与validationKey属性：分别表示对验证cookie进行加密的密钥与Hash运算的验证码。

另外，上述配置中：

Ø AutoGenerate：表示ASP.NET将产生随机密钥，并将其存储在LSA（本地独立存储）

Ø IsolateApps表示将为Web服务器每个应用程序创建唯一的密钥。

我们可以重写服务器端Web.config中的设置，将前文默认配置中decryptionKey和validationKey两个属性中的IsolateApps去掉即可，即表示该设置不是对每个应用独立的。

小提示：

服务器端web.config的路径：

C:\Windows\Microsoft.NET\Framework(64)\[version]\CONFIG\web.config

另一种情况，如果我们想要不同web服务器(如在一个web farm中)上的应用程序共享相同的cookie加密。我们需要手动生产decryptionKey和validationKey属性值，并使它们在服务器间保持一致。

AES算法需要一个64位的十六进制字符随机序列，SHA1算法使用一个128位的十六进制随机序列，我们可以通过这样的代码来生成所需的随机序列：

string GetKey(int length)

{

byte[] buffer = new byte[length / 2];

RNGCryptoServiceProvider provider = new RNGCryptoServiceProvider();

provider.GetBytes(buffer);

StringBuilder builder = new StringBuilder(length);

for (int i = 0; i < buffer.Length; i++)

{

builder.Append(string.Format("{0:X2}", buffer[i]));

}

return builder.ToString();

}

如果我们只是想让两台服务器上同一个应用程序共享相同的验证加密信息，我们需要把machineKey的设置放在应用程序自己的web.config中，另外cookie在设计上就不能用作跨域验证，所以无论是一个Web服务器上的不同应用，还是多个服务器上同一应用都要求在同一个域中(即一级域名要相同，如两个应用app1.sample.com和app2.sample.com就是在同一个域中)使用前文介绍的这种方式才有效。

ASP.NET对跨域的验证共享也提供了一种解决方案 – 通过查询字符串代替cookie传递验证凭据。我们需要在web.config中进行如下设置以允许应用程序通过查询字符串传递验证凭据，从而实现验证信息的跨域共享。

</authentication>

将原本存储于cookie中的验证信息加入Url的方式也很简单，即传递普通查询字符串的传递方式。

如，我们有一个HyperLink：

<asp:HyperLink ID="lnkToOtherDomain" NavigateUrl="http://www.otherdomain.com/secret.aspx"

runat="server" />

我们使用C#代码为其提添加凭据：

protected void Page_Load(object sender, EventArgs e)

{

string cookieName = FormsAuthentication.FormsCookieName;

string cookieValue = FormsAuthentication.GetAuthCookie(User.Identity.Name, false).Value;

lnkToOtherDomain.NavigateUrl += string.Format("?{0}={1}", cookieName, cookieValue);

}

本文链接

.Net学习难点讨论系列16 - 索引器

2011-05-30T23:02:00Z

索引器是一个我们经常打交道的特性，在编程过程中，多多少少都会用到索引器。而关于索引器一些高级话题，如给自定义的类添加索引器等也是本文着重介绍的。索引器本质上是一组get和set访问器， []中提供的是get访问器查找元素所要的参数，以及查找set访问器所要设置的元素时使用的参数。一个类或结构中只能有一个索引器且名称只能为this（但是索引器可以重载，重载方法就是提供不同类型的索引参数，这也是特别值得注意的是一点，索引器可以有多个索引参数，即下面语法结构的[]中可以提供多个参数（当然这样使用索引器时也要提供相应数量的参数））。

索引器的语法结构

public type this[type index]

{

get

{

GetAccessor

}

set

{

SetAccessor

}

第一个type是索引器（返回值）的类型，正如定义属性中的类型。而第二个type是索引的类型。类似于属性，定义的索引器也不会被分配命名空间，且get,set可以只实现一个或者都实现，但属性通常用于访问单个数据成员，索引用于访问多个数据成员。

在索引器中应该对索引器进行范围检查防止出现异常。另外不可以声明static的索引器。示例：下列自定义类型提供了一个索引器以使我们用更方便的方法来操作整型中的位。

struct IntBits

{

public IntBits(int initialBitValue)

{

bits = initialBitValue;

}

private int bits;

public bool this[int index]

{

get

{

return (bits & (1 << index)) != 0;

}

set

{

//如果value为true，就开启比特，否则把它关闭

if (value)

bits |= (1 << index);

else

bits &= -(1 << index);

}

这个类的使用方式：

int adapted = 63;

IntBits bits = new IntBits(adapted);

//获取索引位置6的bool值

bool peek = bits[6];

//将索引0的比特设为true

bits[0] = true;

//将索引31的比特设为false

bits[31] = false;

索引器的下标可以是字符串等非整数。索引器不可以作为ref或者out参数。

下面再提供另一个索引器定义的示例：

class Employee

{

public string LastName;

public string FirstName;

public string CityOfBirth;

public string this[int index]

{

set

{

switch (index)

{

case 0:

LastName = value;

break;

case 1:

FirstName = value;

break;

case 2:

CityOfBirth = value;

break;

default:

throw new ArgumentOutOfRangeException("index");

}

get

{

switch (index)

{

case 0:

return LastName;

case 1:

return FirstName;

case 2:

return CityOfBirth;

default:

throw new ArgumentOutOfRangeException("index");

}

下面的代码展示了索引器重载的代码结构：

class MyClass

{

public string this[int index]

{

set { … }

get { … }

}

public string this[int index1, int index2]

{

set { … }

get { … }

}

public string this[float index]

{

set { … }

get { … }

}

索引器中访问器的访问修饰符与属性访问器的遵守一致的规则：

Ø 当属性或索引既有get访问器也有set访问器时才能给访问器添加访问修饰符。

Ø 只能给两个访问器中的一个添加访问修饰符。

Ø 访问器的修饰符需要比成员的访问级别有更严格的限制。

另外，像是HashTable等字典类内部使用了索引器，从而可以使下列代码1用代码2这种更易懂的方式来表示：

方式1：

Hashtable ages = new Hashtable();

ages.Add("John", 23);

方式2：

ages["Green"] = 36;

接口中的索引器

类似于接口中定义的属性的方式，在索引器中也定义索引器的get与set访问器也不写实现而是直接给出一个分号。

interface IRawInt

{

bool this[int index] { get; set; }

}

接口的实现分隐式与显式，隐式实现时，可以标记public等，也可以标记virtual已被其子类重写。如果是显式实现则不能标记public，virtual等。

索引器中还结合泛型的使用，如Dictionary<T,U>中索引器的实现形如：

public virtual U this[T key]{ get; set; }

本文链接

再谈ASP.NET6 – XML与XSLT

2011-04-23T00:20:00Z

XSLT用于将XML文档转换为我们想要的文档类型，最常见的是转换为HTML。XSLT本身也是一个XML文档，XSLT规范中定义了用于XSLT的一些元素。下面的表格展示了一些常用的元素，注意说明中提到的样式都是指XSLT样式而非用于HTML的CSS样式。

元素	说明
xsl:apply-imports	应用来自导入样式表中的模版规则。导入样式表中的模板将覆盖源样式中的模板。
xsl:apply-templates	向当前元素或当前元素的子元素应用模板。可以通过在select属性中指定XPath表达式来选择要应用模板的元素
xsl:attribute	向输出元素添加属性。
xsl:attribute-set	创建命名的属性集，可以被不同的元素共享。
xsl:call-template	调用一个指定的模板。
xsl:choose	与<xsl:when>以及<xsl:otherwise>协同使用，来表达多重条件测试。类似C#中的switch..case
xsl:comment	在结果树中创建注释节点。
xsl:copy	创建当前节点的一个备份（无子节点及属性）。
xsl:copy-of	创建当前节点的一个备份（带有子节点及属性）。
xsl:decimal-format	定义当通过 format-number() 函数把数字转换为字符串时，所要使用的字符和符号。
xsl:element	在输出文档中创建一个元素节点。
xsl:fallback	假如处理器不支持某个XSLT元素，定义一段备用代码来运行。这常用于在使用某个较新版本的XSLT时，为了让有些不支持这个版本的处理器（常见的是浏览器）也能解析而提供一些备用代码。
xsl:for-each	遍历指定的节点集中的每个节点。
xsl:if	包含一个模板，仅当某个指定的条件成立时应用此模板。
xsl:import	用于把一个样式表中的内容倒入另一个样式表中。倒入的样式表比源样式表优先级高。
xsl:include	把一个样式表中的内容包含到另一个样式表中。这两个样式表的优先级相同。
xsl:key	声明一个命名的键。用于key()函数
xsl:message	向输出写一条消息（用于错误报告）。
xsl:namespace-alias	把样式表中的命名空间替换为输出中不同的命名空间。
xsl:number	测定当前节点的整数位置，并转为数字格式。
xsl:otherwise	定义 <xsl:choose> 元素的默认动作。
xsl:output	定义输出文档的格式。
xsl:param	声明一个局部或全局参数。局部参数的作用域是参数所在的模板
xsl:preserve-space	用于定义保留空白的元素。
xsl:processing-instruction	生成处理指令节点(将处理指令写入输出)。
xsl:sort	对结果进行排序。与<xsl:for-each>或<xsl:apply-templates>共同使用。
xsl:strip-space	定义应当删除空白字符的元素。
xsl:stylesheet	定义样式表的根元素。这个元素必须是XSLT文档中最外层元素并且必须包含一个与XSLT规范相关联的命名空间和一个版本属性。
xsl:template	为匹配特定模式的的节点定义一个应用的模板，这个模板是可重用的。
xsl:text	通过样式表生成文本节点。
xsl:transform	定义样式表的根元素。
xsl:value-of	提取选定节点的值写入输出。
xsl:variable	声明局部或者全局的变量。
xsl:when	定义 <xsl:choose> 元素的动作。
xsl:with-param	定义被传入某个通过<xsl:call-template>调用的模板的参数的值。

接下来是XSLT使用的函数：

函数	说明
current()	返回只有当前节点的节点集。
document()	用于访问外部 XML 文档中的节点。允许从初始化数据输入流之外的源中访问数据。
element-available()	测试 XSLT 处理器是否支持指定的元素。
format-number()	把数字转换为字符串。
function-available()	测试 XSLT 处理器是否支持指定的函数。
generate-id()	返回唯一标识指定节点的字符串值。
key()	检索使用 <xsl:key> 语句标记的元素。
node-set()	将树转换为节点集。产生的节点集总是包含单个节点并且是树的根节点。
system-property()	返回系统属性的值。
unparsed-entity-uri()	返回未解析实体的 URI。

除了在XSLT中使用上面列表中列出的它自身的函数，还可以使用XPath的函数。了解XSLT中的元素和函数接下来展示下如何定义XSLT，如何在XML中使用XSLT。

首先我们给一个简单的例子展示如何通过XSLT把一个XML转为HTML：

如下是带转换的XML文档：

<?xml version="1.0" encoding="utf-8" ?>

<title>Essential C# 4.0</title>

<first-name>Mark</first-name>

<last-name>Michaelis</last-name>

</author>

</book>

<first-name>Jeffrey</first-name>

<last-name>Richter</last-name>

</author>

</book>

<title>Effective C#</title>

<first-name>Bill</first-name>

<last-name>Wagner</last-name>

</author>

</book>

</bookstore>

接着是一个简单的XSLT来处理上面的XML：

<?xml version="1.0" encoding="utf-8"?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:output method="html"/>

<xsl:template match="/">

<html>

<title>XSL Transformation</title>

<body>

<h2>BookShelf</h2>

<th align="left">Title</th>

<th align="left">Price</th>

</tr>

<xsl:for-each select="bookstore/book">

<tr>

<td>

<xsl:value-of select="title"/>

</td>

<td>

<xsl:value-of select="price"/>

</td>

</tr>

</xsl:for-each>

</table>

</body>

</html>

</xsl:template>

</xsl:stylesheet>

当我们使用后文价绍的引用XSLT的代码后，在浏览器中我们可以看到如下输出：

最后我们来解释一下这个XSLT文档，文档最开始是所有XML文档都必须的声明，第二行就是这个XSLT的根元素。而<xsl:template>元素标志着模板的开始，其中的属性match=”/”表示将模板关联到XML源文档的根元素上，在这个例子中即<bookstore>。剩下部分比较值得一提就是通过<xsl:for-each>元素定义了一个循环处理一个节点集中的所有元素。接着我们看一下更复杂的情况：

在输出时对XML元素进行排序

我们要对上面的例子进行一些改造，假如我们想要对输出到表格中的书籍按名称进行排序，我们只需添加一个<xsl:sort>元素到<xsl:for-each>元素中，并使用select属性制定排序列即可，代码段：

<xsl:for-each select="bookstore/book">

<xsl:sort select="title"/>

<tr>

这样输出结果变为：

按条件输出模板

这个例子中我们打算只输出价格大于$50的书籍，这也很简单只需要在模板的外侧套上一层<xsl:if>元素就可以了。这个元素的test属性中我们设置判断是否输出模板的条件，见代码：

<xsl:for-each select="bookstore/book">

<xsl:if test="price > 50">

<tr>

<td>

<xsl:value-of select="title"/>

</td>

<td>

<xsl:value-of select="price"/>

</td>

</tr>

</xsl:if>

</xsl:for-each>

这样输出变为：

处理多个条件

这个场景中我们，我们将不同范围的价格所在的单元格填充不同的背景色。这里我们将用到<xsl:choose>元素及用于这个元素内部的<xsl:when >与<xsl:otherwise>。我们将在输出价格单元的模板外应用这些元素，这段代码也是比较好理解的：

<xsl:for-each select="bookstore/book">

<tr>

<td>

<xsl:value-of select="title"/>

</td>

<xsl:choose>

<xsl:when test="price < 40">

<xsl:value-of select="price"/>

</td>

</xsl:when>

<xsl:when test="price > 40 and price < 50">

<xsl:value-of select="price"/>

</td>

</xsl:when>

<xsl:otherwise>

<xsl:value-of select="price"/>

</td>

</xsl:otherwise>

</xsl:choose>

</tr>

</xsl:for-each>

效果图：

其他有用的元素

<xsl:variable>这个元素可以定义一个XSLT变量，虽然称其为变量但其只能赋值一次不能更改，类似于C#中的常量。其主要作用是用来保存一些会被反复用到的值。XSLT变量的定义很简单：

<xsl:variable name="var_name" select="var_value" />

其中name属性指定了变量的名称，而select属性指定变量的值。

XSLT变量有作用域的概念，直接定义在<xsl:stylssheet>下的为全局变量，否则为局部变量，在不同作用域内的局部变量名称是可以相同的。

要引用一个XSLT变量只需使用$+变量名称即可。另外通过<xsl:param>元素定义参数的方式与变量完全一致，XSLT的参数本质上为参数化的变量，同样参数引用方式也与使用变量相同。

在将XSLT应用于XML有两种方式，一种是静态方式，即在XML中引用样式表，二是动态方式，即通过程序应用样式表。下面是两个例子：

1. 静态方式引用

<?xml version="1.0" encoding="utf-8" ?>

<?xml-stylesheet type="text/xsl" href="books.xsl"?>

</bookstore>

只要books.xsl与xml文件在一个文件夹下（或者使用其他相对路径），当使用如IE浏览器等具有XSLT解析功能的工具打开XML时，将会展示被XSLT转换后的结果。

2. 动态方式引用

这种方式需要借助.NET Framework的支持，.NET框架下System.Xml程序集中提供了XSLT的处理器，用于通过XSLT将XML转换成另外的结构。最主要的一个类就是.NET2.0开始提供的XslCompliedTransform类。这个类有两个核心方法Load()，用于加载Xslt文件，Transform()用于加载XML源文件并进行转换处理，转换输出的结果根据不同的重载分别会输出到Stream、TextWriter或XmlWriter。下面的一小段代码演示了这个过程：

string xmlPath = MapPath(@"App_Data\Books.xml");

string xslPath = MapPath(@"App_Data\Books.xslt");

XPathDocument xpathDoc = new XPathDocument(xmlPath);

XslCompiledTransform transform = new XslCompiledTransform();

transform.Load(xslPath);

transform.Transform(xpathDoc, null, Response.Output);

当我们把其放在一个页面的Page_Load函数中，运行这个页面我们会得到与前文一样的效果。

另一个需要介绍的重要的类是XsltArgumentList类，其可以将参数和扩展对象传递给样式表。我们直接通过示例来说明这个类的使用：

首先我们要改造一下前文给出的样式表：

首先添加一个全局参数变量：

<xsl:param name="discount" select="0.75" />

并添加一列显示折扣价格的模板，使用参数计算折扣后的价格：

<xsl:value-of select="price * ($discount)"/>

我们可以很方便的通过ASP.NET页面向<xsl:param>元素传递参数值，只需要添加这样两行代码：

XsltArgumentList argsList = new XsltArgumentList();

argsList.AddParam("discount", "", "0.15");

当然还要传入Transform方法

transform.Transform(xpathDoc, argsList, Response.Output);

通过.NET扩展XSLT功能

由于XSLT提供的方法功能有限，有时我们需要通过扩展给转换过程添加更复杂的逻辑，我们将详细介绍两种方式：

1. 通过扩展对象

同样我们通过一个例子介绍完整的流程，场景需求和之前一样，我们需要计算一个折扣价格。首先我们需要完成扩展对象的定义，其被定义于一个名为Discount的类中。

public class Discount

{

public Discount()

{

}

public string ReturnDiscount(string price)

{

decimal priceValue = Convert.ToDecimal(price);

return (priceValue * 15 / 100).ToString();

}

我们要做的就是将Discount对象传入XSLT样式表中并调用ReturnDiscount()方法。这个仍然需要借助XsltArgumentList类来完成（XsltArgumentList提供AddExtensionObject方法用于完成扩展对象的添加）：

XsltArgumentList argsList = new XsltArgumentList();

Discount obj = new Discount();

argsList.AddExtensionObject("urn:myDiscount", obj);

接着我们需要在XSLT文件根元素中添加一个自定义的命名空间，命名空间的值即我们传入AddExtensionObject方法的Uri（命名空间的名称可随意定）。

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:myDiscount="urn:myDiscount">

这样我们就可以在xslt模板中通过命名空间方便的调用ReturnDiscount方法：

前文中：

<td>

<xsl:value-of select="price * ($discount)"/>

</td>

可以被如下代码等效替换：

<xsl:value-of select="myDiscount:ReturnDiscount(price)"/>

</td>

扩展对象有两个主要优势，提供更好的类封装和重用（多个样式表共享一个扩展对象），另外可以使样式表更小，更具可维护性。

2. 在XSL样式表中嵌入脚本

除了使用上文介绍的扩展对象，还可以通过msxsl:script元素直接在XSL样式表中潜入脚本来实现自定义的逻辑。下面的例子中实现了与上文相同的功能但这次是通过嵌入脚本来完成的。这里只给出与扩展对象方式示例代码不同的部分（这段元素放在根元素的下一级中）：

<msxsl:script language="C#" implements-prefix="myDiscount">

<![CDATA[

public string ReturnDiscount(string price)

{

decimal priceValue = Convert.ToDecimal(price);

return (priceValue * 15 / 100).ToString();

}

]]>

</msxsl:script>

另外我们还需要通过XsltSettings告知XslCompiledTransform来启用嵌入脚本代码块支持（构造函数第二个参数设为true），并将其传入XslCompiledTransform对象的Load方法：

XPathDocument xpathDoc = new XPathDocument(xmlPath);

XsltSettings settings = new XsltSettings(false, true);

XslCompiledTransform transform = new XslCompiledTransform();

transform.Load(xslPath, settings, null);

transform.Transform(xpathDoc, null, Response.Output);

嵌入脚本唯一的缺点就是不能在多个样式表之间共享。

XsltSettings类

上文我们用到了XsltSettings类，这个类用于指定在XSLT样式表执行过程中所要支持的XSLT功能，其有下面一些属性：

属性	说明
Default	静态属性，默认设置下禁用document()函数和嵌入脚本的支持
EnableDocumentFunction	在XSLT样式表中启用XSLT的document()函数
EnableScript	可以在XSLT样式表中使用脚本（前文我们就通过构造函数使用这个功能）
TrustedXslt	该属性启用document()函数和嵌入脚本的支持

本文链接

.Net学习难点讨论系列15 - 小技巧总结

2011-04-05T23:08:00Z

1. 默认情况下想使用一些.NET Framework SDK中的命令需要”Visual Studio 200x 命令提示”这个工具。如果想使传统”命令提示符”也支持这些命令应该怎样做呢。当然是配置环境变量。在X:\Program Files\Microsoft Visual Studio 8\VC文件夹下有一个名为vcvarsall.bat的脚本文件，运行它即可完成这个环境变量的配置。

2. checked与unchecked关键字只对整型有效，对于浮点型无效，因为浮点型始终不会出现溢出。checked对于整型溢出会引起OverflowException异常（unchecked中始终不会触发OverflowException异常）。.NET中用Int32.MaxValue表示最大值，Int32.MinValue表示最小值。在checked中MaxValue加1，MinValue减1都会引起异常。

3. 结构和类的主要区别

区别	结构	类
是值类型还是引用类型？	值类型	引用类型
实例存储于栈上还是堆上？	结构实例称为值，存储于栈上	实例称为对象，存在于堆上
可否声明默认构造函数？	不可以	可以
声明自定义的构造函数，还会声明默认构造函数吗？	会	不会
如果在自己的构造函数中不初始化一个字段，编译器会帮助初始吗？	不会	会
可以在声明一个实例字段的同时初始化吗？	不可以	可以
是否可以继承？	不可以	可以由基类继承
是否可以存在析构函数？	不可以	可以

4. 关于params参数的问题

1) 只能在一维数组上使用params关键字，所以下面的例子无法通过编译：

Public static int Min(params int[,] table)

2) 不能重载一个只基于params关键字的方法。params关键字不构成方法的签名的一部分。如下面两个方法同时存在将无法通过编译：

public static int Min(int[] paramList)

public static int Min(params int[] paramList)

3) 不允许ref或out params数组，如下面两种声明都无法通过编译

public static int Min(ref params int[] paramList)

public static int Min(out params int[] paramList)

4) params数组参数必须是方法的最后一个参数（即，每个方法的参数只能有一个params数组），如下实例将不能通过编译：

public static int Min(params int[] paramList , int i)

编译器会检查并拒绝任何可能有歧义的重载。例如，以下两个Min方法存在歧义；如果传递两个int参数，将无法辨别具体调用哪一个：

public static int Min(params int[] paramList)

public static int Min(int, params int[] paramList)

5) 非params方法总是优先于一个params方法。也就是说，如果愿意，仍然可以为普通情况创建一个方法的重载版本，如下例：

public static int Min(int leftHandSite, int rightHandSide)

public static int Min(params int[] paramList)

对于Min(2,3);这种形式的调用，前者函数将优先使用。

6) 对于params object[]这类特殊参数，其会匹配同方法名任意参数的调用。也可以不向其传递参数，或传递null。这会被作为new object[0]传入。

7) 调用public int Process(params int[] paramList)这样含有参数为参数数组的方法，我们可以传入几个单独的int值，也可以传入一个int数组，如下两种调用方式都是有效的：

Process(2,3,8);

Process(new []{2,3,8});

5. sealed关键字不仅可以修饰class，也可以修饰method，这称为密封方法。一个密封类不能被派生，而一个派生类中不能覆盖密封方法。

6. C#中的default关键字

default关键字常与泛型的类型参数一起使用，由于泛型类型只有在运行时才能确定类型，所有我们不能在编译之前确定初始化一个泛型类型的方法，如一个引用类型我们需要初始化为null，一个值类型我们需要初始化为0，这时使用default关键字就可以实现这个在运行时根据实际类型来初始化的功能。

7. 判断string为空或长度为0时，不要再使用string str = string.Empty;if(str==null||str.length==0)，直接使用.net2.0开始提供的新的静态方法：String.IsNullOrEmpty(str)。

8. switch语句的特殊用法

switch语句中的case(分支)数不受限制。我们可以将switch放在一个for循环内，见下面的示例代码：

for (int i = 0; i < 5; i++)

{

switch (i)

{

case 1:

Console.WriteLine("first");

break;

case 2:

Console.WriteLine("second");

break;

//...

default:

Console.WriteLine("default");

break;

}

9. Conditional特性

Conditional特性允许包含或排除对一个方法的调用，Conditional特性的使用很简单：

[Conditional(“CompileSymbol”)]

特性的构造函数接收一个字符串。如果定义了一个这样的编译符号，编译器会包含所有调用这个方法的代码，这与普通情况一致。如果没有定义这样的编译符号，编译器会忽略代码中所有对这个方法的调用。定义编译符号需要使用条件编译#define来完成。

10. 自定义Attribute的一个小技巧（来自C#图解教程）

虽然在.NET4.0起才开始支持命名参数，但.NET2.0后在应用一个Attribute时，就可以使用类似命名参数的特性来为Attribute传入参数，如下面这个自定义Attribute：

public sealed class MyAttributeAttribute :Attribute

{

public string Description { get; set; }

public string Ver { get; set; }

public string Reviewer { get; set; }

public MyAttributeAttribute(string desc)

{

Description = desc;

}

应用这个Attribute时，我们可以以如下方式给构造函数传入参数：

[MyAttribute("An excellent class", Reviewer = "lsxqw", Ver = "7.15.33")]

访问自定义特性

Type类提供了两个方法，用于访问自定义的Attribute：

IsDefined：该方法可以检测某个特性是否应用到某个类上，对于我们上面的示例，我们可以使用下面的方法进行判断：

Type t = typeof (MyClass);

t.IsDefined(typeof (MyAttributeAttribute), false);

GetCustomAttribute：该方法返回应用到目标类型的特性的数组，该方法返回值为object[]对象，布尔参数指定是否搜索继承树来查找特性。

static void CallWhenDone(IAsyncResult iar)

{

MyDel del = (MyDel)iar.AsyncState;

long result = del.EndInvoke(iar);

Type t = typeof(MyClass);

var attrLst = t.GetCustomAttributes(false);

//由于我们的例子只应用了一个特性，我们直接取数组第一项

MyAttributeAttribute attribute = attrLst[0] as MyAttributeAttribute;

if (null != attribute)

{

Console.WriteLine("{0},{1},{2}", attribute.Description, attribute.Ver, attribute.Reviewer);

}

本文链接

.Net学习难点讨论系列14 – 多线程下的进程同步(线程同步问题总结篇)

2011-03-30T16:57:00Z

之前写过两篇关于线程同步问题的文章(一，二)，这篇中将对相关话题进行总结，本文中也对.NET 4.0中新增的一些同步机制进行了介绍。

首先需要说明的是为什么需要线程功能同步。MSDN中有这样一段话很好的解释了这个问题：

当多个线程可以调用单个对象的属性和方法时，对这些调用进行同步处理是非常重要的。否则，一个线程可能会中断另一个线程正在执行的任务，使该对象处于一种无效状态。

也就说在默认无同步的情况下，任何线程都可以随时访问任何方法或字段，但一次只能有一个线程访问这些对象。另外，MSDN中也给出定义，成员不受多线程调用中断影响的类即线程安全类。

CLI提供了几种可用来同步对实例和静态成员的访问的策略（前面两边文章介绍了这其中大部分机制）：

Ø 同步代码区域：

可以使用Monitor类或（编译器支持的语法，如C#中的lock关键字）来同步需要安全的接受并发请求的代码段，这种方式比其他等效的同步方法有更好的性能。

lock语句通过Monitor的Enter和Exit方法实现代码段同步，使用try catch finally结构确保锁被释放。当线程执行该代码时，会尝试获取锁。如果该锁已由其他线程获取，则在锁变为可用状态之前，该线程一直处于阻塞状态。当线程退出同步代码块时，锁就会被释放，这与线程的退出方式无关。通常情况下同步一小代码块并且不跨越多个方法的最佳选择是lock 语句，Monitor类功能强大但使用不当容易出现孤立锁与死锁，而由于lock是通过Monitor的Enter和Exit实现的，因此在临界区中可以结合Monitor的其它方法一起使用。

另外可以通过[MethodImpl(MethodImplOptions.Synchronized)]特性标记一个方法是需要被同步的，方法可以是实例方法也可以是静态方法。最终实现的效果与使用lock关键字或Monitor相关方法相同。注意不要在此特性标记的方法内使用lock(this)/lock(typeof(this))（注意，单独使用lock时也不应用对象本身或类型作为锁（应为类型或实例可能被其它机制锁定，如被[MethodImpl(MethodImplOptions.Synchronized)]标记），对于实例方法与静态方法最好分别使用声明新的私有成员或静态私有成员作为锁，避免使用公有成员作为锁）。另外不能对字符串加锁。

Ø 手动同步：

.NET Framework中提供一些类用于手动进行线程间的访问同步。这些类主要分为3大类别（但正如下文中会看到的这些类别划分并非绝对，某些同步机制在多个类别之间有交叉）：

ü 锁定

ü 通知

ü 连锁操作

1. 锁定

排他锁	独占锁	最常见的形式就是C#的lock语句，该语句控制对一个代码块的访问，这个代码块被称作临界区。详见前文xx中对lock的介绍。
	Monitor类	Monitor类提供了许多附加功能，这些功能可以与lock关键字结合使用(在lock的临界区中调用Monitor类的方法)。更多细节见线程同步问题1方法二中的介绍。
	Mutex类	Mutex的作用也是创建一个临界区以同步对其中对象的访问，方式类似Monitor类，但最大的不同是Mutex支持跨进程的同步。当然其效率也不如Monitor类，在同一进程内通信应首先考虑使用Monitor。Mutex的介绍详见线程同步问题2方法五中的介绍。
	SpinLock类	.NET4.0中新增当 Monitor 所需的开销会造成性能下降时，可以使用 SpinLock 类。当SpinLock请求进入临界区时，会反复地旋转（执行空循环），直至锁变为可用的。如果请求锁所需时间非常短，则空转可比阻塞提供更好的性能。但是，如果锁保留数十个周期以上，则SpinLock的表现会和Monitor一样，而且将使用更多的CPU周期，降低其他线程或进程的性能。
其它锁	有些时候锁不必独占，可以允许一定数目的线程并发访问某个资源。下面列举的锁即用于这个目的。
	ReaderWriterLock类	允许多个线程同时读取一个资源，但在向该资源写入时要求线程等待以获得独占锁。更多细节见线程同步问题1方法三中的介绍。
	Semaphore类	Semaphore类允许指定数目的线程访问某个资源。超过这个数目时，请求该资源的其他线程会一直阻塞，直到某个线程释放信号量。更多细节见线程同步问题2方法七中的介绍。
	ReaderWriterLockSlim类	.NET4.0中新增这个类的作用与ReaderWriterLock类完全一致，其拥有更好的性能，在新开发的程序中应当使用ReaderWriterLockSlim而不是ReaderWriterLock。ReaderWriterLockSlim 具有线程关联。
	SemaphoreSlim类	.NET4.0中新增 SemaphoreSlim类是用于在单一进程边界内进行同步的轻量信号量。使用方式上与Semaphore一致。

2. 通知

通知机制是等待另一个线程的信号的所有方法的统称。

Join方法				这是等待来自另一个线程信号最简单的方法，解释Join方法最好有一个场景，假如我们有ThreadA，ThreadB两个线程，假如我们在ThreadB执行的方法中调用ThreadA.Join()方法。这将阻塞B线程的执行直到A线程完成。场景中ThreadB可以是主线程也可以是其它子线程。其中也可以调用多个子线程的Join方法。这样ThreadB将阻塞并等待所有这些线程执行完毕后才继续执行。另外如果ThreadA的方法中调用了其它线程的Join方法，这将形成一个队列形式的线程调用，所有这些线程将一个个排队执行。 Join也具有两个接受时间间隔的重载，用于设置阻塞线程等待的最长时间。依然用上面的例子来说，我们在B线程方法中调用ThreadA.Join(5000)，当在5秒钟内线程A执行完毕了，则Join方法会立刻返回true，ThreadB继续执行，如果5秒钟线程A未完成，则Join方法在5秒钟到时返回false，ThreadA与ThreadB进入并行交替执行状态。
等待句柄	等待句柄派生自WaitHandle类，后者又派生自 MarshalByRefObject。从而等待句柄可用于跨应用程序域边界的线程同步。WaitHandle类封装了Win32的同步句柄，用于表示所有允许多个等待操作的同步对象。通过调用WaitOne实例方法或WaitAll、WaitAny及SignalAndWait中任一个静态方法方法，可以阻塞当前线程以等待WaitHandle发出信号。 WaitHandle的派生类具有不同的线程关联。事件等待句柄（EventWaitHandle、AutoResetEvent 和 ManualResetEvent）以及信号量没有线程关联。任何线程都可以发送事件等待句柄或信号量的信号。另一方面，mutex有线程关联。拥有mutex的线程必须将其释放；而如果在不拥有mutex的线程上调用ReleaseMutex方法，则将引发异常。
	事件等待句柄	事件等待句柄包括EventWaitHandle类及其派生类AutoResetEvent和ManualResetEvent，这些类允许线程通过彼此发送信号和等待彼此的信号来同步活动。当通过调用Set方法或使用SignalAndWait方法通知事件等待句柄时，阻塞线程会从事件等待句柄中释放。事件等待句柄要么自动重置自身（类似于每次得到信号时只允许一个线程通过的旋转门），要么必须手动重置（类似于一道门，在得到信号前一直关闭，得到信号打开后到其关闭前一直打开）。顾名思义，AutoResetEvent和ManualResetEvent分别表示前者和后者。
		AutoResetEvent	派生自EventWaitHandle，表示自动重置的本地事件。详见线程同步问题2方法六的介绍。
		ManualResetEvent	派生自EventWaitHandle，表示手动重置的本地事件。详见线程同步问题2方法六的介绍
	ManualResetEventSlim		.NET4.0中新增 ManualResetEventSlim类提供了ManualResetEvent的简化版本。其模型与使用方式上与ManualResetEvent一致，主要用于同一进程内线程间的同步。
	CountdownEvent		.NET4.0中新增 CountdownEvent的作用与Semaphore相反，Semaphore中设置了最大可用槽数，当计数为0时(即资源不够用时)则阻塞线程。而CountdownEvent用来统计其它线程结束工作的情况，当监听数变为0时，触发信号。本篇文章的最后部分我们详细介绍CountdownEvent类。
	Mutex类/ Semaphore类		这两个类均派生自WaitHandle，所以它们均可与WaitHandle的静态方法一起使用。例如，线程可以使用WaitAll方法/WaitAny方法等待，而以下三个条件均可以使这个线程解除阻塞：EventWaitHandle接收到信号，Mutex被释放，Semaphore被释放。
	Barrier类		.NET4.0中新增利用 Barrier 类，可以对多个线程进行循环同步，以便它们都在同一个点上阻塞来等待其他线程完成。后文将对这个类进行详细介绍。

3. 连锁操作

联锁操作是由 Interlocked 类的静态方法对某个内存位置执行的简单原子操作。这些原子操作包括添加、递增和递减、交换、依赖于比较的条件交换，以及 32 位平台上的 64 位值的读取操作。关于Interlocked类详见线程同步问题1方法一。

特别注意，原子性的保证仅限于单个操作；如果必须将多个操作作为一个单元执行，则必须使用更粗粒度的同步机制。

尽管这些操作中没有一个是锁或信号，但它们可用于构造锁和信号。因为它们是Windows操作系统固有的，因此联锁操作的执行速度非常快。如CountdownEvent的实现中就使用了Interlocked类。

最后注意，只要有一个线程避开同步机制直接访问需要同步访问的资源，这种同步机制就是无效的。

Ø 同步上下文：

可以使用SynchronizationAttribute为ContextBoundObject对象（上下文绑定对象）启用简单的自动同步。介绍详见线程同步问题1方法四中的介绍。

Ø 线程安全集合：

.NET4.0中新引入的命名空间System.Collections.Concurrent中提供的集合类内置对添加和移除操作的同步机制。多个线程可以在这些集合中安全高效地添加或移除项，而无需用户执行其他同步操作。在编写新代码时，如果遇到多个线程同时写入集合的情况，就应使用并发集合类。如果仅从集合进行（并发）读取，则可使用System.Collections.Generic命名空间中的类。

从.NET发展来看，.NET1.0中提供的集合类(Aarry,Hashtable)通过Synchronized属性支持同步，但不支持泛型，NET2.0种提供了泛型类的集合，但没有内置任何同步机制。.NET4.0开始提供的并发集合类把线程安全与类型安全集合起来。为了提高效率这些并发集合的一部分使用了.NET4.0新增的轻量同步机制，如SpinLock、SpinWait、SemaphoreSlim 和 CountdownEvent，另外ConcurrentQueue<T>和ConcurrentStack<T>类没有使用这些同步机制，而是依赖Interlocked操作来实现线程安全性。

这个新增的命名空间下包含如下类型：

类型	说明
BlockingCollection<T>	通过实现IProducerConsumerCollection<T>接口，实现了一个支持生产者消费者模型的数据结构。
ConcurrentDictionary<TKey, TValue>	键/值对字典的线程安全实现。
ConcurrentQueue<T>	线程安全的队列实现。
ConcurrentStack<T>	线程安全的堆栈实现。
ConcurrentBag<T>	无序的元素集合的线程安全实现。
IProducerConsumerCollection<T>	BlockingCollection实现的接口。

CLR中不同类别可以根据要求以不同的方式进行同步。下表显示了上面列出的几类同步策略为不同类别的字段和方法提供的同步支持。

类别	全局字段	静态字段	静态方法	实例字段	实例方法	特定代码块
无同步	不同步	不同步	不同步	不同步	不同步	不同步
同步上下文	不同步	不同步	不同步	可以同步	可以同步	不同步
同步代码区域	不同步	不同步	当标记时同步	不同步	当标记时同步	当标记时同步
手动同步	手动	手动	手动	手动	手动	手动

到这，可以发现.NET4.0添加了很多新的同步类（轻量类型），这些类尽可能避免依赖高开销的Win32内核对象（例如等待句柄）来提高性能。通常，当等待时间较短并且只有在尝试了原始同步类型并发现它们并不令人满意时，才应使用这些类型。另外，在需要跨进程通信的方案中不能使用轻量类型。

以下内容来源这篇文章：

CountdownEvent

CountdownEvent，前文中我们提及了CountdownEvent实现的同步效果。这里我们将给出一个CountdownEvent适用的场景及示例代码。如我们可以在主线程中模拟一个线程池，通过CountdownEvent使得主线程可以等待线程池中所有线程结束后才能继续执行（对所有子线程的执行顺序没有要求）。在给出代码之前先介绍一些CountdownEvent中一些主要的属性与方法：

重载的构造函数：CountdownEvent的构造函数接受一个整型值，表示事件句柄最初必须的信号数。

InitialCount属性：这个属性正是构造函数接收的参数所设置的值。

CurrentCount属性：事件解除阻塞所必需的剩余信号数。

AddCount方法：将CurrentCount属性的值加1。

Single方法：给出一个信号，这将是CurrentCount的值减1。

class Program

{

static void Main()

{

var customers = Enumerable.Range(1, 20);

using (var countdown = new CountdownEvent(customers.Count()))

{

foreach (var customer in customers)

{

int currentCustomer = customer;

ThreadPool.QueueUserWorkItem(delegate

{

BuySomeStuff(currentCustomer);

countdown.Signal();

//for test

Console.WriteLine(" CountdownEvent:" + countdown.CurrentCount);

});

}

countdown.Wait();

}

//主线程继续执行

Console.WriteLine("All Customers finished shopping...");

Console.ReadKey();

}

static void BuySomeStuff(int customer)

{

// Fake work

Thread.SpinWait(200000000);

Console.Write("Customer {0} finished", customer);

}

代码输出（每次运行子线程执行顺序可能不同）：

Customer 1 finished CountdownEvent:19

Customer 2 finished CountdownEvent:18

Customer 3 finished CountdownEvent:17

Customer 4 finished CountdownEvent:16

Customer 5 finished CountdownEvent:15

Customer 6 finished CountdownEvent:14

Customer 7 finished CountdownEvent:13

Customer 8 finished CountdownEvent:12

Customer 9 finished CountdownEvent:11

Customer 10 finished CountdownEvent:10

Customer 11 finished CountdownEvent:9

Customer 12 finished CountdownEvent:8

Customer 13 finished CountdownEvent:7

Customer 14 finished CountdownEvent:6

Customer 15 finished CountdownEvent:5

Customer 16 finished CountdownEvent:4

Customer 17 finished CountdownEvent:3

Customer 18 finished CountdownEvent:2

Customer 20 finished CountdownEvent:1

Customer 19 finished CountdownEvent:0

All Customers finished shopping...

代码中主线程中调用Wait方法来等待子线程完成(即CountdownEvent的CurrentCount属性变为0)。

CountdownEvent内部通过ManualResetEventSlim与Interlocked实现，ManualResetEventSlim用于实现事件等待句柄，而Interlocked用于线程计数。

Barrier

这个类的作用很明确，使用很简单，首先介绍其中几个比较重要的属性与方法，之后直接进入示例：

构造函数：两个重载共同的参数是需要被同步的线程的数量，参数较多的一个重载第二个参数接收一个Action<Barrier>类型对象，表示所有线程达到同一阶段后执行的方法。

ParticipantCount属性：即构造函数中设置的需要被同步的线程的数量。

SignalAndWait方法：发出参与者已达到Barrier的信号，等待所有其他参与者也达到Barrier。

场景如下：Charlie、Mac、Dennis三个人相约在途中的加油站会合后一同前往西雅图。我们用Barrier来模拟这个场景，重要的是在加油站会和这一点进行同步。

代码：

class Program

{

static Barrier sync;

static CancellationToken token;

static void Main(string[] args)

{

var source = new CancellationTokenSource();

token = source.Token;

sync = new Barrier(3);

var charlie = new Thread(() => DriveToBoston("Charlie", TimeSpan.FromSeconds(1)));

charlie.Start();

var mac = new Thread(() => DriveToBoston("Mac", TimeSpan.FromSeconds(2)));

mac.Start();

var dennis = new Thread(() => DriveToBoston("Dennis", TimeSpan.FromSeconds(3)));

dennis.Start();

//source.Cancel();

charlie.Join();

mac.Join();

dennis.Join();

Console.ReadKey();

}

static void DriveToBoston(string name, TimeSpan timeToGasStation)

{

try

{

Console.WriteLine("[{0}] Leaving House", name);

// Perform some work

Thread.Sleep(timeToGasStation);

Console.WriteLine("[{0}] Arrived at Gas Station", name);

// Need to sync here

sync.SignalAndWait(token);

// Perform some more work

Console.WriteLine("[{0}] Leaving for Boston", name);

}

catch (OperationCanceledException)

{

Console.WriteLine("[{0}] Caravan was cancelled! Going home!", name);

}

执行结果（同样每次运行子线程执行顺序可能不同）：

[Charlie] Leaving House

[Mac] Leaving House

[Dennis] Leaving House

[Charlie] Arrived at Gas Station

[Mac] Arrived at Gas Station

[Dennis] Arrived at Gas Station

[Dennis] Leaving for Boston

[Mac] Leaving for Boston

[Charlie] Leaving for Boston

另外可以取消代码中的注释，观察多线程取消的效果。

其它.NET4.0新增的线程类

SpinWait

从.NET Framework 4开始，当线程必须等待发生某个事件发出信号时或需要满足某个条件时，可以使用System.Threading.SpinWait结构，前提是实际等待时间预计会少于通过使用等待句柄或通过其他方式阻塞当前线程所需要的等待时间，否则SpinWait空转导致的CPU开销会影响其它进程。通过使用 SpinWait，可以指定在一个较短的时段内边等待边旋转，然后只有在相应的条件在指定时间内无法得到满足的情况下放弃旋转。

其它小话题：

Thread.Interrupt方法可用于使线程跳出阻塞状态（如等待访问同步代码区域）。Thread.Interrupt 还可用于使线程跳出 Thread.Sleep 等操作。

本文链接

.NET安全系列之七：通信相关内容

2011-03-26T13:05:00Z

安全连接 - SSL

SSL(Secure Sockets Layer, 安全套接字层)协议保证两个在Internet上通信的应用程序之间的保密性和可靠性。SLL建立在TCP层的基础上。其提供了面向连接的安全性，有如下四个属性：

l 链接是私有的，加密仅对这个会话有效。

l 对称密钥加密算法（例如：DES）用于加密。会话密钥使用非对称密钥加密算法来交换。

l 数字证书用于验证通信实体的标识。

l 安全散列函数，如SHA或MD5，用作消息验证代码(MAC)。

SSL协议的目标有：

l 加密的安全性 - 对会话使用对称密钥，对验证使用公共密钥。

l 通用性 - 在不同的OS和编程语言间使用。

l 可扩展性 - 添加允许在SSL框架中使用的数据加密协议。

l 相对的高效 - 使用高速缓存技术减少计算和网络操作。

SSL算法的具体过程

两个使用SSL协议通信的实体必须各有一个公共 - 私有密钥对，并可以用数字证书验证它们各自的公共密钥。

在会话的开始，客户端和服务器交换信息，验证彼此的身份。这个验证过程称为握手协议。在这个过程中，将协商使用什么会话ID、压缩方法和加密包。如果存在证书，它们也要交换。尽管证书是可选的，但如果没有证书，客户端和服务器可能拒绝新链接，停止会话。

在接收到彼此的公共密钥后，就交换建立在随机生成的数字基础上的一组密钥，用彼此的公共密钥加密它们。之后就可以开始交换应用程序数据了。应用程序数据使用一个对称密钥进行加密，并发用一个数据的标记散列，以验证数据的完整性。

.NET Framework中有类实现了SSL客户端。通过IIS Web服务器部署服务时，可以使用服务器端的SSL。这样可以在Windows平台下获得一个完整的保护B/S系统数据安全的方案。

示例1：下面程序演示了在.NET平台上访问SSL保护的Web服务器。

WebRequest req = WebRequest.Create("http://www.cnblogs.com");

WebResponse result = req.GetResponse();

但是用含有https的URL创建WebRequest(System.Net命名空间)时，WebRequest会自动使用SSL协议。

示例2：下面示例了访问一个安全的URL，其考虑了像编码这样的细节。

using System;

using System.IO;

using System.Net;

using System.Text;

class Program

{

static void Main()

{

Console.WriteLine("请输入一个https的url");

string url = Console.ReadLine();

string ms = "";

try

{

ms = Create(url, "utf-8");

}

catch(Exception ex)

{

Console.WriteLine(ex.StackTrace);

}

Console.WriteLine(ms);

}

//创建一个HTTP安全请求对象，并获得它的相应流

public static string Create(string url, string encod)

{

WebRequest req = WebRequest.Create(url);

WebResponse result = req.GetResponse();

Stream ReceiveStream = result.GetResponseStream();

//由Encoding对象创建一个编码实例

Encoding enc = Encoding.GetEncoding(encod);

//创建流读取器

StreamReader sr = new StreamReader(ReceiveStream, enc);

//读取整个流 - 把整个Web页面对象串行化入字符串

string response = sr.ReadLine();

return response;

}

说完了客户端，接着我们来讨论下如何在IIS上配置SSL，由前面介绍我们知道SSL基于公钥私钥对来实现，而安全证书正是作为这样一组密钥提供加密认证服务。我们可以通过域控制器上配置的证书中心得到证书，但这种证书没法被浏览器校验，会出现安全警告，不适合在互联网生产环境中使用（在域内部使用没有这个问题）。更好的方法的是由VeriSign等安全公司申请证书，IE等浏览器中内置这些机构的根证书，可以验证由这些组织得到的证书数字签名，从而确保证书的可靠性，且没有安全警告等影响易用性的问题。

从VeriSign获取SSL证书的步骤：

通过IIS MMC管理窗口中服务器证书内创建证书申请生成一个证书签名请求(CSR)，将生成的CSR中的内容复制到VeriSign申请系统中。这样就可由VeriSign得到一个证书，把其安装到IIS中即可。

在IIS中安装完证书后，就可以使用SSL连接（https）访问服务器上的所有Web页面（服务器防火墙注意开放443端口），只需将http://换成https://即可。在网站设计中我们应该只对登陆，交易等页面使用SSL，对所有页面使用SSL会影响服务器性能。

最后我们讨论一下在网站中部署SSL的方法

1. 将Web.config中的<forms>的requireSSL属性设置为true，这样所有信息都通过SSL传输，对于大型网站会影响性能不建议使用。

2. 在iis中选中一个页面，进入功能视图中SSL设置页，选中“要求SSL”这一项。这个做法也有个的问题，当使用http://访问这个页面时将会被拒绝而不是友好的转到https://下的同页面。一个折中的做法是在链接上使用绝对URL，从而对需要使用SSL的页面上进行正确的导航。

3. 这是我们要介绍的一种比较好的实践

对于需要强制使用SSL的页面我们统一使用一个母版页，在这个母版页的OnInit处理函数中我们进行如下处理：

public override void OnInit(EventArgs e)

{

if (!Request.IsSecureConnection)

{

//第二值设为true表示结束本次请求

Response.Redirect(Request.Url.AbsoluteUri.ToLower().Replace(

"http://", "https://"), true);

}

base.OnInit(e);

}

这样如果在应该使用SSL的请求中使用了普通的http链接，则会结束当前请求（减少资源浪费），并发起一个新的正确请求。

对于不强制使用SSL的页面也使用一个母版页，但对于这些页我们做灵活处理，我们可以通过页面中的ViewState的设置来灵活的选择这个也是否可以使用SSL。在母版页中我们使用一个属性来得到内容页ViewState的设置，这个属性返回一个bool表示是否使用SSL。

public bool EnforceSSL

{

get

{

if (ViewState["enforceSSL"] != null)

{

return (bool)ViewState["enforceSSL"];

}

else

{

return false;

}

set

{

ViewState["enforceSSL"] = value;

}

此属性在母版页面OnInit事件发生时还不能访问，所以在这个母版页中我们选择在OnPreRender事件处理程序中处理：

public override void OnPreRender(EventArgs e)

{

if (EnforceSSL)

{

if (!Request.IsSecureConnection)

{

Response.Redirect(Request.Url.AbsoluteUri.ToLower().Replace(

"http://", "https://"), true);

}

else if (Request.IsSecureConnection)

{

Response.Redirect(Request.Url.AbsoluteUri.ToLower().Replace(

"https://", "http://"), true);

}

这其中对于不需要使用SSL，我们将其转向普通http请求。

本文链接

再谈ASP.NET 5 – 处理流程

2011-02-21T11:34:00Z

内容页与母版页加载事事件处理的先后顺序

在最终访问结果页时，实际访问的是内容页与母版页。作为有密切关系的两个页面，它们各自要处理自身的初始化与加载等事件。这个过程总体上可以由下图来展示：

加载母版页和内容页共需经过如上8个过程。通过这8个过程可以看出初始化和加载母版页与内容页是一个相互交叠的过程。这8个过程中对应着11个具体的事件。如下：

母版页中控件的Init事件；
内容页中Content控件的Init事件；
母版页Init事件；
内容页Init事件；
内容页Load事件；
母版页Load事件；
内容页中Content控件的Load事件；
内容页PreRender事件；
母版页PreRender事件；
母版页控件PreRender事件；
内容页中Content控件的PreRender事件；

可以看出内容页和母版页中会引发相同的事件。例如，两者都引发Init、Load和PreRender事件。引发事件的一般规律是，初始化Init事件从最里面的控件（母版页）向最外面的控件（Content控件及内容页）引发，所有其他事件则从最外面的控件向最里面的控件引发。需要明确的是，母版页会合并到内容页中，并被视为内容页中的一个控件。

对于不包含母版页的页面，这个流程如下：

PreInit

Init,InitComplete

PreLoad

Load,LoadComplete

PreRender,PreRenderComplete

SaveStateComplete

Unload

如图所示：

在页面第一次加载期间，生命周期包括下列步骤：

运行构造函数。对于页面或页面上的任何控件，这是生命周期的第一步。
确定回传模式。是第一次加载，或者是自回传，还是跨页回传。
预初始化。为了在第一个页面初始化之前确定目标设备，这一步是必须的。PreInit是生命周期中第一个事件，该事件使用OnPreInit方法处理事件。
加载并初始化个性化主题
初始化。在初始化阶段构建控件树。在这个阶段可以为请求初始化任何值。通过处理Init事件的OnInit方法可以实现对初始化阶段的修改。
预加载。在回传数据被加载进控件前发生。通过处理PreLoad事件的OnPreLoad方法可以实现对该阶段的修改。
加载。在此阶段，用户代码运行，表单控件显示客户端数据。视图状态数据可用，还可以访问页面控件层次结构内的控件。通过处理Load事件的OnLoad方法可以实现对加载阶段的修改。
加载完成。完成加载过程。通过处理LoadComplete事件的OnLoadComplete方法可以实现对该阶段的修改。
预呈现。这是输出呈现前的一个阶段。通过处理PreRender事件的OnPreRender方法可以实现对该阶段的修改。
保存状态。个性化、控件、视图还有页面状态信息都被保存。
呈现。在此阶段，页面及其控件输出呈现为HTML。可以使用Render方法进行重写。在Render方法内，如果有必要的话，可以调用CreateChildControls方法实现在控件树内创建并初始化服务器控件。
卸载。这是生命周期的最后阶段。这个阶段提供了一个机会，以便完成最终的清除工作，并释放对任何耗费资源的资源，例如，数据库连接。这对于规模是非常重要的。可以通过使用OnUnload方法来处理。

在回传期间，有以下几点与第一次加载不同：

加载状态。初始化完成后，加载页面和控件状态，同时，从页面上的一个隐藏变量加载视图状态。
处理回传数据。在这个阶段，通过Post方法来处理发送到服务器的数据。通过LoadPostData方法可实现对于需要回传的视图状态的任何更新。
预加载和加载。这和第一次加载相同。
发送回传变化通知。如果当前状态较先前状态发生了任何变化，就会通过RaiseChangedEvents方法引发变化事件。引发的顺序和控件在控件树种的顺序相同。
处理回传事件。确切的说是用户行为导致了回传。在所有变化事件得以处理后，将处理用户行为。导致回传的最初客户端事件在RaisePostBackEvent方法中进行处理。
加载完成。从这里开始，都和第一次加载相同。

本文链接

.Net学习难点讨论系列13 – 异步操作

2011-02-05T10:56:00Z

能否让一个用户使用一个软件时有好的感受是一个软件能否成功的一个很重要的方面，适当的使用异步操作完成部分功能，能大大增加用户的使用体验。.NET通过委托提供了一个简单易用的异步编程模式，使用这种多线程机制可以这大大简化了我们手工编写代码处理多线程的工作。

之前委托章节介绍的委托调用都是同步完成的，下面我们要介绍的就是进行异步委托调用。这有个前提委托对象的方法调用列表中只能有一个方法。这样当我们调用委托对象的BeginInvoke方法时，会在独立的线程上执行委托引用的方法。而原始线程不会等待，可以继续执行，调用BeginInvoke方法会返回一个IAsyncResult对象。通过IAsyncResult的IsCompleted属性可以查看子线程是否执行完成。

我们可以通过三种方式知道原始线程发起的子线程是否已经完成。这是异步方法调用的三种标准模式：

& wait-until-done等待直到结束模式：在发起异步调用后，可选的进行一些其他处理，通过调用EndInvoke中断原始线程，并等待异步方法完成后，原线程再执行。如果调用EndInvoke时，子线程已经完成，则直接返回，并继续执行主线程未完的操作。

& polling轮询模式：原线程定期检查子线程是否完成，如果没有完成，则可以先执行其他操作。

& callback回调模式：原线程无需中断等待或定期检查子线程的完成情况，这种模式下委托引用的方法执行完成后，子线程会调用回调方法，回调方法中调用EndInvoke方法获取并处理异步操作结果。

BeginInvoke的参数除了最后两个外都是委托所需的参数，另外对于每一个BeginInvoke都要确保调用了EndInvoke，以保证资源被释放。EndInvoke接收的参数即BeginInvoke方法的返回值 – IAsyncResult的对象。特别注意如果异步调用的方法（即委托调用的方法）中含有ref或out参数，则调用EndInvoke时需要将ref/out参数放在IAsyncResult参数之前。

最后我们分别给出几种模式的代码示例：

1. wait-until-done等待直到结束模式

原始线程发起一个异步方法的调用，做一些其他处理，然后停止并等待，直到开启的子线程结束。首先是异步调用的委托，后面几种模式的示例代码将以其为基础。

delegate long MyDel(int first, int second);

接着是等待直到结束模式的代码：

class Program

{

static long Sum(int x, int y)

{

//模拟一个较长的工作时间

Thread.Sleep(1000);

return x + y;

}

static void Main(string[] args)

{

MyDel del = new MyDel(Sum);

//开始异步调用

IAsyncResult iar = del.BeginInvoke(3, 5, null, null);

Console.WriteLine("进行主线程其它工作");

//等待异步操作结束，并获取结果

long result = del.EndInvoke(iar);

}

2. polling模式

原始线程发起了异步方法的调用，这期间可以做一些其他处理，定期检查IAsyncResult对象的IsCompleted属性来判断开启的线程是否完成。如果未完成则继续处理主线程的工作，否则调用EndInvoke得到异步处理的结果，示例：

static void Main(string[] args)

{

MyDel del = new MyDel(Sum);

//开始异步调用

IAsyncResult iar = del.BeginInvoke(3, 5, null, null);

while (!iar.IsCompleted)

{

//模拟主线程任务

for (long i = 0; i < 1000000; i++) ;

}

//异步操作结束，获取结果

long result = del.EndInvoke(iar);

}

3. callback回调

不同于前两种模式中主线程在开启了子线程后还要等待或查询子线程的状态，回调模式中主线程在开启子线程后将不再考虑子线程而是继续自己的工作。异步线程在完成操作后将调用一个用于自定义的回调函数，这个函数中将调用EndInvoke方法来获得异步处理结果并可选的进行进一步操作。

BeginInvoke方法的最后两个参数与回调有关：

第一个参数，callback，接收一个回调方法（的委托对象）

第二个参数，传入回调方法的参数

回调方法需要符合AsyncCallback委托，如：

static void CallWhenDone(IAsyncResult iar)

{

AsyncResult ar = (AsyncResult) iar;

MyDel del = (MyDel) ar.AsyncDelegate;

long result = del.EndInvoke(iar);

}

有了这个回调函数，我们在调用BeginInvoke时可以传入这样的参数：

IAsyncResult iar = del.BeginInvoke(3, 5, new AsyncCallback(CallWhenDone), null);

借助.NET对委托推断的支持，上面的代码可以简写为：

IAsyncResult iar = del.BeginInvoke(3, 5, CallWhenDone, null);

另外，第“二”参数，如果没有什么其它用途，我们可以将委托对象(del)通过这个参数传入回调函数中：

IAsyncResult iar = del.BeginInvoke(3, 5, CallWhenDone, del);

在回调方法中，我们可以通过IAsyncResult参数的AsyncState属性得到（传入参数即）委托对象的引用。注意AsyncState属性为object类型，需要将其转换为相应的委托类型：

static void CallWhenDone(IAsyncResult iar)

{

MyDel del = (MyDel) iar.AsyncState;

long result = del.EndInvoke(iar);

}

最终将上面这些代码段连在一起就可以了。

本文链接

再谈ASP.NET4 - Page类分析

2011-02-02T14:12:00Z

本文整理自《ASP.NET3.5核心编程》，以下内容适用于ASP.NET2.0以上版本。

Page类提供了由.aspx文件创建所有对象的基本行为。（这个有<asp:Control />标签生成C#描述的类型的对象的过程是我们看不到的，这是由编译器自动完成的。）Page可以实现这个功能是由于其实现了IHttpHandler接口。实现IHttpHandler接口，就可以充当相应类型的（此处为.aspx文件）的HTTP请求的处理程序。IHttpHandler接口的关键方法ProcessRequest完成了上述由.aspx文件创建所有对象的过程。

Page的父类TemplateControl定义了页面（或控件）的一组基本功能。TemplateControl上层的Control类定义ASP.NET服务器端元素（包括页面、控件和用户控件）共享的属性、方法和事件。TemplateControl实现的INamingContainer接口使Page可以作为控件的容器。

Page类的属性

Page类的属性分为三类：内置对象、Worker属性和页面特有的属性。以下分别介绍：

内部对象

这些属性的类型都是页内部的辅助对象，它们都是使页面能够正常执行的基本元素。

属性	说明
Application	返回HttpApplicationState类的实例。它代表当前应用程序的状态。
Cache	返回Cache类的实例，为ASP.NET应用程序实现了缓存。其支持任务优先级和到期(expiration)，且比Application效率更高，功能更强
Profile	返回ProfileCommon类的实例。它代表与请求关联的、用户特有的数据集合
Request	返回HttpResponst类的实例。它代表当前HTTP请求。
Response	返回HttpResponse类的实例。它用于将HTTP响应数据发送给客户端。
Server	返回HttpServerUtility类的实例。它提供处理Web请求的辅助方法。
Session	返回HttpSessionState类的实例。它用于管理用户特有的数据。
Trace	返回TraceContext类的实例。它用于对页面进行跟踪
User	返回IPrincipal类型的对象。它代表发出请求的用户

Worker属性

这些属性用于承载信息和提供基本功能。在进行页面编程时，这些属性必不可少。

属性	说明
ClientScript	用于获取ClientScriptManager对象，它包含页面使用的客户端脚本。
Controls	返回当前页面包含的字控件集合
ErrorPage	表示错误页的属性，在发生未处理页面异常时，发出请求的浏览器会被重定向到该页面上
Form	返回当前页面的HtmlForm对象
Header	返回代表当前页面标头的对象。该对象实现了IPageHeader接口。
IsAsync	用于指示当前页是否被异步处理程序调用。
IsCallback	用于指示当前被加载的页面是否为客户端脚本回调的结果。
IsCrossPagePostBack	用于指示当前被加载的页面是否是对另一个页面回发的响应
IsPostBack	用于指示当前被加载的页面是对客户端回发的响应，还是第一次加载
IsValid	用于指示页面验证是否成功
Master	返回MasterPage类的实例。它代表确定当前页面外观的母版页。
MasterPageFile	表示当前页面的母版页的文件名的属性
NamingContainer	返回null
Page	返回当前Page对象（C#中就是this）
PageAdapter	返回当前Page对象的适配器对象
Parent	返回null
PreviousPage	返回跨页回发中主调用页的引用
TemplateSourceDirectory	获取当前页面的虚拟路径
Validators	返回页中包含的所有验证控件的集合
ViewStateUserKey	字符串类型的属性，代表用户特有的标识，用于对视图状态的内容进行散列加密(hash)。该措施是单键攻击(one-click attack)的防线之一

解释：由于Page对象处于层状结构的根节点。所以，NamingContainer与Parent属性总是返回null。ViewStateUserKey可以接受用户特有的信息，这些信息可以是通过验证的会话id等。此属性可以被用来加密ViewState等。另外ViewStateUserKey必须在Page_Init中设置。

上下文属性

这些属性代表页面的可视和非可视属性(attribute)

属性	说明
ClientID	总是返回空字符串
ClientQueryString	获取被请求URL的查询字符串部分。
ClientTarget	默认为空字符串，允许开发者指定浏览器类型，以便生成正确的HTML。设置此属性将禁用浏览器的自动检测功能
EnableViewState	用于指示当前页是否管理视图状态信息。作用相当于@Page中的EnableViewState属性
EnableViewStateMac	用于指示ASP.NET是否需要生成计算机特有的身份验证吗(MAC)，并将其追加到页面的视图状态中
EnableTheming	用于指示当前页是否支持主题
ID	总是返回空字符串
MaintainScrollPositionOnPostback	用于指示在回发后是否恢复客户端浏览器的滚动条位置
SmartNavigation	用于指示是否开启智能导航。智能导航利用了大量浏览器特有的功能来加深用户对页面的体验
StyleSheetTheme	表示应用于当前页面的样式表名称
Theme	表示应用于页面的主题的名称。注意，若以编码的方式设置主题，则只能在PreInit事件中进行。
Title	表示页面的标题的属性
TraceEnabled	打开或关闭当前页的跟踪功能
TraceModeValue	获取或设置跟踪模式
UniqueID	总是返回空字符串
ViewStateEncryptionMode	用于指示是否加密视图状态及加密方式
Visible	用于指示ASP.NET是否呈现该页面。如果将Visible设置为false，ASP.NET不会为该页生成任何HTML代码，且只有显示使用Response.Write写入的文本会被发往客户端

Page对象中三个与ID有关的属性 – ID、ClientID与UniqueID总返回空字符串，因为这些仅用于服务器控件，在Page中没有意义。

Page类的方法

Page类的方法可以按功能分为以下几类。分别总结如下：

用于呈现（生成标记）的方法

方法	说明
DataBind	用于将页面中的所有可数据绑定的控件绑定到它所对应的数据源上。DataBind方法本身不会生成代码，但为后续的呈现铺平道路
RenderControl	用于将当前页面输出为HTML文本，如果启用跟踪，结果中将会包含跟踪信息
VerifyRenderingInServerForm	控件在生成时会调用该方法，以确保服务器窗体的主体中包含它们。该方法不会返回值，但发生错误时会抛出异常

说明：在ASP.NET中所有runat属性为server的控件都需要放置在<form>标签内，以使其可以由VerifyRenderingInServerForm方法来确保自身被正确呈现。

控件相关的方法

方法	说明
DesignerInitialize	当页面处于Visual Studio设计器模式中时，该方法用于对Page类的实例进行初始化
FindControl	通过控件的ID在页面的命名容器中查找它。该搜索不会进入本身也为命名容器的子控件
GetTypeHashCode	用于在运行时获取由ASP.xxx_aspx页面类生产的哈希码。在基类Page中，该方法的实现仅仅是返回0，而实际的页面类会返回大量数字
GetValidators	返回指定验证组(validation group)的控件验证程序集合。
HasControls	检查当前页是否包含子控件
LoadControl	用于编译并加载.ascx文件中的用户控件，之后会返回一Control对象。如果该用户控件支持缓存，则返回PartialCachingControl
LoadTemplate	编译并加载.ascx文件中的用户控件，返回实现ITemplate接口的内部类的实例，它对该控件进行了封装。这个内部类名为SimpleTemplate
MapPath	获取映射到绝对或相对虚拟路径的完整物理地址
ParseControl	用于对输入的有效字符串进行解析，返回指定标记文本所对应的控件实例。如果该字符串包含多个控件，则只有第一个有效。runat属性会被忽略。该方法返回的是一个Control类型的实例，因而必须转换成更具体的类型
RegisterRequiresControlState	将控件注册为具有持久性控件状态的。
RegisterRequiresPostBack	用于注册指定控件，使其能够接收到回发处理通知(即便其ID与已回发数据集合中的任何ID都不匹配)。该控件必须实现IPostBackDataHandler接口
RegisterRequiresRaiseEvent	用于注册指定控件，使其能够处理输入的回发事件。该控件必须实现IPostBackEventHandler接口
RegisterViewStateHandler	该方法用于设置一内部标志，以便保持当前页视图状态，多数情况为内部使用。如果该方法没有在预呈现阶段被调用，则不会写入任何视图状态。一般仅有页面的HtmlForm服务器控件会调用该方法。不需要在用户应用程序中调用
ResolveUrl	根据TemplateSourceDirectory属性值，将一相对URL解析为绝对URL
Validate	使页中的所有验证控件对其被赋予的信息进行验证。ASP.NET 2.0支持验证组，对需要验证的控件进行逻辑分类，且各组之间互不干扰

这些方法中，有如下值得说道的，LoadControl和LoadTemplate方法除了在返回值得类型上，前者返回Control类对象，后者返回ITemplate类型对象外其于内部代码都相同。另外这两个方法区别于ParseControl方法的地方在于后者不引发编译，而只是解析字符串并推断控件信息。该信息用于控件实例的创建及初始化。

脚本相关的方法

以下这些Page类的方法用于将Html和脚本代码插入到客户端页面。

方法	说明
GetCallbackEventReference	用于获取客户端函数的引用。该函数被调用时，将引发客户端向服务器端的回调事件
GetPostBackClientEvent	转而调用GetCallbackEventReference
GetPostBackClientHyperlink	用于向从GetPostBackEventReference返回的字符串的开始处追加“javascript:”，如：javascript:__doPostBack('CtlID','')
GetPostBackEventReference	返回客户端脚本函数的原型。当该脚本函数被调用时，将引起回发的执行。它接受一个Control对象和一个参数，返回的字符串形式如下：__doPostBack('CtlID','')
IsClientScriptBlockRegistered	用于确定页面是否注册了指定的客户端脚本。该方法已被标记为过时
IsStartupScriptRegistered	用于确定页面是否注册了指定的客户端启动脚本。该方法已被标记为过时
RegisterArrayDeclaration	该方法用于将ECMAScript数组添加到客户端页面上。其接受一数组名和一个代表数组主体的字符串。例如，如果以theArray 和“'a', 'b'”为参数调用该方法，则会得到以下JavaScript代码：var theArray = new Array('a', 'b'); 该方法已被标记为过时
RegisterClientScriptBlock	ASP.NET页使用这个方法向客户端页面的HTTP <form>元素的开标记后添加脚本代码块。该方法已被标记为过时
RegisterHiddenField	用于自动向页面注册隐含字段。该方法已被标记为过时
RegisterOnSubmitStatement	该方法用于添加处理OnSubmit事件的客户端脚本代码。该脚本应为一个JavaScript函数，它会调用已在某处注册的脚本代码。该方法已被标记为过时
RegisterStartupScript	ASP.NET页使用这个方法向客户端页面的HTTP <form>元素的闭标记前添加脚本代码块。该方法已被标记为过时
SetFocus	将浏览器的焦点设置在指定控件上。

这其中很多方法被标记为过时，我们应该使用Page的ClientScript中的相关方法来操作客户端脚本。当我们使用RegisterXXX方法注册脚本时，脚本被缓存在一个结构中并在页面渲染后背生产到最终的Html文档里。

Page类的事件

在页面生命周期里，会触发一些列的事件。这些事件一般都标记者一个关键的处理阶段。

事件	说明
AbortTransaction	若ASP.NET页参与自动事务，该事件会在事务中止时引发
CommitTransaction	若ASP.NET页参与自动事务，该事件会在事务提交时引发
DataBinding	在页的DataBind方法被调用时引发。该方法会对页中的所有子控件与其所对应的数据源进行绑定
Disposed	在页从内存中被释放后引发。该事件标志着页面生命周期的最后阶段
Error	在未处理异常被抛出时引发
Init	在页面被初始化时引发。该事件标志着页面生命周期的第一个阶段
InitComplete	在页及其所有子控件全部初始化完毕后引发。ASP.NET 1.x不支持该事件
Load	在页面初始化完毕后，进行加载时引发
LoadComplete	在页面加载结束，且服务器事件也已引发完毕后引发。ASP.NET 1.x不支持该事件
PreInit	在页面的初始化阶段开始时引发。ASP.NET 1.x不支持该事件
PreLoad	在页面的加载阶段开始时引发。ASP.NET 1.x不支持该事件
PreRender	在页面即将被呈现时引发
PreRenderComplete	在页面的预呈现阶段开始时引发。ASP.NET 1.x不支持该事件
SaveStateComplete	在页面的视图状态已存储在持久性介质中后引发。ASP.NET 1.x不支持该事件
Unload	在页从内存中被卸载后但尚未释放前引发

本文链接