博客园_冠军

装箱拆箱与对象的比较

2012-02-07T14:23:00Z

看到这样的一道面试题：

int  i = 10;
object obj = i;
int j = (int) obj;

分析一下程序执行中的内存处理。

首先，我们可以看到这段程序定义了三个局部变量，局部变量将被定义在栈中，第一个变量比较简单，由于 i 是整形变量，所以变量 i 的值直接被保存在堆栈中。

而第二行对 obj 的赋值要复杂一点点，由于 obj 的类型是 object 类型，这是引用类型，所以，在堆栈中保存的必须是一个对象的引用，而不能是一个值，此时，会发生著名的装箱，CLR 会在堆中创建一个对象，在这个对象中保存变量 i 的值，并且，还会同时保存这个值的类型，这里是整数类型。此时，在内存中将会存在两个 10，一个保存在栈中，一个保存在堆中。

有的人认为此时堆中对象中保存的值就是引用堆栈中 j 的值，这个问题我们可以验证一下，如果是这样的话，我们修改 i 的值，那么 obj 应该也会同时发生变化。我们可以在第二行之后增加两行检查一下i。

i = 99;
Console.WriteLine( obj );

你可以看一看 obj 是否发生了变化。

第三行执行的时候，将一个引用类型的对象赋予一个值类型的变量 j，这时，会发生另外一个著名的事件：拆箱，CLR 会检查拆箱的类型是否匹配，然后从堆的对象中读取保存在其中的值，将这个值保存到位于堆栈中的变量 j 中。至此，在内存中已经存在了三个 10，两个在堆栈中，一个在堆中。如图所示：

如果我们为上面的程序再增加一行：

object obj2 = i;

那么，又会发生什么情况呢？

有的人认为在堆中其实还是第二行中装箱的对象，此时的 obj2 引用的也是这个对象，内存中的结构如下所示：

验证这个问题稍微复杂了一点，因为我们不能为 obj 赋值，赋值的话就是另外一个对象。而这个装箱的对象也没有什么方法让我们在不改变对象的情况下仅仅修改其中的值。

不过，我们还是有办法来检查它们是否为同一个对象的。

首先，我们可以考虑对象的 HashCode，在 Object 基类上定义了 GetHashCode 方法，可以返回对象的 Hash 码，通常我们可以通过比较对象的 HashCode 来判断引用的是否为同一个对象。那么，我们可以使用下面的语句来检查一下。

Console.WriteLine( obj.GetHashCode() );
Console.WriteLine( obj2.GetHashCode() );

不过，很不幸的是，你会看到输出了两次 10，那么，它们是同一个对象吗？我们还不能这么说。

HashCode 的用途主要用在对象作为字典的键的时候，用来判断键是否相同，但是，有的时候，对于不同的对象我们也希望他们看作同样的键，因此这个 GetHashCode 方法实际上是虚方法，是可以被类型重写掉的。在整数类型中，这个方法已经被重写掉了，所以，你会看到具有同样值得整数返回的 HashCode 是相同的。

比如，你有两张 10 元的人民币，这两张人民币显然不是同一张，但是，他们的票面价格是相同的，无论你用那一张存到银行中，银行都会为你记下 10 元的存款，这称为值相等，也就是价值相同。Object 基类还定义了方法 Equals ，这个 Equals 方法就是用来判断值相等的。所以，在重写了 GetHashCode 方法之后，你应该也重写一下 Equals 方法，以保证值相等的比较。

回到我们的问题，我们显然需要判断的不是值相等，还有什么方法吗？有，Object 基类还有一个静态方法 ReferenceEquls，专门用来比较两个对象是否其实是同一个对象实例，这称为引用相等。因此，下面的代码可以轻易地用来完成这个任务。

Console.WriteLine( Object.ReferenceEquals( obj, obj2 ) );

问题进行到这里，已经基本完成了。不过，CLR 又是怎么知道这两个对象是否为同一个对象的呢？在系统内部，每个对象在应用程序域中一旦诞生，CLR 都会赋予一个唯一的 HashCode ，虽然我们可以重写 GetHashCode，但是，这个内部的 HashCode 还是存在的，定义在命名空间 System.Runtime.ComilerServices 命名空间中的类 RuntimeHelpers 助手类就可以帮助我们解决这个问题，它的静态方法 GetHashCode 可以接受一个对象的引用，返回这个对象底层的 HashCode。

使用下面的代码，我们可以看到两个对象的 HashCode 真的是不同的。

Console.WriteLine(System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj));
Console.WriteLine(System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj2));

实际的内存结构应该如下：

完整的代码如下所示：

int i = 10;
object obj = i;
int j = (int)obj;
object obj2 = i;

Console.WriteLine(obj.GetHashCode());
Console.WriteLine(obj2.GetHashCode());

Console.WriteLine(Object.ReferenceEquals(obj, obj2));
Console.WriteLine(System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj));
Console.WriteLine(System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj2));

本文链接

转载：搭建Silverlight 5中文开发环境

2012-01-29T08:19:00Z

原文地址：http://social.msdn.microsoft.com/Forums/zh-CN/silverlightzhchs/thread/25d7a00f-7f08-4630-a6e7-002edd2877c7

注：我参考原文配置了 Silverlight 的开发环境，但是原文的图片不能显示了，这里转载一下，顺便配上图片。

Silverlight 5已于美国时间2011年12月9日正式发布，其在 Silverlight 4 的基础上新增了 40 多个新功能，完善了媒体支持并提供了更加丰富了用户界面。这个版本带来了很多改进，大家可以通过官方列表了解详情，或者点击此网页查看来自Pete Brown的多个视频介绍。

下面是对Silverlight 5新增功能的简要总结：

强数据绑定功能，包括上级绑定、隐式数据模板、自定义标签扩展等
新增3D图形类库，主要引入轻量级XNA 3D功能，该框架目前是XBOX游戏的主要开发框架，这也使得3D图形可以轻松地在Web网页中呈现
改进多媒体功能，包括使用XNA的声效库、支持H.264媒体硬件解码、变速播放、遥控器的按键支持（主要针对Live TV）等
增强文本功能，包括文本清晰度优化、文本块间漂移、矢量打印等
新增与操作系统的集成，包括支持P/Invoke调用外部程序、多窗体、在完全信任模式下无限制的文件系统访问、支持SaveFileDialog和OpenFileDialog的默认文件名、64位浏览器支持等
优化整体性能，包括网络延迟的改进、使用TPL并行任务、解析器的性能改进、为改善启动时间的多核心JIT等
增强控件，包括双击与多击的支持、加入PivotViewer、ComboBox增强等
提高开发效率，包括XAML调试与数据绑定调试、团队测试的支持等

现在，Silverlight开发者可以点击下载正式版Silverlight 5 Tools和Silverlight 5 Toolkit（12月版）。可惜的是目前官方只发布了英文版开发包，按照惯例中文版一般要等到3-5个月之后才会发布，如果您使用的Visual Studio 2010是中文版，在安装时会出现语言不符的提示，但我们有办法将英文版开发包安装到中文开发环境中。下面是如何搭建Silverlight 5中文开发环境的具体步骤：

1.首先确认您的Visual Studio 2010已经升级到SP1

2.解压下载下来的Silverlight5_Tools.exe(winrar 或者7-zip均可);

3.在解压后的目录中，打开ParameterInfo.xml，替换所有1033为2052，保存;

4.运行同目录下SPInstaller.exe 安装Silverlight5 Tools;

5.通常装完后,在VS中新建项目仍然不能使用Silverlight5,提示需要安装Silverlight4 Tools，此时需要修改注册表，在HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\10.0\Setup\VS\BuildNumber下，将 "2052" 的值修改为 "10.0.30319"，然后安装Silverlight 4 Tools中文版程序（可以到这里下载）;

不过，在我这里，安装完成之后就已经没有问题了。

6.安装完Silverlight 4 Tools后,将上述注册表中中修改的 “2052”值还原为“10.0.40219”。

通常如果您需要设计Silverlight应用，还需要使用Blend来进行界面设计，对应Silverlight5的版本请点击这里下载。现在，我们就可以尽情体验Silverlight 5给我们带来的新特性了。

笔者在新书中精心制作了Silverlight 5的新功能示例，大家可以点击此示例网页来体验。

注意：部分示例需要安装后才能查看，对于3D示例需要在Silverlight右键的“权限”选项卡中允许3D显示，如下图。

本文链接

DOM 中的事件处理

2012-01-17T14:46:00Z

根据 W3C DOM 2 Events 描述，EventTarget 接口被所有支持 DOM 事件模型的节点（Node）实现。该接口提供了 'addEventListener' 和 'removeEventListener' 方法，用来绑定或解绑一个 EventListeners 接口到一个 EventTarget。

DOM 2 Events 中定义了 Event 接口，用来提供事件的上下文信息，它提供了若干标准属性和方法。实现 Event 接口的对象一般作为第一个参数传入事件处理函数，以用来提供当前事件相关的一些信息。

事件注册

根据 DOM 2 Events 中描述，节点使用 'addEventListener' 和 'removeEventListener' 方法绑定和解绑事件监听器，但 IE6 IE7 IE8 不支持这两个方法，而使用 'attachEvent' 和 'detachEvent' 方法作为替代方案，Opera 两类方法都支持。Chrome Safari Firefox 只支持标准方法。

为了解决浏览器兼容问题，可以自定义函数来解决。例如：

var EventUtil = {
    addHandler: function (element, type, handler) {
        if (element.addEventListener) {
            element.addEventListener(type, handler, false);
        } else if (element.attachEvent) {
            element.attachEvent("on" + type, handler);
        } else {
            element["on" + type] = handler;
        }
    },
    removeHandler: function (element, type, handler) {
        if (element.removeEventListener) {
            element.removeEventListener(type, handler, false);
        } else if (element.detachEvent) {
            element.detachEvent("on" + type, handler);
        } else {
            element["on" + type] = null;
        }
    }
};

关于 'addEventListener' 和 'attachEvent' 有几点需要注意：

IE 不支持在捕获阶段触发事件监听器，'attachEvent' 方法没有提供参数说明是否响应在捕获阶段触发的事件；
'addEventListener' 和 'attachEvent' 都可以注册多个事件监听器；
在 Firefox Chrome Safari Opera 中给同一事件注册同一个事件监听器多次，重复注册的会被丢弃；而在 IE 中重复注册的事件监听器会被重复执行多次；
当给同一元素注册了多个事件监听器的时候，IE6 IE7 的事件监听器执行顺序是随机的，IE8 是倒序的，Firefox Chrome Safari Opera 是顺序的；
当元素注册的事件监听器中有非法的事件监听器时（非函数），在 IE Firefox 中会抛出异常，而在 Chrome Safari Opera 中则会忽略非法的事件监听器，继续执行其他的事件监听器。

事件对象

在ie中，事件对象是作为一个全局变量来保存和维护的。所有的浏览器事件,不管是用户触发的，还是其他事件，都会更新window.event 对象。所以在代码中，只要轻松调用 window.event 就可以轻松获取事件对象，再 event.srcElement 就可以取得触发事件的元素进行进一步处理。

对于标准的 DOM 处理来说，事件对象却不是全局对象，一般情况下，是现场发生，现场使用，把事件对象自动传递给对应的事件处理函数。在代码中，函数的第一个参数就是事件对象了。

为了解决兼容性问题，通常在代码中如下处理：

function handler(e){
  e = e || window.event;
}

需要注意的是，使用 <button id="btn" onclick="foo()">按钮1</button> 进行事件注册，标准方式下却不能在事件处理方法中取得事件对象。

原因是　onclick="foo()" 就是直接执行了， foo() 函数,没有任何参数传递给 foo 函数。

有两个办法解决这个问题。

第一，将注册的方法修改为 <button id="btn" onclick="foo(event)">按钮</button>，注意，这里的 event 不是形参，而是实参，必须名为 event。这样 foo 函数就可以得到事件参数了。

第二，不修改注册的代码，在事件处理方法上进行处理。关键在于此时实际上存在事件对象，只不过没有传递给 foo 函数罢了，我们可以找到调用 foo 函数的那个函数，当然这是一个系统函数，没有关系，通过 foo.caller 可以取得当前调用 foo 函数的函数，这个函数的第一个参数就是事件对象，所以，我们可以这样取得这个事件对象了。foo.caller.arguments[0]。

注意：

只有在使用 attachEvent 方法注册事件监听器的时候，IE 才支持使用事件监听器传入的第一个参数作为事件对象的方式；
Chrome Safari Opera 两种获取事件对象的方式都支持；
Firefox 只支持获取事件对象的标准方式。

事件对象的属性

IE 对事件对象的标准属性和方法支持有限，针对大部分属性和方法，IE 都提供了一套替代非标准的替代方案；而 Firefox Chrome Safari Opera 除了全面支持事件对象的标准属性和方法外，还在不同程度上支持了 IE 提供的非标准替代方案。

使用特性判断使用与标准对应的非标准方法及属性

target　　　　　　　　　　srcElement

preventDefault()　　　　　returnValue

stopPropagation()　　　　cancelBubble

relatedTarget　　　　　　fromElement toElement

例如：

getEvent: function (event) {
    return event ? event : window.event;
},
getTarget: function (event) {
    return event.target || event.srcElement;
},
preventDefault: function (event) {
    if (event.preventDefault) {
        event.preventDefault();
    } else {
        event.returnValue = false;
    }
},
stopPropagation: function (event) {
    if (event.stopPropagation) {
        event.stopPropagation();
    } else {
        event.cancelBubble = true;
    }
}

参考资料：

SD9011: 事件模型在各浏览器中存在差异

本文链接

在 jQuery 中与 WCF 传递日期类型的参数

2011-12-15T12:47:00Z

通过 WCF 与页面进行 Ajax 进行数据传递非常方便，可以，遇到日期类型就不同了。

WCF 通过 JavaScriptSerializer 将日期格式化为特殊的格式：\/Date(1318287600+0100)\/，实际上传递到页面上的是一个字符串。而不是真正的 JavaScript 日期。

同样，当浏览器想要向服务器传递日期类型的数据时也必须通过这种特殊的字符串来提供数据。

为了解决这个问题，可以使用下面的方法为 jQuery 扩展一个数据转换的方法。

// 为 jQuery 扩展一个解析 wcf 日期的方法
jQuery.extend(
            {
                wcfDate2JsDate: function (wcfDate) {
                    var date = new Date(parseInt(wcfDate.substring(6)));
                    return date;
                },
                jsDate2WcfDate: function (jsDate) {
                    // \/Date(568310400000+0800)\/
                    return "\/Date(" + jsDate.getTime() + "+0000)\/";
                }
            }
        );

在页面中引用 jQuery 脚本文件之后，加入这段脚本即可。

可以如下方式来使用：

var d = new Date();      // 标准的 JavaScript 日期数据
alert(d);

var wcf = $.jsDate2WcfDate(d);    // 转换为 WCF 日期格式
alert(wcf);

alert($.wcfDate2JsDate(wcf));       // WCF 日期格式转化为 JavaScript 日期格式

当然，可以将这段脚本保存在一个文件中，以后在页面中直接引用即可。

下载脚本文件

本文链接

jQuery 中使用 JSON

2011-12-01T11:38:00Z

JSON 格式

json 是 Ajax 中使用频率最高的数据格式，在浏览器和服务器中之间的通讯可离不开它。

JSON 的格式说明可以在可以这里看到，非常详细，还是中文的。

JSON 格式说明

需要特别注意的是，在 JSON 中的属性名是需要使用引号引起来的。

jQuery 中使用 JSON

jQuery 是现在使用广泛的脚本库，那么，在 jQuery 中如何使用 JSON 呢？

解析 JSON

在 jQuery 中已经提供了对于解析 JSON 的内在支持，

jQuery.parseJSON 函数提供了解析的支持，详细的说明见这里。

var obj = jQuery.parseJSON('{"name":"John"}');  
alert( obj.name === "John" );

使用对象生成 JSON 格式串

在 jQuery 中并没有提供直接将普通的 JavaScript 对象转换为 JSON 串的方法，可以使用下面的扩展库来完成。

jquery-json 扩展库

这个库用来扩展 jQuery ，对于 JSON 的使用，扩展了两个方法。

toJSON 方法用来将一个普通的 JavaScript 对象序列化为 JSON 串。

var thing = {plugin: 'jquery-json', version: 2.3};    
var encoded = $.toJSON( thing ); // '{"plugin":"jquery-json","version":2.3}'

evalJSON 方法将一个 JSON 串解析为一个普通的 JavaScript 对象。

var thing = {plugin: 'jquery-json', version: 2.3};    
var encoded = $.toJSON( thing ); // '{"plugin":"jquery-json","version":2.3}'   
var name = $.evalJSON( encoded ).plugin; // "jquery-json"   
var version = $.evalJSON(encoded).version; // 2.3

这个扩展的下载地址：http://code.google.com/p/jquery-json/

使用 jQuery 配合 WCF

客户端

jQuery 中的 $.post 可以直接向服务器发出请求，将服务器返回的数据按照 JSON 方式进行解析，不过，需要注意下面几点：

请求的内容类型必须为 json 格式，这可以通过上面的 jQuery-json 扩展库来完成，需要特别注意的在请求的 contentType 也必须使用 text/json 进行说明，默认的 post 使用普通的名值对方式请求，因此 contentType 是： application/x-www-form-urlencoded，可以通过 $.ajaxSetup 来进行设置：

// Ajax 设置  
$.ajaxSetup({ contentType: 'text/json' });

这样，请求的内容类型就设置为需要的类型。

其次，实际的请求内容必须使用 JSON 方式，这可以通过扩展库的 $.toJSON 来实现，例如：

$.toJSON({ x: 2, y: 3 })

这样，如果服务器端提供了一个服务方法 Sum，定义如下：

public int Sum(int x, int y)  
{  
    return x + y;  
}

就可以如下调用了。注意，WCF 返回的数据在属性 d 中。

// Ajax 设置  
$.ajaxSetup({ contentType: 'text/json' });  

$("#wcfBtn").click(function () {  
    $.post("Service1.svc/Sum", $.toJSON({ x: 2, y: 3 }), function (data) {  
        alert(data.d);  
    });  
});

服务器端的配置

首先，为服务增加标签：[System.ServiceModel.Activation.AspNetCompatibilityRequirements(
RequirementsMode = System.ServiceModel.Activation.AspNetCompatibilityRequirementsMode.Allowed)]

// #1  
// 为了在脚本中使用,必须增加这个标签  
[System.ServiceModel.Activation.AspNetCompatibilityRequirements( 
    RequirementsMode = System.ServiceModel.Activation.AspNetCompatibilityRequirementsMode.Allowed)]  

// #2  
// 在网站的配置文件中也需要进行设定  
public class Service1 : IService1  
{  
    public int Sum(int x, int y)  
    {  
        return x + y;  
    }  
}

然后，在网站的配置文件中，如下配置。

<system.serviceModel>  
  <!-- 为了支持在浏览器端调用 WCF 服务的特定配置 -->  
  <serviceHostingEnvironment aspNetCompatibilityEnabled="true">  
    <serviceActivations>  

      <!-- relativeAddress 服务的地址  
           service 实现服务的类型，全名，包含命名空间，甚至程序集  
           factory 是 WCF 系统提供，直接使用  
      -->  

      <add relativeAddress="Service1.svc" service="MServer.Service1"  factory="System.ServiceModel.Activation.WebScriptServiceHostFactory"   
           />  
    </serviceActivations>  
  </serviceHostingEnvironment>  

    <behaviors>  
        <serviceBehaviors>  
            <behavior name="">  
                <serviceMetadata httpGetEnabled="true" />  
                <serviceDebug includeExceptionDetailInFaults="false" />  
            </behavior>  
        </serviceBehaviors>  
    </behaviors>  
</system.serviceModel>

本文链接

ASP.NET MVC 音乐商店 - 目录

2011-11-23T14:50:00Z

这一个系列的内容来自微软的音乐商店 Music Store, 这是项目在 Codeplex 上的地址：http://mvcmusicstore.codeplex.com/。

这个项目使用 ASP.NET MVC3 完成，项目中除了提供完整的示例代码之外，还提供一个 100 多页的说明文档，这里的内容就翻译自这篇文档。

在我学习这个项目的过程中，发现有一些地方与文档并不完全一致，项目中也引入了一些新的软件，在第一次使用的时候会比较陌生，因此，将整个项目使用中文 VS2010 重新完成一遍，将原文的界面全部替换为使用中文 VS2010 操作的界面，这样对大家可能会有一些帮助。

ASP.NET MVC 音乐商店 - 0 概览

ASP.NET MVC 音乐商店 - 1 创建项目

ASP.NET MVC 音乐商店 - 2.控制器

ASP.NET MVC 音乐商店 - 3. 视图与模型

ASP.NET MVC 音乐商店 - 4. 数据访问

ASP.NET MVC 音乐商店 - 5. 通过支架创建编辑表单

ASP.NET MVC 音乐商店 - 5 通过支架创建编辑表单续

ASP.NET MVC 音乐商店 - 6. 使用 DataAnnotations 进行模型验证

ASP.NET MVC 音乐商店 - 7.成员管理和授权

ASP.NET MVC 音乐商店 - 8. 使用 Ajax 更新的购物车

ASP.NET MVC 音乐商店 - 9. 注册和结账

ASP.NET MVC 音乐商店 - 10. 完成导航和站点的设计

除了上述的资料之外，还需要你已经安装了 VS2010 ，这里系列我们将使用中文版，这样更加方便一些，另外，你当然要安装 ASP.NET MVC3 的插件了，

首先是 ASP.NET MVC 3 RTM ，下载地址：http://www.microsoft.com/downloads/zh-cn/details.aspx?familyid=d2928bc1-f48c-4e95-a064-2a455a22c8f6&displaylang=zh-cn

然后，为了更加高效地开发 MVC3 ，还需要安装一个更新：ASP.NET MVC 3 RTM Tools Update ，下载地址：http://www.microsoft.com/downloads/zh-cn/details.aspx?FamilyID=82CBD599-D29A-43E3-B78B-0F863D22811A

本文链接

ASP.NET MVC 音乐商店 - 10. 完成导航和站点的设计

2011-11-21T11:32:00Z

我们已经完成了网站的大部分工作，但是，还有一些添加到站点的导航功能，主页，以及商店的浏览页面。

创建购物车汇总部分视图

我们希望在整个站点的页面上都可以看到购物车中的数量。

通过创建一个部分视图，然后添加到网站的布局中就可以容易地完成，

前面看到，在 ShoppingCart 控制器中包含了一个名为 CartSummary 的 Action 方法返回分部视图。

//
// GET: /ShoppingCart/CartSummary
[ChildActionOnly]
public ActionResult CartSummary()
{
    var cart = ShoppingCart.GetCart(this.HttpContext);
    ViewData["CartCount"] = cart.GetCount();
    return PartialView("CartSummary");
}

在这个 Action 方法上点击鼠标右键，或者在 Views/ShoppingCart 文件夹夹上点击鼠标右键，选择创建新视图，命名为 CartSummary ，注意选中创建分部视图的复选框。

CartSummary 分部视图非常简单，仅仅链接到 ShoppingCart 的 Index ，显示当前购物车中的数量，完整的代码如下：

@Html.ActionLink("Cart (" + ViewData["CartCount"] + ")", "Index", "ShoppingCart", new { id = "cart-status" })

在网站的任何页面中都可以包含分部视图，使用 Html.RenderAction 方法就可以。RenderAction 需要指定 Action 的名字，这里是 CartSummary，以及控制器的名字，这里是 ShoppingCart。

@Html.RenderAction("CartSummary", "ShoppingCart")

在将这个分部视图加入到布局之前，我们还要创建一个流派的菜单，这样我们可以一次更新完站点的 Site.master。

创建流派菜单的分部视图

通过在页面上增加一个流派的菜单，可以是用户在站点内导航的时候更加容易。

我们可以使用类似前面的步骤来创建流派菜单的分部视图，把两个分部视图一起添加到站点的布局中，首先，在 StoreController 中增加 GenreMenu 的控制器方法。

//
// GET: /Store/GenreMenu
[ChildActionOnly]
public ActionResult GenreMenu()
{
    var genres = storeDB.Genres.ToList();
    return PartialView(genres);
}

这个方法返回流派的列表，在后面创建的视图中用来生成菜单。

注意：在 Action 方法上我们增加了 [ChildActionOnly] 标注，这意味着我们仅仅可以通过分部视图来访问这个 Action，这可以防止通过浏览 /Store/GenreMenu 来访问，对于分部视图来说，这不是必须的，但是一个很好的实践，因为我们希望我们的控制器方法被我们希望的方式使用，这里我们还返回了一个分部视图而不是一个普通的视图，这用来告诉视图引擎，不需要对这个视图使用布局，它将会被包含在其他的视图中。

创建分部视图，使用强类型的 Genre 作为模型类型。使用 List 模板。

更新生成的视图，显示一个列表。

@model IEnumerable<MvcMusicStore.Models.Genre>
<ul id="categories">
    @foreach (var genre in Model)
    { <li>@Html.ActionLink(genre.Name,
            "Browse", "Store",
            new { Genre = genre.Name }, null)
    </li>
    }
</ul>

更新站点的布局显示我们的分部视图

现在，可以在布局中加入分部视图了，在 /Views/Shared/_Layout.cshtml 中通过调用 Html.RenaderAction() 方法可以调用分部视图，把两个分部视图都加入到布局中，如下所示：

<!DOCTYPE html>
<html>
<head>
    <title>@ViewBag.Title</title>
    <link href="@Url.Content("~/Content/Site.css")" rel="stylesheet"
type="text/css" />
    <script src="@Url.Content("~/Scripts/jquery-1.4.4.min.js")"
type="text/javascript"></script>
</head>
<body>
    <div id="header">
        <h1>
            <a href="/">ASP.NET MVC MUSIC STORE</a></h1>
        <ul id="navlist">
            <li class="first"><a href="@Url.Content("~")" id="current">Home</a></li>
            <li><a href="@Url.Content("~/Store/")">Store</a></li>
            <li>
                @{Html.RenderAction("CartSummary", "ShoppingCart");}
            </li>
            <li><a href="@Url.Content("~/StoreManager/")">Admin</a></li>
        </ul>
    </div>
    @{Html.RenderAction("GenreMenu", "Store");}
    <div id="main">
        @RenderBody()
    </div>
    <div id="footer">
        built with <a href="http://asp.net/mvc">ASP.NET MVC 3</a>
    </div>
</body>
</html>

更新 Store 的 Browse 页面

商店的浏览页面现在看来还不太好，我们更新这个页面在一个更好地布局中显示专辑，如下更新我们的视图。

@model MvcMusicStore.Models.Genre 
@{ ViewBag.Title = "Browse Albums"; }
<div class="genre">
    <h3>
        <em>@Model.Name</em> Albums</h3>

    <ul id="album-list">
        @foreach (var album in Model.Albums)
        { <li><a href="@Url.Action("Details", new { id = album.AlbumId })">
            <img alt="@album.Title" src="@album.AlbumArtUrl" />
            <span>@album.Title</span> </a></li> }
    </ul>
</div>

这里，我们将使用 Url.Action 来代替 Html.ActionLink ，以便显示格式化信息，包括艺术家的插画。

注意：我们显示专辑的封面，这些信息保存在数据中，可以通过 StoreManager 进行编辑，也欢迎你加入你的插图。

现在，当我们浏览流派的时候，我们将会看到带有封面的专辑显示在一个网格中。

更新主页来显示畅销专辑

我们希望在首页上增加畅销专辑来增进销售，我们在 HomeController 中增加一下内容来实现，然后增加一些额外的图片来变得更好。

首先，在我们的专辑中增加一个导航属性，以便与 EF 知道关联的的信息。专辑中最后的一行就是新增加的。

public virtual Genre Genre { get; set; }
        public virtual Artist Artist { get; set; }
        public virtual List<OrderDetail> OrderDetails { get; set; }

注意：这里使用了泛型的集合，需要在代码的前面使用 using 来引用 System.Collections.Generic 命名空间。

首先，我们将要增加 storeDB 的字段和引用 MusicStore.Models 命名空间，类似于其他的控制器。

然后，我们在 HomeController 中增加下面的方法，来查询数据库根据 OrderDetails 找到畅销的唱片。

private List<Album> GetTopSellingAlbums(int count)
{
    // Group the order details by album and return
    // the albums with the highest count
    return storeDB.Albums
    .OrderByDescending(a => a.OrderDetails.Count())
    .Take(count)
    .ToList();
}

这是私有方法，因为我们不希望直接可以访问到，这里为了简单将它写在了 HomeController 中，实际开发的时候，可能需要移到后台的逻辑服务中。

这里，我们更新 Index 来访问前面定义的方法，查询销售前 5 名的专辑，然后将他们传递到视图中。

public ActionResult Index()
{
    // Get most popular albums
    var albums = GetTopSellingAlbums(5);
    return View(albums);
}

完整的代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

using MvcMusicStore.Models;

namespace MvcMusicStore.Controllers
{
    public class HomeController : Controller
    {
        private Models.MusicStoreEntities storeDB = new Models.MusicStoreEntities();
        //
        // GET: /Home/

        public ActionResult Index()
        {
            // Get most popular albums
            var albums = GetTopSellingAlbums(5);
            return View(albums);
        }

        private List<Album> GetTopSellingAlbums(int count)
        {
            // Group the order details by album and return
            // the albums with the highest count
            return storeDB.Albums
            .OrderByDescending(a => a.OrderDetails.Count())
            .Take(count)
            .ToList();
        }
    }
}

最后，我们需要更新我们的 Home 控制器的 Index 视图，访问模型在后面加入专辑的列表，借助这个时机，我们还要增加一个标头和一个促销的节。

@model List<MvcMusicStore.Models.Album> 
@{
    ViewBag.Title = "ASP.NET MVC Music Store"; 
}
<div id="promotion">
</div>
<h3>
    <em>Fresh</em> off the grill</h3>
<ul id="album-list">
    @foreach (var album in Model)
    { <li><a href="@Url.Action("Details", "Store",
new { id = album.AlbumId })">
        <img alt="@album.Title" src="@album.AlbumArtUrl" />
        <span>@album.Title</span> </a></li>
    }
</ul>

现在，当运行程序的时候，我们将会看到更新后的主页，带有畅销的专辑和我们的促销信息。

本文链接

ASP.NET MVC 音乐商店 - 9. 注册和结账

2011-11-20T15:24:00Z

在这一节，我们将创建结账的控制器 CheckoutController 来收集用户的地址和付款信息，我们需要用户在结账前注册账户，因为这个控制器需要授权。

当用户点击结账 Checkout 按钮的时候，用户将会被导航到结账的处理流程中。

如果用户没有登录，将会被提示需要登录。

一旦用户成功登陆，用户就可以看到地址和付款的视图。

一旦用户填写了这个表单并提交，他们将会看到订单的确认页面。

视图访问不存在的订单，或者不属于你的订单，将会看到错误页面。

合并购物车

在匿名购物的时候，当用户点击结账 Checkout 按钮，用户会被要求注册和登陆，用户会希望继续使用原来的购物车，所以，在匿名用户登录之后，我们需要维护购物车。

实际上非常简单，因为 ShoppingCart 类已经提供了一个方法，通过当前的用户名来获取购物车中所有的项目，在用户注册登录以后，我们只需要调用这个方法。

打开在成员管理和授权中添加的 AccountController 类，增加一个 using 来引用 MvcMusicStore.Models，然后，增加 MigrateShoppingCart 方法。

private void MigrateShoppingCart(string UserName)
{
    // Associate shopping cart items with logged-in user
    var cart = ShoppingCart.GetCart(this.HttpContext);
    cart.MigrateCart(UserName);
    Session[ShoppingCart.CartSessionKey] = UserName;
}

然后，修改 LonOn 的 Post 处理方法，在用户通过验证之后，调用 MigrateShoppingCart 方法。

//
// POST: /Account/LogOn
[HttpPost]
public ActionResult LogOn(LogOnModel model, string returnUrl)
{
    if (ModelState.IsValid)
    {
        if (Membership.ValidateUser(model.UserName, model.Password))
        {
            MigrateShoppingCart(model.UserName);
            FormsAuthentication.SetAuthCookie(model.UserName, model.RememberMe);
            if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/")
            && !returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
            {
                return Redirect(returnUrl);
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }
        }
        else
        {
            ModelState.AddModelError("", "The user name or password provided is incorrect.");
        }
    }
    // If we got this far, something failed, redisplay form
    return View(model);
}

在 Register 的 Post 处理方法中，一旦用户成功创建帐户，也进行类似的修改，

//
// POST: /Account/Register
[HttpPost]
public ActionResult Register(RegisterModel model)
{
    if (ModelState.IsValid)
    {
        // Attempt to register the user
        MembershipCreateStatus createStatus;
        Membership.CreateUser(model.UserName, model.Password, model.Email, "question", "answer", true, null, out createStatus);
        if (createStatus == MembershipCreateStatus.Success)
        {
            MigrateShoppingCart(model.UserName);
            FormsAuthentication.SetAuthCookie(model.UserName, false /* createPersistentCookie */);
            return RedirectToAction("Index", "Home");
        }
        else
        {
            ModelState.AddModelError("", ErrorCodeToString(createStatus));
        }
    }
    // If we got this far, something failed, redisplay form
    return View(model);
}

就这样，现在匿名用户登录之后，购物车将会被自动传送过来。

创建结账 CheckoutController 控制器

在 Controller 文件夹上右键，添加一个新的控制器，命名为 CheckoutController ，使用空的控制器模板。

首先，在控制器上增加授权的标注 [Authorize]，来确定用户必须在登录之后才能访问。

namespace MvcMusicStore.Controllers
{
   [Authorize]
   public class CheckoutController : Controller

注意：这一步很像我们前面在 StoreManager 控制器上的工作，但是，在那个时候，我们要求用户必须拥有 Administrator 的角色。在结账控制器中，我们不需要用户必须是 Administrator ，而是必须登录。

出于简化的考虑，在这个教程中没有处理付款的信息，作为替代，我们允许用户输入一个促销代码，这里促销代码定义在常量 PromoCode。

像在 StoreController 中一样，在控制器中，我们也需要定义 MusicStoreEntities 的字段，将它命名为 storeDB，结账的开始部分如下。

using MvcMusicStore.Models;

namespace MvcMusicStore.Controllers
{
    [Authorize]
    public class CheckoutController : Controller
    {
        MusicStoreEntities storeDB = new MusicStoreEntities();
        const string PromoCode = "FREE";

结账的控制器将包含下面的控制器方法：

AddressAndPayment ( Get ) 用来显示一个用户输入信息的表单

AddressAndPayment ( Post ) 验证用户的输入，处理订单。

Complete 用来在在用户完成订单之后显示，这个视图包含用户的订单账号和确认信息。

首先，将 Index 方法改名为 AddressAndPayment，这个 Action 方法用来显示结账表单，所以，不需要任何的模型信息。

//
// GET: /Checkout/AddressAndPayment
public ActionResult AddressAndPayment()
{
    return View();
}

AddressAndPayment 的 Post 处理方法使用我们在 StoreManagerController 中类似的模式：如果成功了就完成订单，如果失败了就重新显示表单。

在验证了表单之后，我们将会直接检查促销代码，假设所有的信息都是正确的，我们将会在订单中保存信息，告诉购物车对象完成订单处理，最后，重定向到完成的 Complete Action 方法。

[HttpPost]
public ActionResult AddressAndPayment(FormCollection values)
{
    var order = new Order();
    TryUpdateModel(order);
    try
    {
        if (string.Equals(values["PromoCode"], PromoCode,
        StringComparison.OrdinalIgnoreCase) == false)
        {
            return View(order);
        }
        else
        {
            order.Username = User.Identity.Name;
            order.OrderDate = DateTime.Now;
            //Save Order
            storeDB.Orders.Add(order);
            storeDB.SaveChanges();
            //Process the order
            var cart = ShoppingCart.GetCart(this.HttpContext);
            cart.CreateOrder(order);
            return RedirectToAction("Complete",
            new { id = order.OrderId });
        }
    }
    catch
    {
        //Invalid - redisplay with errors
        return View(order);
    }
}

一旦完成了结账处理，用户将被重定向到 Complete 方法，这个 Action 方法将会进行简单的检查，在显示订单号之前，检查订单是否属于当前登录的用户。

//
// GET: /Checkout/Complete
public ActionResult Complete(int id)
{
    // Validate customer owns this order
    bool isValid = storeDB.Orders.Any(
    o => o.OrderId == id &&
    o.Username == User.Identity.Name);
    if (isValid)
    {
        return View(id);
    }
    else
    {
        return View("Error");
    }
}

注意，错误视图创建项目的时候，保存在 /Views/Shared 文件夹中的 error.cshtml 生成。

完整的 CheckoutController 如下所示.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

using MvcMusicStore.Models;

namespace MvcMusicStore.Controllers
{
    [Authorize]
    public class CheckoutController : Controller
    {
        MusicStoreEntities storeDB = new MusicStoreEntities();
        const string PromoCode = "FREE";

        //
        // GET: /Checkout/AddressAndPayment
        public ActionResult AddressAndPayment()
        {
            return View();
        }

        [HttpPost]
        public ActionResult AddressAndPayment(FormCollection values)
        {
            var order = new Order();
            TryUpdateModel(order);
            try
            {
                if (string.Equals(values["PromoCode"], PromoCode,
                StringComparison.OrdinalIgnoreCase) == false)
                {
                    return View(order);
                }
                else
                {
                    order.Username = User.Identity.Name;
                    order.OrderDate = DateTime.Now;
                    //Save Order
                    storeDB.Orders.Add(order);
                    storeDB.SaveChanges();
                    //Process the order
                    var cart = ShoppingCart.GetCart(this.HttpContext);
                    cart.CreateOrder(order);
                    return RedirectToAction("Complete",
                    new { id = order.OrderId });
                }
            }
            catch
            {
                //Invalid - redisplay with errors
                return View(order);
            }
        }

        //
        // GET: /Checkout/Complete
        public ActionResult Complete(int id)
        {
            // Validate customer owns this order
            bool isValid = storeDB.Orders.Any(
            o => o.OrderId == id &&
            o.Username == User.Identity.Name);
            if (isValid)
            {
                return View(id);
            }
            else
            {
                return View("Error");
            }
        }
    }
}

增加 AddressAndPayment 视图

现在，我们创建 AddressAndPayment 视图，在 AddressAndPayment 控制器的某个 Action 中点击鼠标的右键，增加名为 AddressAndPayment 的强类型 Order 视图，使用编辑模板。

这个视图使用我们在 StoreManager 的 Edit 视图中使用的两个技术：

1.使用 Html.EditorForModel() 来显示订单模型的字段

2.使用 Order 模型的验证标签定义验证规则

我们先使用 Html.EditorForModel() 方法，然后，增加额外的输入框用来输入促销码，完成的视图如下。

@model MvcMusicStore.Models.Order
@{
    ViewBag.Title = "Address And Payment";
}
<script src="@Url.Content("~/Scripts/jquery.validate.min.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")" type="text/javascript"></script>
@using (Html.BeginForm())
{
    <h2>
        Address And Payment</h2>
    <fieldset>
        <legend>Shipping Information</legend>
        @Html.EditorForModel()
    </fieldset>
    <fieldset>
        <legend>Payment</legend>
        <p>
            We're running a promotion: all music is free with the promo code: "FREE"</p>
        <div class="editor-label">
            @Html.Label("Promo Code")
        </div>
        <div class="editor-field">
            @Html.TextBox("PromoCode")
        </div>
    </fieldset>
    <input type="submit" value="Submit Order" />
}

定义订单的验证规则

现在，我们的视图已经创建了，类似于专辑，我们定义订单的验证规则。在 Models 文件夹上点击鼠标的右键，增加名为 Order 的模型类，我们使用专辑中使用过的验证标注，我们还将使用正则表达式来验证用户的电子邮件地址。

using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Web.Mvc;

namespace MvcMusicStore.Models
{
    [Bind(Exclude = "OrderId")]
    public partial class Order
    {
        [ScaffoldColumn(false)]
        public int OrderId { get; set; }
        [ScaffoldColumn(false)]
        public System.DateTime OrderDate { get; set; }
        [ScaffoldColumn(false)]
        public string Username { get; set; }
        [Required(ErrorMessage = "First Name is required")]
        [DisplayName("First Name")]
        [StringLength(160)]
        public string FirstName { get; set; }
        [Required(ErrorMessage = "Last Name is required")]
        [DisplayName("Last Name")]
        [StringLength(160)]
        public string LastName { get; set; }
        [Required(ErrorMessage = "Address is required")]
        [StringLength(70)]
        public string Address { get; set; }
        [Required(ErrorMessage = "City is required")]
        [StringLength(40)]
        public string City { get; set; }
        [Required(ErrorMessage = "State is required")]
        [StringLength(40)]
        public string State { get; set; }
        [Required(ErrorMessage = "Postal Code is required")]
        [DisplayName("Postal Code")]
        [StringLength(10)]
        public string PostalCode { get; set; }
        [Required(ErrorMessage = "Country is required")]
        [StringLength(40)]
        public string Country { get; set; }
        [Required(ErrorMessage = "Phone is required")]
        [StringLength(24)]
        public string Phone { get; set; }
        [Required(ErrorMessage = "Email Address is required")]
        [DisplayName("Email Address")]
        [RegularExpression(@"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4}",
        ErrorMessage = "Email is is not valid.")]
        [DataType(DataType.EmailAddress)]
        public string Email { get; set; }
        [ScaffoldColumn(false)]
        public decimal Total { get; set; }
        public List<OrderDetail> OrderDetails { get; set; }
    }
}

在没有提交必要的信息或者提交错误信息的时候，我们将会看到客户端的验证信息。

现在，我们已经完成了结账中最困难的部分，还有一些小的工作要完成。我们增加两个简单的视图，还需要注意在登录过程中购物车信息。

增加完成结账视图

完成结账的视图非常简单，仅仅需要显示订单的编号，在控制器中的 Complete 方法上点击右键，增加名为 Complete 的强类型 int 视图。

现在，修改视图显示订单的编号。

@model int
@{
    ViewBag.Title = "Checkout Complete"; 
}
<h2>
    Checkout Complete</h2>
<p>
    Thanks for your order! Your order number is: @Model</p>
<p>
    How about shopping for some more music in our @Html.ActionLink("store", "Index", "Home")
</p>

更新错误视图

项目的默认模板中，包含了定义在 /Shared Views 文件夹中的错误页面，可以在整个站点中使用。这个页面仅仅包含简单的信息，也没有使用我们的布局，我们更新一下。

由于这是通用的错误页面，内容非常简单，我们仅仅包含一个提示信息，和用来重做工作的导航到上一个页面的链接。

@{ ViewBag.Title = "Error"; }
<h2>
    Error</h2>
<p>
    We're sorry, we've hit an unexpected error. <a href="javascript:history.go(-1)">Click
        here</a> if you'd like to go back and try that again.

本文链接

使用 NHibernate 的示例查询

2011-11-20T03:54:00Z

示例查询最多的应用场合是组合查询，我们常常需要在界面上提供若干的查询选项，然后根据用户的输入返回符合条件的结果。

使用代码直接进行处理往往需要涉及到复杂的条件，由于组合条件并不确定，导致逻辑判断语句结构复杂。对于多个可选的参数，情况会变得更加严重。

使用示例查询可以很方便地处理这种问题。

在查询的时候，将收集到的查询条件赋予一个对象的属性，当然，这个对象的类型就是需要查询的实体对象。

例如，在 NHibernate 中存在一个 User 的类型，我们需要对它的姓名和口令进行组合查询，User 的定义如下：

namespace Demo.Dao.Domain
{
    // 用户对象
    public class User
    {
        public virtual int UserId { set; get; }
        public virtual string Username { set; get; }
        public virtual string Password { set; get; }

        public virtual Address Address { set; get; }
    }
}

在界面中，我们提供用户输入的输入框。

<p>
    <label for="<%= this.tbxName %>">
        用户名：</label>
    <asp:TextBox ID="tbxName" runat="server"></asp:TextBox>
</p>
<p>
    <label for="<%= this.tbxPassword %>">
        口令：</label>
    <asp:TextBox ID="tbxPassword" runat="server"></asp:TextBox>
</p>
<p>
    <asp:Button ID="btnSearch" runat="server" Text="查询" OnClick="btnSearch_Click"/>
</p>

在按钮的点击事件中，我们将用户的输入组合为一个示例对象。然后提交给 NHibernate 进行查询。

protected void btnSearch_Click(object sender, EventArgs e)
{
    if (this.IsValid)
    {
        Demo.Dao.Domain.User example
            = new Demo.Dao.Domain.User()
                {
                    Username = this.tbxName.Text,
                    Password = this.tbxPassword.Text
                };
        IList<Demo.Dao.Domain.User> list = this.UserService.GetUsers(example);

        this.Repeater1.DataSource = list;
        this.Repeater1.DataBind();

    }
}

在后台的服务中，我们使用示例查询进行处理。

示例查询类型定义在命名空间 NHibernate.Criterion 中，使用静态方法 Create 可以创建示例对象。

首先创建一个查询条件对象，然后使用 Example 的 Create 方法创建出查询示例对象。最后就是实际的查询。

public IList<Demo.Dao.Domain.User> GetUsers( Demo.Dao.Domain.User exampleUser)
{
    // 创建查询标准
    global::NHibernate.ICriteria criteria
        = this.Session.CreateCriteria<Demo.Dao.Domain.User>();
            
    // 创建查询示例
    global::NHibernate.Criterion.Example example
        = global::NHibernate.Criterion.Example.Create(exampleUser);

    // 设置使用示例对象的查询条件
    criteria.Add(example);

    example.EnableLike(global::NHibernate.Criterion.MatchMode.Anywhere);

    IList< Demo.Dao.Domain.User> list = criteria.List<Demo.Dao.Domain.User>();

    return list;
}

对于字符串类型的条件来说，默认使用精确匹配，但是，可以通过示例的 EnableLike 进行设置。NHibernate.Criterion.MatchMode 是一个枚举，支持下面的匹配模式。

// 默认字符串是完全匹配，可以通过 EnableLike 进行设置
// Anywhere 表示任何位置匹配
// End 出现在最后位置
// Start 出现在起始位置
// Exact 完全匹配，默认设置
example.EnableLike(global::NHibernate.Criterion.MatchMode.Anywhere);

当在姓名的输入框中输入 a 的时候，NHibernate 生成的 SQL 语句如下：

SELECT this_.UserId as UserId0_0_, this_.Username as Username0_0_, this_.Password as Password0_0_, this_.AddressId as AddressId0_0_ 
FROM tbl_Users this_ 
WHERE (this_.Username like @p0)

除了强大的 EnableLike 之外，还提供了几个设置参数，比较常用的有 ExcludeZeroes() 方法，它可以排除属性中值为 0 的属性。

比如，在 User 中增加一个 Age 的整数类型属性，还导致查询语句变成下面的 SQL

SELECT this_.UserId as UserId0_0_, this_.Username as Username0_0_, this_.Password as Password0_0_, 

this_.Age as Age0_0_, this_.AddressId as AddressId0_0_ 
FROM tbl_Users this_ 
WHERE (this_.Username like @p0 and this_.Age = @p1)

使用排除 0 的设置

// 排除值为 0 的属性
example.ExcludeZeroes();

现在的 SQL 又成为

SELECT this_.UserId as UserId0_0_, this_.Username as Username0_0_, this_.Password as Password0_0_, 

this_.Age as Age0_0_, this_.AddressId as AddressId0_0_ 
FROM tbl_Users this_ 
WHERE (this_.Username like @p0)

不过，还有两个设置就要小心了。

ExcludeNulls() 方法，看起来是排除值为 null 的属性，不过，代码中是先调用了 ToString() 方法，然后再看字符串的长度，所以会使得前面的 ExcludeZeroes() 失效。

SELECT this_.UserId as UserId0_0_, this_.Username as Username0_0_, this_.Password as Password0_0_, 

this_.Age as Age0_0_, this_.AddressId as AddressId0_0_ 
FROM tbl_Users this_ 
WHERE (this_.Username like @p0 and this_.Age = @p1)

ExcludeNone() 方法，表示需要使用示例对象的所有属性，也会使得 ExcludeZeroes() 失效。

SELECT this_.UserId as UserId0_0_, this_.Username as Username0_0_, this_.Password as Password0_0_, 

this_.Age as Age0_0_, this_.AddressId as AddressId0_0_ 
FROM tbl_Users this_ 
WHERE (this_.Username like @p0 and this_.Password is null and this_.Age = @p1)

最后，还有一个 IgnoreCase() 方法，使用不区分大小写的方法比较字符串，对于 Oracle 是有效的，对于 SQL Server 就用不到了。

SELECT this_.UserId as UserId0_0_, this_.Username as Username0_0_, this_.Password as Password0_0_, 

this_.Age as Age0_0_, this_.AddressId as AddressId0_0_ 
FROM tbl_Users this_ 
WHERE (lower(this_.Username) like lower(@p0) and this_.Age = @p1)

本文链接

ASP.NET MVC 音乐商店 - 8. 使用 Ajax 更新的购物车

2011-11-19T16:10:00Z

在这个项目中，我们将允许用户在没有注册登录的情况下将专辑加入购物车，但是，在完成结账的时候必须完成注册工作。购物和结账将会被分离到两个控制器中：一个 ShoppingCart 控制器，允许匿名用户使用购物车，另一个 Checkout 控制器处理结账。我们先从购物车的控制器开始，然后在下一部分来处理结帐。

加入购物车，订单和订单明细的模型类

在购物车和结账的处理中将会使用到一些新的类，在 Models 文件夹上右键，然后使用下面的代码增加一个新的类 Cart.

using System.ComponentModel.DataAnnotations;

namespace MvcMusicStore.Models
{
    public class Cart
    {
        [Key]
        public int RecordId { get; set; }
        public string CartId { get; set; }
        public int AlbumId { get; set; }
        public int Count { get; set; }
        public System.DateTime DateCreated { get; set; }
        public virtual Album Album { get; set; }
    }
}

这个类非常类似我们前面使用的类，除了 RecordId 属性上的[Key] 标注之外。我们的购物车拥有一个字符串类型的名为 CartId 的标识，用来允许匿名用户使用购物车，但是,CartId 并不是表的主键，表的主键是整数类型的名为 RecordId的字段，根据约定，EF CodeFirst 将会认为表的主键名为 CartId 或者 Id，不过，如果需要的话，我们可以很容易地通过标注或者代码来重写这个规则。这里例子演示了在使用 EF CodeFirst 的时候。当我们的表不是约定的样子时，我们也不必被约定所局限。

下一步，使用下面的代码增加订单 Order 类。

using System.Collections.Generic;
namespace MvcMusicStore.Models
{
    public partial class Order
    {
        public int OrderId { get; set; }
        public string Username { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Address { get; set; }
        public string City { get; set; }
        public string State { get; set; }
        public string PostalCode { get; set; }
        public string Country { get; set; }
        public string Phone { get; set; }
        public string Email { get; set; }
        public decimal Total { get; set; }
        public System.DateTime OrderDate { get; set; }
        public List<OrderDetail> OrderDetails { get; set; }
    }
}

这个类跟踪订单的汇总和发货信息，它的结构也不复杂，订单依赖我们这里还没有定义的一个类，通过 OrderDetails 属性来表示订单的明细。我们来定义一下这个 OrderDetail 类。

namespace MvcMusicStore.Models
{
    public class OrderDetail
    {
        public int OrderDetailId { get; set; }
        public int OrderId { get; set; }
        public int AlbumId { get; set; }
        public int Quantity { get; set; }
        public decimal UnitPrice { get; set; }
        public virtual Album Album { get; set; }
        public virtual Order Order { get; set; }
    }
}

把我们的 MusicStoreEntities 更新一下，以便包含我们新定义的模型类，包括艺术家 Artist，更新之后的 MusicStoreEntities 如下所示。

using System.Data.Entity;

namespace MvcMusicStore.Models
{
    public class MusicStoreEntities : DbContext
    {
        public DbSet<Album> Albums { get; set; }
        public DbSet<Genre> Genres { get; set; } 
        
        public DbSet<Artist> Artists { get; set; } 
        public DbSet<Cart> Carts { get; set; } 
        public DbSet<Order> Orders { get; set; } 
        public DbSet<OrderDetail> OrderDetails { get; set; }
    }
}

管理购物车业务逻辑

下一步，我们在 Models 文件夹中创建 ShoppingCart 类，ShoppingCart 模型类处理 Cart 表的数据访问，另外，它还需要处理在购物车中增加或者删除项目的业务逻辑。

因为我们并不希望用户必须登录系统才可以使用购物车，对于没有登录的用户，我们需要为他们创建一个临时的唯一标识，这里使用 GUID，或者被称为全局唯一标识符，对于已经登录的用户，我们直接使用他们的名称，这个表示我们保存在 Session 中。

注意：Session 会话可以很方便地存储用户的信息，在用户离开站点之后，这些信息将会过期，滥用 Session 信息会对大型站点产生影响，我们这里使用 Session 达到演示目的。

ShoppingCart 类提供了如下的方法：

AddToCart, 将专辑作为参数加入到购物车中，在 Cart 表中跟踪每个专辑的数量，在这个方法中，我们将会检查是在表中增加一个新行，还是仅仅在用户已经选择的专辑上增加数量。

RemoveFromCart，通过专辑的标识从用户的购物车中将这个专辑的数量减少 1，如果用户仅仅剩下一个，那么就删除这一行。

EmptyCart，删除用户购物车中所有的项目。

GetCartItems，获取购物项目的列表用来显示或者处理。

GetCount，获取用户购物车中专辑的数量

GetTotal，获取购物车中商品的总价

CreateOrder，将购物车转换为结账处理过程中的订单。

GetCart ，这是一个静态方法，用来获取当前用户的购物车对象，它使用 GetCartId 方法来读取保存当前 Session 中的购物车标识，GetCartId 方法需要 HttpContextBase 以便获取当前的 Session。

实际的代码如下：

namespace MvcMusicStore.Models
{
    public partial class ShoppingCart
    {
        MusicStoreEntities storeDB = new MusicStoreEntities();

        string ShoppingCartId { get; set; }
        public const string CartSessionKey = "CartId";

        public static ShoppingCart GetCart(HttpContextBase context)
        {
            var cart = new ShoppingCart();
            cart.ShoppingCartId = cart.GetCartId(context);
            return cart;
        }
        // Helper method to simplify shopping cart calls
        public static ShoppingCart GetCart(Controller controller)
        {
            return GetCart(controller.HttpContext);
        }
        public void AddToCart(Album album)
        {
            // Get the matching cart and album instances
            var cartItem = storeDB.Carts.SingleOrDefault(
            c => c.CartId == ShoppingCartId
            && c.AlbumId == album.AlbumId);
            if (cartItem == null)
            {
                // Create a new cart item if no cart item exists
                cartItem = new Cart
                {
                    AlbumId = album.AlbumId,
                    CartId = ShoppingCartId,
                    Count = 1,
                    DateCreated = DateTime.Now
                };
                storeDB.Carts.Add(cartItem);
            }
            else
            {
                // If the item does exist in the cart, then add one to the quantity
                cartItem.Count++;
            }
            // Save changes
            storeDB.SaveChanges();
        }

        public int RemoveFromCart(int id)
        {
            // Get the cart
            var cartItem = storeDB.Carts.Single(
            cart => cart.CartId == ShoppingCartId
            && cart.RecordId == id);

            int itemCount = 0;
            if (cartItem != null)
            {
                if (cartItem.Count > 1)
                {
                    cartItem.Count--;
                    itemCount = cartItem.Count;
                }
                else
                {
                    storeDB.Carts.Remove(cartItem);
                }
                // Save changes
                storeDB.SaveChanges();
            }
            return itemCount;
        }
        public void EmptyCart()
        {
            var cartItems = storeDB.Carts.Where(cart => cart.CartId == ShoppingCartId);
            foreach (var cartItem in cartItems)
            {
                storeDB.Carts.Remove(cartItem);
            }
            // Save changes
            storeDB.SaveChanges();
        }
        public List<Cart> GetCartItems()
        {
            return storeDB.Carts.Where(cart => cart.CartId == ShoppingCartId).ToList();
        }
        public int GetCount()
        {
            // Get the count of each item in the cart and sum them up
            int? count = (from cartItems in storeDB.Carts
                          where cartItems.CartId == ShoppingCartId
                          select (int?)cartItems.Count).Sum();
            // Return 0 if all entries are null
            return count ?? 0;
        }

        public decimal GetTotal()
        {
            // Multiply album price by count of that album to get
            // the current price for each of those albums in the cart
            // sum all album price totals to get the cart total

            decimal? total = (from cartItems in storeDB.Carts
                              where cartItems.CartId == ShoppingCartId
                              select (int?)cartItems.Count * cartItems.Album.Price).Sum();
            return total ?? decimal.Zero;
        }
        public int CreateOrder(Order order)
        {
            decimal orderTotal = 0;
            var cartItems = GetCartItems();
            // Iterate over the items in the cart, adding the order details for each
            foreach (var item in cartItems)
            {
                var orderDetail = new OrderDetail
                {
                    AlbumId = item.AlbumId,
                    OrderId = order.OrderId,
                    UnitPrice = item.Album.Price,
                    Quantity = item.Count
                };
                // Set the order total of the shopping cart
                orderTotal += (item.Count * item.Album.Price);
                storeDB.OrderDetails.Add(orderDetail);
            }
            // Set the order's total to the orderTotal count
            order.Total = orderTotal;
            // Save the order
            storeDB.SaveChanges();
            // Empty the shopping cart
            EmptyCart();
            // Return the OrderId as the confirmation number
            return order.OrderId;
        }

        // We're using HttpContextBase to allow access to cookies.
        public string GetCartId(HttpContextBase context)
        {
            if (context.Session[CartSessionKey] == null)
            {
                if (!string.IsNullOrWhiteSpace(context.User.Identity.Name))
                {
                    context.Session[CartSessionKey] = context.User.Identity.Name;
                }
                else
                {
                    // Generate a new random GUID using System.Guid class

                    Guid tempCartId = Guid.NewGuid();
                    // Send tempCartId back to client as a cookie
                    context.Session[CartSessionKey] = tempCartId.ToString();
                }
            }
            return context.Session[CartSessionKey].ToString();
        }
        // When a user has logged in, migrate their shopping cart to
        // be associated with their username
        public void MigrateCart(string userName)
        {
            var shoppingCart = storeDB.Carts.Where(c => c.CartId == ShoppingCartId);
            foreach (Cart item in shoppingCart)
            {
                item.CartId = userName;
            }
            storeDB.SaveChanges();
        }
    }
}

视图模型

我们的 ShoppingCart 控制器需要向视图传递复杂的信息，这些信息与现有的模型并不完全匹配，我们不希望修改模型来适应视图的需要；模型类应该表示领域信息，而不是用户界面。一个解决方案是使用 ViewBag 来向视图传递信息，就像我们在 Store Manager 中的下列列表处理中那样，但是通过 ViewBag 来传递大量信息就不好管理了。

另外一个解决方案是使用视图模型模式，使用这个模式，我们需要创建强类型的用于视图场景的类来表示信息，这个类拥有视图所需要的值或者内容。我们的控制器填充信息，然后传递这种类的对象供视图使用，这样就可以得到强类型的、编译时检查支持，并且在视图模板中带有智能提示。

我们将会创建两个视图模型用于我们的 ShoppingCart 控制器：ShoppingCartViewModel 将会用于用户的购物车，而 ShoppingCartRemoveViewModel 会用于在购物车中删除内容时的确认提示信息。

首先在项目中创建 ViewModels 文件夹来组织我们的项目文件，在项目上点击鼠标的右键，然后选择添加 –〉新文件夹。

命名为 ViewModels

下一步，在 ViewModels 文件夹中增加 ShoppingCartViewModel 类，它包括两个属性，一个 CartItem 的列表，另外一个属性是购物中的总价。

using System.Collections.Generic;
using MvcMusicStore.Models;

namespace MvcMusicStore.ViewModels
{
    public class ShoppingCartViewModel
    {
        public List<Cart> CartItems { get; set; }
        public decimal CartTotal { get; set; }
    }
}

然后，增加 ShoppingCartRemoveViewModel 类，它包括五个属性。

namespace MvcMusicStore.ViewModels
{
    public class ShoppingCartRemoveViewModel
    {
        public string Message { get; set; }
        public decimal CartTotal { get; set; }
        public int CartCount { get; set; }
        public int ItemCount { get; set; }
        public int DeleteId { get; set; }
    }
}

Shopping Cart 控制器

Shopping Cart 控制器有三个主要的目的：增加项目到购物车，从购物车中删除项目，查看购物车中的项目。控制器使用到我们刚刚创建的三个类：ShoppingCartViewModel，ShoppingCartRemoveViewModel 和 ShoppingCart，像 StoreController 和 StoreManagerController 一样，我们在控制器中增加一个 MusicStoreEntities 字段来操作数据。

在项目中使用空的控制器模板创建 Shopping Cart 控制器

下面是已经完成的控制器代码，Index 和 Add 方法看起来非常熟悉。Remove 和 CartSummary 这两个 Action 方法处理两种特定的场景，我们将在后面讨论。

using MvcMusicStore.Models;
using MvcMusicStore.ViewModels;

namespace MvcMusicStore.Controllers
{
    public class ShoppingCartController : Controller
    {
        MusicStoreEntities storeDB = new MusicStoreEntities();
        //
        // GET: /ShoppingCart/
        public ActionResult Index()
        {
            var cart = ShoppingCart.GetCart(this.HttpContext);
            // Set up our ViewModel
            var viewModel = new ShoppingCartViewModel
            {
                CartItems = cart.GetCartItems(),
                CartTotal = cart.GetTotal()
            };
            // Return the view
            return View(viewModel);
        }
        //
        // GET: /Store/AddToCart/5
        public ActionResult AddToCart(int id)
        {
            // Retrieve the album from the database
            var addedAlbum = storeDB.Albums
            .Single(album => album.AlbumId == id);
            // Add it to the shopping cart
            var cart = ShoppingCart.GetCart(this.HttpContext);
            cart.AddToCart(addedAlbum);
            // Go back to the main store page for more shopping
            return RedirectToAction("Index");
        }
        //
        // AJAX: /ShoppingCart/RemoveFromCart/5
        [HttpPost]
        public ActionResult RemoveFromCart(int id)
        {
            // Remove the item from the cart
            var cart = ShoppingCart.GetCart(this.HttpContext);
            // Get the name of the album to display confirmation
            string albumName = storeDB.Carts
            .Single(item => item.RecordId == id).Album.Title;
            // Remove from cart
            int itemCount = cart.RemoveFromCart(id);
            // Display the confirmation message
            var results = new ShoppingCartRemoveViewModel
            {
                Message = Server.HtmlEncode(albumName) +
                " has been removed from your shopping cart.",
                CartTotal = cart.GetTotal(),
                CartCount = cart.GetCount(),
                ItemCount = itemCount,
                DeleteId = id
            };
            return Json(results);
        }
        //
        // GET: /ShoppingCart/CartSummary
        [ChildActionOnly]
        public ActionResult CartSummary()
        {
            var cart = ShoppingCart.GetCart(this.HttpContext);
            ViewData["CartCount"] = cart.GetCount();
            return PartialView("CartSummary");
        }
    }
}

使用 jQuery 进行 Ajax 更新

下面我们将创建 Shopping Cart 的 Index Action 视图，这个视图使用强类型的 ShoppingCartViewModel ，像以前的视图一样，使用 List 视图模板。

在这里，我们不使用 Html.ActionLink 从购物车中删除项目，我们将会使用 JQuery 来包装客户端使用 RemoveLink 的类所有超级链接元素的事件，不是提交表单，而是通过客户端的事件向 RemoveFromCart 控制器方法发出 Ajax 请求，然后 RemoveFromCart 返回 JSON 格式的结果，这个结果被发送到我们在 AjaxOptions 的 OnSucess 参数中创建的 JavaScript 函数，在这里是 handleUpdate，handleUpdate 函数解析 JSON 格式的结果，然后通过 jQuery 执行下面的四个更新。

从列表中删除专辑
更新头部的购物车中的数量
向用户显示更新信息
更新购物车中的总价

因为在 Index 视图中我们处理了删除的场景，我们就不再需要为 RemoveFromCart 方法增加额外的视图。下面是视图的完整代码。

@model MvcMusicStore.ViewModels.ShoppingCartViewModel 
@{ 
    ViewBag.Title = "Shopping Cart"; 
}
<script src="/Scripts/jquery-1.4.4.min.js" type="text/javascript"></script>
<script type="text/javascript">
    $(function () {
        // Document.ready -> link up remove event handler
        $(".RemoveLink").click(function () {
            // Get the id from the link
            var recordToDelete = $(this).attr("data-id");
            if (recordToDelete != '') {
                // Perform the ajax post
                $.post("/ShoppingCart/RemoveFromCart", { "id": recordToDelete },
function (data) {
    // Successful requests get here
    // Update the page elements
    if (data.ItemCount == 0) {
        $('#row-' + data.DeleteId).fadeOut('slow');
    } else {
        $('#item-count-' + data.DeleteId).text(data.ItemCount);
    }
    $('#cart-total').text(data.CartTotal);
    $('#update-message').text(data.Message);
    $('#cart-status').text('Cart (' + data.CartCount + ')');
});
            }
        });
    });
    function handleUpdate() {
        // Load and deserialize the returned JSON data
        var json = context.get_data();
        var data = Sys.Serialization.JavaScriptSerializer.deserialize(json);
        // Update the page elements
        if (data.ItemCount == 0) {
            $('#row-' + data.DeleteId).fadeOut('slow');
        } else {
            $('#item-count-' + data.DeleteId).text(data.ItemCount);
        }
        $('#cart-total').text(data.CartTotal);
        $('#update-message').text(data.Message);
        $('#cart-status').text('Cart (' + data.CartCount + ')');
    }
</script>
<h3>
    <em>Review</em> your cart:
</h3>
<p class="button">
    @Html.ActionLink("Checkout >>", "AddressAndPayment", "Checkout")
</p>
<div id="update-message">
</div>
<table>
    <tr>
        <th>
            Album Name
        </th>
        <th>
            Price (each)
        </th>
        <th>
            Quantity
        </th>
        <th>
        </th>
    </tr>
    @foreach (var item in Model.CartItems)
    { <tr id="row-@item.RecordId">
        <td>
            @Html.ActionLink(item.Album.Title, "Details", "Store", new { id = item.AlbumId }, null)
        </td>
        <td>
            @item.Album.Price
        </td>
        <td id="item-count-@item.RecordId">
            @item.Count
        </td>
        <td>
            <a href="#" class="RemoveLink" data-id="@item.RecordId">Remove from cart</a>
        </td>
    </tr>
    }
    <tr>
        <td>
            Total
        </td>
        <td>
        </td>
        <td>
        </td>
        <td id="cart-total">
            @Model.CartTotal
        </td>
    </tr>
</table>

为了测试一下，我们需要向购物车中增加一些项目，更新 Store 的 Details 视图包含添加到购物车按钮，在这里，我们还需要包含我们后来增加的专辑的一些额外信息，流派，艺术家，价格等等。更新后的视图如下所示。

@model MvcMusicStore.Models.Album
@{
    ViewBag.Title = "Album - " + Model.Title; 
}
<h2>@Model.Title</h2>
<p>
    <img alt="@Model.Title" src="@Model.AlbumArtUrl" />
</p>
<div id="album-details">
    <p>
        <em>Genre:</em> @Model.Genre.Name
    </p>
    <p>
        <em>Artist:</em> @Model.Artist.Name
    </p>
    <p>
        <em>Price:</em> @String.Format("{0:F}", Model.Price)
    </p>
    <p class="button">
        @Html.ActionLink("Add to cart", "AddToCart", "ShoppingCart", new { id = Model.AlbumId }, "")
    </p>
</div>

现在，我们可以在商店中通过购物车来购买和删除一些项目了。运行程序，浏览 Store 控制器的 Index 。

然后，点击某个分类来查看专辑的列表。

点击某个专辑来显示专辑的详细内容，现在已经有了加入购物车的按钮。

点击加入购物车之后，可以在购物车中看到。

在购物车中，可以点击从购物车中删除的链接，将会看到 Ajax 更新购物车的效果。

现在的购物车允许没有注册的用户使用购物车添加项目，在下一部分，我们将允许匿名用户注册和完成结账的处理。

本文链接