博客园-№.零零伍

http://www.heshunjc.cn/

№.零零伍 — Wed, 22 Aug 2007 05:33:00 GMT

阅读: 318 评论: 0 作者: №.零零伍发表于 2007-08-22 13:33 原文链接

http://www.heshunjc.cn/

最新新闻：
· Yahoo脑震荡关闭服务汇总(2010-02-10 12:06)
· 2003年微软遭遇iTunes：我们彻底晕头转向了(2010-02-10 12:06)
· 百度数据能被“作弊”软件篡改？百度:追究侵权(2010-02-10 11:52)
· Ksplice为Linux提供永远不用重启服务(2010-02-10 11:51)
· 视频网站2010年格局之变：七成企业将被淘汰(2010-02-10 11:48)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

Scott Mitchell 的ASP.NET 2.0数据教程之十六::概述插入、更新和删除数据

№.零零伍 — Mon, 28 Aug 2006 08:04:00 GMT

阅读: 15562 评论: 36 作者: №.零零伍发表于 2006-08-28 16:04 原文链接

在ASP.NET 2.0中操作数据::概述插入、更新和删除数据

导言

结束前面的几节，我们已经探讨过了如何使用GridView、DetailsView和FormView控件来显示数据。这些控件简单地操作提供给它的数据。一般地，这些控件通过使用一个数据源控件，例如ObjectDataSource来存取数据。我们已经看过了ObjectDataSource是如何在ASP.NET页面和潜在的数据之间扮演一个代理的角色。当一个GridView需要显示数据时，它调用ObjectDataSource的Select()方法，这个方法转而调用一个来自我们的业务逻辑层（BLL）的方法，继而调用一个适当的数据访问层（DAL）的表适配器（TableAdapter）的方法，从而它发送一个SELECT查询到Northwind数据库。

记得在我们的教程里当创建DAL中的表适配器时，Visual Studio自动地添加从潜在数据库插入、更新和删除数据的方法。此外，在创建一个业务逻辑层 这一节我们已经设计了调用这些数据更改的DAL方法的BLL方法。

除了它的Select()方法，ObjectDataSource还有Insert()、Update()和Delete()方法。跟Select()方法类似，这三个方法映射到一个隐含的对象。当配置插入、更新或删除数据时，GridView、DetailsView和FormView控件提供了一个修改潜在的数据的用户界面。这个用户界面调用ObjectDataSource的Insert()、Update()和Delete()方法，它们继而调用隐含对象的关联方法（见图1）。

图 1: ObjectDataSource的Insert()、Update()和Delete()方法提供一个到BLL的代理

本节我们将看看如何映射ObjectDataSource的Insert()、Update()和Delete()方法到BLL中的类，也看看如何配置GridView、DetailsView和FormView控件提供修改数据的功能。

第一步: 创建Insert、Update和Delete教程页面

在我们开始探讨如何插入、修改和删除数据之前，让我们先花些时间在我们的站点项目里添加这些本节里和下一节里需要的ASP.NET页面。首先添加一个名为EditInsertDelete的新文件夹。然后，在这个文件夹里添加下面这些ASP.NET页面，并且确认每个页面都关联Site.master母版页：

· Default.aspx

· Basics.aspx

· DataModificationEvents.aspx

· ErrorHandling.aspx

· UIValidation.aspx

· CustomizedUI.aspx

· OptimisticConcurrency.aspx

· ConfirmationOnDelete.aspx

· UserLevelAccess.aspx

图 2: 添加这些与数据更改关联的教程的页面

类似在其它文件夹里，EditInsertDelete文件夹里的Default.aspx将列出这些教程章节。记得用户控件提供这个功能。因此，从解决方案资源管理器中拖拽一个这个用户控件到页面的设计视图，从而添加它到Default.aspx页面。

图 3: 添加SectionLevelTutorialListing.ascx用户控件到tDefault.aspx页面

最后，添加这些页面地址项到Web.sitemap文件。明确地，在Customized Formatting 后添加如下标记：

在更新了Web.sitemap后，花些时间通过浏览器访问本教程站点。左边的菜单里现在包含对应编辑、插入和删除教程的项。

图 4: 站点地图现在包含了对应编辑、插入和删除教程的项

第二步: 添加并配置ObjectDataSource控件

因为GridView、DetailsView和FormView控件在数据修改功能和版面上都有所不同，就让我们逐个研究。不过，与其让这三个控件各自使用自己的ObjectDataSource，还不如让我们仅创建一个ObjectDataSource让这个三个控件的例子共用。

打开Basics.aspx页面，从工具箱拖拽一个ObjectDataSource到设计器，从它的职能标记中点击配置数据源链接。因为ProductsBLL类是唯一一个提供修改、插入和删除方法的BLL类，配置该ObjectDataSource使用这个类。

图 5: 配置ObjectDataSource使用ProductsBLL类

在下一屏中，通过选择适当的tab页并从下拉列表中选择方法，我们可以指定ProductsBLL类里的哪些方法被映射到ObjectDataSource的Select()、Insert()、Update()和Delete()方法。图6，至今我们应该很熟悉，映射ObjectDataSource的Select()方法到ProductsBLL类的GetProducts()方法。Insert()、Update()和Delete()方法可以通过选择上方的适当的tab页进行配置。

图 6: 让这个ObjectDataSource返回所有产品

图7、8和9显示ObjectDataSource的UPDATE、INSERT,和DELETE 的tab页。配置它们从而Insert()、Update()和Delete()方法分别调用ProductsBLL类的UpdateProduct、AddProduct和DeleteProduct方法。

图 7: 映射ObjectDataSource的Update()方法到ProductBLL类的UpdateProduct方法

图8: 映射ObjectDataSource的Insert()方法到ProductBLL类的AddProduct方法

图9: 映射ObjectDataSource的Delete()方法到ProductBLL类的DeleteProduct方法

你也许已经注意到在UPDATE、INSERT和DELETE的tab页里的下拉列表中已经选择了各自的方法。这是由于我们使用了DataObjectMethodAttribute ，它修饰了ProducstBLL类。例如，DeleteProduct方法是如下这样子声明的：

[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Delete, true)]

public bool DeleteProduct(int productID)

{

...

}

DataObjectMethodAttribute指示每一个方法的目的–是否为了查询、插入、更新或删除–

是否它的默认值。如果你在创建BLL类的时候省略了这些属性，现在你将需要手工从UPDATE、INSERT和DELETE的tab页里手工选择方法。

当确认已经适当的ProductsBLL方法映射到ObjectDataSource的Insert()、Update()和Delete()方法后，点击完成结束此向导。

检查ObjectDataSource的标记

在通过数据源配置向导完成了对ObjectDataSource的配置之后，到源视图去检查一下生成的声明标记。标签列明了隐含的对象和需要调用的方法。另外，还有DeleteParameters、UpdateParameters和InsertParameters ，它们映射ProductsBLL类的AddProduct、UpdateProduct和DeleteProduct方法的输入参数：

InsertMethod="AddProduct" OldValuesParameterFormatString="original_{0}" SelectMethod="GetProducts"

TypeName="ProductsBLL" UpdateMethod="UpdateProduct">

ObjectDataSource包含了对应它关联的方法的每一个输入参数的parameter，就像当ObjectDataSource被配置为调用预期一个输入参数的查询方法（例如GetProductsByCategoryID(categoryID)）时出现的SelectParameters一栏。正如我们马上即将看到的，这些DeleteParameters、UpdateParameters和InsertParameters的值在调用ObjectDataSource的Insert()、Update()或Delete()方法之前自动地通过GridView、DetailsView和FormView被设置。必要时这些值也可以通过编程设置，这在以后的章节里讨论。

使用数据源配置向导来配置ObjectDataSource的另一个影响是Visual Studio设置了OldValuesParameterFormatString属性为original_{0} 。这个属性值用来包含数据被编辑时的原始值，它在下面两种情况下非常有用：

· 如果，当编辑一条记录时，用户可以修改主键的值。在这种情况下，新的主键的值和原始的主键值都需要提供，这样具有这个原始主键值的数据库记录才可以被找到然后才能将它的值更新。

· 当使用开放式并发。开放式并发是为了保证同时操作的用户不至于覆盖另一个用户所做更改的一种技巧，这也是后面的教程中的一节（实现开放式并发 ）。

这个OldValuesParameterFormatString属性指明了隐含对象的更新和删除方法中对应原始值的输入参数的名称。我们将在探讨开发式并发的时候更详细地讨论这个属性和它的目的。不过暂时我放下它，因为我们的BLL的方法并不需要这些原始的值因此我们删除这个属性，这一点很重要。如果让OldValuesParameterFormatString属性设置为除了默认值（{0}）以外的其它任何的值，都将在数据Web控件尝试调用ObjectDataSource的Update()或Delete()方法时引发一个错误，因为ObjectDataSource将尝试将这些原始值参数与UpdateParameters或DeleteParameters一起传入。

如果对此不是十分清楚，别担心，我们将在未来的章节中研究这个属性和它的效用。暂时，一定要完全地从声明语法中完全地删除这个属性或者将它设置为默认值（{0}）。

注意: 如果你只是简单地从设计视图的属性窗口删除这个OldValuesParameterFormatString属性的值，这个属性依旧会存在于声明语法中，不过被设置为一个空字符串。不幸地，这将依旧导致上面提到的同样的问题。所以，从声明语法里彻底地删除这个属性，或者从属性窗口将其设置为默认值，{0}。

第三步: 添加一个数据Web服务器控件并配置它为数据更改服务

一般ObjectDataSOurce被添加到页面并配置完成，我们可以添加一个数据Web服务器控件用来显示数据并提供一个最终用户修改数据的途径。我们将分别看看GridView、DetailsView和FormView，因为这些数据Web服务器控件在它们的数据更改功能和配置上都有所不同。

正如我们将在本文剩下的部分里看到的，通过GridView、DetailsView和FormView控件添加一个非常基本的编辑、插入和删除支持是真的非常简单，只需要勾选上一对CheckBox。现实中提供这样的功能有许多微妙之处和边缘案例，这要比仅仅点几下要棘手得多。但是，本教程里，只着眼于提供简单的数据修改功能。以后的章节将研究在现实中不容置疑地出现的问题。

从GridView中删除数据

首先，从工具箱拖拽一个GridView到设计器。然后，通过GridView的智能标记中从下拉列表中选择从而绑定ObjectDataSource到该GridView。在这里GridView的声明标记将是：

ReadOnly="True" SortExpression="ProductID" />

SortExpression="CategoryName" />

SortExpression="SupplierName" />

通过它的职能标记绑定GridView到ObjectDataSource有下面两点的好处：

· 绑定列和CheckBox列被自动地添加，对应ObjectDataSource返回的每一个字段。而且，这些绑定列和CheckBox列的属性已经被设置，基于隐含字段的元数据。例如ProductID、CategoryName和SupplierName列在ProductsDataTable里被标记为只读，因此它们在编辑时也是不可更新的。为了实现这一点，这些绑定列的ReadOnly属性设置为true 。

· DataKeyNames属性被赋值为隐含对象的主键。这是在使用GridView来编辑或删除数据的要点，因为这个属性象指出了标识唯一记录的那个字段（或是一组字段）。如果要获得更多的关于DataKeyNames属性的信息，请回到使用GridView 和DetailView实现的主/从报表 一节。

虽然可以通过属性窗口或者声明语法将GridView绑定到ObjectDataSource，不过这需要你手工添加适当的绑定列和DataKeyNames标记。

GridView控件提供了对行编辑和删除的内建的支持。配置一个GridView支持删除需要添加一个删除按钮列。当最终用户点击某一特定行的删除按钮时，引发一次回传并且GridView执行以下步骤：

1. 对ObjectDataSource的DeleteParameters赋值

2. 调用ObjectDataSource的Delete()方法，删除指定的记录

3. 通过调用它的Select()方法GridView重新绑定到ObjectDataSource

赋值到DeleteParameters的值是点击删除按钮这一行的DataKeyNames字段的值。因此正确地设置GridView的DataKeyNames属性是至关重要的。如果缺少了这个，DeleteParameters将在第1步被赋上一个null值，从而在第2步中将不会导致删除任何记录。

为了给GridView增加删除功能，简单地到它的职能标记里勾选上“启用删除”。

图 10: 勾选“启用删除”

从智能标记中勾选启用删除会添加一个CommandField到GridView。这个CommandField在GridView中补充一个按钮列，它履行一个或多个下属任务：选中一行记录、编辑一行记录和删除一行记录。我们先前在使用GridView 和DetailView实现的主/从报表 一节的教程里也看到过了CommandField用作选中记录时如何运作。

这个CommandFIeld包含了一些ShowXButton属性，它指示哪一系列的按钮显示在CommandField中。通过勾选启用删除，一个ShowDeleteButton属性为true的CommandField被添加到GridView的列集合。

... BoundFields removed for brevity ...

到这里，你可能还不能相信，我们已经完成了给这个GridView增加删除支持！正如图11显示的，当我们通过浏览器访问此页面时，一列删除按钮已经出现。

图 11: 这个CommandField添加一列删除按钮

如果你是从一开始就是自己创建本教程的程序，当测试这个页面点击删除按钮时将引发一个异常。继续读下去学习关于为什么会引发这些异常，还有如何修复它们。

注意: 如果你是跟随着下载的教程的程序，这些问题已经被解决。然而，我鼓励你从头到尾读一遍下面列出的详细资料来帮助你识别可能出现的问题和适宜的工作区。

如果，当尝试删除一个产品，你得到一个类似于“ObjectDataSource 'ObjectDataSource1' could not find a non-generic method 'DeleteProduct' that has parameters: productID, original_ProductID,”的异常，你可能忘记了从ObjectDataSource里删除OldValuesParameterFormatString属性。指定了OldValuesParameterFormatString属性的话，该ObjectDataSource会试图向DeleteProduct方法一并传入productID和original_ProductID输入参数，然而，DeleteProduct方法只能接受一个输入参数，导致异常。删除OldValuesParameterFormatString属性（或设置它为{0}）指示ObjectDataSource不要试图传入这个原始值的输入参数。

图 12: 确保OldValuesParameterFormatString属性已被彻底清除

即使你已经删除了OldValuesParameterFormatString属性，当你尝试删除一个产品时依旧将得到一个异常：“The DELETE statement conflicted with the REFERENCE constraint 'FK_Order_Details_Products'.”。Northwind数据库包含了一个在Order Details和Products表间的字段约束，表示如果一个产品在Order Details表里对应它有一条或多条记录，那么该产品不能被删除。因为Northwind数据库里的每一个产品在Order Details表里都至少有一条记录，所以我们不能删除任何产品，除非我们从order details表里删除这个产品的关联记录。

图 13: 一个字段间约束阻止了对产品的删除

为了我们的教程，就让我们删除Order Details表里的所有记录吧。在一个真实的应用程序中我们需要的是下面任一措施：

· 通过另外一个页面管理order details信息

· 在DeleteProduct方法里增加包含删除指定产品的订单明细的逻辑

· 修改TableAdapter所使用的SQL语句，包含对指定产品的订单明细的删除

就让我们从Order Details表里删除所有记录从而绕过字段间约束的问题。到Visual Studio的服务器资源管理器，在NORTHWND.MDF节点上点击鼠标右键，选择“新建查询”。然后，再查询窗口执行下面的SQL语句：DELETE FROM [Order Details]

图 14: 从Order Details表里删除所有记录

在清空了Order Details表后，点击删除按钮将会正确无误地删除这个产品。如果点击了删除按钮但是没有删除该产品，检查并确保GridView的DataKeyNames属性设置为主键（ProductID）。

注意:当点击删除按钮时引发一次回传并删了了该记录。这是危险的，因为它很容易意外地错误点击了别的行的删除按钮。以后的章节里我们将看看如何在删除记录时添加一个客户端的确认询问。

在GridView中编辑数据

跟删除支持一起，GridView还提供了内建的对行编辑的支持。配置GrdiView支持编辑将添加一列编辑按钮。从最终用户的角度，点击一行的编辑按钮可使这一行变成可编辑的，它的单元格转换成文本框并包含现有的值，并把编辑按钮替换成保存和取消按钮。在完成了他们期望的更改之后，最终用户可以点击保存按钮提交这些修改，或者点击取消按钮放弃这些修改。在任意一种情况，点击保存或者取消按钮后GridView回到它编辑前的状态。

站在我们页面开发者的角度，当最终用户点击特定一行的编辑按钮时，引发一次回传并且GridView执行以下步骤：

1. GridView的EditItemIndex属性被赋值为当前点击编辑按钮的行的索引

2. 通过调用它的Select()方法，GridView重新绑定自己到ObjectDataSource

3. 与EditItemIndex相匹配的行呈现为编辑模式。在此模式下，编辑按钮替换为保存和取消按钮，并且那些ReadOnly属性为False的绑定列呈现为TextBox服务器控件，这些TextBox的Text属性被赋值为相应的数据字段的值。

到这里HTML标记被返回到浏览器，允许最终用户可以修改行数据。当用户点击保存按钮，再次发生一次回传，并且GridView执行以下几个步骤：

1. ObjectDataSource的UpdateParameters的值被赋值为最终用户在GridView的编辑界面输入的值

2. 调用ObjectDataSource的Update()方法，更新指定的记录

3. 通过调用它的Select()方法，GridView重新绑定自己到ObjectDataSource

在DataKeyNames属性指定的主键的值在第1步中赋值到UpdateParameters，反之非主键的值来自当前编辑行的TextBox服务器控件。如果这一点遗漏了，那么UpdateParameters主键的值在第1步中将被赋上一个值，然后转入第2步中将不会导致任何记录的更新。

编辑功能可以简单地通过勾选GridView的智能标记中的启用编辑从而被激活。

图 15: 勾选启用编辑

勾选启用编辑将添加一个CommandField（如果需要的话）并设置它的ShowEditButton属性为true 。如我们之前所看过的，CommandField包含一些ShowXButton属性，他们指出哪一系列的按钮要显示在CommandField里。在我们的例子里，勾选启用编辑添加ShowEditButton属性到现有的CommandField里：

... BoundFields removed for brevity ...

就这样就添加了根本的编辑支持。如图16所示，编辑界面还比较粗糙–每一个非只读的绑定列呈现为一个TextBox。这包括像CategoryID和SupplierID的字段，而它们是来自其它表的外键。

图 16: 点击产品“Chai”的编辑按钮让此行显示为“编辑模式”

为了要求用户直接编辑外键，这个编辑界面还缺少了以下途径：

· 如果用户输入一个在数据库中不存在的CategoryID或SupplierID，此更新将违反一个字段间的约束，引发一个异常。

· 这个编辑界面不包含任何数据验证。如果你不提供一个必填的值（例如ProductName），或者在要求输入数字的地方输入一个字符串，将抛出一个异常。未来的章节里将研究如何在编辑的用户界面中增加验证控件（给编辑和新增界面增加验证控件 ）。

· 通常，产品的所有非只读字段都必须包含在GridView里。如果我们从GridView里剔除一列，比如说UnitPrice，当更新数据时GridView将不会设置UnitPrice UpdateParameters的值，这将把该数据库记录的UnitPrice值更改为NULL值。类似地，如果一个必填的字段，例如ProductName，从GridView中被剔除了，那么这个更新将失败，并出现一个上文中提及过的“Column 'ProductName' does not allow nulls”异常。

· 这个编辑界面遗留了许多必要的格式化的问题。UnitPrice显示为四位小数。理想地CategoryID和SupplierID应该包含下拉列表（DropDownList），它列出系统中存在的类别和供应商。

我们不得不承认现在这还有许多缺点，但这些将在未来的章节里谈及。

在DetailsView中插入、编辑和删除数据

正如我们在之前的章节里看过的，DetailsView控件一次只显示一条记录，就像GridView一样，它也允许对当前显示的记录进行编辑和删除。不管是对最终用户来说从DetailsView进行编辑和删除的体验，还是在ASP.NET这一面的工作流程，都跟GridView是一样的。DetailsView和GridView不同的地方是，它还提供了内键的插入支持。

为了示范DetailsView的数据修改功能，首先，添加一个DetailsView控件到Basics.aspx页面，放在现有的GridView的上方，并通过DetailsView的职能标记把它绑定到现有的ObjectDataSource。然后，清除DetailsView的Height和Width属性，并从它的职能标记中勾选“启用分页”。为了启用编辑、插入和删除支持，只需要简单地从它的职能标记里勾选上“启用插入”、“启用编辑”和“启用删除”。

图 17: 配置DetailsView支持编辑、插入和删除

与GridView一样，添加编辑、插入或删除支持会添加一个CommandField到该DetailsView，如下声明语法所示：

DataSourceID="ObjectDataSource1" AllowPaging="True" EnableViewState="False">

ReadOnly="True" SortExpression="ProductID" />

SortExpression="CategoryName" />

SortExpression="SupplierName" />

注意DetailsView的CommandField默认显示在列集合的下方。因为DetailsView的字段是以行的方式呈现的，所以CommandField也表现为包含插入、编辑和删除按钮的一行，出现在DetailsView的下方。

图 18: 配置DetailsView支持编辑、插入和删除

点击删除按钮就会开始与GridView相同的一系列的事件：一次回传；随之DetailsView基于DataKeyNames的值组成它的ObjectDataSOurce的DeleteParameters；最后以调用ObjectDataSource的Delete()方法结束，此方法从数据库中删除该产品的记录。在DetailsView中编辑也以GridView同样的方式运作。

为了插入数据，最终用户面对的是一个“新建”按钮，当点击时，DetailsView呈现为“插入模式”。在“插入模式”下，新建按钮被“插入”和“取消”按钮取代，并且显示那些InsertVisible属性设置为true（默认）的绑定列。这些自增长标识的数据字段，例如ProductID字段，当通过职能标记绑定该DetailsView到数据源的时候让它们的InsertVisible属性设置为false 。

当通过智能标记绑定数据源到DetailsView时，Visual Studio为自增长的字段设置其InsertVisible属性为false。只读的字段，像CategoryName和SupplierName，将显示在“插入模式”下的用户界面中，除非它们的InsertVisible属性也明确地设置为false 。稍稍花些时间把这两个字段的InsertVisible属性设置为false ，通过DetailsView的声明语法或者通过智能标记中的“编辑字段”链接。

图 19: Northwind商人现在提供产品“Acme Tea”

在设置好InsertVisible属性后，通过浏览器看看这个Basics.aspx页面并点击新建按钮。图20显示的是添加一个新的饮料“Acme Tea”到我们的生产线时的DetailsView。

图 20: Northwind商人现在提供产品“Acme Tea”

输入Acme Tea的详细信息并点击插入按钮后，随之发生一次回传并将这个新记录添加到Products数据表。因为这个DetailsView是按照数据库中的顺序依次列出产品，所以我们必须翻到最后一页才能看到这个新增加的产品。

图21: 产品Acme Tea的详细信息

注意: DetailsView的CurrentMode 属性指示当前显示的界面并可以被设置为下面几个值之一：Edit、Insert或ReadOnly 。DefaultMode属性则指示DetailsView在完成一次编辑或插入之后显示的模式，这在需要让DetailsView保持编辑或插入模式不变时是很有用的。

DetailsView这个点击插入和编辑的功能跟GridView有相同的局限性：用户必须通过文本框输入存在的CategoryID和SupplierID值；界面缺少任何验证的逻辑；产品的所有不允许为NULL值或者没有在数据库中指定默认值的字段必须包含在插入界面里，等等。

在以后的章节里我们将会研究的扩展和提高GridView的编辑界面的技巧，同样可以应用到DetailsView的编辑和插入界面。

使用FormView做一个更灵活的数据修改用户界面

FormView控件提供内建的对插入、编辑和删除数据的支持，不过因为它使用模版而不是列，它没有地方让我们添加像GridView和DetailsView控件提供给数据修改界面的绑定列和CommandField。取而代之的是，这个界面 – 收集新增一项或编辑现有项时用来收集用户输入的Web服务器控件，连同新增、编辑、删除、插入、保存和取消按钮 – 都必须手工添加到适当的模版里。幸运的是，Visual Studio将在通过它的职能标记的下拉列表绑定FormView到数据源时自动地创建需要的界面。

为了阐明这些技巧，首先，添加一个FormView控件到Basics.aspx页面，并从FormView的职能标记，绑定它到已经存在的ObjectDataSource。这将为FormView生成一个EditItemTemplate、InsertItemTemplate和ItemTemplate ，用TextBox服务器控件收集用户的输入并用Button服务器控件作为添加新增、编辑、删除、插入、保存和取消按钮。另外，FormView的DataKeyNames属性被设置到ObjectDataSource所返回的对象的主键（ProductID）。最后，在FormView的职能标记中勾选“起用分页”选项。

下面展示出FormView绑定到ObjectDataSource后它的ItemTemplate声明标记。默认地，每一个除了布尔值以外的产品的字段都绑定到一个Label服务器控件的Text属性，相应地布尔类型的字段（Discontinued）绑定到一个不可更改的CheckBox服务器控件的Checked属性。为了让新增、编辑和删除按钮点击时能够引发某个FormView行为，必要的工作是将它们的CommandName属性的值分别设置为New、Edit和Delete。

...

ProductID:

ProductName:

SupplierID:

CategoryID:

QuantityPerUnit:

UnitPrice:

UnitsInStock:

UnitsOnOrder:

ReorderLevel:

Discontinued:

Enabled="false" />

CategoryName:

SupplierName:

Text="Edit">

Text="Delete">

Text="New">

图22显示出通过浏览器查看时FormView的ItemTemplate 。列出产品的每一个字段，并且在下方分别由新增、编辑和删除按钮。

图 22: FormView默认的ItemTemplate列出产品的每一个字段并连同新增、编辑和删除按钮

类似GridView和DetailsView，点击删除按钮 – 或者其它任何一个CommandName属性设置为“Delete”的Button、LinkButton或者ImageButton – 引发一次回传，在FormView的DataKeyNames值的基础上组建ObjectDataSource的DeleteParameters ，并调用ObjectDataSource的Delete()方法。

当点击编辑按钮时，引发一次回传并且数据重新绑定到EditItemTemplate ，它作为开始的编辑界面。这个界面包含为编辑数据用的Web服务器控件连同保存和取消按钮。默认的通过Visual Studio生成的EditItemTemplate包含对应自增长字段(ProductID)的Label、对应每一个非布尔型字段的TextBox和对应每一个布尔型字段的CheckBox 。这个动作与在GridView和DetailsView控件里自动生成的绑定列非常相似。

注意: FormView的自动生成的EditItemTemplate有一个小问题，就是对于诸如CategoryName和SupplierName这样的字段将TextBox服务器控件呈现为只读。我们马上看看如何解决这个问题。

在EditItemTemplate里的TextBox控件的Text属性已通过双向绑定 的方式绑定到相应的数据字段的值。双向绑定，以<%# Bind("dataField") %>表示，在绑定数据到模版和为组装ObjectDataSource插入或编辑记录的参数时都回执行绑定的动作。就是说，当用户从ItemTemplate里点击编辑按钮时，Bind()方法返回指定的数据字段的值。用户完成他们的修改并点击报存时，通过Bind()指定的数据字段的值回传到ObjectDataSource的UpdateParameters 。作为另一种选择，单向绑定，以<%# Eval("dataField") %>表示，仅仅在绑定数据到模版时取得数据字段的值，但并不会在回传时将用户输入的值返回到数据源控件的参数。

下面的声明标记显示了该FormView的EditItemTemplate 。注意这里在绑定语法里用的是Bind()方法，并且因此保存和取消按钮设置它们的CommandName属性。

ProductID:

ProductName:

SupplierID:

CategoryID:

QuantityPerUnit:

UnitPrice:

UnitsInStock:

UnitsOnOrder:

ReorderLevel:

Discontinued:

CategoryName:

SupplierName:

Text="Update">

Text="Cancel">

...

在这里我们的EditItemTemplate如果我们尝试使用它的话将引起抛出一个异常。问题是CategoryName和SupplierName字段在EditItemTemplate里以TextBox服务器控件呈现。我们或者需要把这些TextBox替换为Label或者干脆把它们删除。让我们就简单地从EditItemTemplate里把它们彻底删除吧。

图23显示的是在产品“Chai”上点击编辑按钮后浏览器中的FormView。注意显示在ItemTemplate里的SupplierName和CategoryName字段现在不在出现了，因为我们刚刚从EditItemTemplate里删除了它们。当点击保存按钮时，FormView执行的是与GridView和DetailsView控件相似的一系列的步骤。

图 23: EditItemTemplate默认显示每一个可编辑的产品字段为TextBox或CheckBox

当点击FormView的ItemTemplate中的新建按钮时发生一次回传。不过，没有数据绑定到FormView，因为新建了一条记录。该InsertItemTemplate界面包含添加新记录用的Web服务器控件连同插入和取消按钮。通过Visual Studio生成的默认的InsertItemTemplate包含对应每一个非布尔型字段的TextBox和对应布尔型字段的CheckBox，类似于自动生成的EditItemTemplate的界面。这些TextBox控件的Text属性通过双向绑定的方式绑定到相应的数据字段。

下面的声明标记显示了该FormView的InsertItemTemplate 。注意这里的绑定语法使用的是Bind()方法并且因此设置了插入和取消按钮的CommandName属性。

...

ProductName:

SupplierID:

CategoryID:

QuantityPerUnit:

UnitPrice:

UnitsInStock:

UnitsOnOrder:

ReorderLevel:

Discontinued:

CategoryName:

SupplierName:

Text="Insert">

Text="Cancel">

...

FormView的自动生成的InsertItemTemplate有一点细微的区别。特别的是，对于只读的字段，例如CategoryName和SupplierName，也为它们添加了相应的TextBox服务器控件。类似EditItemTemplate，我们也需要从InsertItemTemplate里删除这些TextBox。

图24显示新增一个产品（Acme Coffee）时浏览器中的FormView。注意显示在ItemTemplate中的SupplierName和CategoryName字段现在不再显示了，因为我们刚刚删除了它们。当点击插入按钮时，FormView执行的是与GridView和DetailsView控件相似的一系列的步骤，插入一条新记录到Products表。图25显示了新产品插入成功后在FormView中的详细信息。

图 24: InsertItemTemplate规定FormView的插入界面

图 25: 新增产品Acme Coffee的详细信息显示在FormView中

通过分开read-only、editing和inserting界面到这3个不同的模版，FormView可以比DetailsView和GridView更高程度地控制这些界面。

注意: 就像DetailsView，FormView的CurrentMode属性指示当前显示的界面，而它的DefaultMode属性指示编辑或新建完成后FormView返回的显示方式。

总结

在这一节里，我们研究了基本的使用GridView、DetailsView和FormView插入、编辑和删除数据。这三种控件都提供一些内建的数据修改功能，这可以被利用而不需要在ASP.NET页面里写一行代码，这得益于数据Web控件和ObjectDataSource控件。不过，这个简单的指和点的技巧只能提供出一个简陋的数据修改用户界面。为了提供数据验证、注入编程设置的值、适当地处理异常、自定义用户界面等等，我们就需要依赖于一些在下面几个章节了将讨论的技巧。

祝编程快乐！

作者简介

Scott Mitchell，著有六本ASP/ASP.NET方面的书，是4GuysFromRolla.com的创始人，自1998年以来一直应用微软Web技术。Scott是个独立的技术咨询顾问，培训师，作家，最近完成了将由Sams出版社出版的新作，24小时内精通ASP.NET 2.0。他的联系电邮为mitchell@4guysfromrolla.com，也可以通过他的博客http://ScottOnWriting.NET与他联系。

评论: 36　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

Scott Mitchell 的ASP.NET 2.0数据教程之十七:: 研究插入、更新和删除的关联事件

№.零零伍 — Fri, 18 Aug 2006 08:58:00 GMT

阅读: 8553 评论: 25 作者: №.零零伍发表于 2006-08-18 16:58 原文链接

在ASP.NET 2.0中操作数据::研究插入、更新和删除的关联事件

导言

当使用GridView、DetailsView或FormView控件的内建插入、编辑或删除特征时，在用户添加一条新记录或更新/删除一条现在记录的过程中发生了多个步骤。正如我们之前一节里所讨论的，在GridView中编辑一行时，保存（Update）和取消（Cancel）按钮将取代编辑（Edit）按钮，并且绑定列转换成TextBox。在用户更新了数据并点击保存按钮之后，下述步骤在回传时执行：

1. 该GridView控件根据当前编辑行的唯一标识字段（通过DataKeyNames属性）组装它的ObjectDataSource的UpdateParameters参数，连同用户输入的值

2. 该GridView控件调用它的ObjectDataSource的Update()方法，它转而调用潜在对象的适当的方法（ProductsDAL.UpdateProduct，我们之前一节里）

3. 现在，这些隐含的数据，包含保存后的更改，被重新绑定到GridView控件

在这一连串的步骤里，触发了许多事件，这让我们可以创建事件处理程序从而在需要的地方增加自定义逻辑。例如，在第1步之前，触发GridView的事件。在这里，如果有什么validation错误我们可以取消更新请求。当调用Update()方法时，触发ObjectDataSource的Updating事件，提供了增加或自定义UpdateParameters的值的机会。在ObjectDataSource的潜在对象的方法完全执行后，触发ObjectDataSource的Updated事件。针对Updated事件的事件处理程序可以检查更新操作的相关详细信息，例如影响了多少行数据，或者是否引发了一个异常。最后，在第2步之后，GridView的RowUpdated事件触发；针对此事件的事件处理程序可以检查关于刚刚完成的更新操作的相关额外信息。

图1描述了使用GridView更新时这一系列连续的事件和步骤。图1里的这个事件模式不仅是在GridView的更新操作。从GridView、DetailsView或者FormView里插入、更新或者删除数据时，数据Web服务器控件和ObjectDataSource都会发生这一连串的pre-level和post-level的事件。

图1: 当在GridView里更新数据时，触发一连串的Pre-和Post-事件

在这一节里，我们将探讨使用这些事件从而扩展ASP.NET数据Web服务器控件的内建插入、更新和删除功能。我们也会看看如何自定义编辑界面从而仅仅更新部分产品字段。

第一步: 更新产品的ProductName和UnitPrice字段

在之前一节的编辑界面里，包含了产品的所有字段并且它们都不是只读的。如果我们从GridView中剔除一列（QuantityPerUnit），那么当更新时数据Web服务器控件就不会设置ObjectDataSource的QuantityPerUnit UpdateParameters的值。ObjectDataSource则传入一个null值到UpdateProduct这个业务逻辑层的方法，它将当前编辑的数据库记录的QuantityPerUnit字段更改为值。同样地，如果是一个必需的字段，例如ProductName，如果从编辑界面中剔除了，那么此更新将会失败并抛出一个“Column 'ProductName' does not allow nulls”异常。导致这一现象的原因是ObjectDataSource被配置为调用ProductsBLL类的UpdateProduct方法，它预期每一个产品字段都对应一个输入参数。因此，ObjectDataSource的UpdateParameters集合包含了该方法的每一个输入参数。

如果我们希望提供一个允许最终用户仅仅可以更新部分字段的数据Web服务器控件，那么我们需要在ObjectDataSource的Updating事件处理程序中编程设置缺失的UpdateParameters值，或者创建并调用一个预期部分字段的BLL方法。让我们在接下来的步骤中探讨。

特别地，让我们创建一个在一个可编辑的GridView中仅显示ProductName和UnitPrice字段的页面。这个GridView的编辑界面将仅仅允许用户更新两个显示的字段，ProductName和UnitPrice 。因为这个编辑界面仅仅提供产品的部分字段，我们需要创建一个ObjectDataSource，它使用现有的BLL的UpdateProduct方法并在Updating事件处理程序中编程设置产品的缺少的字段的值，或者我们需要创建一个新的BLL方法，它仅接受那些在GridView中已经定义的部分字段。在这一节里，我们使用后者，创建一个UpdateProduct方法的重载，它提取3个输入参数：productName、unitPrice和productID：

[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Update, false)]

public bool UpdateProduct(string productName, decimal? unitPrice, int productID)

{

Northwind.ProductsDataTable products = Adapter.GetProductByProductID(productID);

if (products.Count == 0)

// no matching record found, return false

return false;

Northwind.ProductsRow product = products[0];

product.ProductName = productName;

if (unitPrice == null) product.SetUnitPriceNull(); else product.UnitPrice = unitPrice.Value;

// Update the product record

int rowsAffected = Adapter.Update(product);

// Return true if precisely one row was updated, otherwise false

return rowsAffected == 1;

}

跟原有的UpdateProduct方法类似，这个重载方法首先检查是否在数据库中存在一个指定ProductID的产品。如果不存在，它返回false，指示更新产品信息的请求失败。否则，它因而更新现存的产品记录的ProductName和UnitPrice字段并通过调用TableAdapter的Update()方法提交此更新，传入ProductsRow实例。

通过这些对我们的ProductsBLL类的额外处理，我们现在可以创建一个简单GridView界面。打开EditInsertDelete文件夹中的DataModificationEvents.aspx ，添加一个GridView控件到页面。新建一个ObjectDataSource并配置它使用ProductsBLL类，它的Select()方法映射到GetProducts ，Update()方法映射到仅接受productName、unitPrice和productID输入参数的UpdateProduct方法重载。图2展示了映射ObjectDataSource的Update()方法到ProductsBLL类的新的UpdateProduct方法重载时的数据源配置向导。

图 2: 映射ObjectDataSource的Update()方法到新的UpdateProduct重载

因为我们的例子将仅仅需要编辑数据的能力，不需要插入或删除记录，那么花些时间明确地指明该ObjectDataSource的Insert()和Delete()方法不会映射到ProductsBLL类的任何方法--通过到INSERT和DELETE的tab页并从下拉列表中选择（无）。

图 3: 在INSERT和DELETE的Tab页，从下拉列表中选择（无）

完成了此向导后，从GridView的职能标记里勾选上启用编辑。

完成了此数据源配置向导并绑定到GridView后，Visual Staudio就已经添加好它们的声明语法。到源视图察看该ObjectDataSource的声明标记，它将如下所示：

TypeName="ProductsBLL" UpdateMethod="UpdateProduct">

因为ObjectDataSource的Insert()和Delete()方法没有映射，也就没有InsertParameters或者DeleteParameters片段。此外，因为方法映射到UpdateProduct方法重载，它仅接受3个输入参数，UpdateParameters片段也就仅包含3个Parameter实例。

注意到ObjectDataSource的属性被设置为original_{0}。这个属性是使用数据源配置向导时Visual Studio自动设置的。因此，由于我们的BLL方法不需要传入原始的ProductID值，从ObjectDataSource的声明语法中删除所有这些属性设置。

注意: If you如果你只是简单地在设计视图里从属性窗口清除OldValuesParameterFormatString属性的值，这个属性会依旧存在于声明语法里，但会被设置为一个空字符串。要么从声明语法里把该属性通通删掉，要么从属性窗口，设置它的值为默认值：{0} 。

虽然ObjectDataSource仅仅包含对productName、unitPrice和productID的UpdateParameters，Visual Studio还是为产品的每一个字段添加一个绑定列或CheckBoxField。

图 4: 对应产品的每一个字段，GridView都包含一个BoundField或CheckBoxField

当最终用户编辑一个产品并点击它的保存按钮（Update），该GridView遍历那些可编辑的字段，然后把用户输入的值赋值到ObjectDataSource的UpdateParameters集合里对应的参数。如果没有对应的参数，GridView则添加一个到参数集合里。因此，如果我们的GridView包含对应产品的所有字段的绑定列或CheckBox列，那么ObjectDataSource则会调用能接受这些参数的方法重载，而不顾ObjectDataSource的声明标记指定只接受3个输入参数的事实（见图5）。类似地，如果存在某些由GridView非只读列构成的组合，而没有一个UpdateProduct重载能接受相应的参数，则会在试图保存时引发一个异常。

图 5: GridView将添加参数到ObjectDataSource的UpdateParameters集合

为了确保ObjectDataSource调用仅接受productName、unitPrice和productID参数的UpdateProduct重载，我们需要限定GridView仅包含ProductName和UnitPrice这两个可编辑的列。这可以通过删除其他绑定列和CheckBox列，或者把这些列的ReadOnly属性设置为true实现，又或者上述两种方法结合使用。在本节里让我们简单地删除除了ProductName和UnitPrice绑定列以外的GridView的所有列，然后，GridView的声明标记将如下所示：

DataSourceID="ObjectDataSource1" EnableViewState="False">

即使重载预期3个输入参数，在我们的GridView里仅包含两个绑定列。这是因为productID输入参数是一个主键（primary key）的值，它通过当前编辑行的DataKeyNames属性传入值。

我们的GridView控件，连同这个UpdateProduct重载，允许一个用户仅仅编辑产品的名称和单价而不会丢失产品的其他字段。

图 6: 仅允许编辑 ProductName和UnitPrice的界面

完善UnitPrice格式化

虽然图6所示的GridView实例能够正常工作，UnitPrice字段还完全未被格式化，导致显示价格时缺少货币符号，还有4个小数位。为了在非编辑状态的行应用货币格式，只需要简单地设置UnitPrice绑定列的DataFormatString属性为{0:c}，还有它的HtmlEncode属性为false 。

图 7: 设置UnitPrice绑定列的DataFormatString和HtmlEncode属性

通过此项更改，处于非编辑状态的行将价格格式化为货币；然而，当前编辑的行，仍然显示为没有货币符号并保留四位小数。

图 8: 现在，非编辑状态的行格式化为货币值

通过设置此绑定列的ApplyFormatInEditMode属性为true（默认为false），可以把DataFormatString属性里指定的格式化指令应用到编辑界面。

图 9: 设置此绑定列的ApplyFormatInEditMode属性为true

通过这个更改，当前编辑行里显示的UnitPrice值也被格式化为货币。

图 10: 现在，当前编辑行的值也被格式化为货币

然而，如果把产品价格更新为文本框里带货币符号的值– 例如$19.00 – 则会抛出一个FormatException异常。当GridView尝试把用户提供的值赋值到ObjectDataSource的UpdateParameters集合，它无法把UnitPrice字符串“$19.00”转换成参数要求的decimal类型（见图11）。为了补救这个问题我们可以为GridView的RowUpdating事件添加一个事件处理程序并让它把用户输入的UnitPrice格式化为货币格式的decimal 。

这个GridView的RowUpdating事件接受的第二个参数是一个GridViewUpdateEventArgs类型的对象，它包含一个NewValues字典，当中的每一个属性保存着用户输入的值，准备赋值到ObjectDataSource的UpdateParameters集合。我们可以重写现有的NewValues集合中的UnitPrice值为一个货币金额，通过下面的事件处理程序中的代码进行解析：

protected void GridView1_RowUpdating(object sender, GridViewUpdateEventArgs e)

{

if (e.NewValues["UnitPrice"] != null)

e.NewValues["UnitPrice"] = decimal.Parse(e.NewValues["UnitPrice"].ToString(), System.Globalization.NumberStyles.Currency);

}

如果用户提供了一个诸如“$19.00”的UnitPrice值，这个值会被通过Decimal.Parse计算并解析为货币金额的值重写。这将正确的解析货币值，无论是货币符号、逗号、小数点、等等，并使用System.Globalization命名空间的NumberStyles枚举。

图11展示因用户输入的UnitPrice值带有货币符号引起的问题，还展示了如果利用GridView的RowUpdating事件处理程序从而正确地解析这样的输入。

图 11: 现在，当前编辑行的UnitPrice值被格式化为货币金额

第二步: 阻止NULL UnitPrices

虽然数据库被配置为允许Products表里的UnitPrice字段为NULL值，但我们可能希望防止用户访问这个特别的页面并指定一个空的UnitPrice值。更确切地说，如果用户在编辑一个产品行记录时忘记输入一个UnitPrice值，与其保存这个结果到数据库，我们还不如给用户显示一个提示信息，自始至终这个页面，任何的对产品的编辑必须指定一个价格。

传入到GridView的事件处理程序的GridViewUpdateEventArgs对象包含一个Cancel属性，如果把它设置为true，则中止这个更新过程。让我们扩展RowUpdating事件处理程序，设置e.Cancel为true并显示一个信息说明为什么在NewValues集合里的UnitPrice值为null 。

首先，添加一个Label服务器控件到页面并命名为MustProvideUnitPriceMessage 。这个Label控件将显示用户是否在更新一个产品时忘记指定一个UnitPrice值。设置这个Label的Text属性为“您必须为产品提供一个价格。”。我也已经在Styles.css文件中添加了一个名为Warning的新CSS类别，定义如下：

.Warning

{

color: Red;

font-style: italic;

font-weight: bold;

font-size: x-large;

}

最后，设置Label的CssClass属性为Warning 。这样设计器中将在GridView上方显示这个红色、斜体、加粗、并且较大字体的警告信息。

图 12: 一个Label控件已被添加到GridView上方

默认地，这个Label控件隐藏，那么在Page_Load事件处理程序中设置它的Visible属性为false 。

protected void Page_Load(object sender, EventArgs e)

{

MustProvideUnitPriceMessage.Visible = false;

}

如果用户尝试更新一个产品并不指定UnitPrice值，我们希望取消这个更新并显示警告标签。在GridView的RowUpdating事件处理程序中增加如下的代码：

protected void GridView1_RowUpdating(object sender, GridViewUpdateEventArgs e)

{

if (e.NewValues["UnitPrice"] != null)

e.NewValues["UnitPrice"] = decimal.Parse(e.NewValues["UnitPrice"].ToString(), System.Globalization.NumberStyles.Currency);

else

{

// Show the Label

MustProvideUnitPriceMessage.Visible = true;

// Cancel the update

e.Cancel = true;

}

如果一个用户试图保存一个产品并不指定价格，这个更新操作就被取消并显示一个有用的提示信息。虽然数据库（和业务逻辑）允许NULL值的UnitPrice，但这个特定的ASP.NET页面不允许。

图 13: 用户不能让UnitPrice为空

到目前为止我们看过了如何使用GridView的RowUpdating事件来编程改变赋值到ObjectDataSource的UpdateParameters集合的参数值，还有如何完全地取消这个更新过程。这些思想也可以延展至DetailsView和FormView控件并且应用到插入或删除。

这些任务也可以在ObjectDataSource这一层通过的Inserting、Updating和Deleting事件处理程序完成。这些事件在隐含对象的关联方法被调用前触发，并且提供一个更改输入参数集合或者完全取消此操作的最后机会。对应这3个事件的事件处理程序传入一个ObjectDataSourceMethodEventArgs 类型的对象，我们对它的这两个属性感兴趣：

· Cancel，它如果被设置为true，取消执行中的操作

· InputParameters，它是InsertParameters、UpdateParameters或DeleteParameters的集合，这取决于这是Inserting、Updating、还是Deleting事件的事件处理程序

为了举例说明在ObjectDataSource这一层如何处理参数的值，让我们在页面里包含一个DeailsView，它允许用户新增一个新的产品记录。这个DetailsView将用作提供一个快捷的方式添加一个新的产品记录到数据库。为了在新增产品时保持界面一致，我们仅允许用户输入ProductName和UnitPrice字段。作为默认值，这些在DetailsView的插入界面提供的值将被设置为一个数据库的NULL值。不过，我们可以使用ObjectDataSource的Inserting事件注入不同的默认值，正如我们马上要看的。

第三步: 提供一个添加新产品的界面

在GridView的上方，从工具箱里拖放一个DetailsView控件到设计器，清空它的Height和Width属性，并将它绑定到页面中已经存在的ObjectDataSource 。这将为产品的每一个字段添加一个绑定列或CheckBox列。因为我们希望用这个DetailsView控件来添加新产品，我们需要从它的职能标记里勾选启用插入这一项；然而并没有这一项，这是因为此ObjectDataSource的Insert()方法还没有映射到ProductsBLL类的方法（回想起我们在配置数据源时设置了这个映射为（无） – 见图3）。

为了再次配置这个ObjectDataSource，从它的职能标记中选择“配置数据源”的链接，载入向导。第一屏允许你更改ObjectDataSource绑定到的隐含对象；让它依旧是ProductsBLL 。下一屏列出从ObjectDataSource到隐含对象的方法的映射。尽管我们已经明确地指定Insert()和Delete()不映射到任何方法，然而如果你到INSERT和DELETE的tab页你还是会看到那里有一个映射。这是因为ProductsBLL的AddProduct和DeleteProduct方法使用了DataObjectMethodAttribute指出它们分别是为Insert()和Delete()服务的默认的方法。因此，ObjectDataSource向导在每次运行时都会自动地选择它们，除非那里被明确地指定了一个别的值。

让Insert()方法依旧指向AddProduct方法，不过再次从DELETE的tab页的下拉列表中选择“(无)”。

图 14: 从INSERT的Tab页的下拉列表中选择AddProduct方法

图 15: 从DELETE的Tab页的下拉列表中选择(无)

完成了这些更改后，该ObjectDataSource的声明语法中将包含一个InsertParameters集合，如下所示：

TypeName="ProductsBLL" UpdateMethod="UpdateProduct" OnUpdating="ObjectDataSource1_Updating" InsertMethod="AddProduct" OldValuesParameterFormatString="original_{0}">

再次运行向导导致重新添加OldValuesParameterFormatString属性。把这个属性设置为默认值（{0}）或者从声明语法中把它们完全删除。

随着ObjectDataSource提供插入数据的能力，现在DetailsView的职能标记里包含“启用插入”的checkbox；回到设计器并勾选这一项。然后，减少DetailsView的列直道它只包含两个绑定列- ProductName和UnitPrice ，还有一个CommandField。此时DetailsView的声明语法将如下所示：

DataSourceID="ObjectDataSource1" EnableViewState="False">

图16展现的是在此时通过浏览器查看的页面。正如你所看到的，DetailsView列出第一个产品（Chai）的名称和价格。不过，我们需要的是一个插入界面来提供一个用户快速增加一个新产品到数据库的手段。

图16: 该DetailsView当前呈现在只读模式

为了展示插入模式的DetailsView我们需要设置DefaultMode属性为Inserting。这让DetailsView在第一次访问和插入一条新纪录之后，它都呈现在插入模式。如图17所示，这样的一个DetailsView提供了一个快捷的界面用以添加新记录。

图 17: 这个DetailsView提供了一个快速添加新产品的界面

当用户输入一个产品名称和价格（例如“Acme Wate”和1.99，如图17）并点击插入按钮，发生回传并且开始插入的工作流程，直到最后添加一个新产品记录到数据库。DetailsView维持在它的插入界面，并且GridView自动地重现绑定到它的数据源，目的是为了包含新增加的产品，如图18所示。

图 18: 产品“Acme Water”已经被添加到数据库

虽然图18的GridView中没有显示出来，DetailsView界面里缺少的产品字段 – CategoryID、SupplierID、QuantityPerUnit、等等 – 被赋上一个数据库NULL值。你可以通过履行下面一个步骤来看到这一点：

1. 到Visual Studio的服务器资源管理器

2. 展开NORTHWND.MDF数据库节点

3. 在Products数据表节电上右键点击

4. 选择“显示表数据”

这将列出Products表中的所有记录。如图19所示，除了ProductID、ProductName和UnitPrice字段，我们的新产品的其它字段都为NULL值。

图 19: 未在DetailsView中提供的产品的其它字段被赋予NULL值

我们可能希望给予一个或几个这些字段的值一个默认值，而不是NULL，要么是因为NULL并非最佳的默认项，要么是因为数据库字段本身不允许NULL值。为了实现这一点，我们可以编程设置这些DetailsView的InputParameters集合里的参数值。这项工作可以在DetailsView的ItemInserting事件处理程序中完成，或者在ObjectDataSource的Inserting事件处理程序。因为我们已经看过了如何在数据Web服务器控件中如何使用pre-和post-level的事件，这次让我们探究一下ObjectDataSource的事件。

第四步: 给CategoryID和SupplierID参数赋值

在这里我们假设当我们的应用程序通过这个界面添加一个新产品时应该给CategoryID和SupplierID字段赋值为1。如之前提及的，ObjectDataSource控件有一对pre-和post-level的事件发生在数据更改过程中。当它的Insert()方法被调用时，ObjectDataSource首先触发它的Inserting事件，然后调用它的Insert()方法所映射到的业务方法，最后触发Inserted事件。这个Inserting事件处理程序提供给我们一个处理输入参数或者彻底取消此操作的最后机会。

注意: 在一个真实的应用程序中你很可能希望既让用户指定category和supplier的值，又希望基于一定的标准和业务逻辑的基础上选择这个值（而不是盲目地选择ID为1）。不管如何，这个例子阐明了如何在ObjectDataSource的pre-level的事件中编程设置一个输入参数的值。

花些时间为ObjectDataSource的Inserting事件创建一个事件处理程序。注意到该事件处理程序的第二个输入参数是一个ObjectDataSourceMethodEventArgs类型的对象，它有一个属性来存取参数集合（InputParameters），还有一个属性用来取消此操作（Cancel）。

protected void ObjectDataSource1_Inserting(object sender, ObjectDataSourceMethodEventArgs e)

{

}

此时，InputParameters属性包含了通过DetailsView赋值到ObjectDataSource的InsertParameters集合。为了修改这些参数里的一个值，简单地使用：e.InputParameters["paramName"] = value 。所以，为了设置CategoryID和SupplierID为1，把Inserting事件处理程序调整为如下：

protected void ObjectDataSource1_Inserting(object sender, ObjectDataSourceMethodEventArgs e)

{

e.InputParameters["CategoryID"] = 1;

e.InputParameters["SupplierID"] = 1;

}

这次当我们添加一个新产品（例如Acme Soda），这个新产品的CategoryID和SupplierID字段被赋值为1（见图20）。

图 20: 现在，新产品的CategoryID和SupplierID字段被设置为1

总结

在编辑、插入和删除的过程中，无论数据Web服务器控件还是ObjectDataSource都会发生许多pre-和post-level的事件。在这一节里，我们研究了pre-level的事件，并看到了如何在数据Web服务器控件和ObjectDataSource的事件里使用它们来自定义输入参数或取消当前的数据更改操作。下一节，我们将看看创建和使用post-level的事件的事件处理程序。

祝编程快乐！

作者简介

评论: 25　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

Scott Mitchell 的ASP.NET 2.0数据教程之二十一:: 实现开放式并发

№.零零伍 — Mon, 14 Aug 2006 03:35:00 GMT

阅读: 12520 评论: 12 作者: №.零零伍发表于 2006-08-14 11:35 原文链接

在ASP.NET 2.0中操作数据:实现开放式并发

下载本教程中的编码例子 | 下载本教程的PDF版

导言

对于那些仅仅允许用户查看数据，或者仅有一个用户可以修改数据的web应用软件，不存在多用户并发冲突的问题。然而对于那些允许多个用户修改或删除数据的web应用软件，则有可能发生一个用户所做的更改与另一个并发用户的更改冲突。在没有任何并发策略的地方，当两个用户同时编辑某一条记录，最后提交的用户的更改将覆盖先提交的用户所作的更改。

例如，假设两个用户，Jisun和Sam，都访问我们的应用软件中的一个页面，这个页面允许访问者通过一个GridView控件更新和删除产品数据。他们都同时点击GridView控件中的Edit按钮。Jisun把产品名称更改为“Chai Tea”并点击Update按钮，实质结果是向数据库发送一个UPDATE语句，它将更新此产品的所有可修改的字段（尽管Jisun实际上只修改了一个字段：ProductName）。在这一刻，数据库中包含有这条产品记录“Chai Tea”—种类为Beverages、供应商为Exotic Liquids、等该产品的详细信息。然而，在Sam的屏幕中的GridView里，当前编辑行里显示的产片名称依旧是“Chai”。在Jisun的更改被提交后片刻，Sam把种类更改为“Condiments”并点击Update按钮。这个发送到数据库的UPDATE语句的结果是将产品名称更改为“Chai”、CategoryID字段的值是种类Beverages对应的ID，等等。Jisun所作的对产品名称的更改就被覆盖了。图1展示了这些连续的事件。

图 1: 当两个用户同时更新一条记录，则存在一个用户的更改覆盖另一个的更改的可能性

类似地，当两个用户同时访问一个页面，一个用户可能更新的事另一个用户已经删除的记录。或者，在一个用户加载页面跟他点击删除按钮之间的时间里，另一个用户修改了这条记录的内容。

有下面三中并发控制策略可供选择：

Ø 什么都不做 –如果并发用户修改的是同一条记录，让最后提交的结果生效（默认的行为）

Ø 开放式并发（Optimistic Concurrency） - 假定并发冲突只是偶尔发生，绝大多数的时候并不会出现；那么，当发生一个冲突时，仅仅简单的告知用户，他所作的更改不能保存，因为别的用户已经修改了同一条记录

Ø 保守式并发（Pessimistic Concurrency） – 假定并发冲突经常发生，并且用户不能容忍被告知自己的修改不能保存是由于别人的并发行为；那么，当一个用户开始编辑一条记录，锁定该记录，从而防止其他用户编辑或删除该记录，直到他完成并提交自己的更改

注意：在本节里，我们不讨论保守式并附的例子。保守式并发控制很少使用，因为锁定如果没有完全释放，会妨碍其他用户进行数据更新。例如，如果一个用户为了编辑而锁定某一条记录，但在解锁之前就离开了，那么其他任何用户都不能更新这条记录，直到最初的用户返回并完成他的更新。因此，使用保守式并发控制的地方，相应地会作一个时间限制，如果到达这个时间限制，则取消锁定。例如订票网站，当用户完成他的订票过程时会锁定某个特定的座位，这就是一个使用保守式并发控制的例子。

第一步:如何实现开放式并发控制

开放式并发控制能够确保一条记录在更新或者删除时跟它开始这次更新或修改过程时保持一致。例如，当在一个可编辑的GridView里点击编辑按钮时，该记录的原始值从数据库中读取出来并显示在TextBox和其他Web控件中。这些原始的值保存在GridView里。随后，当用户完成他的修改并点击更新按钮，这些原始值加上修改后的新值发送到业务逻辑层，然后到数据访问层。数据访问层必定发出一个SQL语句，它将仅仅更新那些开始编辑时的原始值根数据库中的值一致的记录。图二描述了这些事件发生的顺序。

图2: 为了更新或删除能够成功，原始值必须与数据库中相应的值一致

有多种方法可以实现开放式并发控制（查看Peter A. Bromberg的文章 Optmistic Concurrency Updating Logic，从摘要中看到许多选择）。ADO.NET类型化数据集提供了一种应用，这只需要在配置时勾选上一个CheckBox。使用开发式并发的目的是使类型化数据集的TableAdapter的UPDATE和DELETE语句可以检测自该记录加载到DataSet中以来数据库中的值是否被更改。例如下面的UPDATE语句，当当前数据库中的值与GridView中开始编辑的原始值一致才更新某个产品的名称和价格。@ProductName 和 @UnitPrice参数包含的是用户输入的新值，而参数@original_ProductName 和 @original_UnitPrice则包含最初点击编辑按钮时加载到GridView中的值：

1UPDATE Products SET
2    ProductName = @ProductName,
3    UnitPrice = @UnitPrice
4WHERE
5    ProductID = @original_ProductID AND
6    ProductName = @original_ProductName AND
7    UnitPrice = @original_UnitPrice
8

注意：这个UPDATE语句是为了易读而简单化了。实际上，在WHERE子句中检测UnitPrice会比较棘手，这是因为UnitPrice可以包含空值，而NULL = NULL则总是返回False（相应地你必须用IS NULL）。

除了使用一个不同的UPDATE语句之外，配置TableAdapter使用开放式并发控制还需要修改它直接发送到数据库的方法。回到我们的第一节，创建一个数据访问层，这些发送到数据库的方法接收一列标量的值作为输入参数（不仅仅是强类型DataRow或DataTable的实例）。当使用开放式并发，直接发送到数据库的Update() 和 Delete()方法就包含了对应原始值的输入参数。而且，业务逻辑层中批量方式更新的代码（Update()的重载，它不仅接受标量值，也接受DataRows 和 DataTables）也要做出相应的更改。

与其扩展我们现有得数据访问层表适配器使用开放式并发（同时也必须修改业务逻辑层以协调），不如让我们创建一个新的类型化数据集NorthwindOptimisticConcurrency，在它里面我们添加一个使用开放式并发的Products表适配器。然后，我们将在业务逻辑层中创建类ProductsOptimisticConcurrencyBLL，它为了支持开放式并发的DAL会有适当的更改。一旦这些基础工作都已完成，我们就可以创建ASP.NET页面。

第二步: 创建一个支持开放式并发的数据访问层

为了创建一个新的类型化数据集，在App_Code文件夹里的DAL文件夹上右键点击，选择添加一个新的数据集并命名为NorthwindOptimisticConcurrency。正如我们在第一节中看到过的那样，系统会自动添加一个表适配器（TableAdapter）到当前的类型化数据集众，并自动地进入TableAdapter配置向导。在第一屏中，向导提示我们选择数据库连接 – 连接到同样的数据库Northwind并使用Web.config里设置好的连接字符串NORTHWNDConnectionString。

图 3: 连接到同一个数据库Northwind

下一步，向导提示我们选择如何访问数据库：通过一个指定的SQL语句，创建新的存储过程，或者使用一个现有的存储过程。既然我们最初的DAL是使用的是指定SQL查询语句，这里我们还是使用它。

图4: 使用指定SQL语句的方式访问数据库

下一步，进入查询分析器，返回产品信息。让我们使用在最初的DAL中产品TableAdapter相同的SQL查询，它返回产品的所有字段包括产品的供应商和类别名称。

1SELECT   ProductID, ProductName, SupplierID, CategoryID, QuantityPerUnit,
2
3           UnitPrice, UnitsInStock, UnitsOnOrder, ReorderLevel, Discontinued,
4
5           (SELECT CategoryName FROM Categories WHERE Categories.CategoryID = Products.CategoryID) as CategoryName,
6
7           (SELECT CompanyName FROM Suppliers WHERE Suppliers.SupplierID = Products.SupplierID) as SupplierName
8
9FROM       Products
10

图5：使用在最初的DAL中产品TableAdapter相同的SQL查询

在我们进入下一步之前，点击“高级选项”按钮。要让这个TableAdapter使用开放式并发，仅仅需要勾选上“使用开放式并发”。

图6：勾选“使用开放式并发”启用开放式并发控制

最后，需要指出的是，该TableAdapter应该同时使用“填充DataTable”和“返回DataTable”两种要生成的方法；并且，勾选“创建方法以将更新直接发送到数据库（GenerateDBDirectMethods）”。将返回DataTable的方法名称从GetData改为GetProducts，使之与我们最初的DAL中的命名规则匹配。

图7：让这个TableAdapter利用所有的数据访问方式

完成了配置向导后，该数据集设计器将包含一个强类型的Products DataTable和TableAdapter。让我们花些时间把该DataTable的名称Products改为ProductsOptimisticConcurrency，方法是右键点击DataTable的标题栏，从菜单中选择“重命名”。

图8：一个DataTable和TableAdapter已经添加到类型化数据集

为了看看ProductsOptimisticConcurrency TableAdapter（使用开放式并发）和Products TableAdapter（不使用并发控制）的UPDATE 和 DELETE查询之间有什么不同，选中该TableAdapter并转到属性窗口。在DeleteCommand 和 UpdateCommand 这两个属性的 CommandText 子属性里，我们可以看到调用DAL的update或者delete关联的方法时发送到数据库的实际的SQL语法。ProductsOptimisticConcurrency TableAdapter使用的DELETE语句是：

DELETE FROM [Products]

    WHERE (([ProductID] = @Original_ProductID)

    AND ([ProductName] = @Original_ProductName)

    AND ((@IsNull_SupplierID = 1 AND [SupplierID] IS NULL) OR ([SupplierID] = @Original_SupplierID))

    AND ((@IsNull_CategoryID = 1 AND [CategoryID] IS NULL) OR ([CategoryID] = @Original_CategoryID))

    AND ((@IsNull_QuantityPerUnit = 1 AND [QuantityPerUnit] IS NULL) OR ([QuantityPerUnit] = @Original_QuantityPerUnit))

    AND ((@IsNull_UnitPrice = 1 AND [UnitPrice] IS NULL) OR ([UnitPrice] = @Original_UnitPrice))

    AND ((@IsNull_UnitsInStock = 1 AND [UnitsInStock] IS NULL) OR ([UnitsInStock] = @Original_UnitsInStock))

    AND ((@IsNull_UnitsOnOrder = 1 AND [UnitsOnOrder] IS NULL) OR ([UnitsOnOrder] = @Original_UnitsOnOrder))

    AND ((@IsNull_ReorderLevel = 1 AND [ReorderLevel] IS NULL) OR ([ReorderLevel] = @Original_ReorderLevel))

    AND ([Discontinued] = @Original_Discontinued))

相反，最初的DAL的Products TableAdapter所使用的DELETE语句则简单得多：

DELETE FROM [Products] WHERE (([ProductID] = @Original_ProductID))

正如你所看到的，启用了开发式并发的TableAdapter所使用的DELETE语句里的WHERE子句包含了对表Product每一个字段现有的值与GridView（或者DetailsView，FormView）最后一次加载时的原始值的对比。因为除了ProductID，ProductName, 和Discontinued之外，其他所有字段都可能为NULL值，所以WHERE子句里还包含了额外的参数以及与NULL值恰当的比较。

在这一节里，我们不会在启用了开放式并发的数据集里增加其他的DataTable了，因为我们的ASP.NET页面将仅提供更新和删除产品信息的功能。然而，我们仍然需要在ProductsOptimisticConcurrency TableAdapter里添加GetProductByProductID(productID) 方法。

为了实现这一点，在TableAdapter的标题栏（在Fill和GetProducts方法名的上方）上右键并从菜单里选择“添加查询”。这将启动TableAdapter查询配置向导。在TableAdapter的最初配置的基础上，选择指定SQL语句来创建GetProductByProductID(productID)方法（见图四）。因为GetProductByProductID(productID)方法返回指定产品的信息，因此需要指定SQL查询类型为“SELECT（返回行）”。

图9：标记SQL查询类型为“SELECT（返回行）”

进入下一步，向导提示我们指定SQL语句，并且与载入TableAdapter默认查询语句。在现有的查询语句的基础上添加WHERE ProductID = @ProductID子句，如图10：

图10：在预载入的查询语句上添加WHERE子句从而返回特定的产品记录

最后，把生成的方法重命名为FillByProductID和GetProductByProductID。

图11：把生成的方法重命名为FillByProductID和GetProductByProductID

完成这个向导之后，现在这个TableAdapter包含两个访问数据的方法：GetProducts()，它返回所有的产品；和GetProductByProductID(productID)，它返回特定的产品。

第三步: 创建一个支持启用了开放式并发的DAL的业务逻辑层

我们现有的ProductsBLL类包含批量更新和直接发送数据库的模式的例子。AddProduct方法和 UpdateProduct重载都使用了批量更新模式，通过一个ProductRow实例发送到TableAdapter的Update方法。另一方面，DeleteProduct方法则使用直接发送到数据库的模式，调用TableAdapter的Delete(productID)方法。

在新的ProductsOptimisticConcurrency TableAdapter里，发送到数据库的方法现还要求传入原始的值。例如，Delete方法现在要求十个输入参数：原始的ProductID、ProductName、SupplierID、CategoryID、QuantityPerUnit、UnitPrice、UnitsInStock、UnitsOnOrder、ReorderLevel和Discontinued。它在发送到数据库的DELETE语句的WHERE子句里使用这些额外的输入参数，仅仅删除当前数据库的值与原始值一致的指定记录。

使用批量更新模式时，如果标记给TableAdapter的Update使用的方法没有更改，那么代码就需要同时记录原始值和新的值。然而，与其在我们现有的ProductsBLL类的基础上试图使用启用了开放式并发的DAL，不如让我们重新创意一个业务逻辑类支持我们新的DAL。

在App_Code文件夹下的BLL子文件夹里，添加一个名为ProductsOptimisticConcurrencyBLL的新类。

图 12: 添加ProductsOptimisticConcurrencyBLL类到BLL文件夹

然后，在ProductsOptimisticConcurrencyBLL类里添加如下代码：

1using System;
2
3using System.Data;
4
5using System.Configuration;
6
7using System.Web;
8
9using System.Web.Security;
10
11using System.Web.UI;
12
13using System.Web.UI.WebControls;
14
15using System.Web.UI.WebControls.WebParts;
16
17using System.Web.UI.HtmlControls;
18
19using NorthwindOptimisticConcurrencyTableAdapters;
20
21
22
23
24
25[System.ComponentModel.DataObject]
26
27public class ProductsOptimisticConcurrencyBLL
28
29{
30
31    private ProductsOptimisticConcurrencyTableAdapter _productsAdapter = null;
32
33    protected ProductsOptimisticConcurrencyTableAdapter Adapter
34
35    {
36
37        get
38
39        {
40
41            if (_productsAdapter == null)
42
43                _productsAdapter = new ProductsOptimisticConcurrencyTableAdapter();
44
45
46
47            return _productsAdapter;
48
49        }
50
51    }
52
53
54
55    [System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Select, true)]
56
57    public NorthwindOptimisticConcurrency.ProductsOptimisticConcurrencyDataTable GetProducts()
58
59    {
60
61        return Adapter.GetProducts();
62
63    }
64
65}
66

注意在类的声明开始之前的using NorthwindOptimisticConcurrencyTableAdapters语句。命名空间NorthwindOptimisticConcurrencyTableAdapters包含了类ProductsOptimisticConcurrencyTableAdapter，它提供DAL的方法。并且，在类声明之前我们还能找到System.ComponentModel.DataObject属性标志，它指示Visual Studio把该类包含在ObjectDataSource向导的数据对象下拉列表中。

类ProductsOptimisticConcurrencyBLL的Adapter属性提供快速访问ProductsOptimisticConcurrencyTableAdapter类的一个实例，并和我们最初的BLL类（ProductsBLL、CategoriesBLL等等）相似。最后，方法GetProducts()仅仅是调用DAL的GetProdcuts()方法并返回一个ProductsOptimisticConcurrencyDataTable对象，该对象由对应数据库里每一个产品记录的ProductsOptimisticConcurrencyRow实例组成。

使用支持开放式并发的发送到数据库的模式删除一个产品记录

当使用支持开放式并发的DAL发送到数据库的模式，方法必须传入新值和原始值。对删除来说，这没有新的值，所以仅仅需要传入原始值。那么，在我们的BLL里，我们必须接收所有原始值所为输入参数。让ProductsOptimisticConcurrencyBLL类的DeleteProduct方法使用这个发送到数据的方法。这意味着此方法必须接受所有的十个产品数据字段作为输入参数，并传送这些参数到DAL，如下面的代码所示：

1[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Delete, true)]
2
3public bool DeleteProduct(int original_productID, string original_productName, int? original_supplierID, int? original_categoryID,
4
5                          string original_quantityPerUnit, decimal? original_unitPrice, short? original_unitsInStock,
6
7                          short? original_unitsOnOrder, short? original_reorderLevel, bool original_discontinued)
8
9{
10
11    int rowsAffected = Adapter.Delete(original_productID,
12
13                                      original_productName,
14
15                                      original_supplierID,
16
17                                      original_categoryID,
18
19                                      original_quantityPerUnit,
20
21                                      original_unitPrice,
22
23                                      original_unitsInStock,
24
25                                      original_unitsOnOrder,
26
27                                      original_reorderLevel,
28
29                                      original_discontinued);
30
31
32
33    // Return true if precisely one row was deleted, otherwise false
34
35    return rowsAffected == 1;
36
37}
38
39

如果这些在GridView（或者是DetailsView、FormView）最后一次加载时的原始值跟用户点击删除按钮时数据库中的值不一致， WHERE子句将不能匹配任何数据库记录，这就没有记录会受到影响。因此，TableAdapter的Delete方法将返回0并且BLL的DeleteProduct方法返回false。

使用支持开放式并发的批量更新模式修改一个产品记录

正如之前注意到的，批量更新模式时用的TableAdapter的Update方法也有同样的方法声明为不管是否支持开放式并发。也就是，Update方法可以接受一个DataRow，一批DataRow，一个DataTable，或者一个类型化的数据集。正是因为DataTable在它的DataRow(s)里保留了从原始值到修改后的值这个变化的轨迹使这成为可能。当DAL生成它的UPDATE语句时，参数@original_ColumnName装入DataRow中的原始值，反之，参数@ColumnName装入DataRow中修改后的值。

在类ProductsBLL（我们最初使用的不支持开放式并发DAL的）里，当我们使用批量更新模式更新产品信息时，我们的代码执行的则是按顺序执行下列世间：

1. 使用TableAdapter的GetProductByProductID(productID)方法读取当前数据库中的产品信息到ProductRow实例

2. 在第1步里将新的值赋值到ProductRow实例

3. 调用TableAdapter的Update方法，传入该ProductRow实例

这一连串的步骤，无论如何都不可能支持开放式并发，因为在第一步中产生的ProductRow是直接从数据库组装的，这意味着，DataRow中使用的原始值是当前存在于数据库中值，而并非开始编辑过程时绑定到GridView的值。相反地，当使用启用开放式并发的DAL，我们需要修改UpdateProduct方法的重载以使用下面这些步骤：

1. 使用TableAdapter的GetProductByProductID(productID)方法读取当前数据库中的产品信息到ProductsOptimisticConcurrencyRow实例

2. 在第1步里将原始值赋值到ProductsOptimisticConcurrencyRow实例

3. 调用ProductsOptimisticConcurrencyRow实例的AcceptChanges()方法，这指示DataRow目前这些值是“原始”的值

4. 将新的值赋值到ProductsOptimisticConcurrencyRow实例

5. 调用TableAdapter的Update方法，传入该ProductsOptimisticConcurrencyRow实例

第1步读取当前数据库里指定产品记录的所有字段的值。对更新所有产品字段的UpdateProduct的重载里，这一步是多余的（因为这些值在第2步中被改写），而对那些仅仅传入部分字段值的重载方法来说则是必要的。一旦原始值赋值到ProductsOptimisticConcurrencyRow实例，调用AcceptChanges()方法，这将当前DataRow中的值标记为原始值，这些值将用作UPDATE语句的@original_ColumnNam参数。然后，新的参数值被赋值到ProductsOptimisticConcurrencyRow，最后，调用Update方法，传入这个DataRow。

下面这些代码展示了重载方法UpdateProduct接受所有产品数据字段作为输入参数。虽然这里没有展示，实际上从本节教程下载的ProductsOptimisticConcurrencyBLL类里还包含了重载方法UpdateProduct，它仅仅接受产品名称和单价作为输入参数。

1protected void AssignAllProductValues(NorthwindOptimisticConcurrency.ProductsOptimisticConcurrencyRow product,
2                                      string productName, int? supplierID, int? categoryID, string quantityPerUnit,
3                                      decimal? unitPrice, short? unitsInStock, short? unitsOnOrder, short? reorderLevel,
4                                      bool discontinued)
5{
6    product.ProductName = productName;
7    if (supplierID == null) product.SetSupplierIDNull(); else product.SupplierID = supplierID.Value;
8    if (categoryID == null) product.SetCategoryIDNull(); else product.CategoryID = categoryID.Value;
9    if (quantityPerUnit == null) product.SetQuantityPerUnitNull(); else product.QuantityPerUnit = quantityPerUnit;
10    if (unitPrice == null) product.SetUnitPriceNull(); else product.UnitPrice = unitPrice.Value;
11    if (unitsInStock == null) product.SetUnitsInStockNull(); else product.UnitsInStock = unitsInStock.Value;
12    if (unitsOnOrder == null) product.SetUnitsOnOrderNull(); else product.UnitsOnOrder = unitsOnOrder.Value;
13    if (reorderLevel == null) product.SetReorderLevelNull(); else product.ReorderLevel = reorderLevel.Value;
14    product.Discontinued = discontinued;
15}
16
17[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Update, true)]
18public bool UpdateProduct(
19                          // new parameter values
20                          string productName, int? supplierID, int? categoryID, string quantityPerUnit,
21                          decimal? unitPrice, short? unitsInStock, short? unitsOnOrder, short? reorderLevel,
22                          bool discontinued, int productID,
23
24                          // original parameter values
25                          string original_productName, int? original_supplierID, int? original_categoryID,
26                          string original_quantityPerUnit, decimal? original_unitPrice, short? original_unitsInStock,
27                          short? original_unitsOnOrder, short? original_reorderLevel, bool original_discontinued,
28                          int original_productID)
29{
30    // STEP 1: Read in the current database product information
31    NorthwindOptimisticConcurrency.ProductsOptimisticConcurrencyDataTable products = Adapter.GetProductByProductID(original_productID);
32    if (products.Count == 0)
33        // no matching record found, return false
34        return false;
35
36    NorthwindOptimisticConcurrency.ProductsOptimisticConcurrencyRow product = products[0];
37
38    // STEP 2: Assign the original values to the product instance
39    AssignAllProductValues(product, original_productName, original_supplierID,
40                           original_categoryID, original_quantityPerUnit, original_unitPrice,
41                           original_unitsInStock, original_unitsOnOrder, original_reorderLevel,
42                           original_discontinued);
43
44    // STEP 3: Accept the changes
45    product.AcceptChanges();
46
47    // STEP 4: Assign the new values to the product instance
48    AssignAllProductValues(product, productName, supplierID, categoryID, quantityPerUnit, unitPrice,
49                           unitsInStock, unitsOnOrder, reorderLevel, discontinued);
50
51    // STEP 5: Update the product record
52    int rowsAffected = Adapter.Update(product);
53
54    // Return true if precisely one row was updated, otherwise false
55    return rowsAffected == 1;
56}
57

第四步: 从ASP.NET页面把原始值和新值传入BLL 方法

完成了DAL和BLL后，剩下的工作就是创建一个能利用系统中内建的开放式并发逻辑的ASP.NET页面。特别地，数据 Web 服务器控件（GridView，DetailsView或FormView）必须记住它的原始值，并且ObjectDataSource必须同时传送这两套值到业务逻辑层。此外，ASP.NET页面必须加以配置从而适当地处理并发冲突。

首先，打开EditInsertDelete文件夹中的OptimisticConcurrency.aspx页面，添加一个GridView控件到设计器，设置它的ID属性为ProductsGrid。从GridView的职能标记里，选择创建一个新的ObjectDataSource名为ProductsOptimisticConcurrencyDataSource。既然我们希望这个ObjectDataSource使用支持开放式并发的DAL，就把它配置为使用ProductsOptimisticConcurrencyBLL对象。

图 13: 该ObjectDataSource使用ProductsOptimisticConcurrencyBLL对象

在向导中从下拉列表选择GetProducts，UpdateProduct，和DeleteProduct方法。对UpdateProduct方法，则使用接受所有产品数据字段的重载。

配置ObjectDataSource控件的属性

完成了向导之后，该ObjectDataSource的声明标记应该如下：

1<asp:ObjectDataSource ID="ProductsOptimisticConcurrencyDataSource" runat="server" DeleteMethod="DeleteProduct"
2    OldValuesParameterFormatString="original_{0}" SelectMethod="GetProducts" TypeName="ProductsOptimisticConcurrencyBLL"
3    UpdateMethod="UpdateProduct">
4    <DeleteParameters>
5        <asp:Parameter Name="original_productID" Type="Int32" />
6        <asp:Parameter Name="original_productName" Type="String" />
7        <asp:Parameter Name="original_supplierID" Type="Int32" />
8        <asp:Parameter Name="original_categoryID" Type="Int32" />
9        <asp:Parameter Name="original_quantityPerUnit" Type="String" />
10        <asp:Parameter Name="original_unitPrice" Type="Decimal" />
11        <asp:Parameter Name="original_unitsInStock" Type="Int16" />
12        <asp:Parameter Name="original_unitsOnOrder" Type="Int16" />
13        <asp:Parameter Name="original_reorderLevel" Type="Int16" />
14        <asp:Parameter Name="original_discontinued" Type="Boolean" />
15    DeleteParameters>
16    <UpdateParameters>
17        <asp:Parameter Name="productName" Type="String" />
18        <asp:Parameter Name="supplierID" Type="Int32" />
19        <asp:Parameter Name="categoryID" Type="Int32" />
20        <asp:Parameter Name="quantityPerUnit" Type="String" />
21        <asp:Parameter Name="unitPrice" Type="Decimal" />
22        <asp:Parameter Name="unitsInStock" Type="Int16" />
23        <asp:Parameter Name="unitsOnOrder" Type="Int16" />
24        <asp:Parameter Name="reorderLevel" Type="Int16" />
25        <asp:Parameter Name="discontinued" Type="Boolean" />
26        <asp:Parameter Name="productID" Type="Int32" />
27        <asp:Parameter Name="original_productName" Type="String" />
28        <asp:Parameter Name="original_supplierID" Type="Int32" />
29        <asp:Parameter Name="original_categoryID" Type="Int32" />
30        <asp:Parameter Name="original_quantityPerUnit" Type="String" />
31        <asp:Parameter Name="original_unitPrice" Type="Decimal" />
32        <asp:Parameter Name="original_unitsInStock" Type="Int16" />
33        <asp:Parameter Name="original_unitsOnOrder" Type="Int16" />
34        <asp:Parameter Name="original_reorderLevel" Type="Int16" />
35        <asp:Parameter Name="original_discontinued" Type="Boolean" />
36        <asp:Parameter Name="original_productID" Type="Int32" />
37    UpdateParameters>
38asp:ObjectDataSource>
39

正如你所看到的，DeleteParameters集合包含了对应ProductsOptimisticConcurrencyBLL类的DeleteProduct方法的每一个输入参数的Parameter实例。同样地，UpdateParameters集合也包含了对应UpdateProduct每一个输入参数的Parameter实例。

在先前的那些关于数据修改的教程中，我们在这里都会移除ObjectDataSource的OldValuesParameterFormatString属性，因为这个属性需要BLL方法既要求传入原始值也要求传入修改后的值。此外，这个属性还需要对应原始值的输入参数的名称。既然我们现在要把原始值传送到BLL，那就不要删除这个属性。

注意：OldValuesParameterFormatString属性的值必须映射到BLL里接收原始值的输入参数的名称。因为我们把这些参数命名为original_productName，original_supplierID，等等，我们可以让OldValuesParameterFormatString属性的值依旧是original_{0}。然而如果BLL方法的输入参数名为的old_productName，old_supplierID等等，那么，你不得不把OldValuesParameterFormatString属性的值改为old_{0}。

为了ObjectDataSource能够正确地将原始值传送到BLL方法，还有最后一个属性需要设置。ObjectDataSource有一个 ConflictDetection属性，它可以设定为下面的下面两个值之一：

Ø OverwriteChanges – 默认值；不将原始值发送到BLL方法相应的输入参数

Ø CompareAllValues – 将原始值发送到BLL方法；当使用开放式并发时使用这一项

稍花些时间将ConflictDetection属性设置为CompareAllValues。

配置GridView的属性和字段

当正确的配置完ObjectDataSource的属性后，让我们把注意力放在GridView的设置上。首先，因为我们希望GridView支持编辑和删除，因此，从GridView的智能标记中点击添加新列，从下拉列表中选择CommandField并勾选上“删除”和“编辑/更新”。这将增加一个CommandField，它的ShowEditButton和ShowDeleteButton属性都已设置为true。

当绑定ProductsOptimisticConcurrencyDataSource ObjectDataSource，该GridView对应每一个产品数据字段都包含一列。虽然这样的一个GridView可以被编辑，但用户的体验将是不可接受的。这没有对数字栏作格式化处理，也没有validation控件以确保提供product's name并且unit price、units in stock、units on order、和reorder level的值都是大于零的数字。

跟我们在之前的给编辑和新增界面增加验证控件 这一节里所论述的一样，用户界面可以通过将绑定列（BoundFields）替换为模板列（TemplateFields）实现自定义。我已经通过以下方式修改了这个GridView和它的编辑界面：

Ø 删除ProductID、SupplierName、和CategoryName这几个绑定列；

Ø 将ProductName绑定列替换为模板列并添加一个RequiredFieldValidation控件；

Ø 将CategoryID和SupplierID绑定列替换为模板列，并调整编辑界面，使用DropDownList而不是TextBox。在这些模板列的ItemTemplates里，显示CategoryName和SupplierName字段；

Ø 将UnitPrice、UnitsInStock、UnitsOnOrder、和ReorderLevel绑定列替换为模板列并添加CompareValidator控件。

因为我们在之前的章节里已经详细说明了如何完成这些任务，我仅仅把最终的声明语法列出并把具体执行留给读者作为练习。

1<asp:GridView ID="ProductsGrid" runat="server" AutoGenerateColumns="False" DataKeyNames="ProductID"
2    DataSourceID="ProductsOptimisticConcurrencyDataSource" OnRowUpdated="ProductsGrid_RowUpdated">
3    <Columns>
4        <asp:CommandField ShowDeleteButton="True" ShowEditButton="True" />
5        <asp:TemplateField HeaderText="Product" SortExpression="ProductName">
6            <EditItemTemplate>
7                <asp:TextBox ID="EditProductName" runat="server" Text='<%# Bind("ProductName") %>'>asp:TextBox>
8                <asp:RequiredFieldValidator ID="RequiredFieldValidator1" runat="server" ControlToValidate="EditProductName"
9                    ErrorMessage="You must enter a product name.">*asp:RequiredFieldValidator>
10            EditItemTemplate>
11            <ItemTemplate>
12                <asp:Label ID="Label1" runat="server" Text='<%# Bind("ProductName") %>'>asp:Label>
13            ItemTemplate>
14        asp:TemplateField>
15        <asp:TemplateField HeaderText="Category" SortExpression="CategoryName">
16            <EditItemTemplate>
17                <asp:DropDownList ID="EditCategoryID" runat="server" DataSourceID="CategoriesDataSource" AppendDataBoundItems="true"
18                    DataTextField="CategoryName" DataValueField="CategoryID" SelectedValue='<%# Bind("CategoryID") %>'>
19                    <asp:ListItem Value="">(None)asp:ListItem>
20                asp:DropDownList><asp:ObjectDataSource ID="CategoriesDataSource" runat="server"
21                    OldValuesParameterFormatString="original_{0}" SelectMethod="GetCategories" TypeName="CategoriesBLL">
22                asp:ObjectDataSource>
23            EditItemTemplate>
24            <ItemTemplate>
25                <asp:Label ID="Label2" runat="server" Text='<%# Bind("CategoryName") %>'>asp:Label>
26            ItemTemplate>
27        asp:TemplateField>
28        <asp:TemplateField HeaderText="Supplier" SortExpression="SupplierName">
29            <EditItemTemplate>
30                <asp:DropDownList ID="EditSuppliersID" runat="server" DataSourceID="SuppliersDataSource" AppendDataBoundItems="true"
31                    DataTextField="CompanyName" DataValueField="SupplierID" SelectedValue='<%# Bind("SupplierID") %>'>
32                    <asp:ListItem Value="">(None)asp:ListItem>
33                asp:DropDownList><asp:ObjectDataSource ID="SuppliersDataSource" runat="server"
34                    OldValuesParameterFormatString="original_{0}" SelectMethod="GetSuppliers" TypeName="SuppliersBLL">
35                asp:ObjectDataSource>
36            EditItemTemplate>
37            <ItemTemplate>
38                <asp:Label ID="Label3" runat="server" Text='<%# Bind("SupplierName") %>'>asp:Label>
39            ItemTemplate>
40        asp:TemplateField>
41        <asp:BoundField DataField="QuantityPerUnit" HeaderText="Qty/Unit" SortExpression="QuantityPerUnit" />
42        <asp:TemplateField HeaderText="Price" SortExpression="UnitPrice">
43            <EditItemTemplate>
44                <asp:TextBox ID="EditUnitPrice" runat="server" Text='<%# Bind("UnitPrice", "{0:N2}") %>' Columns="8">asp:TextBox>
45                <asp:CompareValidator ID="CompareValidator1" runat="server" ControlToValidate="EditUnitPrice"
46                    ErrorMessage="Unit price must be a valid currency value without the currency symbol and must have a value greater than or equal to zero."
47                    Operator="GreaterThanEqual" Type="Currency" ValueToCompare="0">*asp:CompareValidator>
48            EditItemTemplate>
49            <ItemTemplate>
50                <asp:Label ID="Label4" runat="server" Text='<%# Bind("UnitPrice", "{0:C}") %>'>asp:Label>
51            ItemTemplate>
52        asp:TemplateField>
53        <asp:TemplateField HeaderText="Units In Stock" SortExpression="UnitsInStock">
54            <EditItemTemplate>
55                <asp:TextBox ID="EditUnitsInStock" runat="server" Text='<%# Bind("UnitsInStock") %>' Columns="6">asp:TextBox>
56                <asp:CompareValidator ID="CompareValidator2" runat="server" ControlToValidate="EditUnitsInStock"
57                    ErrorMessage="Units in stock must be a valid number greater than or equal to zero."
58                    Operator="GreaterThanEqual" Type="Integer" ValueToCompare="0">*asp:CompareValidator>
59            EditItemTemplate>
60            <ItemTemplate>
61                <asp:Label ID="Label5" runat="server" Text='<%# Bind("UnitsInStock", "{0:N0}") %>'>asp:Label>
62            ItemTemplate>
63        asp:TemplateField>
64        <asp:TemplateField HeaderText="Units On Order" SortExpression="UnitsOnOrder">
65            <EditItemTemplate>
66                <asp:TextBox ID="EditUnitsOnOrder" runat="server" Text='<%# Bind("UnitsOnOrder") %>' Columns="6">asp:TextBox>
67                <asp:CompareValidator ID="CompareValidator3" runat="server" ControlToValidate="EditUnitsOnOrder"
68                    ErrorMessage="Units on order must be a valid numeric value greater than or equal to zero."
69                    Operator="GreaterThanEqual" Type="Integer" ValueToCompare="0">*asp:CompareValidator>
70            EditItemTemplate>
71            <ItemTemplate>
72                <asp:Label ID="Label6" runat="server" Text='<%# Bind("UnitsOnOrder", "{0:N0}") %>'>asp:Label>
73            ItemTemplate>
74        asp:TemplateField>
75        <asp:TemplateField HeaderText="Reorder Level" SortExpression="ReorderLevel">
76            <EditItemTemplate>
77                <asp:TextBox ID="EditReorderLevel" runat="server" Text='<%# Bind("ReorderLevel") %>' Columns="6">asp:TextBox>
78                <asp:CompareValidator ID="CompareValidator4" runat="server" ControlToValidate="EditReorderLevel"
79                    ErrorMessage="Reorder level must be a valid numeric value greater than or equal to zero."
80                    Operator="GreaterThanEqual" Type="Integer" ValueToCompare="0">*asp:CompareValidator>
81            EditItemTemplate>
82            <ItemTemplate>
83                <asp:Label ID="Label7" runat="server" Text='<%# Bind("ReorderLevel", "{0:N0}") %>'>asp:Label>
84            ItemTemplate>
85        asp:TemplateField>
86        <asp:CheckBoxField DataField="Discontinued" HeaderText="Discontinued" SortExpression="Discontinued" />
87    Columns>
88asp:GridView>
89

我们已经非常接近于完成一个完整的例子。然而，还有一些细节问题需要我们慢慢解决。另外，我们还需要一些界面，当发生并发冲突时用来提示用户。

注意: 为了让数据Web服务器控件能够正确地把原始的值传送到ObjectDataSource（它随之将其发送到BLL），将GirdView的EnableViewState属性设置为true（默认值）是至关重要的。如果禁用了视图状态，这些原始值在postback的时候将会丢失。

传送正确的原始值到ObjectDataSource

完成了GridView的配置，还有几个问题。如果这个ObjectDataSource的ConflictDetection 属性设置为CompareAllValues （正如我们所做的），它会尝试复制GridView的原始值到它的Parameter实例。回到图2查看这个过程的图解。

特别需要指出的是，这个GridView的原始值是被指定为双向绑定的。因此，这些必需的原始值是通过双向绑定获取的，并且它们是规定为可改变的格式，这一点很重要。

为了看看为什么这一点非常重要，花些时间通过浏览器访问我们的页面。正如所预料那样，GridView列出每一个产品，并且每行最左边的一列都显示编辑和删除按钮。

图 14: GridView列出所有的产品信息

如果你点击任意一行的删除按钮，则抛出一个FormatException异常。

图 15: 尝试删除任意一个产品导致FormatException异常

当ObjectDataSource试图读取原始的UnitPrice值引发了一个FormatException异常。因为该模板列将UnitPrice的值限制为货币格式（<%# Bind("UnitPrice", "{0:C}") %>），它包含一个货币符号，例如$19.95。该FormatException异常发生在ObjectDataSource试图将字符产转换成小数。为了绕过此问题，我们有许多种选择：

Ø 从模板列里删除货币格式限制。就是说，取代<%# Bind("UnitPrice", "{0:C}") %>，简单地使用<%# Bind("UnitPrice") %>。下方的价格就是没有格式化的。

Ø 在模板列中显示UnitPrice时格式化为货币，但是使用Eval关键字实现绑定。记得Eval是实现单向绑定的。我们仍然需要提供UnitPrice的值作为原始的值，因此在模板列里我们依旧需要一个双向绑定的声明，但这可以放在一个Visible属性设置为false的Label服务器控件里。在模板列里我们可以使用下面的标记：

1<ItemTemplate>
2 <asp:Label ID="DummyUnitPrice" runat="server" Text='<%# Bind("UnitPrice") %>' Visible="false">asp:Label>
3 <asp:Label ID="Label4" runat="server" Text='<%# Eval("UnitPrice", "{0:C}") %>'>asp:Label>
4ItemTemplate>

Ø 从模板列里删除货币格式限制，使用 <%# Bind("UnitPrice") %>。在GridView的RowDataBound事件处理里，编码访问显示UnitPrice的值的Label服务器控件并设置其Text属性为格式化的版本。

Ø • 让UnitPrice保留货币格式化。在GridView的RowDeleting事件处理里，将现存的UnitPrice的原始值（$19.95）替换为实际的小数值（使用Decimal.Parse）。在前面的 在ASP.NET页面中处理BLL/DAL异常 这一节教程里我们也已经看过如何RowUpdating事件处理里实现类似的功能。

在我的例程里我选择第二种方法，添加一个隐藏的Label服务器控件，并将它的Text属性双向绑定到无格式的UnitPrice值。

解决了这个问题之后，再次点击任意一个产品的删除按钮。这一次，当ObjectDataSource尝试调用BLL的UpdateProduct方法时我们得到一个InvalidOperationException异常。

图 16: ObjectDataSource找不到具有它要发送的输入参数的方法

仔细看看异常信息，明显地ObjectDataSource希望调用一个BLL的DeleteProduct方法，此方法包含original_CategoryName和original_SupplierName输入参数。这是因为CategoryID和SupplierID模板列的ItemTemplate当前是双向绑定到CategoryName和SupplierName数据字段。作为替换，我们需要包含对CategoryID和SupplierID数据字段的Bind声明。为了实现这一点，把现有的Bind声明更改为Eval声明，并且添加隐藏的Label服务器控件，这些Label的Text属性使用双向绑定的方式绑定到CategoryID和SupplierID数据字段，如下所示：

1<asp:TemplateField HeaderText="Category" SortExpression="CategoryName">
2    <EditItemTemplate>
3
4    EditItemTemplate>
5    <ItemTemplate>
6        <asp:Label ID="DummyCategoryID" runat="server" Text='<%# Bind("CategoryID") %>' Visible="False">asp:Label>
7        <asp:Label ID="Label2" runat="server" Text='<%# Eval("CategoryName") %>'>asp:Label>
8    ItemTemplate>
9asp:TemplateField>
10<asp:TemplateField HeaderText="Supplier" SortExpression="SupplierName">
11    <EditItemTemplate>
12
13    EditItemTemplate>
14    <ItemTemplate>
15        <asp:Label ID="DummySupplierID" runat="server" Text='<%# Bind("SupplierID") %>' Visible="False">asp:Label>
16        <asp:Label ID="Label3" runat="server" Text='<%# Eval("SupplierName") %>'>asp:Label>
17    ItemTemplate>
18asp:TemplateField>
19

通过这些更改，现在我们可以成功地删除和编辑产品信息了！在第五步里，我们将看看如何验证删除时发生并发冲突。但是现在，花几分钟尝试更新和删除一些记录，确认在单用户的情况下更新和删除能够正常运作。

第五步: 测试开放式并发支持

为了验证并发冲突是否能够被发现（而不是导致数据被盲目改写），我们需要打开两个浏览器窗口来访问这个页面。在两个浏览窗口里，都点击产品“Chai”的编辑按钮。然后，在其中一个窗口修改其名称为“Chai Tea”并点击更新。这个更新应该会成功并且GridView回到预编辑状态，并且该产品的名称已经改为“Chai Tea”。

而在另一个浏览器窗口里，产品名称域依旧显示的是“Chai”。在这个浏览器窗口，将UnitPrice的值更新为25.00。如果没有开放式并发支持的话，点击第二个浏览器窗口的更新按钮将把产品名称改回“Chai”，从而覆盖了第一个浏览器窗口里所作的修改。然而现在有了开发式并发，当点击第二个窗口中的更新按钮时导致了一个DBConcurrencyException异常。

图 17: 发现并发冲突，抛出一个DBConcurrencyException异常

这个DBConcurrencyException异常仅当利用DAL的批量更新模式时会被抛出。直接发送到数据库的模式则不会引发异常，它仅仅会提示没有行受到影响。为了举例说明这个，两个浏览器窗口里的GridView都回到预编辑的状态。然后，在第一个窗口里，点击编辑按钮，把产品名称从“Chai”改为“Chai Tea”并点击更新。在第二个窗口里，点击产品“Chai”的删除按钮。

点击删除按钮，页面会传，GridView调用ObjectDataSource的Delete()方法，然后ObjectDataSource调用ProductsOptimisticConcurrencyBLL类的DeleteProduct方法，传入原始的值。在第二个浏览器窗口里原始的ProductName值是“Chai Tea”，这个值与当前数据库中相应的ProductName值是不一致的。因此，发送到数据库的DELETE语句影响0行，因为数据库中没有记录能够满足WHERE子句。DeleteProduct方法返回false并且ObjectDataSource的数据重新绑定到GridView控件。

从最后一个用户的观点来看，在第二个浏览器窗口里点击了产品“Chai Tea”的删除按钮导致屏幕闪烁，恢复后该产品依旧在，虽然现在它的名称是“Chai”（在第一个浏览器窗口里修改了产品名称）。如果用户再次点击删除按钮，这次就能成功删除，因为GridView的原始的ProductName值（“Chai”）现在能够与数据库中相应的值匹配。

在这些例子里，用户的体验跟理想的状况还有颇远的距离。显然我们在使用批量更新模式时不希望用户看到DBConcurrencyException异常生硬的详细信息。并且使用直接发送到数据库模式的行为也会让用户有些疑惑，因为用户操作失败了但是没有准确的提示说明为什么。

为了补救这两个小问题，我们可以在页面上放置一个Label服务器控件，它用来提供为什么更新或删除失败的说明。在批量更新模式，我们可以在GridView的post级事件处理里判定是否引发了一个DBConcurrencyException异常，显示必要的警告标签。对于直接发送到数据库的方法，我们可以检测BLL方法（它对一行或多行产生影响返回true，否则false）的返回值并显示必要的提示信息。

第六步: 添加提示信息并且在发生并发冲突时显示

当一个并发冲突出现时，展现出来的行为取决于是使用DAL的批量更新还是直接发送到数据库的模式。我们这一节的教程两种模式都用了，用批量更新模式实现修改，用直接发送到数据库的方式实现删除。首先，我们添加两个Label服务器控件到页面，它们用来解释更新或删除数据时出现的并发冲突。设置Label控件的Visible和EnableViewState属性为false；这意味一般情况下它们都是隐藏的，除非是那些特别的页面访问，在那里它们的Visible属性通过编码设置为true。

1<asp:Label ID="DeleteConflictMessage" runat="server" Visible="False" EnableViewState="False" CssClass="Warning"
2     Text="The record you attempted to delete has been modified by another user since you last visited this page.
3            Your delete was cancelled to allow you to review the other user's changes and determine if you want to continue deleting this record." />
4
5<asp:Label ID="UpdateConflictMessage" runat="server" Visible="False" EnableViewState="False" CssClass="Warning"
6     Text="The record you attempted to update has been modified by another user since you started the update process.
7            Your changes have been replaced with the current values. Please review the existing values and make any needed changes." />
8
9

在设置了它们的Visible、EnabledViewState和Text属性之外，我们还要把CssClass属性设置为Warning，这让标签显示大的、红色的、斜体、加粗的字体。这个CSS Warning 分类是在研究插入、更新和删除的关联事件 这一节里添加到Styles.css并且定义好的。

添加了这些标签之后，Visual Studio设计器里看起来应该类似于图18：

图 18: 两个Label控件添加到页面

这些Label服务器控件放置到适当的位置后，我们准备好检测当并发冲突发生时如何判定，在哪个时间点把适当的Label的Visible属性设置为true并显示提示信息。

更新时处理并发冲突

让我们首先看看当使用批量更新模式是如何处理并发冲突。因为批量更新模式下的这些冲突导致抛出一个DBConcurrencyException异常，我们需要在ASP.NET页面中添加代码来判定更新过程中出现的是否DBConcurrencyException异常。如果是，我们则显示一个信息向用户解释他们的更改没有被保存，由于别的用户在他开始编辑和点击更新按钮之间的时间里修改了同样的数据记录。

正如我们在在ASP.NET页面中处理BLL/DAL异常 这一节里看过的那样，这样的异常可以在数据Web服务器控件的post级事件处理里被发现和排除。因此，我们需要创建一个GridView的RowUpdated事件的处理，它用来检测是否抛出了一个DBConcurrencyException异常。这个事件处理通过一个不同的分支区别更新过程中引发的其它异常，如下面的时间处理代码所示：

1protected void ProductsGrid_RowUpdated(object sender, GridViewUpdatedEventArgs e)
2{
3    if (e.Exception != null && e.Exception.InnerException != null)
4    {
5        if (e.Exception.InnerException is System.Data.DBConcurrencyException)
6        {
7            // Display the warning message and note that the
8            // exception has been handled
9            UpdateConflictMessage.Visible = true;
10            e.ExceptionHandled = true;
11        }
12    }
13}

面对一个DBConcurrencyException异常，该事件处理显示UpdateConflictMessage Label控件并且指出该异常已经被处理。正确地编写了这些代码后，当更新记录时发生了并发冲突，用户的更改会丢失，因为他们不能覆盖同时发生的另一个用户的更改。特别地，GridView回到预编辑幢白并且绑定到当前数据库中数据。这将在GridView的行中显示出别的用户的更改，而之前这些更改是看不见的。另外，UpdateConflictMessage Label控件将向用户说明发生了什么。图19详细展示了这一连串的事件。

图 19: 面对并发冲突，一个用户的更改丢失了

注意：作为另一种选择，与其让GridView回到预编辑状态，我们还不如让GridView停留在编辑状态，通过设置传入的GridViewUpdatedEventArgs对象的KeepInEditMode属性为true。如果你接受这种方法，那么，必须重新绑定数据到GridView（通过调用它的DataBind()方法）从而将其他用户更改后的值栽入到编辑界面。在这一节的可下载的代码里，RowUpdated事件处理里有这两行注悉掉的代码；仅仅需要启用这两行代码就可以让GridView在发生了并发冲突之后保留编辑模式。

响应删除时的并发冲突

对于直接发送到数据库的模式，面对并发冲突时并不会引发异常。然而，数据库语句不影响任何记录，因为WHERE子句不能匹配任何记录。所有在BLL里创建的修改数据的方法都被设计为返回一个布尔值指示它们是否正好影响了一条记录。因此，为了确定删除记录时是否发生了并发冲突，我们可以检查BLL的DeleteProduct方法的返回值。

BLL方法的返回值可以在ObjectDataSource的post级事件处理中通过传入事件处理的ObjectDataSourceStatusEventArgs对象的ReturnValue属性被检测。因为我们感兴趣的是判断从DeleteProduct方法返回的结果，我们需要创建一个ObjectDataSource的Deleted事件的事件处理程序。该ReturnValue属性是object类型的，并且如果在方法可以返回一个值之前引发了异常并且方法被中断的情况下，它的值也可能为null。所以，我们应该首先确保ReturnValue属性非空并是个布尔值。若能通过这个检查，如果ReturnValue是 false我们显示DeleteConflictMessage Label控件。可以通过下面的代码完成：

1protected void ProductsOptimisticConcurrencyDataSource_Deleted(object sender, ObjectDataSourceStatusEventArgs e)
2{
3    if (e.ReturnValue != null && e.ReturnValue is bool)
4    {
5        bool deleteReturnValue = (bool)e.ReturnValue;
6
7        if (deleteReturnValue == false)
8        {
9            // No row was deleted, display the warning message
10            DeleteConflictMessage.Visible = true;
11        }
12    }
13}
14

面对一个并发冲突，用户的删除请求会被取消。GridView被刷新，显示在用户载入页面跟点击删除按钮之间的时间里发生在该记录上面的更改。当发生这样的一个冲突，显示DeleteConflictMessage Label控件，说明发生了什么（见图20）。

图 20: 面对并发冲突，一个用户的删除请求被取消了

总结

并发冲突可能存在于所有允许多用户同时更新或删除数据的应用程序里。如果不解决这样的冲突，当两个用户同时更新同一条数据，无论谁最后得到“胜利”，都将覆盖掉另一个用户所做的更改。作为另一种选择，开发者可以实现开放式并发控制（optimistic concurrency control），或者保守式并发控制（pessimistic concurrency control）。开放式并发控制假定并发冲突很少发生，简单地否决一个会提起并发冲突的更新或者删除命名。保守式并发控制则假定并发冲突频繁地发生，简单地拒绝某个用户的更新或者删除命令是不可接受的。在保守式并发控制下，编辑一条记录涉及到锁定它，从而该记录被锁定时预防其他用户的修改或删除。

.NET中的类型化数据集提供了支持开放式并发控制的功能。特别地，发送到数据库的UPDATE和DELETE语句包含了这个表的所有字段，从而确保了仅当该记录但前的值与用户开始他们的修改或更新时的原始值相匹配时，修改或删除才会发生。一旦DAL配置为支持开放式并发，BLL的方法就需要修改。另外，调用BLL的ASP.NET页面也需要配置为ObjectDataSource能从它的数据Web服务器控件获取到这些原始的值并将这些值传送到BLL。

正如我们在本节里所看到的，在ASP.NET web应用程序中实现开放式并发控制包括修改DAL和BLL，还包括在ASP.NET页面中添加相应的支持。无论这些额外的工作对你的时间来说是否一项明智的投入，对你的应用程序来说是否有所成效。如果你极少面对多个用户同时更新数据，或者不同的用户对数据作出不同的更改，那么并发控制并非必选项。然而，如果你时常面对多个用户在线并且对同一些数据进行操作，并发控制可以帮助预防一个用户的更新或删除被另一个用户在不知情的情况下覆盖。

祝编程快乐！

作者简介

评论: 12　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

Scott Mitchell 的ASP.NET 2.0数据教程之十八:: 在ASP.NET页面中处理BLL/DAL层的异常

№.零零伍 — Tue, 08 Aug 2006 10:43:00 GMT

阅读: 11563 评论: 25 作者: №.零零伍发表于 2006-08-08 18:43 原文链接

在ASP.NET 2.0中操作数据::在ASP.NET页面中处理BLL/DAL层的异常

下载本教程中的编码例子 | 下载本教程的PDF版

导言

在一个使用了分层体系架构的ASP.NET web应用系统里处理数据，一般遵循以下几步：

1. 确定业务逻辑层需要调用哪个方法，并且需要出入哪些参数。这些参数可以通过硬编码设置，程序自动设定，或者由用户输入。

2. 调用此方法。

3. 处理结果。当调用一个返回数据的BLL方法时，这包括绑定数据到Data Web服务器控件。而对于修改数据的BLL方法而言，这包括基于返回值的基础上执行某些动作，或者适当地处理在第二步中引发的异常。

正如我们在前一节里看到的，无论ObjectDataSource控件还是数据Web服务器控件，都为第1和第3步提供了可扩展性。例如GridView控件，触发它的RowUpdating事件之前把它的字段的值赋值到ObjectDataSource的UpdateParameters集合；在ObjectDataSource完成它的操作之后触发RowUpdated事件。

我们已经检测到第1步中触发的事件，并且看过了如何使用它们实现自定义出入参数或者取消操作。这一节我们将把我们的注意力转到操作完成后所触发的事件。通过这些post级的event handler和其它，可以判断在操作过程中是否产生了一个异常，并且适当地处理它，在屏幕中显示友好的错误信息要优于转到ASP.NET的默认错误处理页。

为了举例说明这些post级事件的工作方式，让我们创建一个页面，它在一个可编辑的GridView中列出产品信息。当更新一个产品时，如果引发了一个异常，我们的ASP.NET页面会在GridView控件的上方显示一个简短的信息，说明出现了一个问题。好吧，让我们开始！

第一步: 为产品创建一个可编辑的GridView

这一节里我们创建一个可编辑的GridView，它仅仅包含两个的字段，ProductName和UnitPrice 。这需要为ProductsBLL类的UpdateProduct方法增加一个额外的重载，它仅仅接受3个输入参数（product’s name，unit price，和ID），相对于接受每一个产品的字段的方法。在本节里让我们再一次练习一下这些技巧，创建一个可编辑的GridView，它显示产品的name、quantity per unit、unit price、和units in stock，但仅仅允许name，unit price，和units in stock可编辑。

为了提供这个场景，我们需要对UpdateProduct方法的另一个重载，它接收4个参数： product’s name，unit price，units in stock和ID。在ProductsBLL类中添加下面这个方法：

1[System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Update, false)]
2public bool UpdateProduct(string productName, decimal? unitPrice, short? unitsInStock, int productID)
3{
4    Northwind.ProductsDataTable products = Adapter.GetProductByProductID(productID);
5    if (products.Count == 0)
6        // no matching record found, return false
7        return false;
8
9    Northwind.ProductsRow product = products[0];
10
11    product.ProductName = productName;
12    if (unitPrice == null) product.SetUnitPriceNull();
13      else product.UnitPrice = unitPrice.Value;
14    if (unitsInStock == null) product.SetUnitsInStockNull();
15      else product.UnitsInStock = unitsInStock.Value;
16
17    // Update the product record
18    int rowsAffected = Adapter.Update(product);
19
20    // Return true if precisely one row was updated, otherwise false
21    return rowsAffected == 1;
22}
23

完成了此方法后，我们可以创建一个ASP.NET页面，它允许编辑这四个产品字段。打开EditInsertDelete文件夹里的ErrorHandling.aspx页面，并通过设计器添加一个GridView控件到页面中。绑定这个GridView到一个新的ObjectDataSource控件，映射Select()方法到ProductsBLL类的GetProducts()方法，方法Update()映射到刚刚创建的UpdateProduct重载。

图1: 使用UpdateProduct方法重载，它接受四个输入参数

这将创建一个ObjectDataSource，它包含四个参数的UpdateParameters集合，还有一个一个GridView，它包含产品的每一个字段。ObjectDataSource的声明标记给OldValuesParameterFormatString属性赋值为original_{0}，它将引发一个异常，因为我们的BLL类没有一个名为original_productID的输入参数需要传入。别忘了从声明语法里把这些设置通通删除（或者把它们设置为默认值：{0}）。

然后，减少GridView的绑定列，仅包含ProductName，QuantityPerUnit，UnitPrice和UnitsInStock这几列。随意设置一些你认为必要的字段级的格式（例如更改HeaderText属性）。

在之前的章节里我们已经看过了如何在只读和编辑两种模式下格式化UnitPrice绑定列为货币格式。在这里我们同样这样做。这需要设置绑定列的DataFormatString属性为{0:c}，它的HtmlEncode属性为false，还有它的ApplyFormatInEditMode属性为true，如图2所示。

图2: UnitPrice绑定列配置为显示一个货币金额

要在编辑界面将UnitPrice格式化为货币，这需要为GridView的RowUpdating事件创建一个事件处理，它将一个货币格式的字符串转换成decimal。回想上一节，RowUpdating事件处理也用来检测并确保用户输入的是一个UnitPrice的值。不过，本节我们可以允许用户忽略price列。

1protected void GridView1_RowUpdating(object sender, GridViewUpdateEventArgs e)
2{
3 if (e.NewValues["UnitPrice"] != null)
4 e.NewValues["UnitPrice"] =decimal.Parse(e.NewValues["UnitPrice"].ToString(), System.Globalization.NumberStyles.Currency);
5}
6
7

我们的GridView包含一个QuantityPerUnit绑定列，但它仅仅用作显示，不能被用户编辑。为了实现这一点，只需要简单地将该绑定列的ReadOnly属性设置为true。

图 3: 设置QuantityPerUnit绑定列为只读

最后，从GridView的智能标记里勾选上“启用编辑”。完成了这些步骤后，ErrorHandling.aspx页面在设计视图里将如图4所示。

图 4: 删除除了必需的绑定列之外的其它列并启用编辑

在这里我们显示产品的所有列，ProductName、QuantityPerUnit、UnitPrice和UnitsInStock；不过仅仅ProductName、UnitPrice和UnitsInStock这几列可以编辑。

图 5: 用户现在可以很方便地编辑Products’ Names、Prices和Units In Stock字段

第二步:适当地处理DAL层异常

这时我们的可编辑的GridView在用户输入合法的product’s name、price和units in stock时表现极佳，输入不合法的值时则导致一个异常。例如，遗漏了ProductName值则引发抛出一个NoNullAllowedException异常，因为ProdcutsRow类的ProductName属性设置了它的AllowDBNull属性为false；如果数据库不正常运作，则在试图连接数据库时通过TableAdapter抛出一个SqlException异常。没有任何的动作，这些异常都会从数据访问层冒出到业务逻辑层，然后到ASP.NET页面，最后到ASP.NET运行时。

取决于你的web应用程序如何配置以及是否从localhost访问该应用，一个未经处理的异常会出现在一类服务器错误处理页，一个详细的错误报表，或者一个对用户友好的web页面。查看Web Application Error Handling in ASP.NET 和 customErrors Element 获得更多的关于ASP.NET页面如何响应一个未捕获的异常的相关信息。

图6展示的是试图不指定ProductName的值更新一个产品时屏幕的状况。这显示的是通过localhost访问时的默认详细错误报表。

图 6: 省略Product’s Name将显示异常明细

虽然这样的异常明细在我们测试应用程序的时候是很有用的，然而当一个最终用户面对这样的异常呈现时却是无所适从的。一个最终用户很可能并不知道NoNullAllowedException是什么，或者它是如何引起的。更好的方法是呈现给用户一个更友好的信息说明试图更新产品时出现了问题。

如果在执行这项操作时出现了一个异常，ObjectDataSource 和数据Web控件的post级事件都提供了发现并不让它出现在ASP.NET运行时的方法。在我们的例子里，让我们为GridView的RowUpdated事件创建一个事件处理程序，它判断是否激发了一个异常，如果是，则在一个Label服务器控件中显示异常详细信息。

首先，添加一个Label控件到ASP.NET页面，设置它的ID属性为ExceptionDetails并清空它的Text属性。为了吸引用户的实现到此信息，设置其CssClass为Warning，这是我们在之前的章节里添加到Styles.css文件的一个CSS类别。记得这个CSS类别让Label的text显示为红色、斜体、加粗的较大的字体。

图 7: 添加一个Label服务器控件到页面

因为我们希望这个Label控件仅在异常出现时显示，在Page_Load事件处理中设置它的Visible属性为false：

1protected void Page_Load(object sender, EventArgs e)
2{
3 ExceptionDetails.Visible = false;
4}
5

通过这些代码，当第一次访问页面和随后的回传后，ExceptionDetails控件的Visible属性都将被设置为false。当在GridView的RowUpdated事件处理程序中检测到一个DAL/BLL层的异常时，我们将设置ExceptionDetails控件的Visible属性为true。因为页面生命周期里Web服务器控件的事件处理出现在Page_Load事件处理之后，该Label将会显示。不过，下一次回传，Page_Load事件处理将重新将Visible属性设置回false，再次隐藏它。

注意: 我们也可以不必在Page_Load里设置ExceptionDetails控件的Visible属性，作为另一种选择，可以在声明语法里设置其Visible属性为false并禁用视图状态（设置它的EnableViewState属性为false）。我们将在以后的章节里使用这种方法。

通过添加这个Label控件，我们下一步是为GridView的RowUpdated事件添加一个事件处理程序。在设计视图中选中GridView控件，打开属性窗口，点击黄色闪电状图标，列出GridView的所有事件。在GridView的RowUpdating事件里我们可以看到已经存在一个入口，因为我们在本节较早的时候已经为此事件创建了一个事件处理程序。为RowUpdated事件创建一个事件处理程序。

图 8: 为GridView的事件创建一个事件处理

注意: 你也可以通过代码隐藏文件顶处的下拉列表创建这个事件处理。从左边的下拉列表中选择这个GridView控件，并从右边的下拉列表中选择RowUpdated事件。

创建这个事件处理将添加下面这些代码到ASP.NET页面的代码隐藏类中：

1protected void GridView1_RowUpdated(object sender, GridViewUpdatedEventArgs e)
2{
3
4}
5

这个事件处理程序的第二个输入参数是一个GridViewUpdatedEventArgs类型的对象，它有三个关于处理异常的属性：

· Exception –获取更新操作过程中引发的异常；如果没有抛出异常，该属性的值为null

· ExceptionHandled –获取或设置一个值，它指示在更新操作过程中所引发的异常是否已在RowUpdated事件处理程序中得到处理；如果设为false（默认值)，该异常将被重新引发，漏出到ASP.NET运行时

· KeepInEditMode – 如果设置为true，GridView当前编辑行将维持在编辑模式；如果设置为false（默认值），当前行将恢复到只读模式

那么我们的代码应该检测Exception是否为null，不是null则意味着执行此操作时引发了一个异常。如果是这样，我们则希望：

· 在ExceptionDetails控件中显示一个对用户友好的提示信息

· 指示异常已经被处理

· 让当前行保持编辑模式

下面的代码实现了上述的目的：

1protected void GridView1_RowUpdated(object sender, GridViewUpdatedEventArgs e)
2{
3    if (e.Exception != null)
4    {
5        // Display a user-friendly message
6        ExceptionDetails.Visible = true;
7        ExceptionDetails.Text = "There was a problem updating the product. ";
8
9        if (e.Exception.InnerException != null)
10        {
11            Exception inner = e.Exception.InnerException;
12
13            if (inner is System.Data.Common.DbException)
14                ExceptionDetails.Text += "Our database is currently experiencing problems. Please try again later.";
15            else if (inner is NoNullAllowedException)
16                ExceptionDetails.Text += "There are one or more required fields that are missing.";
17            else if (inner is ArgumentException)
18            {
19                string paramName = ((ArgumentException)inner).ParamName;
20                ExceptionDetails.Text += string.Concat("The ", paramName, " value is illegal.");
21            }
22            else if (inner is ApplicationException)ExceptionDetails.Text += inner.Message;
23        }
24
25        // Indicate that the exception has been handled
26        e.ExceptionHandled = true;
27
28        // Keep the row in edit mode
29        e.KeepInEditMode = true;
30    }
31}
32

在这个事件处理程序中，首先检测e.Exception是否为null。如果不是，设置ExceptionDetails控件的Visible属性为true、设置它的Text属性为“There was a problem updating the product.”。当前抛出的异常详细信息则保存在e.Exception对象的InnerException属性里。检查这个内部异常，如果它是特定的类型，则把一些额外的有用的信息附加到ExceptionDetails标签的Text属性。最后，ExceptionHandled和KeepInEditMode属性都设置为true。

图9展示的是遗漏了产品名称时的页面的截屏；图10则显示输入一个不合法的UnitPrice值（-50）时的结果。

图 9: ProductName绑定列必须包含一个值

图 10: UnitPrice值不接受负数

通过设置属性为，事件处理程序指示该异常已经被处理。因此，这个异常不会传送到ASP.NET运行时。

注意: 图9和图10显示了一种得体的方式处理不正确的用户输入所引发的异常。可是，更理想地，这些不正确的输入不应该到达业务逻辑层，因为ASP.NET页面应该在调用ProductsBLL类的UpdateProduct方法之前就确保用户的输入是有效的。我们在下一节里将会看看如何添加validation控件到编辑和插入界面从而保证提交到业务逻辑层的数据遵循业务规则。validation控件不但可以阻止调用UpdateProduct方法直到用户提供有效的数据，还可以为定位数据输入问题提供一个更充满提示性的用户体验。

第三步: 适当地处理BLL层异常

当插入、更新或删除数据时，面对一个数据相关的错误时数据访问层会抛出一个异常。数据库可能未连线，一个必需的数据库表字段可能未指定值，或者违反了某个表间约束。除了确定的数据相关的异常外，业务逻辑层也使用异常指示违反了业务逻辑。在创建一个业务逻辑层 这一节里，作为例子，我们添加了一个业务规则检查最初的UpdateProduct重载。特别地，如果用户标记一个产品为停止供应，我们要求这个产品不能是该供应商唯一供应的产品。如果违反了这个条件，抛出一个ApplicationException异常。

在这一节里，我们给UpdateProduct重载增加一个业务规则：禁止把UnitPrice字段的值设置为超过原来的两倍。为了实现这一点，调整UpdateProduct重载以使它可以执行这个检查并且在违反该规则时抛出一个ApplicationException异常。此更新方法如下：

1public bool UpdateProduct(string productName, decimal? unitPrice, short? unitsInStock, int productID)
2{
3    Northwind.ProductsDataTable products = Adapter.GetProductByProductID(productID);
4    if (products.Count == 0)
5        // no matching record found, return false
6        return false;
7
8    Northwind.ProductsRow product = products[0];
9
10    // Make sure the price has not more than doubled
11    if (unitPrice != null && !product.IsUnitPriceNull())
12        if (unitPrice > product.UnitPrice * 2)
13          throw new ApplicationException("When updating a product price," + " the new price cannot exceed twice the original price.");
14
15
16    product.ProductName = productName;
17    if (unitPrice == null) product.SetUnitPriceNull();
18      else product.UnitPrice = unitPrice.Value;
19    if (unitsInStock == null) product.SetUnitsInStockNull();
20      else product.UnitsInStock = unitsInStock.Value;
21
22    // Update the product record
23    int rowsAffected = Adapter.Update(product);
24
25    // Return true if precisely one row was updated, otherwise false
26    return rowsAffected == 1;
27}
28

通过这个修改，任何超过现有价格两倍的价格更新都回引发一个ApplicationException异常被抛出。就像DAL中引发的异常一样，这个BLL引发的ApplicationException异常可以在GridView的RowUpdated事件处理程序中被侦测并处理。实际上，我们已有的RowUpdated事件处理程序的代码可以正确地发现到这个异常并显示ApplicationException的Message属性的值。图11显示的是当一个用户试图将产品“Chai”的价格更新为$50.00时的截屏，这超过了它原有价格$19.95的两倍。

图 11: 这个业务规则不接受价格增长超出产品现有价格的两倍

注意: 理想化地我们的业务规则不应该在UpdateProduct方法重载里而应该在一个公共的方法中。这留作读者练习。

总结

在插入、更新或删除操作的过程中，数据Web控件和ObjectDataSource控件都包含了pre- 和post-级的事件，它们记录着当前的操作。正如我们在本节和前面的一节里所看到的，当使用一个可编辑的GridView时，GridView的RowUpdating事件在ObjectDataSource的Updating事件之后触发，此时update命令发送到ObjectDataSource的隐含对象。完成了此操作，在GridView的RowUpdated事件之后，触发ObjectDataSource的Updated事件。

我们可以为这些发生在操作之前的事件创建事件处理程序，目的是自定义输入参数；为发生在

操作之后的事件创建事件处理，目的是检测和相应操作的结果。Post-level的事件处理程序通常用作侦测在操作过程中是否出现了一个异常。当面对一个异常时，这些post-level的事件处理程序可以随意地处理该异常。在本节里我们看过了如何处理这样的一个异常，显示一个友好的错误提示信息。

在下一节里我们将看看如何降低因数据格式的问题引起异常的可能性（例如在UnitPrice输入一个负数）。特别地，我们将看看如何添加validation控件到编辑和插入界面。

祝编程快乐！

作者简介

评论: 25　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库