技术尝鲜 - 老赵点滴 - 追求编程之美

HTML Metro开发里的数据绑定（1）：WinJS.Binding.List

jeffz@live.com (老赵) — Tue, 01 May 2012 14:53:21 GMT

前段时间接触了一些WPF开发方面内容，了解如何使用MVVM模式将界面与模型几乎彻底分离开来，只通过其强大的绑定功能连接两者，让人叹为观止。Win8的Metro开发支持使用XAML（配合C#，C++等语言）或是HTML（配合JavaScript），前者的控件和数据的绑定已经相当完备，而后者一直没有一个标准的模型。之前我也简单了解过如Knockout这样的绑定支持与MVVM模式实现，理论上说也完全可以在Metro开发里使用，但其实Metro开发本身也已经提供了一些内置的绑定支持，基本对应于XAML/C#开发里涉及到的ObservableCollection与INotifyPropertyChanged。

ObservableCollection的功能是作为元素的集合，绑定到一个控件上去，当集合发生改变时，将会触发一个CollectionChanged事件，通知控件（或其他监听者）发生了什么样的变化：

public class ObservableCollection<T>
{
    public event NotifyCollectionChangedEventHandler CollectionChanged;
}

public delegate void NotifyCollectionChangedEventHandler(object sender, NotifyCollectionChangedEventArgs e);

public class NotifyCollectionChangedEventArgs : EventArgs
{
    public NotifyCollectionChangedAction Action { get; }
    public IList NewItems { get; }
    public int NewStartingIndex { get; }
    public IList OldItems { get; }
    public int OldStartingIndex { get; }
}

public enum NotifyCollectionChangedAction
{
    Add = 0,
    Remove = 1,
    Replace = 2,
    Move = 3,
    Reset = 4,
}

ObservableCollection在Metro开发中的JavaScript对应物为WinJS.Binding.List类型，它包含许多成员，可惜目前文档奇缺，多亏Visual Studio 2011对JavaScript的强大提示功能，可以让我们了解到该类型有哪些成员，例如：

这样我们便能知道如何实现一些常见的场景：

var list = new WinJS.Binding.List();
list.push("Hello"); // iteminserted
list.push("World"); // iteminserted
list.push("How are you?"); // iteminserted
list.setAt(0, "Hello World"); // itemchanged
list.move(0, 2); // itemmoved
list.slice(1, 2); // itemremoved
list.notifyMutated(0); // itemmutated
list.notifyReload(); // reload

与ObservableCollection的集中式CollectionChanged事件相比，WinJS.Binding.List的事件更为分散。此外，还有两个事件是需要外部方法notifyMutated和notifyReload来触发的。其中itemsMutated事件比较特殊，它似乎是在通知集合中某个元素自身状态产生了变化，在XAML开发中这事儿完全不关ObservableCollection管，而是后面要说的，由元素自己实现INotifyPropertyChanged接口来负责。

WinJS.Binding.List的各种接口和JavaScript数组基本一致，此外它还包括一些有趣的功能，例如它的构造函数可以传递一个数组以及一个options参数，如果options.proxy为true，则直接将该数组作为内部的存储结构。另外，其实这个集合会为其中每个元素分配一个key，通过getItem(index)可以得到一个key/value对，通过getItemFromKey可以通过key得到元素。交换数组中元素的顺序并不会改变key对应的元素，因此这个功能在某些情况下会很有帮助。

更有特色的可能是createFiltered，createGrouped和createSorted方法，他们都是在原有集合的基础上，返回一个（或一组）新的WinJS.Binding.List对象，每个新集合都和原有集合的内容保持“一致”。例如，基于一个过滤条件由createFiltered方法创建出来的新集合，假如向原集合添加一个满足该过滤条件的元素，则这个元素也会添加到新的容器里，同时触发新容器的iteminserted事件。同样，其他对原集合的修改也会影响新的集合。要实现类似的功能并不困难，只不过比较麻烦，如果您有兴趣，也不妨实验下。

HTML Metro开发里的数据绑定（1）：WinJS.Binding.List

在.NET平台下使用C#交互式控制台（上）：简介

jeffz@live.com (老赵) — Wed, 31 Aug 2011 16:25:50 GMT

上周日在广州的珠三角技术沙龙上，我的演讲题目是“Mono之于.NET程序员”。Mono一直是我十分喜爱的产品，我也一直关注它的发展，总有很多人用各种方式对它进行FUD，甚至是.NET程序员自己。这其实跟程序员使用盗版一样，自掘坟墓，是种无比愚蠢的行为。在演讲中，我提到.NET程序员可以如何从Mono项目中得到帮助，现在便以C#交互式控制台为例，演示下在.NET平台下使用Mono项目的常见方式。

Mono和.NET都是CLI（ECMA 335）的实现，包括C#语言编译器，运行时和类库等等。与微软实现的.NET不同，Mono是个开源项目，我们可以在授权允许的范围内任意折腾。例如，微软在Silverlight里提供了一个JSON类库，但我们无法将其用于普通的.NET项目，于是我们就可以从Mono里剥离相关代码出来。再比如，Windows Phone的SDK中没有提供像.NET 4.0里面一样的任务并行库，于是也有开发人员将Mono里面的实现移植了过来。社区成员也十分喜欢开源，因此无论是Mono团队还是其他开发人员都会很乐意捣鼓各种东西，并且也搞出许多有意思的东西来。C#交互式控制台（有时也将其称为REPL，即Read-Eval-Print-Loop）就是其中一个。

之前Anders Hejlsberg在PDC 2010中提到“C#与Visual Basic的未来”，其中一项功能就是“编译器即服务（Compiler as a Service）”。这个功能是指，把编译器的功能向普通用户开放出来，这样便可以实现更多的东西，例如代码解释执行，或是把代码变成语法树，让程序理解其语义等等（这便是Jscex的根本所在）。其实几年前就已经在Mono有类似的实现了。Mono的C#编译器mcs本身是由C#实现的，因此它直接就包含了编译器的完整功能，API好用与否暂且不论，但的确提供了这方面的能力，需要的同学完全可以自行获取。

Mono编译器功能暴露在Mono.CSharp类库中，而C#的交互式控制台便是“编译器即服务”顺理成章的衍生品。我想你一定遇到过这样的情况，例如，知道DateTime类型的ToString在接受某些参数会输出什么样的效果，却有些记不清，查文档自然会有答案但是太麻烦，其实一试便知。还有比如字符串解析，正则表达式匹配，临时计算等等。我见过很多同学在遇到这种情况的时候，都会直接把代码写在程序里，然后设置断点，然后运行程序观察执行效果。经验丰富一点的朋友则会时刻准备着一个控制台项目或是用Snippit Compiler，写点试验代码运行一下。不过，最理想的方式其实是使用F#，Scala，Ruby，Python等语言中都有的交互式控制台。例如以下便是在VS 2010中自带的F#交互式控制台：

我几乎天天都会用到F#交互式控制台，用来验证一些做法和猜想是否正确，确定之后再写成C#代码。我会F#，使用F#交互控制台自然不在话下。如果您懂得Python或Ruby，则使用IronPython或IronRuby的交互式控制台也是个不错的办法。但如果您只会用C#，那似乎就没辙了。幸运的是，Mono为C#程序员打开了这扇窗，我们也完全可以使用C#的交互式控制台来辅助工作，如下图：

在下一篇文章里，我们便来一起看一下，如何让Mono提供的C#交互式控制台运行在Windows和.NET下。这是个不错的例子，略有障碍，也没有过于复杂或取巧的地方，可以作为.NET程序员利用Mono组件的一个典型示例。

最后再附上上周日的演讲幻灯片，大伙后睹为快：

Mono for .NET Developers

View more presentations from jeffz

总之一句话：作为.NET程序员，如果您忽视或排斥Mono的话，损失的将会是你自己。

“花钱”购买App Hub Membership终于成功了

jeffz@live.com (老赵) — Mon, 10 Jan 2011 17:45:57 GMT

作为一个身在天朝的开发人员，要及早使用国外的服务总是一件杯具的事情，注册Windows Phone 7的App Hub Membership也不例外。不幸中的万幸，我工作于盛大创新院，这也是个奇妙的地方，身边的同事就有美国人，在他的帮助下，从提及注册信息到审核成功也只用了6、7个小时。说起来美国人在这方面的确占有十分重大的优势，不光是审核速度快（其他国家用户还需要等待GeoTrust主动联系，并提交更多信息，多花上2、3个工作日十分正常），连价格也便宜（年费只需99美金，前两天让荷兰的朋友帮忙注册需要99欧元），不得不长叹一声。

由于注册无法重现，我在这里只能简单描述一番。第一个环节是选择国家/地区，以及帐号类型等等，这与接下来的信用卡以及费用有关。接着则是各种信息，姓名电话地址邮编等等，也要和最后那张信用卡相符。之后则是提交信用卡的信息了，自不必说。值得一提的是，在提交信用卡的时候，网站总是说我的信息无法通过认证，几经尝试，最后使用我的美国VPS作代理才注册通过，看来是IP问题。通过之后，邮箱里会收到微软和GeoTrust发来的确认邮件，其中包含一个用于身份认证的链接，点开后则要求输入美国公民的各种信息，例如社会保障号等等。填写必需的字段，提交后便说“请等待处理”了。下午注册，晚上8点就收到邮件说成功了。总体而言，对于国内用户来说，App Hub Membership的“注册代理”比Android Market要宽松一些，后者似乎还要验证邮箱等等。

App Hub包含了Windows Phone和XBox的开发和发布权限，我虽然也刚入手了XBox和Kinect，但我注册个App Hub完全就是为了Windows Phone上面的开发。诚然，如果不需要发布到Marketplace，使用微软提供的免费工具，再加上ChevronWP7的破解早已足够了，但我还是选择了购买App Hub。这不到700块钱用于体验时代潮流，仔细想来也并不太多——当然这也涉及到个人的价值观。有些人认为4、500块钱的手机用来打电话发短信也已够用，而另一部分人（包括我）的看法是，几千块钱本身说起来也不能做太多事情，不如用于体会互联网时代的价值，这也是一种进修。所以我会较快购进Windows Phone、Kinect以及MonoTouch等等，即使从某些角度来看Windows Phone并非是一个适合国内用户的产品。

以前我总是舍不得花钱，和许多朋友一样觉得这也很贵，那也很贵，于是也会用盗版等等。后来我和别人一起创业，虽然并非直接掌管资金，但也对于各种花销建立了一些概念。例如我知道了开一天公司需要多少钱，给员工交工资和福利、网站托管、流量购买需要多少钱，于是我就不会认为一套不到3000的MonoTouch，或是其他某个组件的商业授权有多么昂贵，因为它们的确可以为我省下更多的钱。从那时起，我会适当地选择开发效率更高的.NET平台加上价格便宜（3000左右）工作足够对硬件也十分宽松的Windows Web Server 2008，配合价格便宜选择丰富的*nix作后端存储。

学会合理花钱的好处其实很多，首先我可以自豪地宣布，我已经不用盗版软件许多年，其次我学会通过花费现在的钱来提高自己或是节省精力，以便赚到更多的钱。我现在越来越喜欢适当使用一些收费的组件，因为我相信他们为了卖更多的授权，会不断提高自己的产品以及服务质量，这让我可以轻松不少。反之如果一切都由自己从头做起，可能大量的时间都耗费在一些无谓的细节上面才能得到与商业产品差不多的质量。时间往往比金钱更有价值。如果纠缠于那些细节无法让人提高，我情愿将时间用在自我学习、娱乐甚至是简单的休息上面。

说起来购买App Hub Membership也是类似的道理，我不想把大量精力耗费在刷机、破解等方面（虽然我知道许多朋友乐在其中）。非官方的解锁方式总是无法让人安心，可能一次系统升级就让手机重新锁定了，于是又要折腾半天。现在则不然，即便微软接下来会升级Windows Phone，我也可以放心继续使用。因为我已经成为了正式的开发人员，XBox Live的Avatar都可以使用新装备了，哈哈。

如今是程序员的黄金年代，移动平台和应用市场的兴起让我们可以比以往任何时候都轻松地赚取零花钱，甚至开创一番事业——当然前提是要有创意，这也是我最缺乏的。因此，如果您有什么需求或是点子，也不妨给我一些指点，我也有点实际内容可做。

最后，依然来推广一下本周六即将举办的“第三届nBazaar技术交流会”，欢迎继续报名（近日将发出邀请函）。在今后的交流会上，我也会引入更多有趣的话题，例如移动平台的开发，甚至是与Kinect相关的话题。Kinect的确是神器，在我家已经成为父母每天必修的娱乐活动，可能我还会再买一套送给他们。

HTC 7 Mozart T8698（Windows Phone 7）初体验

jeffz@live.com (老赵) — Wed, 05 Jan 2011 15:43:33 GMT

上个星期去香港旅游，对于我等IT从业人员来说，数码产品卖场自然是必逛的地方之一。香港的衣食住行都很贵，但是数码产品却十分便宜。看着手中使用了3个月滚珠就已失灵的奥巴马御用机型，决定就在香港采购一台吧。鉴于Android和iPhone 4都已经是烂大街的机器，我打算着重关注一下Windows Phone 7的机器。当时在香港到处可以看到HTC HD 7以及LG Optimus 7 E900，不过都是接近5000港币的价格，再加上实在不是很喜欢它们的外观，于是迟迟不愿下手。后来在百老汇发现新上市的HTC 7 Mozart T8698，据说是加强了多媒体能力的机型，外形和手感都不错，价格也相对较低（4200元港币，约合人民币约3600元），于是遍选中了这台。把玩了几天，记录一下感受。

对于手机来说，iPhone 4就是iPhone 4，但是说到Android和Windows Phone，不同机器之间的感受还是有很大区别的（尤其是前者）。就拿屏幕来说，Windows Phone的固定配置是480*800的分辨率，于是屏幕越小，画面就显得越精致。例如Mozart是3.7寸屏幕，就比HD 7的4.3寸屏细腻许多。从显示效果上看，Mozart的画面质量远胜iPhone 3GS，从数据上看不如iPhone 4的Retina屏幕（每英寸326像素，Mozart是252像素），不过效果可以说是一个等级的。

从操作上看，Windows Phone不同于iPhone和Android的图标式布局让人耳目一新，选中某项和程序界面的切换效果也很酷。系统和自带的应用程序使用起来都很流畅，毫无卡顿。系统内置的功能都不错，界面也都很酷。邮箱功能十分令人满意，尤其是对Hotmail和Gmail的支持。令人有些奇怪的是，WP7居然没有自带Live Messenger，不过可以从Marketplace里下载到第三方编写的免费Messenger程序，功能中规中矩。值得一提的是，这个Messenger可以在“退出”之后得到消息推送，让我对系统的“多任务”能力感到很好奇。之前有很多说法认为Windows Phone没有多任务功能，按理来说是无法实现此类功能的。

其他的例如浏览器，搜索，地图之类的功能就不多说了。游戏方面，Xbox LIVE应该是Windows Phone的特色。Windows Phone的3D功能很强，XNA框架和XBOX游戏开发一脉相承，而且都是使用.NET托管代码（C#）编写，就从极品飞车的效果来看，相信可以让某些认为“托管代码”或是“自动GC”等等“不堪大用”的人更新自己的观念。总体来说，这台HTC 7 Mozart T8698还是让我比较满意的。

接下来说说它的缺点，当然，这些估计也已经有很多人谈过了，例如暂时还没有复制粘贴等等。对于国内用户来说，最大的缺点莫过于缺少中文输入法的支持。由于微软没有提供相应的API，因此我们无法替换掉系统的输入法，于是如今所有的中文输入功能都是在某个特定程序中实现的，然后“发送”至短信、浏览器地址栏或是邮箱中。这对于一些基础功能来说还算够用，但是限制也很大。例如在联系人列表里（Windows Phone称之为People Hub），我们无法使用中文或是拼音来快速搜索某个联系人，十分不便，这迫使我不得不把联系人的姓名写成英文。现在我都打算开发一个支持中文输入的联系人管理工具了，顺便研究一下怎么开发一个简单的输入法。已有的中文输入法软件，功能可能还不错（如疯光输入法），但都很丑，使用也不太方便，我不很喜欢。

说到软件市场，可以说是Windows Phone软肋了，数量实在太少，更别说面向国内用户的应用程序了。即使是如T-Sina这样的新浪微博客户端，界面也很难看，很没有Windows Phone的样子，这可能也是我打算抽空做的一个功能。考虑到这些，如果您不是手机“玩家”而是普通用户的话，那么Windows Phone的确不太适合您，至少等到今年下半年Windows Phone进入中国市场以后再考虑吧。

如果您要开发Windows Phone应用程序，可以下载免费的Windows Phone Develop Tools，其中包含Visual Studio 2010 Express Edition和Expression Blend for Windows Phone等工具，应该够用。只可惜这也只能让您在Windows Phone模拟器上运行程序，如果要在真机上调试，还需要购买App Hub会员，这可以让您解锁一定数量的机器，于是可以直接将xap包安装进去。App Hub会员的年费是99美金，但最大的问题其实是无法使用国内的信用卡购买，您可以选择一些代理服务或是请朋友帮忙（希望有条件的朋友也可以来帮我一下，提供一些经验也行）——或者像我一样选择“破解”，俗称“越狱”。

Windows Phone的破解很容易，应该也是不同机型通用的方式，因为我也是根据HD 7的破解方法来解锁Mozart的：

准备一台PC，装好Windows Phone Develop Tools和Zune，用数据线将手机和PC连接起来，让Zune和手机处于完全同步的状态（即Sync Relationship不能是Guest）。
下载ChevronWP7，将其中的ChevronWP7.cer证书文件传输至手机（可以放在某个站点上用Windows Phone的浏览器下载，或用Email做个中转）并安装。
确保开着Zune，且机器并没有PIN-Locked（即不是黑屏待机或是主画面锁定状态），打开ChevronWP7.exe，选中两个checkbox，再点击Unlock即解锁成功。Unlock之后可以Relock。

经多次试验，发现每次将手机连上机器后（并启动Zune），则会重新变成锁定状态，这时则需要使用ChevronWP7.exe重新解锁。为了避免被重新锁定，您可以在连接之前把手机的飞行模式（airplane mode）打开，连上以后再关闭。解锁后的机器，可以直接使用Application Deployment工具安装xap文件，也可以在VS里选择在Windows Phone 7 Device里调试。在真机上部署和调试都很快，很流畅，让人完全不想用模拟器。我写了点简单的程序（一个Instagram客户端雏形），不得不再次感叹F#写异步程序真的很爽。

香港之行除了Windows Phone以外，我还带回了一台Xbox 360及Kinect（加起来大约3200人民币）。

如果您还不知道这是什么的话，那么实在是落伍了。与Wii或PS3的控制杆不同，Kinect识别的是整个人体。因此，以后（其实应该说已经是“现在”了）人们完全是这样玩游戏的：

程序是这样操作的：

而我们也可以写这样的程序：

什么叫革命？什么叫突破？这就叫革命，这就叫突破。

最后再补充个好消息：MonoDroid的预览版已经对外公开了，可以自由安装。至此，.NET的“跨平台移动开发”战略又踏出了坚实的一步。此外据Mono老大之前的说法，接下来还会有Nokia……

第三届nBazaar技术交流会开始报名

jeffz@live.com (老赵) — Mon, 20 Dec 2010 16:45:46 GMT

为了错开年底密集的技术会议，第三届nBazaar技术交流会（即前“盛大创新院赞助的.NET技术交流会”）将于2011年1月15日举行。第三届的交流会将继续以往四场高质量的演讲，这也是确定nBazaar名称之后的第一次活动，希望nBazaar能够真正成为“集市”般热闹的社区活动。从现在开始，nBazaar技术沙龙的相关信息将逐渐集中至独立域名中，欢迎关注。

志愿者招募

为了留下每次的活动资料，我们希望为每场演讲进行拍摄。如果您有这方面的志愿请发邮件至jeffz@nbazaar.org与我联系。

时间及议程安排

本次交流会首次向社区征集议题，我们在回复中挑选了三场：面向iPad平台的网站架构、面向企业应用语言ABAP、基于.NET的轻量级分布式框架，以及在创新院内部分享会上倍受好评的“分布式版本管理”话题。四位演讲者都是业界一线技术高手，四场话题都是他们的实战心得，希望能够让您满意。

时间	议程
12:30 ~ 13:00	签到
13:00 ~ 14:00	针对iPad平台的高性能网站架构
14:00 ~ 14:10	短休
14:10 ~ 15:10	分布式版本管理
15:10 ~ 15:40	茶歇
15:40 ~ 16:40	企业开发领域的语言特性
16:40 ~ 16:50	短休
16:50 ~ 17: 50	使用.NET构建轻量级分布式框架

演讲内容

以下为是四场演讲的信息：

针对iPad平台的高性能网站架构

讲师：马士杰，EF英孚教育，Tech Leader。关注高性能网站架构和前沿技术在线教育领域的应用创新。曾经重点关注的技术领域包括ORM，AOP和SOA。近期的关注重点是针对移动平台的高性能网站架构。

简介：iPad的横空出世，几乎使得2010年成为全球IT领域的平板电脑之年。摩根士丹利发布的《移动互联网报告》认为移动互联网周期是50年来的第5个新技术周期，以Apple的iPad平板电脑和手机上网为代表的移动互联网的增长势头将超过电脑上网。本演讲的目的是和听众分享本人近一年在针对iPad平台的高性能网站架构方面的一些经验，包括兼容不同平台桌面和移动浏览器的表现层设计模式，针对iPad Mobile Safari浏览器的Web页面性能优化和iPad本地程序和在线网站的无缝整合等。

分布式版本管理

讲师：李骏，中国第一批J2EE开发者，大中华区第一个中间件和SOA领域的Oracle ACE Director。有着10年以上企业级应用系统咨询/设计/实施以及软件公司管理经验的行业老兵，因为喜欢创造能影响人们日常生活的东西，所以来到盛大创新院，梦想能找到“正确的把软件作成业务”的方法。

演讲：源代码和其它软件工程产物的版本管理，是每个开发者每天都会碰到的问题，经过数十年的发展，CVS、SVN等上一代版本管理系统中的一些问题，催生着新的技术及其应用模式。在过去几年中以Git和Mercurial为代表的分布式版本管理工具有了较大的发展，已经基本具备了普及应用的基础。这里将介绍分布式版本管理欲解决的问题及其关键价值，并以Mercurial为例介绍具体使用的方法和流程。

企业开发领域的语言特性

讲师：师建茁（Amos Shi），GRC软件工程师，SAP Labs China。中学时代在 286、486 系统上学会了 12个DOS内部命令，若干外部命令；使用QBasic开始程序生涯，半夜起来在图画本上设计流程图。后来跟着谭浩强的C语言课本和Borland的TC 2.0进入 Windows CMD 时代，后来有了 C++、Delphi、Python、.NET、Java，排名不分先后，意识到语言并非那么重要；直到有一天，遇到了 ABAP，以及 Web Dynpro，意识到，对于优秀的软件，高级语言特性还是有所帮助的。2007年加入SAP Labs China，从事GRC软件产品的研发。日常工作涉及GRC 的多个部分。

演讲：作为一个程序员，在加入SAP之前用过一些各种各样流行的技术来写软件产品，到了Labs之后开始使用一种不广为所知的ABAP语言开发GRC软件产品。在学习和使用ABAP语言的过程中，经常会有类似“啊！对了，以前我就想过应该是这样的”、“是的！就是应该这样集成！”、“本来嘛，已经有足够的信息在那里了，她就是应该自动生成，一行代码都不应该写！”这样的感叹，对很多特性总是有相见恨晚的感觉。回想到以前的产品开发中遇到的种种问题，觉得如果这些特性已经有了的话，可以大大提高效率，降低错误。后来逐渐接触到其后面的NetWeaver平台，和Web Dynpro之后，更觉得这一整套东西为企业应用进行了精心设计。又回想起了“程序员如何在非洲捕捉大象？”这个经典笑话，哈哈哈哈。如果你要开发企业应用的话，确实有很多东西可以从这里借鉴，希望对你能有所裨益。

使用.NET构建轻量级分布式框架

讲师：乔捷，瓦格纳比罗舞台系统公司，技术主管。热爱技术，对多种技术领域都有涉猎，目前主要从事剧院舞台控制系统和虚拟舞台系统的设计和研发工作，主要涉及到分布式系统、实时控制系统、虚拟现实系统、3D实时/离线渲染等技术领域。主要的编程语言为C++/C#/JavaScript，喜爱.NET技术，最近比较关注分布式计算和并行计算技术，并已在实际的项目应用中取得了初步的成功。

演讲：分布式系统的设计和构建是一项复杂多变而很具有挑战性的任务，设计的目标包括服务的伸缩性、可靠性、安全性、实时性、性能、容错等多个方面，同时还可能需要面对各种异构平台的集成和整合。目前市面上已有的分布式框架包括.NET提供的Remoting和WCF，都不能很好的满足上述所有的这些需求。因此，打造一套轻量级的、高度可定制的、符合自身项目需求的分布式框架变得很有现实意义。本演讲就来讨论如何应用.NET技术构建这样一套轻量级的分布式框架。

地点

本次交流会举办地为上海市浦东新区碧波路888号畅星大厦（地铁二号线张江高科站下，步行10分钟可达）3楼会议厅，地图如下：

鸟瞰图：

畅星大厦外观：

会场实景照片：

会场容量可以容纳超过200人，希望到时候不会显得太过空旷。:)

报名信息

本次交流会现已开始报名，请填写报名表。

关于即将到来的“演出季”以及Jscex类库

jeffz@live.com (老赵) — Mon, 22 Nov 2010 12:30:57 GMT

又到了一年一度的“演出季”，接下来将是各式会议扑面而来的一个月。作为“与会爱好者”我自然也进入了繁忙的准备工作。接下来我将在TUP（11月27日）、2010年第二届.NET技术大会（12月4~5日）以及CSDN软件开发2.0大会（12月9~10日）上与大家分享四场演讲。不过除了一场是关于Windows并发编程的基础以外，其余三场的话题都是围绕“微软在异步编程方面的演变”。在这场演讲中，我还会引入一个与该话题密切相关的JavaScript类库：Jscex。

并发编程已经成为我们无法回避的一点，但是传统的编程语言在并发、异步等方面的支持非常有限，除了一些面向并发的编程语言（如Erlang），我们只能使用回调的方式，这样代码则被拆得支离破碎。如今的一些新语言，如F#，Scala，Go以及未来的C#都会在这方面有直接的支持。就我个人而言，用过了这些语言之后，就几乎无法回头，因为我实在无法体会到编程的快感。

如今微软的.NET平台在异步编程领域已经开始发力，从最初十分原始的Begin/End的异步模型和基于事件的异步模型，到后来F#中的异步工作流，.NET 4.0中的Observable及响应式框架，以及未来C#中将要出现的异步特性，.NET平台上涌现了各种与并发和异步编程的机制。未来几场演讲的主要话题，便是关于这些异步编程模型的演变。

只可惜，在某些和异步密切相关的平台上，例如使用JavaScript的浏览器平台，开发人员还是不得不利用最传统的开发模型。响应式框架通过引入一个“推模型”改进了这一点，不过我最欣赏的异步编程支持还是F#上的异步工作流。首先，它是一套“类库”（基于F#中的计算表达式特性）；其次，它让异步编程变得像传统的顺序式开发那样简单。有天我突然意识到，JavaScript其实提供一个很强大的机制：它可以使用toString方法得到一个函数的原始代码，于是我们可以对此解析并生成新的代码，最后使用eval得到新的函数。通过这个手法，JavaScript语言几乎得到了无限的灵活性。

于是在未来的演讲中，我将会展示一个JavaScript类库的原型：Jscex（目前还未提交任何代码）。Jscex是JavaScript Computation Expressions的缩写，即“JavaScript的计算表达式”。计算表达式的原理，便是将一段顺序式的代码，重新编译成另外一个表达式，它便是F#中异步工作流的基础。

例如，它会将下面这段JavaScript函数：

function (urlA, urlB) {
    var reqA = $await(Jscex.Async.sendRequest(urlA, "GET"));
    var lengthA = reqA.responseText.length;

    var reqB = $await(Jscex.Async.sendRequest(urlB, "GET"));
    var lengthB = reqB.responseText.length;

    return lengthA + lengthB;
}

编译成另一段代码：

function (urlA, urlB) {
    return $async.Delay(function() {
        return $async.Bind(Jscex.Async.sendRequest(urlA, "GET"), function(reqA) {
            var lengthA = reqA.responseText.length;
            return $async.Bind(Jscex.Async.sendRequest(urlB, "GET"), function(reqB) {
                var lengthB = reqB.responseText.length;
                return $async.Return(lengthA + lengthB);
            });
        });
    });
};

对于$async这个构造器来说，$await便是一个bind函数，在此处则会形成一个回调。此外，Jscex也必须能够正确处理循环操作，例如这个时钟示例（建议使用IE 9，Chrome或Firefox等支持canvas的浏览器观看）其实是这样实现的：

var drawClockAsync = eval(Jscex.compile("$async", function (interval) {
    while (true) {
        drawClock(new Date());
        $await(Jscex.Async.sleep(interval));
    }
}));

Jscex.Async.start(drawClockAsync(1000));

对于时钟来说，我们往往会不断使用window.setTimeout来更新界面。不过有了Jscex，一切都变得“顺其自然”。我们只要写一个“死循环”，在需要“等待”的时候，直接$await一个sleep操作即可。这种看似“阻塞”的代码，其实最终会被重新编译成新的函数：

function(interval) {
    return $async.Delay(function() {
        return $async.While(
            function() { return true; },
            $async.Delay(function() {
                drawClock(new Date);
                return $async.Bind(Jscex.Async.sleep(interval), function() {
                    return $async.Return();
                });
            })
        );
    });
};

实际上，它们都是异步的。

其实在浏览器上有太多的异步场景。例如一个AJAX请求，或者是一段动画效果。这里我还准备了第二个示例，其中有一段移动元素的方法（将元素e在duration时间内从startPos移动至endPos）是这样编写的：

var moveAsync = eval(Jscex.compile("$async", function (e, startPos, endPos, duration) {
    e.style.left = startPos.x;
    e.style.top = startPos.y;

    var time = 0;
    while (time < duration) {
        $await(Jscex.Async.sleep(50));
        time = time + 50;
        e.style.left = startPos.x + (endPos.x - startPos.x) * time / duration;
        e.style.top = startPos.y + (endPos.y - startPos.y) * time / duration;
    }
}));

var moveBox = document.getElementById("moveBox");
Jscex.Async.start(moveAsync(moveBox, { x: 0, y: 0 }, { x: 300, y: 0 }, 1000));

没有回调，只有最普通的顺序式编程。甚至我们还可以将moveAsync方法组合到另一个方法中去：

var moveSquareAsync = eval(Jscex.compile("$async", function (e) {
    $await(moveAsync(e, { x: 100, y: 100 }, { x: 400, y: 100 }, 1000));
    $await(moveAsync(e, { x: 400, y: 100 }, { x: 400, y: 400 }, 1000));
    $await(moveAsync(e, { x: 400, y: 400 }, { x: 100, y: 400 }, 1000));
    $await(moveAsync(e, { x: 100, y: 400 }, { x: 100, y: 100 }, 1000));
}));

var moveSquareBox = document.getElementById("moveSquareBox");
Jscex.Async.start(moveSquareAsync(moveSquareBox));

如何让一个元素沿方形移动？“连续执行”四遍moveAsync方法即可。当然，moveSquareAsync方法最终还是由“回调”组成的：

function (e) {
    return $async.Delay(function () {
        return $async.Bind(moveAsync(e, {...}, {...}, 1000), function () {
            return $async.Bind(moveAsync(e, {...}, {...}, 1000), function () {
                return $async.Bind(moveAsync(e, {...}, {...}, 1000), function () {
                    return $async.Bind(moveAsync(e, {...}, {...}, 1000), function () {
                        return $async.Return();
                    });
                });
            });
        });
    });
};

我以前在许多地方说过，目前浏览器上的开发效率已经受限于JavaScript的语言特性了。不过，正如我刚才所提到的那样，JavaScript语言的灵活性几乎是无穷的。我认为，Jscex会是一个突破。当然，现在您看到的演示只不过是个原型，如果要提供一个完整的解决方案还有太多的路要走。例如现在的Jscex还不支持for，if，try...catch等常见语言特性，代码也丑陋得很。与此对应的Jscex.Async也只是个初步的模型，且只有寥寥无几的辅助方法。

使用Narcissus解析JavaScript代码

jeffz@live.com (老赵) — Wed, 17 Nov 2010 10:08:03 GMT

最近在做一个有关JavaScript的实验，需要在客户端将JavaScript代码解析为一棵语法树。换句话说，就是一个用JavaScript实现的JavaScript解析器。这方面的选择有很多，常见的yacc、lex或是bison等等都有JavaScript的版本，使用ANTLR也可以将生成目标设为JavaScript。不过我不想在这方面耗费太多时间，自然想找个现成的工具，于是最终我将目标放在了Narcissus上。

Narcissus是一个JavaScript引擎，完全使用JavaScript编写，不过利用了SpiderMonkey的一些扩展，因此无法直接在仅仅实现了ECMAScript 3的引擎上执行（例如各浏览器）。从它的Wikipedia页面上得知，Narcissus由SpiderMonkey的作者Brendan Eich开发，名称来源于希腊神话中爱上自己倒影的人物，和“JavaScript编写的JavaScript引擎”的概念契合（真是太有文化了）。此外，Firefox有一个Zaphod插件，可以将浏览器的JavaScript引擎替换为Narcissus。

Narcissus是个十分简单的JavaScript引擎，可以用来做一些JavaScript语言新特性的探索工作。它几乎不做任何优化，因此不能与其他引擎比拼性能，但很显然它包含完整的JavaScript分析器，正好为我所用。首先，从Github上下载它的源代码，其中包括六个文件，而我只需要其中的三个：

jsdef.js：包含了Narcissus.definitions组件，各种Token定义等等。
jslex.js：包含了Narcissus.lexer组件，分词器。
jsparse.js：包含了Narcissus.parser，分析器。

之前提到过，Narcissus不能直接在浏览器上运行，因此我们还必须对它进行修改。首先，是在jsdefs.js文件中，我们需要将开头的一段利用Object.create方法的定义：

(function() {
    var builderTypes = Object.create(null, {
        ...
    });

    ...

    var narcissus = {
        ...
    };

    Narcissus = narcissus;
})();

替换成直接的声明：

var Narcissus = { };

其次还是在jsdefs.js中，我们要改变defineProperty和defineGetter的实现：

function defineGetter(obj, prop, fn, dontDelete, dontEnum) {
    Object.defineProperty(...);
}

function defineProperty(obj, prop, val, dontDelete, readOnly, dontEnum) {
    Object.defineProperty(...);
}

Object的defineProperty和defineGetter方法也是SpiderMonkey的扩展，我们要把它们修改为“直接赋值”的版本：

function defineGetter(obj, prop, fn, dontDelete, dontEnum) {
    obj[prop] = fn;
}

function defineProperty(obj, prop, val, dontDelete, readOnly, dontEnum) {
    obj[prop] = val;
}

当然，这么做与之前的效果并不等价，不过并不影响代码的使用。您可以从jsparse.js文件中找到使用了这两个方法的地方。

现在您就可以在一个页面里引入这三个JavaScript文件，并Narcissus.parser分析JavaScript代码了。Narcissus几乎没有说明文档，不过从代码中找到它的使用方法并不困难。例如：

function parseSelf() { 
    var builder = new Narcissus.parser.DefaultBuilder();
    return Narcissus.parser.parse(builder, parseSelf.toString(), "temp", 1);
}

document.write("<pre>" + parseSelf() + "</pre>");

<pre>{
    type: SCRIPT,
    children: {
        type: FUNCTION,
        body: {
            type: SCRIPT,
            children: {
                type: VAR,
                children: {
                    type: IDENTIFIER,
                    children: ,
                    end: 38,
                    initializer: {
                        type: NEW,
                        children: {
                            type: DOT,
                            children: {
                                type: DOT,
                                children: {
                                    type: IDENTIFIER,
                                    children: ,
                                    end: 55,
                                    lineno: 2,
                                    start: 46,
                                    tokenizer: [object Object],
                                    value: Narcissus
                                },{
                                    type: IDENTIFIER,
                                    children: ,
                                    end: 62,
                                    lineno: 2,
                                    start: 56,
                                    tokenizer: [object Object],
                                    value: parser
                                },
                                end: 62,
                                lineno: 2,
                                start: 46,
                                tokenizer: [object Object],
                                value: .
                            },{
                                type: IDENTIFIER,
                                children: ,
                                end: 77,
                                lineno: 2,
                                start: 63,
                                tokenizer: [object Object],
                                value: DefaultBuilder
                            },
                            end: 77,
                            lineno: 2,
                            parenthesized: true,
                            start: 46,
                            tokenizer: [object Object],
                            value: .
                        },
                        end: 77,
                        lineno: 2,
                        start: 41,
                        tokenizer: [object Object],
                        value: new
                    },
                    lineno: 2,
                    name: builder,
                    readOnly: false,
                    start: 31,
                    tokenizer: [object Object],
                    value: builder
                },
                destructurings: ,
                end: 38,
                lineno: 2,
                start: 27,
                tokenizer: [object Object],
                value: var
            },{
                type: RETURN,
                children: ,
                end: 90,
                lineno: 3,
                start: 84,
                tokenizer: [object Object],
                value: {
                    type: CALL,
                    children: {
                        type: DOT,
                        children: {
                            type: DOT,
                            children: {
                                type: IDENTIFIER,
                                children: ,
                                end: 100,
                                lineno: 3,
                                start: 91,
                                tokenizer: [object Object],
                                value: Narcissus
                            },{
                                type: IDENTIFIER,
                                children: ,
                                end: 107,
                                lineno: 3,
                                start: 101,
                                tokenizer: [object Object],
                                value: parser
                            },
                            end: 107,
                            lineno: 3,
                            start: 91,
                            tokenizer: [object Object],
                            value: .
                        },{
                            type: IDENTIFIER,
                            children: ,
                            end: 113,
                            lineno: 3,
                            start: 108,
                            tokenizer: [object Object],
                            value: parse
                        },
                        end: 113,
                        lineno: 3,
                        start: 91,
                        tokenizer: [object Object],
                        value: .
                    },{
                        type: LIST,
                        children: {
                            type: IDENTIFIER,
                            children: ,
                            end: 121,
                            lineno: 3,
                            start: 114,
                            tokenizer: [object Object],
                            value: builder
                        },{
                            type: CALL,
                            children: {
                                type: DOT,
                                children: {
                                    type: IDENTIFIER,
                                    children: ,
                                    end: 132,
                                    lineno: 3,
                                    start: 123,
                                    tokenizer: [object Object],
                                    value: parseSelf
                                },{
                                    type: IDENTIFIER,
                                    children: ,
                                    end: 141,
                                    lineno: 3,
                                    start: 133,
                                    tokenizer: [object Object],
                                    value: toString
                                },
                                end: 141,
                                lineno: 3,
                                start: 123,
                                tokenizer: [object Object],
                                value: .
                            },{
                                type: LIST,
                                children: ,
                                end: 142,
                                lineno: 3,
                                start: 141,
                                tokenizer: [object Object],
                                value: (
                            },
                            end: 142,
                            lineno: 3,
                            start: 123,
                            tokenizer: [object Object],
                            value: (
                        },{
                            type: STRING,
                            children: ,
                            end: 151,
                            lineno: 3,
                            start: 145,
                            tokenizer: [object Object],
                            value: temp
                        },{
                            type: NUMBER,
                            children: ,
                            end: 154,
                            lineno: 3,
                            start: 153,
                            tokenizer: [object Object],
                            value: 1
                        },
                        end: 154,
                        lineno: 3,
                        start: 113,
                        tokenizer: [object Object],
                        value: (
                    },
                    end: 154,
                    lineno: 3,
                    start: 91,
                    tokenizer: [object Object],
                    value: (
                }
            },
            end: 90,
            funDecls: ,
            id: 0,
            lineno: 1,
            start: 21,
            tokenizer: [object Object],
            value: {,
            varDecls: {
                type: IDENTIFIER,
                children: ,
                end: 38,
                initializer: {
                    type: NEW,
                    children: {
                        type: DOT,
                        children: {
                            type: DOT,
                            children: {
                                type: IDENTIFIER,
                                children: ,
                                end: 55,
                                lineno: 2,
                                start: 46,
                                tokenizer: [object Object],
                                value: Narcissus
                            },{
                                type: IDENTIFIER,
                                children: ,
                                end: 62,
                                lineno: 2,
                                start: 56,
                                tokenizer: [object Object],
                                value: parser
                            },
                            end: 62,
                            lineno: 2,
                            start: 46,
                            tokenizer: [object Object],
                            value: .
                        },{
                            type: IDENTIFIER,
                            children: ,
                            end: 77,
                            lineno: 2,
                            start: 63,
                            tokenizer: [object Object],
                            value: DefaultBuilder
                        },
                        end: 77,
                        lineno: 2,
                        parenthesized: true,
                        start: 46,
                        tokenizer: [object Object],
                        value: .
                    },
                    end: 77,
                    lineno: 2,
                    start: 41,
                    tokenizer: [object Object],
                    value: new
                },
                lineno: 2,
                name: builder,
                readOnly: false,
                start: 31,
                tokenizer: [object Object],
                value: builder
            }
        },
        children: ,
        end: 158,
        functionForm: 0,
        lineno: 1,
        name: parseSelf,
        params: ,
        start: 0,
        tokenizer: [object Object],
        value: function
    },
    funDecls: {
        type: FUNCTION,
        body: {
            type: SCRIPT,
            children: {
                type: VAR,
                children: {
                    type: IDENTIFIER,
                    children: ,
                    end: 38,
                    initializer: {
                        type: NEW,
                        children: {
                            type: DOT,
                            children: {
                                type: DOT,
                                children: {
                                    type: IDENTIFIER,
                                    children: ,
                                    end: 55,
                                    lineno: 2,
                                    start: 46,
                                    tokenizer: [object Object],
                                    value: Narcissus
                                },{
                                    type: IDENTIFIER,
                                    children: ,
                                    end: 62,
                                    lineno: 2,
                                    start: 56,
                                    tokenizer: [object Object],
                                    value: parser
                                },
                                end: 62,
                                lineno: 2,
                                start: 46,
                                tokenizer: [object Object],
                                value: .
                            },{
                                type: IDENTIFIER,
                                children: ,
                                end: 77,
                                lineno: 2,
                                start: 63,
                                tokenizer: [object Object],
                                value: DefaultBuilder
                            },
                            end: 77,
                            lineno: 2,
                            parenthesized: true,
                            start: 46,
                            tokenizer: [object Object],
                            value: .
                        },
                        end: 77,
                        lineno: 2,
                        start: 41,
                        tokenizer: [object Object],
                        value: new
                    },
                    lineno: 2,
                    name: builder,
                    readOnly: false,
                    start: 31,
                    tokenizer: [object Object],
                    value: builder
                },
                destructurings: ,
                end: 38,
                lineno: 2,
                start: 27,
                tokenizer: [object Object],
                value: var
            },{
                type: RETURN,
                children: ,
                end: 90,
                lineno: 3,
                start: 84,
                tokenizer: [object Object],
                value: {
                    type: CALL,
                    children: {
                        type: DOT,
                        children: {
                            type: DOT,
                            children: {
                                type: IDENTIFIER,
                                children: ,
                                end: 100,
                                lineno: 3,
                                start: 91,
                                tokenizer: [object Object],
                                value: Narcissus
                            },{
                                type: IDENTIFIER,
                                children: ,
                                end: 107,
                                lineno: 3,
                                start: 101,
                                tokenizer: [object Object],
                                value: parser
                            },
                            end: 107,
                            lineno: 3,
                            start: 91,
                            tokenizer: [object Object],
                            value: .
                        },{
                            type: IDENTIFIER,
                            children: ,
                            end: 113,
                            lineno: 3,
                            start: 108,
                            tokenizer: [object Object],
                            value: parse
                        },
                        end: 113,
                        lineno: 3,
                        start: 91,
                        tokenizer: [object Object],
                        value: .
                    },{
                        type: LIST,
                        children: {
                            type: IDENTIFIER,
                            children: ,
                            end: 121,
                            lineno: 3,
                            start: 114,
                            tokenizer: [object Object],
                            value: builder
                        },{
                            type: CALL,
                            children: {
                                type: DOT,
                                children: {
                                    type: IDENTIFIER,
                                    children: ,
                                    end: 132,
                                    lineno: 3,
                                    start: 123,
                                    tokenizer: [object Object],
                                    value: parseSelf
                                },{
                                    type: IDENTIFIER,
                                    children: ,
                                    end: 141,
                                    lineno: 3,
                                    start: 133,
                                    tokenizer: [object Object],
                                    value: toString
                                },
                                end: 141,
                                lineno: 3,
                                start: 123,
                                tokenizer: [object Object],
                                value: .
                            },{
                                type: LIST,
                                children: ,
                                end: 142,
                                lineno: 3,
                                start: 141,
                                tokenizer: [object Object],
                                value: (
                            },
                            end: 142,
                            lineno: 3,
                            start: 123,
                            tokenizer: [object Object],
                            value: (
                        },{
                            type: STRING,
                            children: ,
                            end: 151,
                            lineno: 3,
                            start: 145,
                            tokenizer: [object Object],
                            value: temp
                        },{
                            type: NUMBER,
                            children: ,
                            end: 154,
                            lineno: 3,
                            start: 153,
                            tokenizer: [object Object],
                            value: 1
                        },
                        end: 154,
                        lineno: 3,
                        start: 113,
                        tokenizer: [object Object],
                        value: (
                    },
                    end: 154,
                    lineno: 3,
                    start: 91,
                    tokenizer: [object Object],
                    value: (
                }
            },
            end: 90,
            funDecls: ,
            id: 0,
            lineno: 1,
            start: 21,
            tokenizer: [object Object],
            value: {,
            varDecls: {
                type: IDENTIFIER,
                children: ,
                end: 38,
                initializer: {
                    type: NEW,
                    children: {
                        type: DOT,
                        children: {
                            type: DOT,
                            children: {
                                type: IDENTIFIER,
                                children: ,
                                end: 55,
                                lineno: 2,
                                start: 46,
                                tokenizer: [object Object],
                                value: Narcissus
                            },{
                                type: IDENTIFIER,
                                children: ,
                                end: 62,
                                lineno: 2,
                                start: 56,
                                tokenizer: [object Object],
                                value: parser
                            },
                            end: 62,
                            lineno: 2,
                            start: 46,
                            tokenizer: [object Object],
                            value: .
                        },{
                            type: IDENTIFIER,
                            children: ,
                            end: 77,
                            lineno: 2,
                            start: 63,
                            tokenizer: [object Object],
                            value: DefaultBuilder
                        },
                        end: 77,
                        lineno: 2,
                        parenthesized: true,
                        start: 46,
                        tokenizer: [object Object],
                        value: .
                    },
                    end: 77,
                    lineno: 2,
                    start: 41,
                    tokenizer: [object Object],
                    value: new
                },
                lineno: 2,
                name: builder,
                readOnly: false,
                start: 31,
                tokenizer: [object Object],
                value: builder
            }
        },
        children: ,
        end: 158,
        functionForm: 0,
        lineno: 1,
        name: parseSelf,
        params: ,
        start: 0,
        tokenizer: [object Object],
        value: function
    },
    id: 0,
    lineno: 1,
    tokenizer: [object Object],
    varDecls: 
}</pre>

在JavaScript中调用一个函数的toString方法会得到它的代码，于是执行上面这段代码会打印出parseSelf方法的语法树。剩下的我就不多说了，爱玩的同学自然知道可以做什么。

补：经过实验，Narcissus还是过于依赖SpiderMonkey引擎的特性，如果要在IE上运行还是需要修改更多内容。此外，最新的Narcissus源码还有一些bug，如果您想要使用合适的实现，不妨参考NarrativeJS中旧版的Narcissus代码。

PDC 2010：C#与Visual Basic的未来（下）

jeffz@live.com (老赵) — Mon, 15 Nov 2010 09:47:47 GMT

前几天在PDC 2010会议上Anders Hejlsberg发表了一场名为“The Future of C# and Visual Basic”的演说，谈论了未来C#和VB中最为重要的两个特性：“异步（Async）”及“编译器即服务（Compiler as a Service）”。我现在对这场演讲进行总结，但不会像上次《编程语言的发展趋势及未来方向》那样逐句翻译，而是以Anders的角度使用一种简捷合适的方式表述其完整内容。上一篇Anders对async和await的的实现及效果作更进一步的解释，本篇则是对“编译器即服务”做了些最表面的尝试。

你们某些人可能参加了PDC 2008，那时我谈到了“编译器即服务（Compier as a Service）”，也作了点演示。现在我来演示一点这方面的进展。

编译器即服务的关键，在于目前的编译器是个黑盒，输入源文件，输出.NET程序集。至于它是如何工作的，你不能参与进去。

为了打造更灵活工作过程，我们把编译器展开，把其中的信息展示出来并加以利用，这样就能做到实现元编程、REPL，把C#和VB作为内嵌的DSL，或是根据语言对象模型实现重构，代码生成器等语义相关的工作。

我最后的示例便是些这方面的展示。（译注：这个示例展示的代码非常复杂，但并不重要，它的主要目的便是根据编译器提供的语言对象模型，判断其中的if/else逻辑，并在Visual Studio中显示出轮廓（就像方法的折叠功能一样）。有趣的是，这个演示失败了……）

这里的语言对象模型，就是C#和VB编译器内部所使用的，包含了完整的语义，可用于理解代码的工作目的。有了这些数据，我们就能作一些非常有趣的事情了。例如，我们有两个语言，它们的语法非常接近，不是吗？那么我们理解了其中一个语言，把它转化成另外一个应该也不太困难。

这里还有一个简单的C#到VB的代码转换器（译注：又一个演示），你可以把C#代码复制到剪贴板里，然后粘贴成VB代码。在实现时，只不过遍历了C#语法树，生成另一个对象模型。当然，这个程序也不是太简单，实际上还是要有几千行代码的，这里只是个最简单的实现。那么我这里来试着把那段没法工作的代码，粘贴到VB文件中……砰，这就出现了功能一致的VB代码（掌声）。这就是利用这种技术可以做到的事情。我们也已经发布了CTP版本的编译器，也包含了这些示例。

我答应过，这里是Visual Studio Async CTP的下载地址，它基于Visual Studio 2010安装。其中包含了所有我演示过的示例，有C#也有VB。此外还有一些相关的讲座，例如LINQ，我也会参加下午的语言话题讨论。接下来还有点时间，可以回答一两个问题。

提问：除了这里您提到的这些，C#和VB还会包含其他功能吗？

Anders：呃，现在说起C#和VB最终是什么样的为时尚早，不过的确还有些其他的功能。

提问：我想知道您对于数据并发和数据共享的看法。

Anders：并发有许多令人头痛的地方，你说的就是其中之一。我们在内部有些研究是关于不可变性，状态隔离，纯函数式编程，还有其他一些编译器方面的工作。现在还没有准备好公开，不过我们正在取得些不错的进展。我相信接下来的几十年间并发会一直是个课题，这里的异步功能是其中的一小步，我肯定还会有更多进展。

提问：从反射的视角来说，异步方法和普通方法有什么区别？

Anders：对于反射来说，异步方法就是普通的方法，调用方法也一样。不过它会在第一个await的地方返回，等异步任务完成之后，它再继续执行下去。所以它其实和普通方法没有任何区别，但如果你要知道它什么时候结束，那么就必须去关注它返回的Task对象了。你还看到我写过一些void方法，可能你根本不会在乎它什么时候结束，不过原理上它还是一样的。

就到这里，非常感谢各位参与。

服务器端执行JavaScript代码

jeffz@live.com (老赵) — Tue, 09 Nov 2010 10:11:28 GMT

话说，如今不在客户端使用JavaScript代码才是稀奇事儿。由于Web应用的体验越来越丰富，客户端用JavaScript实现的逻辑也越来越多，这造成的结果就是某些几乎一致的逻辑需要在客户端和服务器端各实现一遍。这违反了DRY原则，不容易维护。幸运的是，我们可以在服务器端执行JavaScript代码，谁让JavaScript傍上了这无比霸道的浏览器平台呢？

例如，如今在客户端使用JavaScript进行验证已经是个标准，它可以有效避免用户在正常情况下提交错误的数据，增强用户体验。当然，服务器端的验证是必不可少的，因为这才是“安全性”的体现。有些解决方案，会在服务器端提供有限的验证种类，然后在客户端生成JavaScript代码，并辅以服务器端的验证框架。这种做法可以追溯到ASP.NET 1.x上的Validator控件，但这显然会有扩展性，灵活性上的限制，因此我更倾向于在服务器端执行JavaScript代码。

例如，要检查用户名是否合法，我们可能会写这样的JavaScript代码：

var checkName = function (name) { return /^\w{3,10}$/.test(name); }

这在客户端验证自然没有任何问题，服务器端就要借助一些JavaScript执行引擎了。在.NET平台上有例如比较新的IronJS项目，这是个基于DLR的JavaScript执行引擎，十分重视性能，从作者博客上的评测结果来看，甚至领先于以速度见长的V8。可惜的是，IronJS还没有完整实现ECMAScript 3.0，还缺少一些重要功能，例如正则表达式。

Jint是一个.NET平台上较早的JavaScript执行引擎，因此与DLR关系不大，因此可能不太容易与IronPython，IronRuby等语言进行互操作。用它来执行一些简单的JavaScript脚本不成问题，例如上面的代码：

var jint = new Jint.JintEngine();
jint.Run(@"var checkName = function(name) { return /^\w{3,10}$/.test(name); }");

Console.WriteLine(jint.CallFunction("checkName", "jeffz")); // True
Console.WriteLine(jint.CallFunction("checkName", "hello world")); // False

只可惜，在实际使用中，Jint不支持多线程的环境，即我们无法在多个线程下同时调用jint的CallFunction方法，但是如果每次都重新Run一遍JavaScript代码，也会带来较多的性能开销。其实要解决这个问题也并不困难，构造一个对象池即可，.NET 4中提供了并行容器（如ConcurrentStack，ConcurrentQueue），实现一个简单的对象池可谓不费吹灰之力。

这方面Jurassic的表现要好的多，这是一个构建于.NET 4.0的JavaScript执行引擎：

var engine = new Jurassic.ScriptEngine();
engine.Evaluate(@"var checkName = function(name) { return /^\w{3,10}$/.test(name); }");

Console.WriteLine(engine.CallGlobalFunction<bool>("checkName", "jeffz"));
Console.WriteLine(engine.CallGlobalFunction<bool>("checkName", "hello world"));

此外，从Benchmark上来看，Jurassic性能也比Jint有所提高，但还是远远落后于V8，甚至IE 8里的JavaScript引擎。而且，它还提供了一个基于Silverlight控制台，您可以在浏览器里把玩一番。

令人感到意外的是，Jint和Jurassic作为JavaScript执行引擎都有一些严重的问题，那便是不能正确运行showdown.js（JavaScript实现的Markdown转化器）——虽然我并没有发现showdown.js中有过于复杂的内容，基本就是些字符串操作吧。原本我还想把它们用在mono中，既然如此也就不做进一步尝试了。不过，经过简单的实验，Jurassic似乎使用了mono 2.8中尚不支持的接口，但也有可能只是Jurassic控制台中的问题。

有趣的是，.NET平台下最靠谱的JavaScript执行引擎居然是Rhino JavaScript，最近一次发布是在2009年3月，不过实现的十分完整。要说缺点，可能就是使用起来比较麻烦，还有，这是个Java项目。

嗯，我没有开玩笑，我们完全可以在.NET平台下使用Rhino JavaScript：

var cx = Context.enter();
try
{
    var scope = cx.initStandardObjects();
    cx.evaluateString(scope, @"var checkName = function(name) { return /^\w{3,10}$/.test(name); }", "checkName.js", 1, null);
    var func = (Function)scope.get("checkName", scope);

    Console.WriteLine(Context.toString(func.call(cx, scope, scope, "jeffz")));
    Console.WriteLine(Context.toString(func.call(cx, scope, scope, "hello world"));
}
finally 
{
    Context.exit();
}

因为我们有IKVM.NET。mono等.NET开源社区上有大量宝藏，就看您能利用多少了。我用ikvmc把js.jar转化为RhinoJs.dll之后就可以直接使用，效果很好，对调试也有很好的支持（如果JavaScript执行时出现了错误，则VS会直接带您至出错的那行）。性能也是比较令人满意的，在我的Mac OSX上安装的Ubuntu Server 10.10虚拟机，单线程转化并过滤博客上最近的3800条评论，大约耗时20秒。试验时Host上还开着一个Windows 7虚拟机，还有大量浏览器等应用程序，并不十分空闲。

您可能知道，我的博客目前是基于mono 2.6的，其中比较有特色的地方便是评论功能了，我使用Markdown标记，并提供了实时的预览功能，这自然需要在客户端解释Markdown标记，并进行过滤。目前，我还在服务器使用了C#实现的Markdown转化器及过滤逻辑，但在某些特殊情况下结果会有所不同，且需要维护两套代码。不久以后，我会将把博客升级为ASP.NET 4.0及mono 2.8（C# 4.0的dynamic特性在某些情况下的确比较方便），并且在服务器端使用IKVM.NET + Rhino JavaScript执行相同转化代码。从效果上来看还是十分令人满意的。

值得一提的是，其实在.NET平台上还有一个基于DLR的JavaScript执行引擎，是为RemObjects Script for .NET，据称也支持mono。只可惜它并不是开源产品（不过公开了源代码），且授权协议要求我们最多在5台机器上安装代码，且只供我们自己使用，于是我就没有对它有关注太多了。

PDC 2010：C#与Visual Basic的未来（中）

jeffz@live.com (老赵) — Sun, 31 Oct 2010 13:49:48 GMT

前几天在PDC 2010会议上Anders Hejlsberg发表了一场名为“The Future of C# and Visual Basic”的演说，谈论了未来C#和VB中最为重要的两个特性：“异步（Async）”及“编译器即服务（Compiler as a Service）”。我现在对这场演讲进行总结，但不会像上次《编程语言的发展趋势及未来方向》那样逐句翻译，而是以Anders的角度使用一种简捷合适的方式表述其完整内容。上一篇Anders讲述了async和await的使用方式，而这篇则是对这两个关键字的实现及效果作更进一步的解释。

异步方法的目标，是为了让代码与同步方法保持一致。微软要让代码充斥着回调函数，混乱不堪，它们完全不是逻辑上你想做的事情。可能您的代码中包含着一个核心模型，你也已经实现了，只是您现在想把它的执行过程变得异步化。您自己就可以享受到这一点。

与我们之前做的一些扩展一样，工作分为语言和框架两部分。语言的异步功能基于框架中的Task<T>，我们会围绕着Task<T>扩展框架，将它作为异步模型的核心。事实上，从Begin/End，或是基于事件的异步模型进行扩展往往只需要一两行封装的代码，于是您也可以得到自己的Task<T>模型。

而在语言方面，我们添加了两个新的关键字。一个是async关键字，用于把方法标记为异步。还有一个是await方法，用于等待异步工作完成，或者说是把控制权交换给调用方继续执行其他工作。这两个功能在C#和VB种均有体现。

那么什么是Task<T>呢？它表现的是一个“后续会继续进行的操作”，这可以是许多东西，Task<T>并不做任何限制，例如是一个异步I/O，后台工作线程等等，甚至可以是UI上的一个按钮，在用户点击之后任务就结束了。

Task<T>的优势在于，它使用一个对象封装了整个概念，您可以查询其结果或是状态，或是这个任务所引发的异常。您可以用它来构造一个可组合的异步模型，这正式我们目前的异步编程模型所不足的地方。

此外，它还提供了一个可组合的回调模型，您可以对一个任务指定说，在它结束之后执行另外一段代码，然后还可以对这个新的任务继续进行设定。这便构造出一个完整的逻辑流，框架会自行帮你完成这些工作。事实上await操作符便会自动把您的逻辑改写成这样的代码，它将您从Lambda表达式及回调函数中的逻辑里解放了出来，一切都交给编译器去做了。您可能会有些疑惑，不过其实这些都是编译器所擅长的事情。

由于我们统一了异步模型，我们就可以在此之上构建组合工具。例如WhenAll，它接受一系列的Task对象，并在全部结束之后返回所有结果。还有WhenAny，则等待第一个完成的任务，返回其结果。我们还有Delay，可以等待一段时间，但不占用任何资源。

沿着这个过程走一遍可能就会清晰一些。这里有个例子，一个异步方法调用另一个异步方法。我们假设这是在UI线程上执行的，消息会一个一个发送至UI线程上。

好，有人调用了DoWorkAsync，于是出现了一些任务。

DoWorkAsync的第一件事，是调用了ProcessFeedAsync。

ProcessFeedAsync方法是一个异步方法，所以它做的第一件事是构造一个表示任务的Task对象。

然后它调用了DownloadFeedAsync，这会创建另一个Task对象。然后，我们遇上了await操作符，这意味着ProcessFeedAsync后面的部分，将作为DownloadFeedAsync完成后的回调函数/continuation里的工作。

于是任务返回至DoWorkAsync，我们得到了t1这个对象。

同样的过程会再次出现，是为t2。

然后便调用了Task.WhenAll，这会创建一个新任务，表示前两个任务全部完成。于是这里的await操作符表示接下去的代码会在前两个任务完成后再继续下去。此时控制权便还给了DoWorkAsync的调用者，不会对线程造成负担。

在未来某一时刻t1和t2会执行完，我们假设t2先结束。此时它会说：我完成了，执行回调函数/continuation吧。

于是它会和发起线程的SynchronizationContext交互，给UI线程发一个消息，让后续任务在UI线程上继续执行──您的代码不用关注这些。现在代码运行至SaveDocAsync上了，这是另外一个异步任务。await让代码在这里返回，线程又可以执行目前还未结束的任务了。

于是SaveDocAsync任务完成了，UI线程又获得了一个消息执行后续工作。

此时任务便到达了ProcessFeedAsync的末尾，于是t2任务结束了。

继续等待，上面的过程会再次出现，最终t1也结束了。

当t1和t2完成以后，最后DoWorkAsync任务也终于结束了。可以看到，我们逻辑流程，无论是循环还是异常捕获都是同步的，但是其中的执行过程完全是异步的。

但是这又是如何实现的？我不会在这里说太细，这又是个完整的话题了。这里有一个例子，是一个异步方法，它会调用并await另一个异步方法。

而编译器则最终则生成类似于这样的代码。我只会提几点，首先，这是个状态机，编译器构造的其实就是个状态机，例如迭代器就是个状态机，事实上这里编译器的工作和yield之余迭代器的重写本质上没有太大区别。

其次就是关于任务的执行和等待，假如在等待时任务已经完成了，那么其实您是在同步地执行后续代码。我们没有必要交还控制，反正已经完成了，我们不妨就直接进行下去了。await有自己的模式，会决定这一任务是同步还是异步地执行。对于同步执行的任务，一切就继续执行下去了，直到某个需要异步执行的地方，便把控制权交还给调用方。

那么我们再来看一下异步之于Web服务的意义。这里有个ASP.NET页面，它会向数据库里获取许多RSS地址，然后下载到本地并解析：

private void ProcessData()
{
    // ...

    var urls = new List<string>();
    using (var conn = new SqlConnection(connectionString))
    {
        conn.Open();
        var cmd = new SqlCommand("GetUserFeeds", conn);
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Parameters.AddWithValue("@UserID", user);
        using (var reader = cmd.ExecuteReader())
        {
            while (reader.Read()) urls.Add(reader["FeedURL"].ToString());
        }
    }

    var feeds = (from url in urls select CreateWebClient().DownloadString(url)).ToArray();

    // ...
}

这里用到了DownloadString这个同步下载数据的方法。执行下来大约要花费1秒多的时间。这里我不再演示令人痛苦的异步写法了，你必须在Page_Load和Page_PreRender各写一些逻辑，注册一些异步工作，或者就要启用一些后台线程，但这又会影响后台的线程池，对系统的表现会带来影响。

现在我来演示一些简单的异步化工作：

private async void ProcessData()
{
    // ...

    var urls = new List<string>();
    using (var conn = new SqlConnection(connectionString))
    {
        conn.Open();
        var cmd = new SqlCommand("GetUserFeeds", conn);
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Parameters.AddWithValue("@UserID", user);
        using (var reader = await cmd.ExecuteReaderAsync())
        {
            while (reader.Read()) urls.Add(reader["FeedURL"].ToString());
        }
    }

    var feeds = await TaskEx.WhenAll(
        from url in urls select CreateWebClient().DownloadStringTaskAsync(url));

    // ...
}

我们将DownloadString修改为DownloadStringTaskAsync，这样LINQ返回的就是一系列表示下载任务的Task对象，然后使用await及WhenAll等待它们全部完成。数据库查询也可以如此。这就是所有我们要做的事情。如今页面的执行效率有了很明显的提高。使用这个做法，我们可以很轻松地提高Web系统的伸缩能力。如今我们需要调用很多互相独立的服务的情况越来越多了，异步方法对此有很大帮助。

如今的异步场景有许多种，例如在后台执行一个计算任务，这是基于CPU的异步，还有基于网络或I/O的异步任务。这些都能用Task来表示出来，因为Task表示的就是未来会完成的异步任务。此外，有了async和.NET框架，我们则出现了另外一种任务，既基于某些任务组合而成的异步任务。这也就是async方法所体现出的异步任务，它可以让你使用传统的语句来构造异步执行过程。

例如有这么一个场景：获取链接，根据链接下载Youtube视频，根据下载到的视频创建mashup并组合起来。在执行这些工作的时候，我们也希望UI可以响应用户操作。

而要完成这些工作，代码可能只需要这么简单，完全就像同步代码一样。而这里也体现了多种异步任务：ScrapeYoutubeAsync是网络密集型任务，然后同时下载两个视频并等待它们结束。然后MashupVideosAsync是CPU密集型任务，然后最后则是I/O密集型的的SaveAsync操作。对于异常处理来说，我们可以简捷地使用一个try...catch，就像传统编程那样。

总结一下，一个异步方法可以让代码和同步实现一样简单，并统一了计算、网络及I/O的异步化。这可以用来创建高度伸缩的服务器程序，自然还有响应度高的UI程序。

在演讲的末尾，我会给出Visual Studio Async CTP的下载链接，我很乐于得到大家的反馈。

PDC 2010：C#与Visual Basic的未来（上）

jeffz@live.com (老赵) — Sat, 30 Oct 2010 18:43:29 GMT

PDC不愧为微软最高级的技术人员专业会议，看得我直呼过瘾。前几天在PDC 2010会议上Anders Hejlsberg发表了一场名为“The Future of C# and Visual Basic”的演说，谈论了未来C#和VB中最为重要的两个特性：“异步（Async）”及“编译器即服务（Compiler as a Service）”。我现在对这场演讲进行总结，但不会像上次《编程语言的发展趋势及未来方向》那样逐句翻译，而是以Anders的角度使用一种简捷合适的方式表述其完整内容。

在2000年的PDC上，我们给大家带来了一个全新的平台“.NET”，以及一个语言“C#”。.NET与C#每次发布时都有一个“主题”，一开始是“托管代码”，接着是“泛型”，然后是“LINQ”，直到最近的“动态性”，这就是C#和VB的演变过程。这两种语言面向的用户比较相近，微软也承诺会同时发展两种语言。因此这个演讲虽然以C#作为主题，但其实也会在VB中得以体现。

作为语言的设计者，要设法将工业界所重视的内容，使用语言表现出来，因此也有了这样的分类。“声明式”代表了一种编程的趋势，尽可能表现出“做什么”而不是“怎么做”，于是有了函数式编程与DSL等等。然后，目前研究的热门之一则是动态语言，如Python，Ruby，JavaScript等等，以及它们是如何影响静态语言的。还有便是“并发”，这里所指的广义的“并发”，包括单机上多核以及云或是数据中心上分布式系统等等，也就是各种“同时处理”的方式。

我们可以清楚地看到，C# 3.0和VB 9中的函数式编程，LINQ等特性体现了“声明式”，而C# 4.0和VB 10则出现了动态性，但都没有太多关于“并发”的成分在里面──它都体现在框架中了，例如.NET 4包含了任务并行库（Task Parallel Library），但对于语言来说，除了lock似乎就没有什么这方面的支持了。

如今对“并发”的需求已经是毋庸质疑的，很少有一个应用程序或是服务不需要连接外部系统。这种与外部系统，例如互联网进行交互的行为则增加了应用程序的延迟，这可能导致UI在和外部服务交互时长时间失去响应。而对于一个数据中心的服务，您可能就会发现CPU的利用率不高，因为系统都在等待其他服务的回复了。

为了解决这个问题，我们往往会使用“异步”的编程方式，它逐渐已经成为“高响应度”，“高伸缩性”的代名词了。此外还有一些API只提供了异步的版本，例如在JavaScript中发起HTTP请求，或是Silverlight的网络交互方面。这种情况以后只会越来越普遍。

于是下一版本的C#和VB就会在这里有所行动，目前会展示一下我们的早期工作，希望可以得到一些反馈。

说到异步化，您可以简单认为“一起运行”。一个同步方法，好比DownloadString，应用程序会执行这个方法，并等待结果返回，但是你不能把工作的执行过程与结果的送达区分开来。而对于异步编程来说，DownloadStringAsync在调用之后便会立即返回，过了一段时间，结果就会传递过来，于是执行过程和结果的送达便完全是可分离的了。而对于如今典型的异步模型来说，结果通过一个回调函数传递过来。

异步化可以的得到高度的响应能力，因为在等待任务的结果时我们可以做其他一些事情。而对于服务器来说，异步可以带来很好的伸缩性，因为线程得到释放了，而不需要等待请求返回结果。

通过图示可以更清楚地了解这点。例如有段代码叫做DownloadData，调用以后可以得到一些数据。在执行时，线程会有长时间的终止，它被阻塞了，要等到结果返回之后才能继续处理数据。与此相对的是其异步的版本，我们调用DownloadDataAsync方法之后，它立即将控制权交还给我们，过了一段时间，它会把结果传递给回调函数，让我们继续处理下去。但是在DownloadData和ProcessData之间，我们可以处理其他一些工作。如果这是UI线程，那么就可以用于响应其他用户操作。如果这是个服务器线程，那么在等待结果时这个线程可以用来处理其他请求。

那么，如果我们要执行多个请求，例如要调用两遍，对于同步的版本就会获得双倍的阻塞，即便两个请求是完全独立的。而在异步的情况下，我们可以快速地发出两个请求，这样便形成的并发，即便这里并没有使用额外的线程。于是便可以更快地得到结果，也能保证响应能力。

有人可能会说，我们可以利用后台线程来得到响应。没错，不过就引入了多线程模型，于是就要处理同步等线程安全问题。而且，在开发带有UI的应用程序时，我们不能在后台线程里操作UI，这样又出现了其他的复杂情况。而在服务器应用中，我们又不希望创建更多的线程，因为这会给线程池带来压力，线程之间会有竞争，就会降低请求的处理能力。

以上便是对异步编程的概述，您可能会问，既然异步有那么多好处，那么为什么不把所有的应用程序都写作异步的呢？那么现在我们就来看一下异步编程大概是什么样子的。

这里有个简单的应用程序，输入年份，可以下载到那一年的电影。现在这个程序是同步的写法。在搜索的时候UI会失去响应，这样的结果显然无法令人接受，我们要做的更好。我们可以将其改写为异步的形式。

同步的写法是这样的：

private void searchButton_Click(object sender, RoutedEventArgs e)
{
    LoadMovies(Int32.Parse(textBox.Text));
}

void LoadMovies(int year)
{
    resultsPanel.Children.Clear();
    statusText.Text = "";
    var pageSize = 10;
    var imageCount = 0;

    while (true)
    {
        var movies = QueryMovies(year, imageCount, pageSize);
        if (movies.Length == 0) break;
        DisplayMovies(movies);
        imageCount += movies.Length;
    }

    statusText.Text = String.Format("{0} Titles", imageCount);
}

Movie[] QueryMovies(int year, int first, int count)
{
    var client = new WebClient();
    var url = String.Format(query, year, first, count);
    var data = client.DownloadString(new Uri(url));

    var movies =
        from entry in XDocument.Parse(data).Desendanies(xs + "entry")
        let properties = entry.Element(xm + "properties")
        select new Movie
        {
            /* ... */
        };

    return movies.ToArray();
}

在点击按钮以后会调用LoadMovies方法，它会在一个循环中不断使用QueryMovies方法进行查询，在QueryMovies方法中我们使用WebClient下载一个XML，解析，构造Movie对象并返回，最终呈现在界面上。

下载时我们使用DownloadString方法，这是个同步方法，我们要把它修改成异步的方式。事实上还真有个异步的方法，叫做DownloadStringAsync，不过这就需要我们修改代码，例如要把QueryMovies中的大部分放入DownloadStringCompleted事件的处理函数中。同时，异步编程的痛苦慢慢体现出现了，我们无法返回数据，而必须传递到某个地方，于是QueryMovies方法则要返回void，并接受一个回调函数。

void QueryMovies(int year, int first, int count, Action<Movie[]> action)
{
    var client = new WebClient();
    var url = String.Format(query, year, first, count);

    client.DownloadStringCompleted += (sender, e) =>
    {
        var data = e.Result;
        var movies =
            from entry in XDocument.Parse(data).Descendants(xs + "entry")
            let properties = entry.Element(xm + "properties")
            select new Movie
            {
                /* ... */
            };

        action(movies.ToArray());
    };

    client.DownloadStringAsync(new Uri(url));
}

然后我们还需要处理QueryMovies的调用者，这里实在麻烦到家了，因为我们使用了一个while循环来查询电影，那么我们又该如何反复调用一个异步方法？

void LoadMovies(int year)
{
    resultsPanel.Children.Clear();
    statusText.Text = "";
    var pageSize = 10;
    var imageCount = 0;

    Action<Movie[]> action = null;
    action = movies =>
    {
        if (movie.Length > 0)
        {
            DisplayMovie(movies);
            imageCount += movies.Length;
            QueryMovies(year, imageCount, pageSize, action);
        }
        else
        {
            statusText.Text = String.Format("{0} Titles", imageCount);
        }
    };

    QueryMovies(year, imageCount, pageSize, action);
}

你一定已经发现了，现在的代码已经很难让人保持愉快了。不过它的确是异步的了，运行时界面响应良好。效果是有了，不过这代码变得乱七八糟。想象一下，如果要加上异常处理该怎么做？我们可能要提供两个回调函数，一个处理正常情况，一个处理错误，还到处需要有try...catch，很快麻烦就会接踵而来了。如果不想面对这些麻烦，你可能就要去启用后台线程，这样又有了线程方面的问题。

显然我们可以做的更好。首先让我们回到原来的同步代码，然后再用上我们为异步编程设计的新特性。

如果要把QueryMovies变为异步，则先把它的返回值改为Task<Movie[]>，你如果了解.NET 4则一定已经知道这个类型是任务并行库的一部分。事实上Task类型只是表示一个“开始计算并在未来返回结果”的任务，因此Task<T>表示一个会在将来返回T类型的计算任务，在科学计算领域这通常被称为Future或是Promise。现在方法的返回值是Task<Movie[]>，而最后返回的是Movie[]，这显然不匹配，但我们可以将其标记为一个async方法。对于async方法，编译器会重写整个方法实现来表示一个异步任务，以后我们会来观察它是如何实现这点的。

async Task<Movie[]> QueryMoviesAsync(int year, int first, int count)
{
    var client = new WebClient();
    var url = String.Format(query, year, first, count);
    var data = client.DownloadString(new Uri(url));

    var movies =
        from entry in XDocument.Parse(data).Descendants(xs + "entry")
        let properties = entry.Element(xm + "properties")
        select new Movie
        {
            /* ... */
        };

    return movies.ToArray();
}

不过只做到这点还不够，我们的方法还没有异步化，这还是个同步任务。不过，如今在一个async方法中，我们有能力组合调用另一个async方法，并异步地等待。这里使用了一个扩展方法DownloadStringTaskAsync，以后也会包含在框架中。这个方法返回Task<string>类型，表示未来某一时刻将会得到一个string对象。于是在async方法中，我们使用一个新的await操作符来等待其返回。

async Task<Movie[]> QueryMoviesAsync(int year, int first, int count)
{
    var client = new WebClient();
    var url = String.Format(query, year, first, count);
    var data = await client.DownloadStringTaskAsync(new Uri(url));

    var movies =
        from entry in XDocument.Parse(data).Descendants(xs + "entry")
        let properties = entry.Element(xm + "properties")
        select new Movie
        {
            /* ... */
        };

    return movies.ToArray();
}

在执行时，方法会执行到await操作符这里，并确保接下来的代码是在一个回调函数/continuation中执行的。编译器会在这里重写这个方法，就像为yield重写迭代器那样，于是我们就不需要做其他事情了，任务结束后自然会执行await后面的代码。

这里的美妙之处在于可以任意组合，对于LoadMovies方法来说，我们也可以将其转化为async方法，并await之前的QueryMoviesAsync方法返回。

async void LoadMoviesAsync(int year)
{
    resultsPanel.Children.Clear();
    statusText.Text = "";
    var pageSize = 10;
    var imageCount = 0;

    while (true)
    {
        var movies = await QueryMoviesAsync(year, imageCount, pageSize);
        if (movies.Length == 0) break;
        DisplayMovies(movies);
        imageCount += movies.Length;
    }

    statusText.Text = String.Format("{0} Titles", imageCount);
}

于是异步实现就这么完成了，代码和之前几乎完全一致。您可以看出，这使得我们在执行异步代码时保留原本的逻辑实现。

那么再为应用程序添加一点功能吧。首先是异常处理：

async void LoadMoviesAsync(int year)
{
    resultsPanel.Children.Clear();
    statusText.Text = "";
    var pageSize = 10;
    var imageCount = 0;

    try
    {
        while (true)
        {
            var movies = await QueryMoviesAsync(year, imageCount, pageSize);
            if (movies.Length == 0) break;
            DisplayMovies(movies);
            imageCount += movies.Length;
        }

        statusText.Text = String.Format("{0} Titles", imageCount);
    }
    catch (XmlException)
    {
        statusText.Text = "Data Error";
    }
}

我们无需分离代码或是逻辑，这一切都和同步代码完全一致。再来看看“取消（cancellation）”，对于async方法来说，我们可以传递一个CancellationToken，表示任务需要监听这个对象的改变。如QueryMoviesAsync便可以增加一个参数：

async Task<Movie[]> QueryMoviesAsync(int year, int first, int count, CancellationToken ct)
{
    var client = new WebClient();
    var url = String.Format(query, year, first, count);
    var data = await client.DownloadStringTaskAsync(new Uri(url), ct);

    var movies =
        from entry in XDocument.Parse(data).Descendants(xs + "entry")
        let properties = entry.Element(xm + "properties")
        select new Movie
        {
            /* ... */
        };

    return movies.ToArray();
}

这样便得到了一个可取消的async方法。对于逻辑流来说，取消操作就相当于一个异常，代码里需要处理一个TaskCanceledException：

CancellationTokenSource cts;

async void LoadMoviesAsync(int year)
{
    resultsPanel.Children.Clear();
    statusText.Text = "";
    var pageSize = 10;
    var imageCount = 0;

    cts = new CancellationTokenSource();
    try
    {
        while (true)
        {
            var movies = await QueryMoviesAsync(year, imageCount, pageSize, cts.Token);
            if (movies.Length == 0) break;
            DisplayMovies(movies);
            imageCount += movies.Length;
        }
        statusText.Text = String.Format("{0} Titles", imageCount);
    }
    catch (TaskCanceledException) { }

    cts = null;
}

private void cancelButton_Click(object sender, RoutedEventArgs e)
{
    if (cts != null)
    {
        cts.Cancel();
        statusText.Text = "Canceled";
    }
}

那么超时又怎么说？超时其实就类似一段时间之后的取消。于是我们可以另写一个小方法来处理这个问题：

async void StartTimeoutAsync()
{
    await TaskEx.Delay(5000);
    if (cts != null)
    {
        cts.Cancel();
        statusText.Text = "Timeout";
    }
}

private void searchButton_Click(object sender, RoutedEventArgs e)
{
    LoadMoviesAsync(Int32.Parse(textBox.Text));
    StartTimeoutAsync();
}

第一步，我们先等待5秒钟，如果任务还在执行，那么我们就取消掉。所以无论是超时，取消还是错误处理，程序的逻辑结构都得以最大限度的保留，就好比编写普通的代码一样。例如上面的Delay，看上去是顺序逻辑流，但实际上是异步的。为了表现出这点，我们可以为程序新加上一个有趣的功能：

async void ShowDateTimeAsync()
{
    while (true)
    {
        Title = "Movie Finder " + DateTime.Now;
        await TaskEx.Delay(1000);
    }
}

public MainWindow()
{
    InitializeComponent();
    textBox.Focus();
    ShowDateTimeAsync();
}

于是在标题栏上便会每隔一秒刷新显示当前时间，与此同时搜索也好，超时也罢，在程序执行时UI都可以获得响应。

值得强调的是，上面实现的这些功能都没有启用额外的线程，所有这些都在UI线程上执行。那么什么时候需要额外的线程呢？这便是计算密集型操作。例如这里我要执行五千万次平方根计算，这需要耗费一段时间。不过这样的操作，对于UI线程来说，这也不过是一个异步操作，不是吗？启动操作，然后等待其完成，在它完成之后再对结果做些处理：

async void ComputeStuffAsync()
{
    double result = 0;
    await TaskEx.Run(() =>
    {
        for (int i = 1; i < 500000000; i++)
        {
            result += Math.Sqrt(i);
        }
    });

    MessageBox.Show("The result is " + result, "Background Task",
        MessageBoxButton.OK, MessageBoxImage.Information);
}

private void searchButton_Click(object sender, RoutedEventArgs e)
{
    LoadMoviesAsync(Int32.Parse(textBox.Text));
    StartTimeoutAsync();
    ComputeStuffAsync();
}

TaskEx.Run方法会构造一个后台线程，并返回异步操作，我们使用await等待其返回，这体现了绝佳的组合能力。启动后在任务管理器中便会发现CPU占用率明显上升。

我在这里宣布，之前演示的技术预览版已经可以下载了。我们已经创建了C#和VB编译器的原型，并提供了一些示例。您可以在开发者中心下载，我在演讲最后会给出URL。

在Visual Studio中使用MonoTouch开发iOS应用程序（下）：开发体验

jeffz@live.com (老赵) — Thu, 30 Sep 2010 01:43:53 GMT

对于熟悉.NET程序员来说，编写iOS应用程序的最佳选择自然是MonoTouch。在上一篇文章里，我们已经在Mac OS X上安装了MonoTouch开发环境，并已经能够在Mac OS X和Windows之间共享文件。现在我们就可以来简单体验一下，如何使用Visual Studio，Interface Builder以及少量的MonoDevelop来开发一个最最简单的iOS应用程序。

新建项目

根据我的个人习惯，我会先创建一个空白的解决方案。首先在Mac OS X中打开MonoDevelop，然后在菜单中选择File - New - Solution，在弹出对话框的Other分类中选择Blank Solution模板，并填写合适的位置和名称：

然后便是创建iPhone应用程序项目。还是刚才的对话框，选择C# - iPhone and iPad分类下的iPhone Window-based Project模板。同样，在对话框下方填写合适的位置和名称，我的习惯是将所有的源代码统一放在src目录下（在解决方案中也会创建一个src目录与之对应）：

点击OK。下一步是额外的项目配置，可以直接点击OK。此时我们就会发现MonoDevelop里展示出的项目文件：

其中Main.cs里包含了项目的启动代码及一个AppDelegate类，MainWindow.xib是主窗口的界面文件，而MainWindow.xib.designer.cs文件则是MonoDevelop根据xib文件中的标记所自动创建的C#代码，在绝大部分情况下我们不会去修改它。

编辑界面

双击MainWindow.xib文件，便会打开Interface Builder。下图左为Library窗口（近似于VS中的Toolbox）；中间上方是可视化的UI编辑器，下方则是对象管理器，显示了界面中定义的对象；右侧便是用来修改属性的Inspector窗口（近似于VS中的Properties窗口）：

首先，在Library窗口上方选择Objects，并将一个Round Rect Button拖动至UI编辑器，双击，输入Hello World：

然后，在Library窗口上方选择Classes，在上方列表中选择AppDelegate，并在下方下拉框中选取Outlets，并使用下方加号添加一个id，叫做ButtonCounter：

接着便是个比较有趣的操作。在对象管理器里选中App Delegate对象，并在Inspector上方选择Connections，再将ButtonCounter右侧的小圆点拖动至按钮，这会将ButtonCounter这个id与按钮关联起来，如下图：

在Interface Builder中保存，回到MonoDevelop，打开MainWindow.xib.designer.cs文件，便可以看到其中在AppDelegate中生成的ButtonCounter属性：

private MonoTouch.UIKit.UIButton __mt_ButtonCounter;

[MonoTouch.Foundation.Connect("ButtonCounter")]
private MonoTouch.UIKit.UIButton ButtonCounter {
    get {
        this.__mt_ButtonCounter = ((MonoTouch.UIKit.UIButton)(this.GetNativeField("ButtonCounter")));
        return this.__mt_ButtonCounter;
    }
    set {
        this.__mt_ButtonCounter = value;
        this.SetNativeField("ButtonCounter", value);
    }
}

可见，MonoDevelop根据xib的内容，自动生成了一些C#代码。AppDelegate是个Partial Class，它的另一部分在Main.cs文件中，一会儿我们便会使用这里的ButtonCounter定义。

配置Visual Studio

虽然MonoDevelop的sln和csproj文件的格式与Visual Studio兼容（包括2005、2008、2010三个版本的VS），但是VS无法识别iPhone应用程序的项目模板，因此如果您直接打开iOS101.sln则会加载失败。因此，我们需要并行地创建一些sln和csproj，其中大部分内容与MonoDevelop创建的内容保持同步。

例如，我创建了iOS101.VS.sln及iPhoneApp.UI.VS.csproj（一个.NET 2.0的Class Library）两个文件，它们分别与iOS101.sln和iPhoneApp.UI.csproj放在同样的目录下。值得注意的是iPhoneApp.UI.VS.csproj文件，如果您直接在VS里创建这个项目文件，它的默认命名空间里也会包含“VS”，您可能需要手动修改一下。由于要和MonoDevelop中的项目保持一致的“可编译通过性”，我们还需要引用MonoTouch SDK里提供的dll。于是我在iOS101目录中创建了lib/monotouch目录，并使用如下命令复制所有的MonoTouch提供的dll文件：

cp /Developer/MonoTouch/usr/lib/mono/2.1/*.dll ~/Projects/iOS101/lib/monotouch

然后，编辑iPhoneApp.UI.VS.csproj的程序集引用和项目文件，最终结果差不多是这样的。请注意MonoTouch中xib文件的类型为Page，而VS中则需要设为None：

<?xml version="1.0" encoding="utf-8"?>
<Project ...>
  ...
  <ItemGroup>
    <Reference Include="monotouch">
      <HintPath>..\..\lib\monotouch\monotouch.dll</HintPath>
    </Reference>
    <Reference Include="System">
      <HintPath>..\..\lib\monotouch\System.dll</HintPath>
    </Reference>
    <Reference Include="System.Core">
      <HintPath>..\..\lib\monotouch\System.Core.dll</HintPath>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <None Include="Info.plist" />
    <Compile Include="Main.cs" />
    <None Include="MainWindow.xib" />
    <Compile Include="MainWindow.xib.designer.cs">
      <DependentUpon>MainWindow.xib</DependentUpon>
    </Compile>
  </ItemGroup>
  ...
</Project>

在VS的结果则类似于：

试着编译一下，通过则表示配置成功。

编写代码

这里您是否有些疑惑，为什么上面创建的是一个.NET 2.0项目呢？这样我们还能够使用C# 3.0中的高级特性吗？答案是肯定的，只要我们使用的是Visual Studio 2008或是2010，则即使是针对.NET 2.0所编写的代码，VS也会使用C# 3.0的编译器，因为我们都知道其实C# 3.0只需要一点点框架和类库的支持（扩展方法）。您甚至可以使用C# 4.0的部分特性，例如参数的默认值，命名参数等等。可惜您无法使用C# 4.0的动态性，因为它需要DLR和Microsoft.CSharp.dll，又涉及到大量的动态代码生成，我对此没什么信心和意愿。当然您感兴趣的话也可以尝试一下。我在这里使用.NET 2.0的原因，是希望可以尽可能减少对系统程序集的依赖，而尽量使用MonoTouch所提供的dll。例如现在，除了mscorlib以外，所有的程序集都与Windows上所安装的.NET Framework无关，这保证了我们编写的代码可以在MonoTouch兼容。

现在就来开始编写代码吧，您可以在VS里打开Main.cs，在AppDelegate的FinishedLaunching方法中添加如下代码，使之成为：

public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
    int i = 0;
    this.ButtonCounter.TouchDown += delegate
    {
        this.ButtonCounter.SetTitle((++i).ToString(), UIControlState.Normal);
    };

    window.MakeKeyAndVisible();

    return true;
}

FinishedLaunching方法在程序启动时调用，此时我们为ButtonCounter添加一个TouchDown事件（类似于Click）添加一个处理函数。这里用到了C#中的匿名函数特性，并捕获外部的变量i，每次点击按钮都将i加一，并显示在按钮上。在这里我们使用.NET中比较常用方式添加事件处理，事实上您也可以在Interface Builder中定义一个Action，并把它与Button的TouchDown事件关联起来。这个Action会表现为一个Partial Method，您可以在代码里补全其实现。

保存代码后您便可以回到MonoDevelop中，为了能够在iPhone模拟器里运行，您还要修改一个参数。对iPhoneApp.UI点击右键，打开Options对话框，在左侧选中Build - iPhone Build类别，并将右侧的SDK version设为4.0，如下：

点击OK保存并关闭对话框。此时可以选择菜单Run - Run，或直接使用快捷键Command（即Win键） + Alt + Enter便会编译项目，并打开模拟器执行程序。在默认情况可能打开的iPad模拟器，您可以在Hardware - Device中选择iPhone或iPhone 4。运行效果如下：

试着点击按钮查看效果吧。

单元测试及其他

如果您想调试代码，只需要在MonoDevelop中设置端点，并选择菜单Run - Debug，或直接使用快捷键Command + Enter便可以对模拟器进行调试。但是如果是要单元测试呢？这问题也不大，MonoDevelop自带NUnit项目，您可以创建这样一个单元测试项目，删除其默认引用，换之为MonoTouch SDK里所提供的程序集，同样您可以在Visual Studio中开发单元测试代码，但是调试执行必须在MonoDevelop里进行，因为MonoTouch提供的程序集都是Mac下的Mono实现，它们在Windows下的作用只是为Visual Studio提供必要的元数据，使我们能够享受到智能提示之类的便利，想要在Windows里运行则是不行的。

但是，事实上我们也可以将Visual Studio里面的项目定义为.NET Framework 3.5项目，并直接使用.NET提供的程序集，对于MonoTouch里额外的程序集，例如System.Json.dll，则面向.NET 3.5自己重新构建一遍即可（源代码可以使用.NET Reflector获得或是利用Mono上的开源代码）。这么做的优势在于，对于那些与MonoTouch无关的代码，我们都可以在Visual Studio里进行调试与测试了。于是乎，我们可以在代码开发阶段尽可能留在熟悉而强大的环境中，对开发效率有很大帮助。

这种做法也有缺点，例如，虽然MonoTouch提供的类库与.NET 3.5兼容，但事实上我并不能百分之百保证这点，因此在.NET 3.5里可以编译通过的代码，也有可能无法在MonoTouch里编译执行。此外，这种方法也会让您无法使用Mono程序集中对.NET的扩展（主要是Mono命名空间下的类库）。不过这两个理论上问题到目前为止还没有给我造成什么困扰，我也只有在需要在查看模拟器运行效果时才回到Mac及MonoDevelop中。

有些朋友看到System.Json可能会有些熟悉，因为它在Silverlight开发中也有出现。您说的没错，事实上MonoTouch里的程序集版本号与Silverlight一样，都是2.0.5.0，甚至连强签名都是一致的。只可惜Silverlight里的类库是.NET 3.5的子集，例如所有同步的IO操作都被去除了，因此我们很难使用Silverlight来开发MonoTouch程序。当然，有了Silverlight，对我们开发MonoTouch也是有所帮助的，这点以后再谈。

最后，您应该已经意识到，我们需要在VS的项目文件与MonoDevelop的项目文件直接做同步，这个同步包括程序集引用与代码文件两方面。如果您觉得手动编辑比较麻烦的话，就写一个自动同步的小程序咯——不会？那么还是先别搞MonoTouch了，从编程基础学起吧。

在Visual Studio中使用MonoTouch开发iOS应用程序（上）：环境配置
在Visual Studio中使用MonoTouch开发iOS应用程序（下）：开发体验

在Visual Studio中使用MonoTouch开发iOS应用程序（上）：环境配置

jeffz@live.com (老赵) — Tue, 28 Sep 2010 05:52:52 GMT

前段时间在工作机上装了Mac OS X，这主要是因为我最近需要开发iPhone应用程序。虽然Xcode，Objective C一定是开发iOS应用程序的主流，但是经过一番考虑，我还是决定尝试一下使用MonoTouch进行开发。MonoTouch是Novell公司基于开源的Mono平台构建的一套iOS开发环境，使用MonoDevelop作为代码编写工具。不过目前的MonoDevelop较之Visual Studio可谓“萤火之光比皓月之明”，甚至还有无法输入中文的低级问题。因此，至今我所有在Mono上运行的代码其实都是用Visual Studio写的，这次自然也不例外。不过，这似乎并不是件非常直接的事情……

什么是MonoTouch

Mono是由Novell提供的.NET跨平台执行环境，无论别人如何进行FUD，我使用下来对Mono的感觉很不错，自认为也有足够的理由来支持我的观点，如今无论是微软Mix大会还是社区类型的NDC 2010都有Mono的内容（尤其是后者）。在我看来，如果没有尝试过Mono就发表的猜忌就很难令人接受了。

Mono使用的授权方案允许第三方基于它上构建商业应用程序，MonoTouch便是其中的典型（还有哪些？自己看吧）。MonoTouch是Novell公司的产品，可以让开发人员在.NET环境下开发iOS应用程序（包括iPhone 4和iPad），支持最新的iOS SDK 4.1。这样.NET开发人员就可以利用现有的知识来开发iOS应用程序，如.NET 3.5中的绝大部分类库以及C# 3.0。例如，之前有同事抱怨Android里的API没法方便地使用SOAP协议（似乎iOS下也有不便），但是在MonoTouch中，一切的一切都是最常见的Add Web Services，或是用WCF的svcutil.exe便可直接生成代理。我们同样可以复用大量.NET平台下的开源类库，只要基于MonoTouch重新编译一遍就可以了。在NDC 2010中“深入MonoTouch”演讲中便演示了在MonoTouch中使用Json.NET、FlickrNet及CoolStorage三套类库的做法。

除了.NET 3.5中的类库之外，MonoTouch也提供了访问iOS API（即Cocoa Touch）的.NET接口（尤其是在UI方面）。在这方面MonoTouch不是一味地直接暴露出Cocoa Touch的功能，而是在一定程度上将它的API改写为更倾向于.NET程序员的形式。例如UIView的Frame属性为System.Drawing.RectangleF类型，而不是Cocoa Touch中原本使用的CGRect。当然，尤其是UI方面，MonoTouch还是使用了传统iOS应用程序的架构，包括它的MVC驱动方式。因此，即使您使用MonoTouch，最好也要能够看懂简单的Objective C代码，因为SDK提供的文档和大量的示例都是用它来实现的。

众所周知，Mono使用JIT（Just-in-Time）编译来执行IL代码，JIT代表了在运行时动态生成原生代码，但是iOS不允许这么做。因此，MonoTouch实际上是使用了AOT（Ahead-of-Time）编译方式，真正部署在机器上时已经是原生代码了。此外，MonoTouch还提供了一个Linker，它只会将SDK及我们自己编写的代码中，真正使用到的部分静态链接至应用程序中，这削减了应用程序的体积。从中我们可以看出，使用MonoTouch开发出来的应用程序，其实和普通使用iOS SDK开发出的应用程序并没有什么区别，都是完全独立运行的。当然，这也是因为MonoTouch将一个Runtime塞入应用程序内部的关系，这会给应用程序的体积带来大约5MB的增长，压缩后（也就是用户真正需要下载的体积）大约是3MB。

除了MonoTouch以外，用于Android开发的MonoDroid也已经进入了beta阶段，已经向一些开发人员提供试用版本了。这意味着，在不久的将来，C#及.NET类库将成为Windows Phone，iOS，Android三大移动平台上的跨平台开发工具。关于MonoTouch的更多消息，您可以关注NDC 2010上的相关演讲。

在Windows和Mac OS X中共享文件

MonoTouch的开发工具是MonoDevelop和Interface Builder，后者用于编辑应用程序中的UI文件。不过编写C#代码的神器终归是Visual Studio，即便是最简单的Express版本在代码编写方面也胜出MonoDevelop很多，更别说是经过增强的高级版本了。因此，我打算使用Visual Studio编写C#代码，而使用Interface Builder开发UI界面。不过我们要做的第一件事情是在Windows和Mac OS X之间共享源文件。这里我继续基于之前Win7 + VirtualBox + Snow Leopard的环境进行配置，您也可以使用相同的方法连接两台独立的机器。

由于Mac OS X是在虚拟机上，我选择将源文件放在Windows里，并在Mac OS X上访问。首先，我们在Windows上共享一个目录，这里我将整个E盘共享给vbox账号，取名为host-e，并赋予完全控制权限：

然后在Mac OS X中打开Finder，在Go菜单中选择Connect to Server：

在弹出的对话框中输入Windows的IP：

点击Connect，并在下一个对话框中输入用户名的密码（注意这里需要包含机器名）：

点击Connnet，此时对话框会列出这个账号的共享内容：

于是我们选择host-e，并点击OK。此时，您会在Finder的Shared栏目中访问到共享的内容，其中的projects目录是这里的关键：

我将所有的项目都存放在e:\projects目录中，接下来也不例外。为了方便起见，我在Mac OS X的home目录下建立一个软链接，指向共享中的projects目录

ln -s /Volumes/host-e/projects ~/Projects

此时我们就能在home目录下看到Projects文件夹了，而在各种应用程序中，我们可以使用~/Projects来访问其中的内容：

自然，其他方式也没有问题，您只要找到适合您自己的最合适的方式即可。例如，我现在提到的共享方式要求两台机器通过网络互连，如果您无法实现这点，也可以借助如Dropbox这样的同步工具，其实也非常方便。

安装MonoTouch

要安装MonoTouch，首先您必须安装Mono，MonoDevelop，iOS SDK。我的配置是：

Mono 2.6.7
MonoDevelop 2.4
iOS SDK 4.1

Mono和iOS SDK的安装过程十分普通，而MonoDevelop的安装方式对于Windows用户可能有些特别。在加载了dmg文件以后，会弹出这样一个界面：

根据提示，此时您只需要将MonoDevelop的图标拖至右侧目录中就可以了。

随后，您便可以安装MonoTouch了。MonoTouch是商业产品，不过您可以免费下载它的试用版，无限期使用。不过试用版只能在模拟器上运行调试，如果需要在真机上运行测试、打包、甚至发布至AppStore，则需要购买授权。企业用户自不必说，MonoTouch针对个人用户的授权费用399美金，如果您真有制作应用程序的好点子，那这点钱实在不算什么了。

在Visual Studio中使用MonoTouch开发iOS应用程序（上）：环境配置
在Visual Studio中使用MonoTouch开发iOS应用程序（下）：开发体验

Win7 + VirtualBox安装Mac OS X雪豹操作系统图文详解

jeffz@live.com (老赵) — Sun, 26 Sep 2010 02:50:04 GMT

由于工作需要，我需要同时使用Windows和Mac OS X操作系统，虽然公司可以配置两台机器，但是出于发热量，空间占用，操作系统互通等原因，我还是更倾向于在虚拟机环境里工作。由于在大部分工作还是在Windows上完成的，因此我选择Win 7作为Host，而将Mac OS X Snow Leopard作为Guest系统。由于各种原因（如严格和特殊的硬件需求），在虚拟机下安装OS X一直是件无比折腾的事情，留下了无数先驱的身影。但是，我忽然发现，似乎如今新版的VirtualBox对于OS X已经有了非常优秀的支持，尝试之后感觉大好，因此记录下来供需要的朋友参考。

准备

首先，我建议您准备一台配置充足的机器作为Host。以下是我的机器配置及操作系统：

CPU：Intel E8400 3.0GHz双核处理器
内存：4.00GB（3.37GB可用）
操作系统：Windows 7企业版（32位）

我的机器一开始只有2G内存，OS X虚拟机占用了整整1G，于是剩下的1G内存便显得捉襟见肘了。如果您需要打开一些开发工具，或是Visual Studio、Word、Outlook等大型应用程序，会发现内存换页非常频繁，简直难以忍受。不过将内存增加到4G之后，情况便大有好转，与之前相比几乎感觉不到虚拟机所带来的影响。因此，我建议您至少准备3G内存空间，否则接下来的体验会大打折扣。

在装完Snow Leopard系统之后，便会占用超过9G的硬盘空间。如果您需要在上面做开发，则可能还需要安装Xcode及iOS SDK等工具包，它们都是实打实的大个头，一套下来同样会占用将近10G的硬盘，因此我建议您可以保留30G左右的硬盘空间，以免将来遭遇尴尬的境地。

在软件部分，新版的VirtualBox也是必须的，我使用的是最新的3.2.8 r64453，您可以去官网上下载最新版本。自然，您还需要Mac OS X 10.6 Snow Leopard的安装DVD或是镜像文件（不要问我哪儿可以搞到）。此外，由于VirtualBox自带的EFI Bootloader只能在OS X作Host时才能正常引导，我们还需要empireEFIv1085.iso，您可以根据自己的CPU下载32位Intel版本或是AMD版本，对于64位Intel处理器，可以使用压缩包里的legacyempire_efi1085.iso文件。

至此，万事俱备。

创建虚拟机配置

VirtualBox和Snow Leopard的中文翻译都可谓是茶几，因此两者我使用的都是英文版本。

首先，您需要创建一个虚拟机的配置，设置一个名称（Snow Leopard），并如下图选择合适的操作系统（Mac OS X）及版本（Mac OS X Server）：

选择至少1024 MB内存：

在选择磁盘向导中，创建一个30G大小的虚拟磁盘（如果硬盘空间允许的话，建议创建fixed-size类型的虚拟磁盘，对性能有所帮助。自然，这会在创建虚拟磁盘时消耗一些时间，请耐心等待）：

检查信息，创建虚拟机配置：

右键单击刚创建好的虚拟机，或使用Machine菜单进入Settings面板。首先，选择左侧的System项，调整右侧的启动顺序（先光驱再硬盘），并将默认选中的Enable EFI选项取消（我们将使用刚才下载的empireEFIv1085.iso进行引导）：

然后选中左侧的Display项，将Video Memory调制最大，并启用3D加速：

至此，虚拟机配置完成。

安装系统

首先，我们使用empireEFIv1085.iso进行引导，还是在刚才的Settings面板中，选择左侧的Storage项，并在右侧选中引导用的镜像：

启动虚拟机，稍等片刻，直至出现如下界面：

根据提示，加载Snow Leopard的安装盘，稍等片刻（让虚拟机识别并加载镜像），点击F5，此时您会发现中央的光盘标志下方显示为Ｍax OS X的安装盘：

此时回车，并根据提示按任意键，稍等片刻便会出现Snow Leopard的安装向导界面：

选择一门语言，并根据向导前进，直至安装磁盘选择这一步，此时您会发现可选磁盘列表为空：

从上方Utilities菜单中选取Disk Utility，再选中左侧的磁盘，同时进入右侧的Erase栏。然后选择正确的文件系统（Mac OS Extended，Case-sensitive，Journaled）：

点击Erase对磁盘进行格式化，关闭Disk Utility，并选择刚才格式化后的磁盘作为安装目标：

点击Install按钮开始安装，请耐心等待：

最后则会出现安装失败的提示画面：

不过别担心，事实上Snow Leopard系统已经安装完成了。此时您可以点击Restart按钮，但系统并不会正常地重新启动，会停留在MACH Reboot字样上。您需要重新加载empireEFIv1085.iso，并手动选择虚拟机控制台中Machine菜单的Reset项强制进行重启（此时虚拟机可能会提示发生严重错误并退出，重新启动即可）：

此时便会重新进入之前出现过的引导界面，不过您会发现其中多了一个启动项，便是刚才装好的操作系统：

按键盘右键切换至新项并回车，根据提示按任意键，稍等片刻，便会进入Snow Leopard第一次启动时的语言选择界面：

我在这里还是选择英文作为操作系统的主要语言。根据向导一步一步前进，在设置了键盘，账号，时区等信息后（您可以跳过设置Apple ID的步骤），最终便可以看到Snow Leopard系统的桌面（可能跳出键盘识别的向导，按提示进行即可）：

您现在可以把玩一下Snow Leopard操作系统了。值得一提的是，您很有可能无法使用操作系统的菜单正常关闭和重启操作系统，这时候您只要使用虚拟机的菜单来强制关闭和启动即可。需要注意，在启动时您还是需要empireEFIv1085.iso作为引导。

更新系统

打开System Profiler，会发现当前操作系统的版本是Mac OS X 10.6.3（当然，如果您使用最新的安装光盘，则下个步骤就可以跳过了）：

打开Software Update升级操作系统。经过一段时间的检查，会要求进行操作系统升级，这会下载800多兆的升级文件，这自然需要一个漫长的等待过程。升级完成后重新启动，便会发现操作系统已经更新为Mac OS X 10.6.4（您可能发现截图中升级前后的机器名有所不同，这是我手动修改造成的）：

容易理解，您从表面上很难发现升级前后有什么差异。

调整分辨率

从网上找到的资料来看，调整分辨率的方法有好几种，例如修改com.apple.Boot.plist文件，或是使用VBoxManage.exe修改虚拟机镜像的EfiGopMode参数等等，但我实验下来都没有效果。最终我使用的下面的方法。首先，使用empireEFIv1085.iso引导系统，停留在启动方式选择界面，向右切换至Snow Leopard操作系统，并输入以下命令：

"Graphics Mode"="1280x1024x32"

如下图，请注意图片左下方的命令：

回车，之后Snow Leopard的分辨率便修改成功了。您也可以将1280x1024修改成其他分辨率（并非任意分辨率，系统会自行调整）。我在工作时往往将其设为全屏，并放到扩展桌面上，于是我便可以同时使用两个操作系统了：

看上去还不错吧？

其他

至于其他方面，您可以自行摸索了。网络连接方面，我使用默认的NAT工作正常，USB也没有问题，声音方面需要安装一个驱动程序。此外，我在安装的时候也是遵循几篇文章所提供的向导，如果您想摆脱empireEFIv1085.iso启动系统，也可以根据它们的指引进行尝试：

总结

您现在便可以尝试Mac OS X Snow Leopard操作系统及软件了。当然，这并不能给您带来完整的苹果机的体验，使用苹果机一体化的硬件配合它的操作系统，可以给您带来一些额外的感受，例如苹果笔记本带多点触摸的触摸板，它的使用体验和操作方式都给我留下了非常深刻的印象。

盛大创新院赞助第二届.NET技术交流会 - 演讲录像及下载

jeffz@live.com (老赵) — Tue, 21 Sep 2010 03:27:11 GMT

经过一个多星期的努力，我们在此为大家奉上盛大创新院赞助第二届.NET技术交流会的演讲录像。由于录像过程中的一些失误，我们在在讲师录像方面存在着很大问题，经过补救，也只能得到后两场演讲中使用手持设备拍摄下来的录像。在此向大家表示深深的歉意，有了这次的教训，我们以后会更加重视每一个环节的预防及补救措施，尽力避免如现在这样无可挽回的结果。

响应式编程与响应式框架

讲师：赵劼，盛大创新院，研究员。关注前沿技术，并致力于开源社区与微软平台的组合优化。对函数式编程，并行程序开发，代码之美以及程序员能力与修养等相关问题也有着浓厚的兴趣，同时非常希望能够写程序到60岁。最近致力于F#，Scala语言及mono平台在社区中的推广。

简介：异步编程改变了我们的编程方式，也为我们带来的许多挑战，同时让一些编程模型重新焕发了生机。与传统的“拉”模型不同，响应式编程将异步事件流视为可观察的集合，这是一种“推”模型。微软为了提高云时代的编程体验而设计了响应式框架，其目的是为了简化复杂事件处理之间混合操作。从中我们了解到一些异步编程的模式与LINQ使用技巧，并可以将这种编程模型普及到JavaScript等其他平台上去。

高清格式下载（mov格式，1280 * 720，265M）

大话程序员可用的算法

讲师：程劭非，盛大创新院，研究员。网名winter，无忧脚本版主。Web前端技术的积极倡导者。学生时代曾经热衷于参加ACM/ICPC。目前工作在Bambook电子书项目，主要负责文字排版和浏览器引擎WebKit相关。之前曾负责在Windows CE系统上的IE开发。

简介：俗话说“数据结构+算法=程序”，算法是什么？算法书里满篇是看不懂的形式化推导，网上一些"高人"写的关于算法文章高深莫测，大公司面试最让人讨厌的就是考算法题，“我做了这么多年，跟本在实际开发中就没用过算法！”，算法真的是距离我们如此遥远的东西吗？且听这回演讲，算法究竟如何影响我们的开发。

高清格式下载（mov格式，1280 * 720，128M）

Windows内核技术介绍

讲师：潘爱民，盛大创新院专家，微软学者，集团COO专家顾问。长期从事软件和系统技术的研究和开发工作，撰写了大量软件技术文章，并著译了多部经典计算机图书。在MSR/清华等从事多年科研工作，在北大和清华多年执教经验。数学学士学位和计算机科学博士，主要研究领域包括软件设计、信息安全、操作系统和Internet技术。

简介：Windows操作系统经过二十年的发展，已臻成熟。Microsoft在推动Windows内核方面做了大量工作，譬如于2006年夏季向教育界开放了当时最为先进的内核源代码（Windows Research Kernel）。主讲者在这次讲座中，结合这些可利用的资源，分享对Windows内核研究的体会，尤其将重点讨论Windows中的I/O模型和环境子系统。

高清格式下载（mov格式，1280 * 720，480M）

面向对象与生活

讲师：高翔，5173.com 项目经理。关注前沿技术和技术人员的非技术生活。对面向对象、模式和建模技术有浓厚兴趣，并对游戏设计和图形学方面也比较感兴趣。最近在学习F#，Lua以及关注一些关于职业生涯规划方面的话题。

简介：面向对象这个话题虽然很热，但与哲学一样，很难给其一个很准确的定义。也因为如此，每个人对它都有自己的理解。本次演讲将从一个实际的例子出发，逐步引入面向对象的三个特征，结合对象的生命周期，以及基于事件的对象扩展方式等方面，探讨其与设计模式，与生活之间的联系。

高清格式下载（mov格式，1280 * 720，320M）

异步编程与响应式框架

jeffz@live.com (老赵) — Tue, 14 Sep 2010 12:14:28 GMT

本文原发表于《程序员》杂志9月刊，现将全文公开至此。前几天的技术交流会上我也讲了这部分内容，配合着看会有更好效果。

此外我想再多几句。《程序员》杂志在某些方面必须尽快做出调整。就拿我这篇文章来说，代码除了被三栏的版式搞得支离破碎以外，其中必要的空格也莫名奇妙地少了许多。我认为《程序员》如今在内容方面已经有了显著提高，但是在这种“表面”工夫上也得抓紧才好，这也是国内同类杂志中“最专业者”所应有的风范。

前言

异步操作是强大的，它是许多高伸缩性架构的基石。异步操作在许多情况下是必须的，例如在客户端保持用户界面的响应能力，以及在日益兴起的云计算场景中。但是，异步编程又是十分困难的，它让这让许多程序员敬而远之。因此，越来越多的编程语言都对异步编程提供了相当程度的支持，其中的典型代表便是F#中的异步工作流以及Scala的Actor模型。不过目前的一些主流编程语言，如C#或是JavaScript，它们在设计之时并没有在异步编程上考虑太多，我们便会根据它们的语言特性，提供合适的异步编程模型及其实现。而本文介绍的便是其中一例：响应式编程（Reactive Programming）模型及响应式框架（Reactive Framework，简称Rx）。

异步编程的难点

异步编程之所以困难，主要有三大难点。

首先是对于状态的维护。在普通编程中，我们已经习惯了根据各种状态采取不同做法的编程方式。在异步编程中，状态对于操作的影响则往往更为复杂。例如，我们在编写一个鼠标“拖动及绘图”的行为时，一般会采用这样的逻辑：

在MouseDown事件中将isDragging标记设为true，表示“拖动开始”，并记录当前鼠标位置prevPos。
在MouseUp事件中将isDragging标记设为false，表示“拖动结束”。
在MouseMove事件中检查isDragging标记，如果为true，根据鼠标当前位置currPos和之前记录的prevPos进行绘图，并将currPos的值写入prevPos。

仅在这样一个最基本的场景中，我们便需要编写三个事件处理器（Event Handler），控制isDragging，prevPos等外部状态，并根据这些状态决定事件触发时的效果。这样的例子数不胜数，尤其是在各式拖放操作中，几乎都会涉及大量状态的控制（例如，判断物体是否进入某个特定区域）。

异步编程的另一个难点，在于异步操作之间的组合及交互。例如在如上的简单拖放操作中，我们便涉及到了MouseDown，MouseUp及MouseMove三个事件。从某些角度来说，客户端的UI事件还是比较容易处理的，因为它们往往都是在单一线程上依次执行。但是在另外一些场景中，如云计算时，我们往往会同时发起多个异步操作，并根据这些操作的结果进行后续处理，甚至还会有一个额外的超时监控，这样便很有可能会出现并发操作的竞争（Race）情况，这将会成为程序复杂度的灾难。

此外，异步操作还会破坏“代码局部性（Code Locality）”，这可能也是异步操作中最为常见的阻碍。程序员早已习惯了“线性”地表达逻辑，但即便是多个顺序执行的异步操作，也会因为大量的回调函数而将算法拆得支离破碎，更何况还会出现各种循环及条件判断。同时，在线性的代码中，我们可以使用“局部变量”保存状态，而在编写异步代码时则需要手动地在多个函数中传递状态。此外，由于逻辑被拆分至多个方法，因此我们也无法使用传统的try/catch进行统一异常处理。

推模型与拉模型

平时我们使用最多的便是“交互式（Interactive）”的编程方式，采用的是组件之间的相互调用来表现逻辑。例如，对象A向对象B请求数据并等待返回，待对象B完成并返还数据之后A才继续进行后面的操作。交互式编程的一个典型应用便是GoF23中的迭代器（Iterator）模式，它在.NET中的实现为IEnumerable及IEnumerator接口，例如：

void Traverse(IEnumerable<int> source)
{
    var etor = source.GetEnumerator();
    while (etor.MoveNext())
    {
        Console.WriteLine(etor.Current);
    }
}

为了更好地说明问题，这里我们将标准的foreach操作展开为传统的迭代器使用形式，并省略了using语句。在使用时，我们先调用一个IEnumerable对象的GetEnumerator方法，获得一个迭代器，再根据MoveNext及Current进行遍历。在调用MoveNext时，迭代器会去“准备”下一个元素，并根据存在与否返回true或者false。试想，如果其中某个MoveNext的“准备”工作涉及到一个耗时较长的操作，则迭代器的使用者也必须眼巴巴地等待其返回。

这是一种“拉（Pull）”模型，数据由消费者（Consumer）从生产者（Producer）那里主动“拉”来。这是一种同步的交互方式，数据消费者会依赖于数据生产者的表现。这就好比我们去食堂吃饭时必须主动去取餐，此时则必须从队伍的最后排起，我们什么时候能结束等待并进行下一步操作（即“吃饭”），则要看食堂的生产速度如何。很显然，有些时候这种交互方式是不可接受的，例如我们在实现一个搜索引擎的“关键字提示”功能时，不可能让用户在输入一个字符后，必须等待远程的提示请求返回才能继续输入下一个字符。

而与交互式编程对应的便是“响应式（Reactive）”编程。响应式编程是一种基于“改变”的编程方式。例如在交互式编程中，A = B + C这样的表达式意味着将B与C之和赋给A，而此后B与C的改变都与A无关。而在响应式编程中，A会去“响应”B或C的变化，即一旦B或C改变之后，A的值也会随之变化。响应式编程的一个典型应用便是GoF23中的观察者（Observer）模式。与迭代器的IEnumerable/IEnumerator不同，在之前的.NET框架中并没有对这样一种编程模型指定“标准化（Formallized）”接口，不过在.NET 4.0的基础类库中增加了IObservable及IObserver接口，签名如下：

public interface IObservable<out T>
{
    IDisposable Subscribe(IObserver<T> observer);
}

public interface IObserver<in T>
{
    void OnCompleted();
    void OnError(Exception error);
    void OnNext(T value);
}

如果我们仔细比较“迭代器”与“观察者”的标准化接口，则会发现它们是完全“对偶（dual）”的：

IEnumerable.GetEnumerator方法“输出”一个IEnumerater对象；IObservable.Subscribe方法“输入”一个IObserver对象。
在遍历元素用尽时，IEnumerator.MoveNext方法返回false；在响应内容用尽时，IObserver.OnCompleted方法被调用。
在有新元素需要遍历时，IEnumerator.MoveNext方法返回true，并通过Current属性“输出”；在有新元素需要响应时，IObserver.OnNext方法被调用，并通过参数“输入”。
在出现错误时，IEnumerator.MoveNext方法会“抛出”一个异常；在出现错误时，IObserver.OnError方法会被调用，并通过参数“接受”异常信息。

至于IObservable.Subscribe方法返回的IDisposable对象，则用于“退定”操作，即让输入的IObserver对象再也不需要继续响应IObservable对象的新元素了。

从比较中可以看出，如果说IEnumerator对象是由数据消费者使用的话，那么IObserver对象则是由数据的生产者，即IObservable对象使用的。换句话说，数据是由数据的生产者“推”给数据消费者的，是一种“推（Push）”模型。在这种异步的交互方式中，数据消费者不必依赖于数据生产者的表现。这就好比我们去饭店吃饭，点菜后便可坐下和同伴聊聊天或是用手机上上网，而作为菜品的生产者，饭店，则会在产出之后主动端上桌来。这么做无疑解放了数据的消费者，例如用户可以在文本框里不断地输入字符，而只需等远程服务器将提示结果“推”给客户端后再显示即可。

许多模型都可以统一至标准的生产者接口IObservable上，如MouseMove事件便可以认做是“永不停止的MouseEventArgs对象的生产者”。而另一方面，单个异步操作则可以被视为“只产出单个数据便结束的生产者”。

LINQ to Observable

在许多人眼中，C# 3.0中新增的LINQ特性只是一种用于操作数据的DSL，它的主要作用也仅仅是针对IEnumerable或是IQueryable的数据操作。事实上，LINQ本身的能力远不止此。LINQ是一种非常简单的语言特性，编译器只是将LINQ查询语句转化为“字面等价”的“LINQ标准方法”调用（如Where，Select等等）和“和Lambda表达式”参数（如x => x > 0）而已。但是这里的关键便是“字面等价”四个字，LINQ本身并不规定“LINQ标准方法”是对象的实例方法还是扩展方法，“Lambda表达式”是构造出一个匿名函数还是表达式树，这一切都是由利用LINQ的类库来决定的。因此，微软能够基于LINQ实现了PLINQ这样的并行类库。直到最近的访谈中，LINQ的设计者Erik Meijer依旧认为LINQ还是被低估了，他们自己也还在继续挖掘LINQ的更多能力。

虽然LINQ本身在语法上只是一些方法调用，但是它在语义上是针对数据流的一系列操作，因此LINQ to Object，LINQ to SQL以及PLINQ可以认为是最自然，最符合LINQ语义的应用。如今，微软的“云编程能力团队（Cloud Programmability Team）”在其“响应式框架（Reactive Framework，简称Rx）”提供了LINQ to Observable，这又是另一个LINQ的经典使用案例。IObservable本身可以被认为是一股“推送数据”的数据流，因此也可以对其进行“过滤”或是“投影”等操作，这便是LINQ的应用场景，LINQ to Observable是对IObservable接口实现的一系列LINQ标准方法。因此，我们可以认为，LINQ to Observable是一套与LINQ to Object对偶的类库，事实上在响应式框架中，还有一套与LINQ to Queryable对偶的LINQ to Qbservable，请注意第一个字母是Q，我们可以把它看作是LINQ to Observable的“远程查询”版本。

利用LINQ to Object可以编写出声明式（表示“做什么”）的代码，其可读性往往远高于等价的命令式（表示“怎么做”）代码。LINQ to Observable也有类似的效果。假设现在有一个需求：利用ADWS键控制小球的位置。传统的写法可能是这样的：

void OnKeyPress(object sender, KeyPressEventArgs e)
{
    // 如果游戏已经开始
    if (isPlaying) 
    {
        // 向左且小球没有超出边界
        if (e.KeyChar == 'a' && ball.Left > 0)
        {
            ball.Left -= 5;
        }
        // 向上且小球没有超出边界
        else if (e.KeyChar == 'w' && ball.Top > 0)
        {
            ball.Top -= 5;
        }
        else ... 
    }
    else ...
}

由于KeyPress事件总是不断触发，因此我们只能它的事件处理器中进行判断各种状态，采取不同措施。而如果我们利用LINQ to Observable，则几乎是另外一种思维方式：

// 过滤出isPlaying时的keyPress事件
var keyPress = GetKeyPress().Where(_ => isPlaying);

// 过滤出向左移动的事件
var moveLeft = from ev in keyPress
               where ev.EventArgs.KeyChar == 'a'
               where ball.Left > 0
               select ev;
moveLeft.Subscribe(_ => ball.Left -= 5);

// 过滤出向上移动的事件
var moveTop = from ev in keyPress
              where ev.EventArgs.KeyChar == 'w'
              where ball.Top > 0
              select ev;
moveTop.Subscribe(_ => ball.Top -= 5);

我们可以将“KeyPress事件”视为“推送KeyPressEventArgs对象”这一数据流的数据源（由GetKeyPress方法返回），那么如今的代码便是使用LINQ过滤出“需要”的数据，并针对真正需要的那部分进行响应。这么做，便将“条件”与“操作”解耦，显著增强了代码的语义表达能力。事实上，只要补充一些辅助方法，可以利用LINQ表示更为完整复杂的逻辑。例如，微软咨询师Matthew Podwysocki便在博客中展示过一段代码，基于LINQ to Observable实现了创建一个WebRequest对象，设置属性，异步发送及下载数据的一系列操作。

响应式框架的JavaScript版本

响应式编程的重要使用场景之一便是与用户交互的GUI界面。例如，Silverlight禁止任何阻塞的IO操作，换言之Silverlight中的所有网络操作都是异步的，微软也正是出于简化异步开发的目的才设计了响应式框架（事实上响应式框架已经集成到Silverlight Toolkit中）。不过与Silverlight相比，基于浏览器的原生JavaScript应用程序无疑使用地更为广泛。对于这样的应用程序来说，动画是异步的，AJAX请求也是异步的，我们几乎可以断言，如果有一套面向JavaScirpt应用程序的响应式框架，一定会比面向Silverlight的框架更有意义得多。

微软也想到了这一点。之前我们讨论的“响应式框架”，其实只是响应式编程模型的一种实现。更确切地说，我们只是讨论了这套框架的.NET版本，微软还提供了JavaScript版本的响应式框架。JavaScript版本的API与.NET版本几乎完全一致，例如我们之前讨论的拖放操作，使用JavaScript即可写作：

var target = $("#dragTarget");
var mouseMove = target.toObservable("mousemove");
var mouseDiff = mouseMove.Zip(mouseMove.Skip(1), 
    function(prev, curr) {
        return {
            PrevPos: { x: prev.clientX, y: prev.clientY },
            CurrPos: { x: curr.clientX, y: curr.clientY }
        };
    });

var mouseDown = target.toObservable("mousedown");
var mouseUp = target.toObservable("mouseup");
var mouseDrag = mouseDown.SelectMany(function() {
    mouseDiff.TakeUntil(mouseUp);
});

mouseDrag.Subscribe(...);

由于没有C#中的LINQ查询语言，我们只能直接使用展开后的方法，如SelectMany来编写逻辑。JavaScript版本的响应式框架还提供了一系列的“胶合”层，能够与jQuery，Dojo，MooTools，Prototype等流行框架同时使用。例如，上一段代码中的toObservable便是在jQuery根对象上扩展的方法。

总结

异步编程在用户交互式界面及一些云计算场景中尤其重要。微软的云编程能力团队针对.NET平台和JavaScirpt分别提供了一套响应式框架，希望以此简化异步程序的开发。不过，这套响应式框架所表现出的理念是通用的。而且，事实上只要是拥有匿名函数及闭包的语言，例如Scala，Python，Ruby等等，实现这样一套框架其实都不是十分困难的事情。

盛大创新院赞助第二届.NET技术交流会 - 各场演讲幻灯片

jeffz@live.com (老赵) — Sun, 12 Sep 2010 14:32:31 GMT

昨天有160多位朋友参加了盛大创新院赞助的第二届.NET技术交流会，再次感谢各位对我们的支持。比较遗憾的是，这次的讲师录像方面有着很大问题，我们正在想办法进行修补，希望可以有“差强人意”的结果。现在，大家请在第一时间浏览本次活动新鲜出炉的幻灯片。

响应式编程与响应式框架

响应式编程及框架

View more presentations from jeffz.

大话程序员可用的算法

大话程序员可用的算法

View more presentations from jeffz.

Windows内核技术介绍

Windows内核技术介绍

View more presentations from jeffz.

面向对象与生活

面向对象与生活

View more presentations from jeffz.

相关下载：幻灯片、附加资料“世界的宏观和微观”

盛大创新院赞助第二届.NET技术交流会即将召开

jeffz@live.com (老赵) — Thu, 09 Sep 2010 03:14:43 GMT

由盛大创新院赞助的第二届.NET技术大会将于9月11号下午1点召开，本次交流会请到了四位讲师，议题覆盖了响应式编程、算法、面向对象设计及Windows内核等多个方面，其中最为突出的莫过于由潘爱民老师为大家带来的Windows内核方面的话题。我已经看过了各场演讲的幻灯片终稿，也很期待各位讲师在正式演讲中的表现。

本次大会中，我们还获得了人民邮电出版社图灵教育赠送的15册图书、数枚书签、几件T恤，再加上由会务经费购买的两本潘老师的著作，将会作为各场次的奖品，赠送给在交流会中表现积极的听众。

同样，我们还请到了酷六网的专业摄影师对演讲过程进行全程拍摄，并配合各位讲师自身的屏幕录像，将在后期合成为适合独立观看的演讲视频（效果），让不能到场的朋友在线或是下载后观看。

最后，本次活动中我们还邀请了人间网为我们进行线上直播，我们会有专人负责直播信息的管理和发布。您也可以在活动现场，甚至在场外通过会场的无线网络或者短信发布消息。这些信息都会显示在会场的大屏幕上。

以下是直播效果：

本次会议的邀请函已经发给各位报名者，请携带邀请函至会议现场签到，没有报名的朋友可以在现场直接报名。关于会议的时间、地点、交通、议程等更多信息，请关注会议的报名信息。

盛大创新院赞助第二届.NET技术交流会开始报名了！

jeffz@live.com (老赵) — Mon, 16 Aug 2010 03:02:30 GMT

自上次盛大创新院赞助的首届.NET技术交流会到现在已经有两个月，这意味着按照原来的“一季一次”的计划也已经离第二次的活动不远了，考虑到9月份的中秋和国庆假期将工作日和休息日搞的支离破碎，于是交流会的时间会略微有些提前。第二届交流会的形式与上次相同，将为您献上四场高质量的技术演讲。当然这次在内容上有了新的尝试，除了引入了算法及面向对象设计的内容之外，这次更是请到了“传说中的大侠”为大家带来有关Windows内核的深度内容。人数暂定为200人，事不宜迟，赶快报名吧。除了.NET社区的群众以外，也欢迎其他技术社区的朋友前来参与交流。事实上，我组织技术交流会的目的之一便是希望能够促进.NET社区与其他技术社区的交流及相互学习。

时间及议程安排

第二次交流会定于2010年9月11日（周六）举行，具体时间及议程安排如下。本次依然安排了四场演讲，不过在内容上有了新的尝试：在与一些朋友和同事进行沟通之后，我决定在第二次交流会上引入与算法相关的议题，由创新院内部的ACM/ICPC达人来谈一下日常工作中的算法，如果您对于算法在工作的处境所有疑惑的话，这也是个共同探讨的好机会；此外，我也邀请了5173.com的技术专家来讨论面向对象设计方面的问题，我看过他过去在内部演讲时使用的PPT，内容很充实；而这次的“重头戏”，便是请到了传说中的潘爱民老师为大家演讲Windows内核方面的问题。潘老师是业界著名技术专家，不久前加入了盛大创新院，可谓“镇院之宝”。事实上，在9月初潘老师便会回到北京工作，而这次他也是为了交流会专门出差至上海，您怎能错过这次机会？

时间	议程
12:30 ~ 13:00	签到
13:00 ~ 14:00	响应式编程与响应式框架
14:00 ~ 14:10	短休
14:10 ~ 15:10	大话程序员可用的算法
15:10 ~ 15:40	茶歇
15:40 ~ 16:40	面向对象与生活
16:40 ~ 16:50	短休
16:50 ~ 17: 50	Windows内核技术介绍

演讲内容

以下是关于四场演讲的详细描述。

响应式编程与响应式框架

讲师：赵劼，盛大创新院，研究员。关注前沿技术，并致力于开源社区与微软平台的组合优化。对函数式编程，并行程序开发，代码之美以及程序员能力与修养等相关问题也有着浓厚的兴趣，同时非常希望能够写程序到60岁。最近致力于F#，Scala语言及mono平台在社区中的推广。

简介：异步编程改变了我们的编程方式，也为我们带来的许多挑战，同时让一些编程模型重新焕发了生机。与传统的“拉”模型不同，响应式编程将异步事件流视为可观察的集合，这是一种“推”模型。微软为了提高云时代的编程体验而设计了响应式框架，其目的是为了简化复杂事件处理之间混合操作。从中我们了解到一些异步编程的模式与LINQ使用技巧，并可以将这种编程模型普及到JavaScript等其他平台上去。

大话程序员可用的算法

讲师：程劭非，盛大创新院，研究员。网名winter，无忧脚本版主。Web前端技术的积极倡导者。学生时代曾经热衷于参加ACM/ICPC。目前工作在Bambook电子书项目，主要负责文字排版和浏览器引擎WebKit相关。之前曾负责在Windows CE系统上的IE开发。

简介：俗话说“数据结构+算法=程序”，算法是什么？算法书里满篇是看不懂的形式化推导，网上一些"高人"写的关于算法文章高深莫测，大公司面试最让人讨厌的就是考算法题，“我做了这么多年，跟本在实际开发中就没用过算法！”，算法真的是距离我们如此遥远的东西吗？且听这回演讲，算法究竟如何影响我们的开发。

面向对象与生活

讲师：高翔，5173.com 项目经理。关注前沿技术和技术人员的非技术生活。对面向对象、模式和建模技术有浓厚兴趣，并对游戏设计和图形学方面也比较感兴趣。最近在学习F#，Lua以及关注一些关于职业生涯规划方面的话题。

简介：面向对象这个话题虽然很热，但与哲学一样，很难给其一个很准确的定义。也因为如此，每个人对它都有自己的理解。本次演讲将从一个实际的例子出发，逐步引入面向对象的三个特征，结合对象的生命周期，以及基于事件的对象扩展方式等方面，探讨其与设计模式，与生活之间的联系。

Windows内核技术介绍

讲师：潘爱民，盛大创新院专家，微软学者，集团COO专家顾问。长期从事软件和系统技术的研究和开发工作，撰写了大量软件技术文章，并著译了多部经典计算机图书。在MSR/清华等从事多年科研工作，在北大和清华多年执教经验。数学学士学位和计算机科学博士，主要研究领域包括软件设计、信息安全、操作系统和Internet技术。

简介：Windows操作系统经过二十年的发展，已臻成熟。Microsoft在推动Windows内核方面做了大量工作，譬如于2006年夏季向教育界开放了当时最为先进的内核源代码（Windows Research Kernel）。主讲者在这次讲座中，结合这些可利用的资源，分享对Windows内核研究的体会，尤其将重点讨论Windows中的I/O模型和环境子系统。

地点

本次交流会举办地为上海市浦东新区碧波路888号畅星大厦（地铁二号线张江高科站下，步行10分钟可达）3楼会议厅，地图如下：

鸟瞰图：

畅星大厦外观：

会场实景照片：

会场容量可以容纳超过200人，希望到时候不会显得太过空旷。:)

报名信息

本次交流会现已开始报名，请填写报名表，~~报名截止日期为2010年9月5日~~人数已满，多谢大家支持。

NDC 2010视频下载：看看其他微软平台程序员们都在做什么

jeffz@live.com (老赵) — Tue, 13 Jul 2010 07:13:12 GMT

NDC（Norwegian Developers Conference，挪威开发者大会）是一年一度的挪威最大的微软平台开发者大会，内容丰富，讲师阵容强大。NDC与PDC同为高端技术会议，但NDC与PDC的不同之处在于，PDC是微软官方会议，主要是面向微软资深产品的深入探讨。而NDC涉及的内容则广泛的多，包括了我所感兴趣的Java、Mono、IronRuby/Ruby on Rails、NoSQL方面的内容。这也就像我一直强调的那样，微软技术社区非常开放，微软平台上的太多程序员都能够非常热情地拥抱其他平台的技术。那些认为微软技术社区是井底之蛙的兄弟，殊不知你们的嘲笑只能体现出自身的狭隘。

总而言之，NDC是我理想中的微软平台技术大会。

如今NDC 2010的视频已经全部公开，可以在线观看（使用Silverlight），也可以下载。为了便于大家浏览和下载，我写了一段小程序整理出了所有的视频简介以及下载链接，共计123条，请点击这里。

	Fubu MVC 18 Jun 10 4:20 PM FubuMVC is an open source framework for web development using the ModelView Controller (MVC) pattern. FubuMVC is built in C# and depends on theSystem.Web.Routing subsystem of the base CLR, but has no dependency on the ASP.Net MVC framework. In this talk I will highlight the architectural design of FubuMVC, how it works and more importantly the reasoning behind it. I will not make this into a comparison match with ASP.NET MVC, but there are so many interesting patterns being used in the FubuMVC code base that in its self should make this a very interesting talk. The FubuMVC code base has been an example for many others even in different areas outside of web development. iPod Video 320x240 (71 MB) MPEG-4 for QuickTime Medium 1280x480 (330.7 MB)
	Leading a Self-Organizing Team 18 Jun 10 3:20 PM iPod Video 320x240 (147.7 MB) MPEG-4 for QuickTime Medium 1280x480 (395.2 MB)
	State vs. Interaction Testing 18 Jun 10 3:19 PM Mocking frameworks allow you to stub out behaviour in order to perform tests of individual peices of functionality in isolation. However, there are times when performing certain actions and assert a result is not sufficient. In this session we will drill deep into unit testing and explain the differences between state and interaction-based testing. We will examine the role of stubs versus mocks and how to correctly write unit tests that are not fragile or counter-productive. iPod Video 320x240 (94.8 MB) MPEG-4 for QuickTime Medium 1280x480 (349.5 MB)
	Bridging code between Java & .NET 18 Jun 10 3:18 PM Frustrated .NET developer forced to work with old, boring java? Or are you a java developer having to work with the incompatible and evil .NET technology? With IVKM.NET you can compile your java byte code to the .NET IL and run your favorite java code on .NET and maybe even your Java applications will run faster under IVKM.NET than under SUNs JVM? We take a look at IKVM.NET and how it can be used to bridge your java libraries to your .NET application and the other way around, reusing .NET APIs in your java code. We also show how to use IVKM.NET for creating java-stubs from already existing .NET libraries in order to access your .NET code in java. iPod Video 320x240 (120.1 MB) MPEG-4 for QuickTime Medium 1280x480 (410.8 MB)
	Rough Cuts in Legacy Code 18 Jun 10 3:17 PM Getting legacy code under test is hard, particularly when it is deeply intertwined. In some of the worst code bases, there are no real components, the code is just one large soup.In this session, Michael Feathers will describe a series of strategies and techniques that you can use to separate clusters of classes from your application, characterize them and write tests for them to enable deterministic change. iPod Video 320x240 (57 MB) MPEG-4 for QuickTime Medium 1280x480 (223.6 MB)
	The SharePoint 2010 Business Intelligence Soup 18 Jun 10 4:17 PM SharePoint 2010 has rich BI capabilities, much more enhanced than what SharePoint 2007 provided. Did you try using SharePoint 2007 as a BI delivery mechanism? How was the experience? Was it too difficult to setup? Did you feel you were limited on the lines of performance, capabilities, diagnosis ability? Did you think the featureset was great, and made for good demos ?C but delivering real solutions was a whole another story? Well is SharePoint 2010 any better? Come over and let??s talk about it. In this session, Sahil will talk about the various BI specific improvements in SharePoint 2010, with specific emphasis on what is new compared to SharePoint 2007. iPod Video 320x240 (131.3 MB) MPEG-4 for QuickTime Medium 1280x480 (606.5 MB)
	LINQ - Beyond Queries18 Jun 10 4:14 PM iPod Video 320x240 (115.2 MB) MPEG-4 for QuickTime Medium 1280x480 (523.6 MB)
	Scaling Agile to Work with a Distributed Team 18 Jun 10 2:00 PM iPod Video 320x240 (145.2 MB) MPEG-4 for QuickTime Medium 1280x480 (398.5 MB)
	Get Your Business Out of My Face: Legacy Refactorings for Testable User Interface Code 18 Jun 10 1:58 PM Traditional acceptance testing works at the front-end of a fully-integrated system. There is a need for this kind of testing, however the need accounts for a comparatively small amount of the overall checking you should do on your system. Unfortunately, effectively checking your system requires some basic design principles, which are typically not applied.This session will give you an idea of the kinds of design changes you?ll need to make to improve the testability of your system through a demonstration of legacy refactoring techniques targeted at getting business logic out of UI code.This session will be code-driven. I?ll begin with some example code, displayed for the audience. We will begin by writing automated tests to verify some of the business logic leaving the code as is.After writing a few tests, we will review the pros and cons of the testing approach.I will then provide a few basic design principles that apply to the particular situation: dependency inversion principle, single responsibility principle, not mixing enabling code with business logic.We will then make some ?obvious? legacy refactorings, done badly. Review the results. This first round will be an application of the Single Responsibility Principle. Then we will discuss the Dependency Inversion Principle and do the refactoring more effectively.We will continue with a comparison of the first tests with their final form and the first version of the business logic with the refactored version. We will review iPod Video 320x240 (92.8 MB) MPEG-4 for QuickTime Medium 1280x480 (396.8 MB)
	No Source Code, No Problem - Reverse Code Engineering in Product Development 18 Jun 10 2:58 PM Reverse Code Engineering (RCE) is commonly applied to solve security-related challenges. It is all about understanding the behavior of software without access to its source code. This often means studying low-level machine code generated from a higher level language like C or C++. Such translation is lossy and highly architecture and compiler dependent, which makes going in the reverse direction quite challenging.In this talk I'm going to discuss RCE from a product development perspective, where interoperability with platform-specific undocumented APIs could be a necessity. First some background including practical examples of key challenges solved by RCE from my own experience, followed by a live demonstration of some tools and techniques. iPod Video 320x240 (182.2 MB) MPEG-4 for QuickTime Medium 1280x480 (735.8 MB)
	Collaboration in ABB - from drawing board to real-life solution using SharePoint 2010 18 Jun 10 2:57 PM ABB is a global leader in power and automation technologies, operates in around 100 countries and employs about 117,000 people. ABB's global intranet is a complex and highly tailored solution containing several hundred thousand pages in more than fifty country sites. The intranet was named one of "The Ten Best Intranets of the Year" by Nielsen Norman Group in 2002, but the general concept of the intranet has not evolved substantially since then. For several years ABB worked on new concepts for making the intranet more valuable to users, by increasing findability, quality of content and opportunities for collaboration. Late last year, SharePoint 2010 was selected as the technical platform to achieve these goals. This talk will outline the collaboration concept that ABB envisioned, and what happened when the concept from the drawing board met the real-life platform SharePoint 2010. The talk will focus on the "social" aspects of the solution such as profiles, networking with colleagues, sharing of information through status updates, activity feeds, social tagging and commenting. It will describe, feature by feature, which parts of SharePoint were used as they are, and which were tailored to achieve a more interactive and collaborative intranet for ABB. The talk will focus both on functionality and on hands-on technical implementation.The speakers will share their experiences of what worked well and what not in terms of conceptual design, development of improved or new social fea iPod Video 320x240 (131.9 MB) MPEG-4 for QuickTime Medium 1280x480 (614.5 MB)
	Creating Web Sites with Open Rasta 18 Jun 10 2:57 PM OpenRasta is a framework built from the ground?Cup to unleash the power of HTTP. Be it web sites, forms or web services, OpenRasta lets you build your application quickly and efficiently, without the hassle of complicated APIs and god objects. Come and discover why OpenRasta is the most talked about ReST framework on .net, and how it can help you deliver better, more http?Cfriendly systems. iPod Video 320x240 (137 MB) MPEG-4 for QuickTime Medium 1280x480 (679.4 MB)
	Product Development in TANDBERG 18 Jun 10 1:57 PM TANDBERG has never cared much about documentation, procedures, methodologies and risk reduction. However, we do care very much about our culture and our principles. This has enabled us to outperform all competition in the video conferencing and telepresence market during the last decade.In retrospect, we realize that TANDBERG has for 10-15 years built a culture that is quite compatible with Agile and Lean ideas.This talk will give a glimpse into how we do product development in TANDBERG R&D at Lysaker. I will show an example of how we developed a particular product with emphasis on software development, before I dive into the principles that we follow. iPod Video 320x240 (112.7 MB) MPEG-4 for QuickTime Medium 1280x480 (320.4 MB)
	Clean Code III: Functions 18 Jun 10 1:51 PM Get ready for a challenge as Robert Martin dives deep into the topic of clean Java code by examining what makes a good function. In this talk you will look at a lot of code; some good and some bad. You will experience how such code is analyzed, critiqued, and eventually refactored. You will understand the decisions made by an expert in the field as bad code is gradually transformed into good code. How big should a function be? How should it be named? How should it be documented. How many indent levels should it have? How should it deal with exceptions, arguments, and return values. This talk is all about code at the lowest level. And yet the principles and techniques presented have far reaching implications. iPod Video 320x240 (149 MB) MPEG-4 for QuickTime Medium 1280x480 (449.2 MB)
	Advanced Topics in Agile Planning 18 Jun 10 12:40 PM Velocity is perhaps the most useful metric available to agile teams. In this session we will look at advanced uses of velocity for planning under special but common circumstances. We will see how to forecast velocity in the complete absence of any historical data. We will look at how a new team can forecast velocity by looking at other teams. We will see how to predict the velocity of a team that will grow or shrink in size. Most importantly we will look at the use of confidence intervals to create plans we can be 90% confident in, even on fixed-price or fixed-date contracts. iPod Video 320x240 (143.8 MB) MPEG-4 for QuickTime Medium 1280x480 (396.1 MB)
	SharePoint 2010 - Is it Scalable or not? 18 Jun 10 12:38 PM If there is any topic that has generated more debate, it is the scalability of SharePoint lists and document libraries. In this session, Sahil will talk about the new and improved details around the scalability, and performance aspects of SharePoint 2010. Topics covered will include List management infrastructure, content database schema improvements, and RBS capabilities, with practical gotchas and things to watch out for. iPod Video 320x240 (98 MB) MPEG-4 for QuickTime Medium 640x480 (186 MB)
	Aspect Oriented Programming: Learning by Re-Invention 18 Jun 10 1:38 PM This talk aims to provide an in-depth understanding of the concept of Aspect Oriented Programming and how an AOP framework does what it does, by taking the audience through the implementation of (a simple) one from scratch. iPod Video 320x240 (154.3 MB) MPEG-4 for QuickTime Medium 1280x480 (616.3 MB)
	Agile Release Strategy 18 Jun 10 12:37 PM Releasing often is probably the most important practice in agile development. In many projects it can also be the hardest practice. This talk will give you hands on advice on how to reliably reduce your release cycle. iPod Video 320x240 (62.9 MB) MPEG-4 for QuickTime Medium 1280x480 (244.9 MB)
	Testing C# and ASP.NET Applications with Ruby 18 Jun 10 1:37 PM With the reach and diversity of different programming languages andparadigms at the moment, it's possible to use the appropriate languagefor the appropriate task. In my case, I develop applications using C# but test the code using Ruby. The Ruby community has always understood the importance of testing. They strive to make applications more testable while improving the approaches and tools they use. As aresult, they have created some amazing frameworks and a series of best practices to support testing. While this is great for Ruby developers, C# and ASP.net developers can take full advantage for their own applications. This session provides an insight into the Ruby world and how you can take advantage to create readable, maintainable and valuable tests for ASP.net based web applications, from the business logic up to the user interface. Taken from my own experiences of using this approach, the session will demonstrate how to integrate Ruby frameworks such as RSpec and Cucumber into your application development cycle, and how different frameworks combined with Ruby can solve a number of problems traditionally faced when using C#. There will also be discussionaround IronRuby and JRuby and their implications for the future andthe future of Testing ASP.net applications in general. iPod Video 320x240 (98.4 MB) MPEG-4 for QuickTime Medium 1280x480 (523.3 MB)
	The Art of the Method 18 Jun 10 12:35 PM Have you ever looked at a method or function in someone else's code and felt that you've seen it before? Methods don't come in infinite varieties. There are some very common structural and semantic patterns which recur in code. Some of them occur because teams have adopted good coding and design conventions. others occur because methods tend to fall apart and degrade in similar ways.In this session, Michael Feathers will name and describe various types of methods seen in the field and talk about how a nomenclature for these methods can simplify and focus design. iPod Video 320x240 (75.8 MB) MPEG-4 for QuickTime Medium 1280x480 (285.2 MB)
	ASP.NET MVC vs Ruby on Rails - The .NET Rocks Smackdown 18 Jun 10 1:18 PM Shay Friedman's comparison of ASP.NET MVC and Ruby on Rails gets redesigned for an NDC 2010 exclusive. Carl Franklin and Richard Campbell joins in and moderates a smackdown between the two leading web frameworks featuring Rob Conery, Chris Hardy, Hadi Hariri, Scott Bellware and of course Shay Friedman. This is you're chance to be part of a lively discussion which will be broadcasted on the leading .NET talkshow .NET Rocks this summer. iPod Video 320x240 (286.4 MB) MPEG-4 for QuickTime Medium 320x240 (209 MB)
	Spark Deep Dive 18 Jun 10 11:40 AM iPod Video 320x240 (173.2 MB) MPEG-4 for QuickTime Medium 1280x480 (619.7 MB)
	SharePoint 2010 - Business Connectivity Services 18 Jun 10 10:39 AM Business connectivity services, now enables you to bring external data into SharePoint and office with full CRUD (Create/Retrieve/Update/Delete) capabilities. This talk explains BCS in SharePoint 2010 in an end-to-end fashion, covering from the browser, through SPD, to the Visual Studio 2010 story iPod Video 320x240 (95.2 MB) MPEG-4 for QuickTime Medium 1280x480 (442.5 MB)
	Agile Estimating 18 Jun 10 10:38 AM iPod Video 320x240 (126.5 MB) MPEG-4 for QuickTime Medium 1280x480 (247.6 MB)
	Using ReST to design a better OData 18 Jun 10 11:40 AM iPod Video 320x240 (162.9 MB) MPEG-4 for QuickTime Medium 1280x480 (777.7 MB)
	Code Contracts 18 Jun 10 11:36 AM Code Contracts are a new feature of .NET 4 and present themselves as a way of greatly simplifying our code by using the concepts of Design by contract. In this talk we will cover the basics of Code Contracts and see how they can be used in real-world applications, how they can be tested, and see if they are all they are cut out to be. iPod Video 320x240 (139.5 MB) MPEG-4 for QuickTime Medium 1280x480 (633 MB)
	Clean Code I: Arguments 18 Jun 10 10:35 AM Keeping code clean is a simple matter of professional ethics. In this talk Robert Martin shows how a Java module can start clean, grow to become messy, and then be refactored back to cleanliness. Be forewarned: his tutorial is about CODE. We will put code on the screen and we will read and critique it. And then, one tiny step at a time, we will clean it. In this tutorial you will participate in the step by step improvement of a module. You will see the techniques of the Prime Directive (Never Be Blocked), and Agile Design Principles brought into play. You will witness the decision making process that Agile Developers employ to write code that is expressive, flexible, and clean. Finally, you learn an attitude of professional ethics that defines the software developer??s craft. iPod Video 320x240 (111.8 MB) MPEG-4 for QuickTime Medium 1280x480 (309.4 MB)
	The Deep Synergy Between Testability and Good Design 18 Jun 10 10:34 AM Many people moan about it the fact that their code is hard to test. They hack their code to make it testable and then they moan some more about how unit testing is an irritant, it makes code ugly. The fact of the matter is, it isn't true. There's a deep synergy between testability and good design. All of the pain that we feel when writing unit tests points at underlying design problems. In this session, Michael Feathers will, through a series of examples, show how you can use testability challenges to reconsider and improve your design. iPod Video 320x240 (79.4 MB) MPEG-4 for QuickTime Medium 1280x480 (283.1 MB)
	User Stories for Agile Requirements 18 Jun 10 9:20 AM The technique of expressing requirements as user stories is one of the most broadly applicable techniques introduced by the agile processes. User stories are an effective approach on all time constrained projects and are a great way to begin introducing a bit of agility to your projects. In this session, we will look at how to identify and write good user stories. The class will describe the six attributes that good stories should exhibit and present thirteen guidelines for writing better stories. We will explore how user role modeling can help when gathering a project??s initial stories. Because requirements touch all job functions on a development project, this tutorial will be equally suited for analysts, customers, testers, programmers, managers, or anyone involved in a software development project. By the end of this tutorial, you will leave knowing the six attributes of a good story, learn a good format for writing most user stories, learn practical techniques for gathering user stories, know how much work to do up-front and how much to do just-in-time. iPod Video 320x240 (132.4 MB) MPEG-4 for QuickTime Medium 1280x480 (340.9 MB)
	The Solid Principles of OO & Agile Design 18 Jun 10 9:19 AM What happens to software? Why does is rot over time? How does an Agile development team prevent this rot, and prevent good designs from becoming legacy code? How can we be sure our designs are good in the first place? This class presents the agile S.O.L.I.D. principles for designing object oriented class structures. These principles govern the structure and interdependencies between classes in large object oriented systems. The principles include: The Open Closed Principle, The Liskov Substitution Principle, and the Dependency Inversion Principle, among others. iPod Video 320x240 (140 MB) MPEG-4 for QuickTime Medium 1280x480 (579.1 MB)
	Being an effective team leader 18 Jun 10 9:18 AM In this talk we'll review practices and principles that make good team leaders into great ones. from basic communication and influencing skills to essential day to day practices and things to look out for - this is a session every team lead should be interested in. iPod Video 320x240 (108.8 MB) MPEG-4 for QuickTime Medium 1280x480 (509.1 MB)
	The Dependency Inversion Principle Applied 18 Jun 10 10:17 AM This is a talk which aims to explain the Dependency Inversion Principle in practice. It is not a one hour theoretical explanation of what the principle states, but rather a real life demonstration of how it becomes a natural pattern to apply in the pursuit of a clean, maintainable design within the boundaries of a statically typed language. This is a ??code and commentary?? talk, with virtually no slides. Though the code demonstrated is C#, this is not a technology-specific talk. iPod Video 320x240 (154.6 MB) MPEG-4 for QuickTime Medium 1280x480 (637 MB)
	Testable C# 18 Jun 10 9:16 AM Unit testing is valuable, but it's hard to go very far with it without realizing that sometimes languages make it easy and sometimes they make it hard. In this code rich presentation, Michael Feathers will present a series of testability traps in the C# language: features and ways of using them which make unit testing impossible without specialized tooling. He will also present a simple rule along with supporting concepts that you can use to sidestep all of them and produce C# code which is always easily testable. iPod Video 320x240 (22.8 MB) MPEG-4 for QuickTime Medium 1280x480 (234.8 MB)
	Developing Testable Web Parts for SharePoint 18 Jun 10 10:15 AM The development of components for use in SharePoint is a complex process, and often seems to fly in the face of what is considered good development practice in a Test Driven Development world.In this session I will show how using some good design practices and tools such as Typemock Isolator you can develop testable components for SharePoint (2007 & 2010); often without even having to have SharePoint on your development PC. iPod Video 320x240 (145.2 MB) MPEG-4 for QuickTime Medium 1280x480 (702.8 MB)
	Introducing Spark View Engine 18 Jun 10 10:08 AM iPod Video 320x240 (134.8 MB) MPEG-4 for QuickTime Medium 1280x480 (481.9 MB)
	Getting Agile with Scrum 18 Jun 10 8:00 AM Scrum is one of the leading agile software development processes. Over 12,000 project managers have become certified to run Scrum projects . Since its origin on Japanese new product development projects in the 1980s, Scrum has become recognized as one of the best project management frameworks for handling rapidly changing or evolving projects. Especially useful on projects with lots of technology or requirements uncertainty, Scrum is a proven, scalable agile process for managing software projects.Through lecture, discussion and exercises, this fast-paced tutorial covers the basics of what you need to know to get started with Scrum. You will learn about all key aspects of Scrum including product and sprint backlog, the sprint planning meeting, the sprint review, conducting a sprint retrospective, activities that occur during sprints, measuring and monitoring progress, and scaling Scrum to work with large and distributed teams. Also covered are the roles and responsibilities of the ScrumMaster, the product owner, and the Scrum team.This session will be equally suited for managers, programmers, testers, product managers and anyone else interested in improving product delivery. iPod Video 320x240 (108.3 MB) MPEG-4 for QuickTime Medium 1280x480 (330.5 MB)
	Introduction to GIT 18 Jun 10 9:00 AM An introduction to distributed version control using Git, and how your VCS should work with you and not against you. How DVCS can completely alter your development process, streamline it, and help you produce better software, faster. Covering how local repositories speed up your development, multiple authoritative sources, distributed teams, multiple workflows, and some of the more distinct features of Git. With experiences from an OSS team on how the migration from SVN to Git has helped the project and changed how the team works (Fluent NHibernate). iPod Video 320x240 (152.8 MB) MPEG-4 for QuickTime Medium 1280x480 (717.4 MB)
	Riding IronRuby on Rails 18 Jun 10 9:00 AM The most famous Ruby?Cdriven framework is, by far, Ruby on Rails. With IronRuby, .NET developers can now take advantage of this incredible web framework without leaving their comfort zone. In this session, Shay Friedman will build an entire Web 2.0 site from scratch while using and explaining the key features of Ruby on Rails. Come and see what Ruby on Rails is all about and what's made it the success it is today. iPod Video 320x240 (108.3 MB) MPEG-4 for QuickTime Medium 1280x480 (468.2 MB)
	Developing for SharePoint 2010 18 Jun 10 8:57 AM Sure you're a .NET developer. Maybe you are even a SharePoint developer. But have you seen development for SharePoint 2010? It comes with full tooling support in VS2010, and massive improvements in the platform itself. Developing for SharePoint is finally manageable, but is it easy to be a SharePoint developer? Come and find out! iPod Video 320x240 (154.3 MB) MPEG-4 for QuickTime Medium 1280x480 (794.5 MB)
	The Three Laws of TDD 18 Jun 10 9:00 AM The jury is in, the case is closed. TDD works, and works well. In this talk Uncle Bob makes the point that TDD is not a testing technique at all. Rather, TDD is a way to ensure good architecture, good design, good documentation, and that the software works as the programmer intended. TDD is a necessary discipline for those developers seeking to become professionals. This talk is half lecture and half demonstration. Examples are in Java and Junit. iPod Video 320x240 (186.8 MB) MPEG-4 for QuickTime Medium 1280x480 (622.3 MB)
	The Next Big Thing Or Cool-Kid Koolaid? Slicing Through The Rhetoric of MVC vs. WebForms 18 Jun 10 9:00 AM In this presentation Rob Conery dissects the arguments that are polluting the blogosphere, surrounding the discussion of whether ASP.NET MVC is "right" for you and your team. Passion, misinformation, assumptions and fear have pushed people into entrenched positions, leaving little room for intelligent thought. The goal of this presentation is to "shake loose" the rhetoric and give you some concrete ideas to think about if you're considering a move to ASP.NET MVC. In addition, Rob will try to offer an answer to the question: "Is WebForms Dead?" iPod Video 320x240 (104.7 MB) MPEG-4 for QuickTime Medium 1280x480 (592.8 MB)
	C# Quo Vadis? 17 Jun 10 4:40 PM What??s next for C#? This session will not answer that question! Mads will open with about 10 minutes about the challenges and constraints of language design, followed by an open discussion on where to take C# involving fellow C# designers Eric Lippert and Neal Gafter, C# author and luminary Jon Skeet as well as you in a lively free-form discussion that can take us anywhere and will be absolutely once-in-a-lifetime. iPod Video 320x240 (75.5 MB) MPEG-4 for QuickTime Medium 1280x480 (256.5 MB)
	ASP.NET performance for free using caching 17 Jun 10 5:39 PM Is your ASP.NET application not performing like you wished it would? Performance not what it has to be? Have you considered caching? While many developers know the basics of caching in ASP.NET, there's actually a lot more possible than initially thought. Also, not every technique is good to solve every problem. In this session, we'll do an overview of all the options ASP.NET has to offer for caching and state management, helping you to get a better performing application. iPod Video 320x240 (156.6 MB) MPEG-4 for QuickTime Medium 1280x480 (637.1 MB)
	jQuery: Write less, do more 17 Jun 10 4:40 PM jQuery is a JavaScript library which allows you to develop solutions with less code, in less time. You can build interactive prototypes for your prospective clients, or take an existing solution and add new dynamic behaviour with little effort.We will see how jQuery can be used to quickly and concisely apply JavaScript behaviour to your web app. It will cover selectors, Ajax, DOM manipulation and more. The aim: to produce lean unobtrusive JavaScript with jQuery iPod Video 320x240 (73.8 MB) MPEG-4 for QuickTime Medium 1280x480 (273.3 MB)
	Beautiful Teams & Leaders 17 Jun 10 4:38 PM A look at what makes teams productive, and what makes team leaders effective. from team practices such as automation and communication, to team leads that grow and coach their people, confront problems and finds ways to make people better. this is an overview session. specific issues are elaborated in other sessions. iPod Video 320x240 (107 MB) MPEG-4 for QuickTime Medium 1280x480 (516.5 MB)
	5 reasons why projects using DDD fail 17 Jun 10 4:40 PM Many people try applying Domain Driven Design and #fail miserably.This presentation looks at five top reasons for failure and discusses how to avoid them. iPod Video 320x240 (140.3 MB) MPEG-4 for QuickTime Medium 1280x480 (459.6 MB)
	Introducing the .NET Service Bus 17 Jun 10 5:37 PM The .NET services bus is part of the new Microsoft Cloud Computing Windows Azure initiative, and arguably, it is the most accessible, ready to use, powerful, and needed piece. The service bus allows clients to connects to services across any machine, network, firewall, NAT, routers, load balancers, virtualization, IP and DNS as if they were part of the same local network, and doing all that without compromising on the programming model or security. The service bus also supports callbacks, event publishing, authentication and authorization and doing all that in a WCF-friendly manner. This session will present the service bus programming model, how to configure and administer service bus solutions, working with the dedicated relay bindings including the available communication modes, relying on authentication in the cloud for local services and the various authentication options, and how to provide for end-to-end security through the relay service. You will also see some advanced WCF programming techniques, original helper classes, productivity-enhancing utilities and tools, as well as discussion of design best practices and pitfalls. iPod Video 320x240 (146.4 MB) MPEG-4 for QuickTime Medium 1280x480 (674.7 MB)
	Architecting for the .NET Event Model 17 Jun 10 5:25 PM You may have a basic understanding of .NET's event model, but how can you best architect your applications to take advantage of .NET events? This session spends a few minutes on the basics, then provides real-world examples showing how you can design your applications to take advantage of the .NET event model for things such as:* Custom data binding in Windows Forms and Web Forms* Establishing relationships between business components* Creating world-class, end-user-configurable security* Localizing the user interface dynamically at run time iPod Video 320x240 (123.2 MB) MPEG-4 for QuickTime Medium 1280x480 (660.1 MB)
	The Purpose of Leadership and Governance 17 Jun 10 4:21 PM There are three types of organizations: ordered, chaotic, and complex organizations. The best management approach depends on the type of organization, and the amount of rule?Cmaking a development manager?team leader should concern himself with. However, this distinction is a false (but useful) metaphor. In reality, development teams are complex _adaptive_ systems, meaning that they should be doing their own rule?Cmaking, as self?Corganizing systems. However, self?Corganization alone is not enough. Management is needed for imposing boundaries and constraints. There's a great checklist available to managers and team leaders for defining boundaries to authority in self?Corganizing teams. There are two kinds of purpose: archeo?Cpurpose and neo?Cpurpose. Both the team itself and the manager can assign a neo?Cpurpose to a team. This neo?Cpurpose is not the same as the goal of the project they are working on, or the goals of any of the stakeholders. One thing a manager?leader can do is to assign purpose to a self?Corganizing team. We will discuss how to do that. iPod Video 320x240 (129.8 MB) MPEG-4 for QuickTime Medium 1280x480 (733.6 MB)
	Building Applications with Silverlight 4 17 Jun 10 3:20 PM Now that Silverlight 4 is released, find out what is new?changed and how to write great data-driven applications with Silverlight 4. Learn about how you can leverage Silverlight 4 for rich desktop applications using the new ??trusted application?? model and how to best take advantage of these features. Accessing data using RIA Services makes data-driven applications easier and can support a ViewModel development pattern approach. This session will be faced pace in overview, but deep in code. Few slides, mostly code. iPod Video 320x240 (131.8 MB) MPEG-4 for QuickTime Medium 1280x480 (323.4 MB)
	From one web server to two: Making the leap to web farms 17 Jun 10 4:20 PM iPod Video 320x240 (143.2 MB) MPEG-4 for QuickTime Medium 1280x480 (709.9 MB)
	Code Excavations, Wishful Invocations, and Domain Specific Unit Test Frameworks 17 Jun 10 3:20 PM In this talk I'll describe a technique for unit-testing code embedded in an impenetrable framework (such as Sharepoint, Silverlight, and BizTalk) that make such code inaccessible. We know we should write code that is easy to test because it has clean boundaries, but sometimes the vendors we work with make that kind of modularity just too hard. I will talk about how we can test such plug-in code by faking its environment in memory, simulating the underlying engines. As an example, I'll be showing SilverUnit, a framework to test code written for the Silverlight framework without driving through the browser. I'll talk about how the need for this sort of testing arose during silverlight development and how it allowed me to make sure my silverlight code worked as expected. even the UI logic. iPod Video 320x240 (102.3 MB) MPEG-4 for QuickTime Medium 1280x480 (475.7 MB)
	If I Ruled the World - C# 5.0 According to Jon 17 Jun 10 3:20 PM Now that C# 4 is out, thoughts are naturally turning towards what C# 5 might hold. Speaking from a position of breathtaking ignorance of what the team is actually planning, and without the safety net of a working implementation, I will outline a few ideas about what could be in C# 5. Some will be wacky, some mundane and perhaps even obvious. One thing's almost certain: this won't be the feature set of the real C# 5. Even so, it will provide some food for thought. iPod Video 320x240 (126.4 MB) MPEG-4 for QuickTime Medium 1280x480 (529.2 MB)
	Domain Driven Entity Framework 17 Jun 10 3:20 PM If you think of your database as an "implementation detail", it is likely that you are not interested in building your all important domain classes based on a database or being bound by the limitations of a modeling tool. In the U.S., Telemark skiers cry "Free the Heel". In this session we'll make that a call to "Free the Domain Classes". We'll take a look at the different mechanisms that do not involve reverse engineering a database. In VS2010, EF's Model-First support and in the Entity Framework Feature CTP, the completely model-less Code Only support. We'll finish with a quick look at SQL Server Modeling's M language, which provides yet another option for defining entity classes without the EDM designer . iPod Video 320x240 (121.8 MB) MPEG-4 for QuickTime Medium 1280x480 (422 MB)
	Top Security Scenarios for WCF Services: On Premise & In The Cloud 17 Jun 10 4:20 PM Today you will be hard-pressed to find an enterprise application that does not rely on distributed messaging and service-orientation. Client applications such as rich clients, Rich Internet Applications (RIAs) built with Silverlight or some flavor or AJAX, and those targeting mobile devices all access resources via services exposed to the intranet or Internet. Oftentimes the middle tier also includes layers of services living in the DMZ or behind it. There are many possible security models available for scenarios involving the various client technologies and service tiers - and Windows Communication Foundation (WCF) supplies the tools necessary to implement each and every possibility. In this session, you will learn the most common and practical security scenarios that involve WCF services within the intranet or exposed to the Intranet including classic Windows security, username and password, certificates, federated identity, REST-based and securing calls between tiers. The session will also discuss scenarios that can benefit from aspects of Windows Azure platform including AppFabric Service Bus and Access Control - such as for securing services behind the DMZ and enabling federation for REST-based services. All examples will cover requirements for the client and service, give you a formula to achieve each scenario, and show you custom components that simplify implementation. You??ll leave this session with a recipe for the most common security scenarios including sample code iPod Video 320x240 (152.7 MB) MPEG-4 for QuickTime Medium 1280x480 (727.6 MB)
	MonoTouch Deep Dive 17 Jun 10 2:00 PM A deep dive into developing applications with MonoTouch. Learn about the different UI components available on the iPhone and iPad and how to use these with MonoTouch as well as how you can create interoperability with your .Net libraries within MonoTouch. iPod Video 320x240 (108.2 MB) MPEG-4 for QuickTime Medium 1280x480 (294.4 MB)
	What I've learned About DDD Since the Book 17 Jun 10 2:00 PM In the 5 years since the book was published, I've practiced DDD on various client projects, and I've continued to learn about what works, what doesn't work, and how to conceptualize and describe it all. Also, I've gained perspective and learned a great deal from the increasing number of expert practitioners of DDD who have emerged.The fundamentals have held up well, as well as most patterns, but there are differences in how I do things and look at things now. I will try to describe them, very informally, in this talk.Over this time, I have folded in a couple of additional patterns, and essentially come to ignore a few, but the biggest change has been a subtle shift of emphasis. Ubiquitous Language and Context Mapping and Core Domain are at the center, with aggregates in close orbit. Why, I ask myself, did I put context mapping in Chapter 14? Core domain in Chapter 15?! Before the book, it seemed self-evident to me that SOA fit well with DDD, but five years of questions on that topic have made it clear that my early explanations were inadequate and helped me clarify how it fits. Increased emphasis on events and distributed processing have crystallized the significance of aggregates and refined the building blocks.The talk cannot go into depth on all these topics, but the goal will be to give a quick look at where my view of DDD has been heading. iPod Video 320x240 (117.1 MB) MPEG-4 for QuickTime Medium 1280x480 (448.6 MB)
	Advanced Tips & Tricks for ASP.NET MVC 2 17 Jun 10 1:57 PM In this session we??ll not only look at improving the maintainability and performance of an MVC application, but also how to increase your productivity. Topics include model binding, meta-data providers, and T4 Templates. iPod Video 320x240 (111.5 MB) MPEG-4 for QuickTime Medium 1280x480 (416 MB)
	C# in the Big World 17 Jun 10 1:57 PM C# 4.0 focuses on being a good citizen in a big world. In this talk we look at named and optional arguments, as well as the much improved COM interaction. We pay special attention to the new dynamic feature and the Dynamic Language Runtime (DLR) that it builds on: How do they work, how can you use them and why did we design them this way. We??ll also interoperate with COM and the HTML DOM, and build our own dynamic objects. iPod Video 320x240 (110.7 MB) MPEG-4 for QuickTime Medium 1280x480 (365.5 MB)
	Tasks & Threading in .NET 4.0 17 Jun 10 3:00 PM Writing multi-threaded applications is hard - making them work is even harder. Scaling applications to the current and future multiple-core machines can really be a daunting task --- but it doesn't have to be! In this session, Ingo Rammer shows you the new task-based API and how it simplifies the creation of multi-core supporting applications. You will learn how you can take advantage of the fine-grained parallelism and control which is offered by this new .NET feature. Ingo will also show you how to extend your in-memory LINQ query to run in parallel, and how the new Visual Studio 10 debugging tools will make troubleshooting this kind of applications a lot easier. iPod Video 320x240 (158.9 MB) MPEG-4 for QuickTime Medium 1280x480 (579.7 MB)
	Making Manual Testing a Part of Your Development Process 17 Jun 10 3:00 PM Software has always needed to be tested manually, automation can help, but it is never going to replace the need for manual testing totally. How a team manages this requirement for manual testing can be key to a projects success or failure.In the 2010 release of Visual Studio, Microsoft have provided a whole new set of tools to aid in this process - Microsoft Test Manager. In this session I will show how MTM can be used to assist a tester in creating detailed, accurate and repeatable testing that are a joy to use (well might be stretching a point there!). Also I will show how the tooling can allow these manual tests can become the basis for automated tests and Coded UI tests, and how the advanced logging features of the tools allow bugs to be accurately passed back to developers for speed the production of fixes. iPod Video 320x240 (137.6 MB) MPEG-4 for QuickTime Medium 1280x480 (644.4 MB)
	Windows Identity Foundation and Windows Azure 17 Jun 10 3:00 PM Claims-based identity provides an open and interoperable approach to identity and access control that can be consistently applied both on-premises and in the cloud. Come to this session to learn about how Windows Identity Foundation can be used to secure your Web Roles hosted in Windows Azure, how you can take advantage of existing on-premises identities and how to make the best of features in our cloud offering, such as certificate management and staged environments. iPod Video 320x240 (110.5 MB) MPEG-4 for QuickTime Medium 1280x480 (572.5 MB)
	Software Is Not Manufacturing 17 Jun 10 12:45 PM While we assert that software development is not manufacturing, we often slip into manufacturing metaphors and analogies and then fail to extricate our explorations of how software development unfolds from manufacturing. Some of these analogies are so deeply-rooted into our customs that we readily contradict our own assertions. This presentation looks at just how handicapped your software development becomes at the hand of these engrained manufacturing perspectives. It looks at product development theory as a better analogy to software development and a more practicable body of knowledge for software development. And it looks at how even product development theory fails to illuminate software development when we backslide into manufacturing-specific product development. Lean and Agile methods are framed in terms of product development and software development productivity problems are laid open under the surgical precision of product development analogies to building software machines. iPod Video 320x240 (62.1 MB) MPEG-4 for QuickTime Medium 1280x480 (255.1 MB)
	Introduction to MonoTouch 17 Jun 10 12:39 PM An overview of what's possible using Monotouch, Novell's tool to enable C# and .Net based applications for the iPhone, iPod touch and iPad. Find out what you need to start using Monotouch and how to create a sample application. If you have any questions on why you'd use this, what are the benefits and downsides of using Monotouch then this is your place! iPod Video 320x240 (90.9 MB) MPEG-4 for QuickTime Medium 1280x480 (251.7 MB)
	Technology Supported Requirement Handling and Estimation 17 Jun 10 1:40 PM Lindorff Group is a leading outsourced receivables management company in Europe, and one of the leading on a global basis. For the past three-four years, they have increasingly adopted agile practices, especially in a large scale project converting and improving an old system written in Powerhouse to new .Net-technology.The results from adopting agile practices have been mostly positive, however, there were challenging issues related to requirement handling and estimation that needed attention. In 2008, Lindorff joined a project with Symphonical funded by Innovation Norway. The purpose of the project was to develop software for requirements handling, estimation and knowledge management for the Symphonical platform. Symphonical is a flexible web-based collaboration platform, where users can brainstorm, plan, organize and coordinate any process.This talk presents results from a case study detailing the challenges faced by Lindorff as they simultaneously adopted agile practices and introduced a new system for requirement handling and estimation. According to the respondents of the case study, Lindorff appears to have improved on two of the main points of concern presented in the 2007 study: requirement handling and estimation. Many users report that the introduction of agile methods and the platform Symphonical has improved the quality of important work processes. Furthermore, they report that the introduction of Symphonical has provided a framework for structured discussions re iPod Video 320x240 (124.2 MB) MPEG-4 for QuickTime Medium 1280x480 (594.5 MB)
	Rocking AppFabric Access Control: Practical Scenarios, Killer Code and Wicked Tools 17 Jun 10 12:38 PM AppFabric Access Control is a feature of the Windows Azure platform that makes it easy to secure web resources such as REST-based services using a simple set of standard protocols. In fact, AppFabric Access Control uniquely facilitates several scenarios not previously possible including a standards-based mechanism for securing web resources, identity federation for REST, and secure calls from Silverlight and AJAX clients to web resources including REST-based WCF services or REST-based MVC implementations. In this session you will get a tour of the AppFabric Access Control feature set and learn how to implement these key security scenarios with the help of some custom tools that encapsulate common functionality exposing a simple object model for working with the protocols underlying Access Control. In addition, you will learn how to integrate typical Windows Identity Foundation (WIF) authorization techniques such as ClaimsPrincipal to decouple the authentication and authorization mechanism from the business logic. iPod Video 320x240 (138.5 MB) MPEG-4 for QuickTime Medium 1280x480 (570.6 MB)
	Unleash Your Domain 17 Jun 10 12:40 PM Our application runs over 10,000 sustained transactions per second with a rich model. The key? Modeling state transitions explicitly.In today's world many systems have non-functional requirements that prevent them from being single database centric. This presentation looks at how Domain Driven Design can fit into such environments including extremely large scale web sites, batch processing, and even using highly scalable backing stores such as CouchDb or HyperTable.Event streams, a different way of storing the current state of an object, open many doors in this session not only in how we scale and store our domain but also in how we rationalize about it. iPod Video 320x240 (112.6 MB) MPEG-4 for QuickTime Medium 1280x480 (410 MB)
	Testers Are Not Your Enemy 17 Jun 10 1:40 PM Manual testing has been marginalized in agile development. Usdevelopers seems to think that manual testing is outdated and shouldnow be replaced by automatic test scripts. I think that manual testingshould still be a part of the development process, and in this talk,you will learn why that is and how we can integrate manual testers onagile teams. iPod Video 320x240 (66.3 MB) MPEG-4 for QuickTime Medium 1280x480 (330.1 MB)
	Improving Your ASP.NET Application Performance with Asynchcronous Pages and Parallel Extensions 17 Jun 10 1:40 PM Asynchronous pages and handlers can be used in ASP.NET to improve the performance of the application, especially the throughput, but wrongly used can lead to unexpected behavior, including a degraded performance. One of the key technologies that are part of the Visual Studio 2010 is Parallel Extensions. So come to this interactive session to see how you can benefit from those new technologies and how they can help you to mitigate some of the problems. iPod Video 320x240 (141.8 MB) MPEG-4 for QuickTime Medium 1280x480 (674.5 MB)
	Fluent Nhibernate 17 Jun 10 11:40 AM (misses 4 minutes in the start)An introduction and overview to object?relational mapping using Fluent NHibernate. See how Fluent NHibernate can help you map your domain with the least amount of effort, how you can remain flexible with your database, and how to drive your design through convention?Cover?Cconfiguration; all without writing a single line of XML. The talk is an introduction to Fluent NHibernate for those that aren't familiar with it, and assumes some NHibernate experience and is for .Net developers primarily. The goal is to show people how low?Cimpact NHibernate can be with Fluent NHibernate, and how it can actually speed up development in rapid?Cchange environments. I'll cover an overview of what Fluent NHibernate is, the various parts of it (the fluent interface, the conventions, and the auto?Cmappings, and the configuration aspect), then expand on how these features can be utilised to improve your NHibernate experience and simplify your development process. iPod Video 320x240 (94.8 MB) MPEG-4 for QuickTime Medium 1280x480 (512.5 MB)
	Folding Design to Agile 17 Jun 10 10:40 AM After a decade of heavy process, the Agile revolution of the late '90s threw off the dead hand of big upfront design. The bloody purge that followed was needed!There were unintended consequences. Too many teams interpret "Agile" as a permit to not think about design. But if they have ambitious goals, Agile teams need more than standup meetings and iterations. Many teams get off to a quick start, building lots of features in early iterations, but end up with a "Big Ball of Mud". Without clear and well-structured code, they cannot sustain their pace and also put themselves at risk of, one day, encountering a critical feature they simply cannot deliver. Without the common understanding between developers and stakeholders that is forged in domain analysis, one of the greatest benefits of iteration, the deepening communication about what the software should do and how it should do it, is never realized.We must not return to the "Analysis Paralysis" that we used to endure (and that many teams still do), but interpreting "Do the Simplest Thing" as "Do the Easiest Thing" doesn't work either.This talk will consider ways of incorporating modeling and design into the iterative process in a lightweight way that increases communication with stakeholders and decreases the likelihood of painting ourselves into corners, without returning to the dead-hand of the analysis phase. As a concrete example of how such techniques can be incorporated into the Agile framework, we'll have an overview of iPod Video 320x240 (88.4 MB) MPEG-4 for QuickTime Medium 1280x480 (234.3 MB)
	Silverlight data access and services not for the faint of heart 17 Jun 10 10:40 AM For data needs, Silverlight can talk to services like WCF or REST enabled services. These service types are sufficient for most scenarios. But what if it isn't? Most examples that can be found out there cover the basics, but in the real world, that's sometimes not enough. In this session, we'll explore the dark corners of Silverlight??s service access. Among others, we??ll cover duplex communication, debugging services, the HttpWebRequest, TCP communication and securing service communication from Silverlight. iPod Video 320x240 (126.8 MB) MPEG-4 for QuickTime Medium 1280x480 (414.6 MB)
	Zen of Architecture 17 Jun 10 10:37 AM Wonder about architecture best practices, guidelines and pitfalls? Wonder how to design world?Cclass systems? You understand the concepts but not how to apply them? In the first half of this high pace session, Juval will explain his original approach to large system analysis design. Then, he will discuss logical tiers, security, interoperability, scalability, transactions, and other aspects of a modern application. You will see how to approach rarely discussed topics such as allocation of services to assemblies, allocation of services to processes, transaction boundaries, identity management, authorization and authentication boundaries and more. iPod Video 320x240 (101.8 MB) MPEG-4 for QuickTime Medium 1280x480 (393.9 MB)
	Modularization, Testing & Technical Debt in a Large Agile Project 17 Jun 10 10:40 AM This experience reports focuses on the major scrum?Crelated technical challenges that arose during a 120 000 hour scrum controlled project. For each of them, we try to identify the cause and the consequence, and then follow up with any solutions we tried. Finally we sum up and assess whether the problem was successfully solved or not. iPod Video 320x240 (66 MB) MPEG-4 for QuickTime Medium 1280x480 (294.1 MB)
	Hardcore .NET Production Debugging 17 Jun 10 11:40 AM But ... it used to work yesterday! In this newest version of his classic session, Ingo Rammer will introduce the hardcore and low-level tools used for production debugging of .NET applications. You'll learn how to attack the nastiest bugs in your applications, how to look at what's causing that grinding halt of your ASP.NET application and how to find the cause of that horrible memory leak in your Windows Forms application. Knowledge of these production debugging tools like WinDbg and SOS is not only important for cases when you really don't have access to Visual Studio and your source code, but these tools also reveal a lot more information than just the regular managed code debuggers. iPod Video 320x240 (165.9 MB) MPEG-4 for QuickTime Medium 1280x480 (697 MB)
	Solid C++ code by example 17 Jun 10 11:36 AM Sometimes you see code that is perfectly OK according to the definition of the language, but which is flawed because it breaks too many established idioms and conventions. On the other hand, a solid piece of code is something that looks like it is written by an experienced person who cares about professionalism in programming. This will be an interactive discussion about good vs bad C++ code. We will discuss simple C++ idioms and coding conventions, but we will also touch upon best practices when working with C++ in large codebases with lots of developers with mixed skills. iPod Video 320x240 (98.9 MB) MPEG-4 for QuickTime Medium 1280x480 (337.1 MB)
	Silverlight Applications for Windows Phone 7 17 Jun 10 9:20 AM Windows Phone 7 is brand new, totally fresh operating system that will appear in phones before Christmas. The new platform is a complete rewrite and offers lots of interesting opportunities to third party developers. The development platform for Windows Phone 7 is all based around managed code and the tools and frameworks you already know and love. This presentation you will give you an overview of the Windows Phone 7 development platform, and how you can leverage your existing Silverlight skills to build great applications for the Windows Phone 7 marketplace. The session assumes some prior knowledge of Silverlight, as the focus of this presentation will be features that are specific to the phone. It will not only cover the basics of the Windows Phone 7 platform, but also how you can re-use many of the same patterns, frameworks, techniques and practices that you use when building regular Silverlight applications. iPod Video 320x240 (115.6 MB) MPEG-4 for QuickTime Medium 1280x480 (366.1 MB)
	Entity Framework Persistance Ignorance 17 Jun 10 9:20 AM Entity Framework in .NET 4 has finally embraced agile development. Thanks to it's new POCO support, you can now build completely persistent ignorant entity classes. In this session, we'll look at building an intelligent repository from entity classes and mocking up some extra classes in order to build unit tests against methods that have some dependency on the Entity Framework without touching the EF APIs. A prior understanding of the PI and Unit Testing should keep your head from spinning too much. iPod Video 320x240 (115.2 MB) MPEG-4 for QuickTime Medium 1280x480 (425.7 MB)
	Service Oriented Development Process 17 Jun 10 9:20 AM When you develop a service-oriented application, it would be naive of you to expect that the only things you will do differently will be limited to design and technology. The development process itself needs to be service-oriented. You cannot "stare into the fire" of WCF without a mature service-oriented development process supporting your effort. This talk presents you with a service-oriented development process that you can apply to your WCF-based products to achieve robust applications, manage requirements and ensure faster time to market. iPod Video 320x240 (90.7 MB) MPEG-4 for QuickTime Medium 1280x480 (324.9 MB)
	IronRuby - A Brave New World for .NET 17 Jun 10 10:18 AM .NET developers are about to enter a brave new world. With Microsoft'sDynamic Language Runtime (DLR) developers can start taking advantageof dynamic languages, such as IronRuby and IronPython, on top of the.Net platform and integrating the language into their existing .netbased applications. However, why is this important?In this session, Ben will provide an insight into the deep darksecrets of why he loves the Ruby language and how it can result in amore effective solution when compared to C#. After demonstrating thepowerful capabilities, Ben will explain how the DLR with IronRubyallows you to take full advantage of Ruby from C# applications,resulting in you choosing the appropriate language (C# or Ruby) forthe appropriate feature. The combination results in a powerfultool-set and opens some amazing possibilities for both C# and Rubydevelopers. With C# 4.0, these capabilities are taken a step further.But the advantage is not just one way, there are also advantages forRuby developers by allowing them to develop against the .Netframework. iPod Video 320x240 (119.8 MB) MPEG-4 for QuickTime Medium 1280x480 (570.1 MB)
	jQuery for ASP.NET developers 17 Jun 10 9:20 AM This session is a practical tour of the ??write less, do more?? JavaScript library - jQuery. In this session we will build an application using ASP.NET and jQuery while learning about CSS selectors, DOM manipulation, and asynchronous communications using the jQuery library. We??ll also look at the jQuery plug-in model, examine common jQuery programming paradigms, and see how to invoke WCF web services using jQuery. iPod Video 320x240 (97.3 MB) MPEG-4 for QuickTime Medium 640x480 (190.4 MB)
	Advanced Debugging with Visual Studio 17 Jun 10 10:17 AM Basically every .NET developer knows the Visual Studio debugger, but only few know its little secrets. In this session, Ingo shows you what you can achieve with this tool beyond the setting of simple breakpoints. You will learn how advanced breakpoints, debugger macros and visualizers, interactive breakpoints, tracepoints and interactive object instantiation at development time can support your hunt for bugs in your applications. Ingo will also show you the new crash-dump debugging features of Visual Studio 2010 which allow you to get closer to your problem even if you don't have access to Visual Studio on the machine which exhibits the unexpected behavior. iPod Video 320x240 (177.7 MB) MPEG-4 for QuickTime Medium 640x480 (176.5 MB)
	Unit Testing Best Practices & Test Reviews 17 Jun 10 10:20 AM In this session we look at existing .NET code form open source projects and discuss anti patterns worst practices when doing unit testing in the wild. From abuse of mock objects, unmaintainable tests and unreadable tests to checking interactions vs. state - this talk will take you deep into the real ugly world of unit testing. iPod Video 320x240 (134.8 MB) MPEG-4 for QuickTime Medium 1280x480 (664.2 MB)
	Ruby for .NET developers 17 Jun 10 9:00 AM After having spent many years coding in C#, and after having spent equally as much time in the C# language culture, Ruby seemed like a lot of bad ideas and heresy. In fact, much of Ruby is heretical to a C# or VB.NET mono-culture, but the productivity gains demonstrated by Ruby on Rails teams remains an unavoidable elephant in the room. This presentation looks at C# code examples side by side with some equivalent Ruby code and shines a little light on what it means to have either "ceremony" and "essence". It challenges the claims of static typing's effect on tooling to deliver "developer productivity". And finally, some examples of Ruby meta programming are given to demonstrate direct solutions to programming problems that would require much ado with restrictions in C# that don't end up doing much more than reducing the efficiency of software development efforts. iPod Video 320x240 (2.3 MB) iPod Video 320x240 (22.5 MB) iPod Video 320x240 (98 MB) MPEG-4 for QuickTime Medium 1280x480 (384.6 MB)
	Silverlight for Windows Phone 17 Jun 10 9:00 AM Windows Phone 7 Series is coming??and if you are a Silverlight developer there is good news: Silverlight is the development platform for Windows Phone applications. This session will provide an overview of the tools, the emulator, and the core APIs for Silverlight for Windows Phone development. Find out what is (and is not) possible in creating and porting your Silverlight applications ready for Windows Phone 7. iPod Video 320x240 (130.3 MB) MPEG-4 for QuickTime Medium 1280x480 (316 MB)
	Putting Some Testing Into Your TFS Build 17 Jun 10 9:00 AM Continuous Integration and scheduled builds are an important part of any development process. To get the best out of these tools, as much testing as possible should be wired into the post build process. With the 2010 release of Visual Studio we get the Lab Manager product that allows us to deploy our automated build to a virtualised test environment for either manual and?or automated testing. In this session I will show by doing an end to end demo, showing how an application can be build, deployed and tested with the Lab Manager environment. iPod Video 320x240 (132.8 MB) MPEG-4 for QuickTime Medium 1280x480 (578.1 MB)
	Big-Ass View on Competency 17 Jun 10 9:00 AM Agile team members create their own rules, based on constraints imposed by the environment. But something else is needed for good results: some call it discipline, craftsmanship, or competence. Traffic management teaches us that there are 7 approaches to achieving competence in a self-organizing system. We are going to look at all of them. iPod Video 320x240 (129.4 MB) MPEG-4 for QuickTime Medium 1280x480 (699.8 MB)
	Strategic Design 17 Jun 10 9:00 AM As software development leaders, we need to think more strategically. Some design decisions affect the trajectory of the whole project or even the organization. These decisions arise in early chartering and throughout development, and they are about much more than architecture. This talk will examine these issues through the lens of the Strategic Design principles of domain-driven design, which systematize a few critical practices some successful teams do intuitively.It is common for skilled teams to deliver software they are not proud of, due to compromises with legacy designs. Others toil for years, producing a platform that is never used to good advantage. These are strategic failures. On the other hand, there are projects with a direct explanation of how the software contributes to business goals. There are projects where designers work with a realistic view of the context of their development within the larger system, allowing them to maintain design clarity and integrity. These are strategic successes. Winning strategy starts with the domain.Two domain-driven design principles, "Context Mapping" and "Distilling the Core Domain", help you see your strategic situation more clearly and approach strategic design decisions more systematically. These techniques require extensive interaction with domain experts as well as the leaders of the organization, in discussions broader than functional requirements. They sometimes lead to priorities quite different from our most comfort iPod Video 320x240 (130.2 MB) MPEG-4 for QuickTime Medium 1280x480 (603.5 MB)
	Co- and contra-variance in C# 17 Jun 10 7:57 AM What's the difference between a bunch of bananas and a fruit bowl? Why can't I order a collection of circles by area? Why is the Hokey Cokey invariant? These questions (and some rather more sensible ones) will be answered in this session on variance. C# has supported variance to different degrees over different versions; C# 4 introduces covariance and contravariance to generic delegates and interfaces. Many developers may well use these features without even being aware of them - but as ever, it's useful to know what's going on for the times where things go wrong. Pre-requisites: a strong cup of coffee for when we discuss higher order functions, and a reasonable grasp of generics. Understanding Func, Action, IEnumerable and IComparer would be a good start. iPod Video 320x240 (132.2 MB) MPEG-4 for QuickTime Medium 640x480 (139.9 MB)
	Windows Identity Foundation Overview 17 Jun 10 8:51 AM Hear how Windows Identity Foundation makes advanced identity capabilities and open standards first class citizens in the Microsoft .NET Framework. Learn how the Claims Based access model integrates seamlessly with the traditional .NET identity object model while also giving developers complete control over every aspect of authentication, authorization, and identity-driven application behavior. See examples of the point and click tooling with tight Microsoft Visual Studio integration, advanced STS capabilities, and much more that Windows Identity Foundation consistently provides across on-premise, service-based, ASP.NET and Windows Communication Foundation (WCF) applications. iPod Video 320x240 (119.8 MB) MPEG-4 for QuickTime Medium 1280x480 (608.3 MB)
	Browsers with Wings: HTML5 APIs for webapp developers 16 Jun 10 4:40 PM HTML5 is all the rage with the cool kids, and although there's a lot of focus on the new language, there's plenty for web app developers with new JavaScript APIs both in the HTML5 spec and separated out as their own W3C specifications. This session will take you through demos and code and show off some of the outright crazy bleeding edge demos that are being produced today using the new JavaScript APIs. But it's not all pie in the sky - plenty is useful today, some even in Internet Explorer!Specifically we'll be looking at scripting the video media element, 2D canvas and some of the mashups we can achieve. How to take our web apps completely offline, going beyond the cookie and HTML5's answer to threading: web workers. iPod Video 320x240 (95.3 MB) MPEG-4 for QuickTime Medium 1280x480 (370.2 MB)
	Test-Driven JavaScript 16 Jun 10 4:40 PM Javascript becomes much more important to interactive website development then before (ok it has been for a while already) but the notion of testing that logic seems even further fetched then testing the code written in C#, Java. And this is something that is wrong as well. How do you test drive your javascript development, what do you need to think about to make it testable? How can you deal with timers, async calls and the dom. Demonstrate all these things including how easy it is to make your own fakes for testing. Demonstrate the refactoring and changing behaviour becomes so much easier.And not to forget that the design of the code is much better as well. Basically that you gain all the benefits that TDD gives you in other languages also when doing TDD for javascript development.Building a feature without ever loading up a web-page to physically look at it and when you finally do it does exactly what you intended it to do, that is magic :-) iPod Video 320x240 (123.8 MB) MPEG-4 for QuickTime Medium 1280x480 (326.5 MB)
	Windows Azure AppFabric 16 Jun 10 4:40 PM As one of the key platform providers for enterprise solutions today, Microsoft realizes that there are very many assets in corporate datacenters that are not easily moved to the cloud. A lot of data is subject to government or corporate regulation about data protection that does not allow for the data to be hosted off-site and over the past decade, companies have made enormous investments in streamlining and integrating their applications in ways that make it not particularly attractive to break out parts of that integration chain and move them off into the cloud as insular solutions. The Windows Azure AppFabric??s Service Bus and Access Control services which Clemens will introduce in this session are about bridging these gaps and to provide application-to-application connectivity and access control federation across network and trust scopes. iPod Video 320x240 (120.7 MB) MPEG-4 for QuickTime Medium 1280x480 (379.1 MB)
	The Parallel Task Library in .NET 4.0 16 Jun 10 5:b40PM Introduced with .Net 4.0, the Parallel Task Library gives a new approach to task-parallel programming. In this session we dive into the details of the library, looking at the various ways that it can be utilised. We will cover a number of areas, including:? Data Parallelism, using Parallel.For and Parallel.ForEach? Task Parallelism, using Parallel.Invoke and the Task class? Exception Handling? Cancellation? Asynchronous continuation patterns? PLinq The session is aimed at the intermediate developer - a good understanding of basic threading principles is a requirement. iPod Video 320x240 (153.5 MB) MPEG-4 for QuickTime Medium 1280x480 (651.2 MB)
	The Whole Team Approach to Testing 16 Jun 10 5:40 PM Many test teams find themselves ??squeezed to the end??, with code delivered too late to complete all the testing before the release deadline. They can??t get traction on critical activities such as test automation, and find themselves falling further and further behind. The software development organization is weighed down by increasing technical debt. Customers aren??t getting the software they wanted. Serious bugs get out to production, slowing the team down more as fixing one bug might cause two more. It can seem impossible to break out of this downward spiral.One way to turn this trend around is to get the whole team involved in building quality into the application, and solving testing problems together. In this session, Lisa Crispin will explain how to make quality a team responsibility, and testing a team??s problem to solve. She??ll explain how the ??whole team?? approach, leveraging multiple skill sets and planning in time for testing activities, leads to more testable code, better testing solutions. Participants will leave with some practical ideas to try right away. iPod Video 320x240 (101.6 MB) MPEG-4 for QuickTime Medium 1280x480 (422.1 MB)
	Real-World Design with the Visual Studio 2010 Modelling Tools 16 Jun 10 3:21 PM Visual Studio 2010 introduces new Layer, Class, Activity, Use Case, Sequence, and Component diagrams. This session provides an overview of each of these diagrams and demonstrates practical examples of when they are useful, and when they are not! You will see how VS 2010 allows you to reverse-engineer your existing .NET code and generate sequence diagrams that graphically depict the object interaction in your applications. You??ll also get a tour of the new Architecture Explorer, and learn how you can best fit these design tools into your software development processes - including agile software processes. iPod Video 320x240 (103.9 MB) MPEG-4 for QuickTime Medium 1280x480 (299.5 MB)
	Building a Real-World, E-Commerce, Data-Driven Web Site 16 Jun 10 3:20 PM In this session, I'll take you on a tour of what it took to go from an empty space in my ISPs web farm and turn it into a functional ecommerce web site. We'll include a discussion of how the domain was attached, how the site was built in ASP.NET, where the graphics and layout came from, how the products and site settings were managed in SQL Server, how the site was published, how shipping, taxes and handling are calculated, how money is collected and how the site is maintained. If you've ever wanted to see what it takes to start from scratch and build a real-world ecommerce web site, this is the place for you. iPod Video 320x240 (103.7 MB) MPEG-4 for QuickTime Medium 1280x480 (325.9 MB)
	Distributed Computing 2.0 16 Jun 10 4:19 PM iPod Video 320x240 (164.5 MB) MPEG-4 for QuickTime Medium 1280x480 (864.3 MB)
	Windows Azure Platform Compute & Storage 16 Jun 10 3:20 PM At the heart of Windows Azure are its compute and management capabilities, which are foundational not only for ISV and enterprise solutions, but also for the Windows Azure platform components themselves. In this session Clemens will introduce Windows Azure??s notion of service and configuration models, the deployment and upgrade mechanisms, and introduce the diagnostics and management capabilities. You will furthermore learn about the various storage capabilities including the relational SQL Azure database service. Clemens will also show how Windows Azure??s different roles provide an architectural guidance framework for building scalable apps. iPod Video 320x240 (147.7 MB) MPEG-4 for QuickTime Medium 1280x480 (40.5 MB) MPEG-4 for QuickTime Medium 1280x480 (690.6 MB)
	Noda time: An Alternative Date & Time Framework 16 Jun 10 3:20 PM The date and time API within the .NET framework has certainly improved over time, but it's still not as rich as it might be. Noda Time is an open source project porting the popular "Joda Time" framework from Java to .NET, and improving it along the way. I'll explain why DateTime and DateTimeOffset aren't always enough, the main concepts in Noda Time, and some lessons we've learned about .NET, porting in general, and running an open source project. iPod Video 320x240 (140 MB) MPEG-4 for QuickTime Medium 1280x480 (611.2 MB)
	Does Self-Organization Actually Work & Are Agile Teams Actually Motivated By It? 16 Jun 10 4:20 PM Self-organising teams are a key component of all of the agile methodologies, but do teams and organisations know what they are actually letting themselves in for when signing up for things like Scrum? In my experience the definition of "self-organisation" is widely different from organisation to organisation, team to team and even individual to individual within a team. This leads to fear, sub-optimisation and in a lot of cases subversion of the principle such that teams are being directed to work in sprints or iterations. In this session, Geoff will share his experiences of self-organisation, the common characteristics that are required for self-organisation to work and how commonly these characteristics are found in organisations that say that are "doing agile". iPod Video 320x240 (103.2 MB) MPEG-4 for QuickTime Medium 1280x480 (439.4 MB)
	Mono - A Great Platform for .NET in the Cloud 16 Jun 10 2:00 PM ASP.NET WebForms and MVC apps run out-of-the-box on Mono on a variety of platforms. With so many options for hosting Linux servers on services such as EC2 and Linode, Mono has become an attractive platform for cloud deployment. This presentation will walk through several approaches to developing, debugging, and deploying .NET applications to the cloud with Mono. iPod Video 320x240 (92.9 MB) MPEG-4 for QuickTime Medium 1280x480 (294.8 MB)
	I Can't Hear You - There's an ORM In My Ear: Effective Use of NoSQL In an ASP.NET MVC Web Application 16 Jun 10 2:00 PM The NoSQL movement is gaining momentum (to many people's annoyance) and gaining many fans. For developers who haven't used a NoSQL solution (Object Database, Document Database, etc) it's a bit awkward to conceive of how you might do common tasks - like querying or generating application reports. In this talk Rob Conery shows how you can build an effective data access strategy using both NoSQL and traditional Relational Databases, focusing on using each system for its strengths rather than compensating for its weaknesses. iPod Video 320x240 (364.2 MB) MPEG-4 for QuickTime Medium 320x240 (230.8 MB)
	Lean Quality Assurance 16 Jun 10 3:00 PM Quality Assurance (QA) in software worldwide has in fact degenerated into testing alone. Software?IT management has ignorantly allowed this to happen.Of course many parts of the industry have been well-aware of more cost-effective ways of delivering required quality in practice, but this has in fact been largely ignored; while granting very large resources to testing alone.It is time for a wakeup call!This manifesto is here to tell the industry that;testing alone is 10x more costly than doing Real QA. testing alone is not good enough, this can and need not go on. We know how to do real QA much much better than testing alone, using smarter upstream engineering practices, based on design, prevention and upstream inspections. iPod Video 320x240 (145 MB) MPEG-4 for QuickTime Medium 1280x480 (399.2 MB) MPEG-4 for QuickTime Medium 1280x480 (689.7 MB)
	Design, Don't Decorate 16 Jun 10 3:00 PM Putting the advanced capabilities of WPF and Silverlight to full use requires collaboration, experimentation, and iterative prototyping. In this session, you??ll see all five sequential prototypes for the acclaimed StaffLynx application (as seen on .NET Rocks TV), and discuss practices that worked and didn't work in real-world advanced UI development. We'll also discuss the role of visual and interactive designers in creating new era user interfaces, give some tips on how to think about using WPF and Silverlight capabilities to make interfaces feel natural and less stressful to users, and cover the most valuable lessons learned from a real-world project using advanced, next generation user interface technology. iPod Video 320x240 (109.3 MB) MPEG-4 for QuickTime Medium 1280x480 (457.9 MB)
	Inside modern JavaScript 16 Jun 10 2:00 PM JavaScript is a dynamic, functional, ubiquitous language that has many hidden secrets. In this session we will take a deep look at the core JavaScript features that many contemporary libraries leverage, including constructor functions, prototypical inheritance, closures, hash parameters, method chaining, and more. Having a solid grasp of these features will not only help you write more maintainable JavaScript code, but also allow you to take greater advantage of today??s JavaScript libraries. iPod Video 320x240 (94.6 MB) MPEG-4 for QuickTime Medium 1280x480 (390.6 MB)
	CHESS - Finding & Reproducing Heisenbugs in Concurrent Programs 16 Jun 10 2:55 PM CHESS is a tool from Microsoft Research that aims to find and reproduce hard to locate concurrency bugs. It does so by repeatedly running tests, systematically enumerating how the various threads are interleaved on each run. When (if) errors occur, CHESS can also then re--?]run the specific interleaving that resulted in the error, massively simplifying the debugging effort. iPod Video 320x240 (155.2 MB) MPEG-4 for QuickTime Medium 1280x480 (663.1 MB)
	Windows Azure Overview 16 Jun 10 1:54 PM HASH(0x1060cd48) iPod Video 320x240 (149.6 MB) MPEG-4 for QuickTime Medium 1280x480 (709.7 MB)
	What has Mono done for .NET developers Lately? 16 Jun 10 12:40 PM Mono is an open-source, cross-platform implementation of the .NET framework based on the ECMA standards for C# and the Common Language Infrastructure. With Mono, users can run .NET applications written and compiled in Visual Studio on Windows, Linux, and Mac OS X. This session will provide an introduction to cross-platform development and deployment with Mono. Participants will see how they can leverage their existing skills and tools to write .NET applications that will run on multiple platforms and architectures with Mono. The presentation will also include a discussion of cross-platform considerations for leveraging Mono, and demonstrate how to use MoMA, the Mono Migration Analyzer, to determine how ready anapplication is for cross-platform deployment. Additional demonstrations will examine how best to leverage Visual Studio to develop and deploy to Linux and OS X, and take a peek at the current state of Moonlight 3 and 4. iPod Video 320x240 (78.5 MB) MPEG-4 for QuickTime Medium 1280x480 (245.7 MB)
	Patterns for Parallel Programming 16 Jun 10 1:40 PM Every five to ten years the world of computer programming is facing now a new paradigm shift, like GUI, object orientation, or generics. Right now we are facing a new paradigm shift, the multi-core one. Successful research in this area has been done for the past 30 years, but we are still not using the results efficiently. A pattern is a working solution to a recurring problem, and parallel?multi-core programming has its own problems which led to a set of patterns. Come and see in this session about which patterns exists in the area of parallel?multi-core programming and how they can be used with Visual Studio 2010. iPod Video 320x240 (176.3 MB) MPEG-4 for QuickTime Medium 1280x480 (936.6 MB)
	Programming with GUTs on 16 Jun 10 1:38 PM iPod Video 320x240 (112.4 MB) MPEG-4 for QuickTime Medium 1280x480 (483 MB)
	CouchDB for .NET Developers 16 Jun 10 1:37 PM RDBMS has been the standard for many years, when it has come to data storage. However, recently there has been an increase in document databases. In this talk we are going to cover the basics of CouchDB and how to consume this kind of database from .NET applications. iPod Video 320x240 (132.8 MB) MPEG-4 for QuickTime Medium 1280x480 (684.6 MB)
	How to Get the Best ROI From a Scrum Team as a Product Owner 16 Jun 10 12:37 PM The Product Owner is probably the role that has received the least attention and help of all the three Scrum roles but it is paramount to an organisation's success with Scrum. While most projects benefit immediately from switching or adopting Scrum, to get the best out of the project a Product Owner really needs to understand both the team and the Scrum framework. In this tutorial Geoff will share his views and experiences of working with Scrum teams to provide you with a number of tips to improve your ROI. iPod Video 320x240 (205.3 MB) MPEG-4 for QuickTime Medium 1280x480 (516.8 MB)
	.NET Design Patterns for Agile Software Processes 16 Jun 10 12:40 PM In the world of agile programming techniques, one of your best tools is design patterns. This session provides practical examples and implementation of design patterns in .NET. Familiarizing yourself with patterns such as Model-View-Controller, Observer, Abstract and Concrete Factories, and concepts such as programming to an interface rather than an implementation will help you build applications quickly that can easily adapt to your customer??s changing needs. iPod Video 320x240 (131 MB) MPEG-4 for QuickTime Medium 1280x480 (578 MB)
	C# Puzzlers 16 Jun 10 12:32 PM iPod Video 320x240 (105.8 MB) MPEG-4 for QuickTime Medium 1280x480 (505.3 MB)
	Architecture of the Client Tier for WPF & Silverlight 16 Jun 10 10:40 AM Stateful client-based technologies for user interfaces, such as WPF and Silverlight, require more sophisticated design and architecture for the client tier than typical web applications. This session discusses the construction of a client-based navigation shell that replaces server-based navigation for a cleaner, more responsive user experience in multi-page applications. Implementation of capabilities such as data validation, temporary caching of unsaved data to allow for network downtime, and graceful shutdown will all be discussed. The session features a working model that attendees can use as a starting point for their own projects. iPod Video 320x240 (118.4 MB) MPEG-4 for QuickTime Medium 1280x480 (340.6 MB)
	Individuals & Interaction Over Processes and Tools 16 Jun 10 10:40 AM Although it is a simple value, the idea that individuals and interactions are more significant than processes and tools is overlooked perhaps more often than it is valued. Of course, processes and tools make a difference -- sometimes a very big difference -- but what determines whether a process or tool is effective is related to the individuals and interactions. To best achieve agility you need to start with the current context and understand how people actually behave in response to their environment, their beliefs and one another. What actually motivates and demotivates people, developers in particular? What actually makes their work easier or harder? Does making "business value" the centrepiece of what they do actually motivate the people who ultimately produce such business value? Or is it more about the individuals and interactions? iPod Video 320x240 (119.2 MB) MPEG-4 for QuickTime Medium 1280x480 (385.3 MB)
	Reactive Extensions (Rx) 16 Jun 10 10:37 AM iPod Video 320x240 (123.3 MB) MPEG-4 for QuickTime Medium 1280x480 (534.9 MB)
	Practical IronRuby 16 Jun 10 9:21 AM Ruby has been a home for some great innovative frameworks like Ruby on Rails, Cucumber and Rake. IronRuby version 1.0 will soon be released, unleashing the power of Ruby to the .NET world. In this session you will get familiar with the Ruby language and its amazing ecosystem and you will learn to take advantage of it in your everyday development tasks. Come and see how this great new addition to the .NET family makes your development process faster, clearer and happier! iPod Video 320x240 (90.8 MB) MPEG-4 for QuickTime Medium 1280x480 (308.2 MB)
	Strategies Against Architecture 16 Jun 10 9:18 AM Good architecture requires good vision and good people, but there are times when actions and decisions taken with the best of intent begin to work against an architecture. Instead of helping a system achieve a long life, speculation about reuse, flexibility and generality can bring a system to an early grave, weighing the codebase down with accidental complexity that invites workarounds and, ultimately, a new ad hoc architectural style. Documentation intended to be helpful becomes shelfware, ignored equally by its authors and its prospective readership. Dysfunctional memes in code and tests go unchecked because the detail of code is not considered a part of the architecture. Instead of stability and responsiveness, an architecture achieves stasis and loses reflex.This session looks at the reality of how development process and practices interact with the grander vision of architecture, the pitfalls of "architect as cop" and how to employ speculation and uncertainty to a system's advantage. iPod Video 320x240 (113.6 MB) MPEG-4 for QuickTime Medium 1280x480 (36 MB) MPEG-4 for QuickTime Medium 1280x480 (376.8 MB)
	A Style of Programming 16 Jun 10 9:17 AM This talk describes a set of coding principles that constitutes a style of programming that focuses on ease of coding, ease of changing the code, and ease of testing the code. The presentation aims at helping programmers understand how the principles relate to actual code. Every principle is made concrete through examples. This style of programming is influenced by leading object oriented and agile developers, and it is perfect for applying on object oriented languages such as C#. iPod Video 320x240 (154.5 MB) MPEG-4 for QuickTime Medium 1280x480 (753.5 MB)
	Multicore - The Future of Computing 16 Jun 10 10:16 AM Since hitting both the memory and power wall about 3-5 years ago, all cpu vendors have been forced to turn from making the fastest possible single-thread cpu to instead putting several (sometimes simpler) cores on a single chip.Reducing the clock frequency by 50% can reduce power usage by 80%, so actual throughput per watt can improve a lot, as long as the code can be parallelized.Existing GPUs from Nvidia and AMD, Cell processors as used in the PS3 and Intel's announced Larrabee architecture can all supply an order of magnitude more fp processing power per watt than what is currently available from normal cpus. iPod Video 320x240 (116.6 MB) MPEG-4 for QuickTime Medium 1280x480 (571.8 MB)
	Seven Key Factors for Agile Testing Success 16 Jun 10 10:13 AM Agile development approaches present unique challenges for testers and test teams. Working in short iterations, often with limited written requirements, agile development teams can leave traditional testers behind. Common testing-related activities such as user acceptance testing, testing inter-product relationships, and installation testing need different approaches to fit into agile projects. Lisa Crispin explains seven key factors for testing success within agile projects that you can also apply to more traditional methodologies. Using a whole team approach and adopting an agile testing mindset are among the important components of a successful agile testing strategy. Learn how to overcome cultural and organizational obstacles and barriers to success in areas such as test automation. Discover the seven critical factors that provide a foundation for building your team's focus on quality and that deliver maximum value to your business. iPod Video 320x240 (126 MB) MPEG-4 for QuickTime Medium 1280x480 (661.3 MB)

盛大创新院赞助首届.NET技术交流会 - 演讲录像及下载

jeffz@live.com (老赵) — Thu, 24 Jun 2010 06:40:51 GMT

经过几天的努力，终于将盛大创新院赞助的首届.NET技术交流会的演讲录像制作完成了。本来在现在的高清视频以外，我还想像Channel 9一样提供一些低码率的格式下载，但多次尝试都以失败告终，各中滋味难以言喻。因此目前只能给大家提供mov格式的高清视频下载，对于Windows下各类强大的播放器都不成问题。您也可以在线观看这些视频，不过上传至优酷后，发现除了清晰度较低外，甚至还有音画不同步的问题。我正在联系酷六网，会尽快用上质量更好的视频。

F#语言对异步程序设计的支持

讲师：赵劼，盛大创新院，研究员

简介：如今的Web应用、 Silverlight以及各种分布式系统让异步解决方案有了更进一步的需求。F#是微软.NET平台上的函数式编程语言，并添加了不少让并行及异步编程变得有趣且轻松的特性。本次演讲将讨论F#的核心概念，并探讨F#中的不可变性、函数式设计、异步工作流、代理等特性是如何应对真实应用中的异步挑战的。

高清视频下载（mov格式，1280 * 720，495M）

Rails: Better Framework, Better Life

讲师：吕国宁，Intridea.com，高级工程师

简介：RoR是Ruby on Rails的缩写，是一个用于编写Web应用的框架。它基于Ruby语言，给开发人员提供了强大便利的框架支持。Ruby有很多优点，但是一直以来其流行范围仅局限于日本。2004年，当Rails框架横空出世，让人们认识到了一个更符合实际需要并且高效的web框架，在其出现不久就受到了业内的广泛关注。吕国宁将结合自己三年的Rails开发经验，给大家介绍一些Rails的优点，背后的设计文化，以及Rails的前景发展等内容。

高清视频下载（mov格式，1280 * 720，432M）

大众点评网的技术变迁之路

讲师：王宏，大众点评网，架构师

简介：大众点评网从2003年创建以来，已经经历了7个年头，在技术方面从最初构建时期的简单的、低成本的方案，到发展阶段不断“痛苦”的转型演变，到目前比较复杂的技术架构，大众点评网的技术团队一直在关注业界新技术，力求提高可用性、降低成本、优化用户体验，并针对“点评”这一第三方参与的特点，摸索出一些特有的解决方案，借此机会希望能够分享给大家。

高清视频下载（mov格式，1280 * 720，486M）

Q & A

按照计划，原本还会有一场关于C#的演讲，但该场的讲师由于突然有急事只得作罢。于是我在最后增加了“演讲嘉宾问答”的环节，您可以在酷六网上进行在线观看。

第1段：

第2段：

盛大创新院赞助首届.NET技术交流会 - 各场演讲幻灯片

jeffz@live.com (老赵) — Sat, 19 Jun 2010 15:48:23 GMT

今天是近期最热的一天，气温高达35度，异常闷热，但是依然有160多位朋友冒着酷暑参加了盛大创新院赞助的首届.NET技术交流会，这让我感到很欣慰，因此这里首先要感谢大家的支持。我刚才浏览了一下三场演讲的桌面录像，可谓异常完美，现在只等酷六网的摄影师的讲师录像到手，便可以合成为最终的演讲视频了，希望能够尽快展示给大家。不过现在，大家可以在第一时间浏览本次活动新鲜出炉的幻灯片。

F#语言对异步程序设计的支持

讲师：赵劼，盛大创新院，研究员

F#语言对异步程序设计的支持

View more presentations from jeffz.

Rails: Better Framework, Better Life

讲师：吕国宁，Intridea.com，高级工程师

Better Framework Better Life

View more presentations from jeffz.

大众点评网的技术变迁之路

讲师：王宏，大众点评网，架构师

大众点评网的技术变迁之路

View more presentations from jeffz.

盛大创新院赞助首届.NET技术交流会即将召开

jeffz@live.com (老赵) — Thu, 17 Jun 2010 03:45:06 GMT

由盛大创新院赞助的首届.NET技术大会将于6月19号下午1点召开，本次交流会请到了四位讲师，议题覆盖了F#、C#、Rails及架构等多个方面。我已经看过了各场演讲的幻灯片草稿，也很期待各位讲师在正式演讲中的表现。

本次大会中，我们还获得了人民邮电出版社图灵教育赠送的20册图书，将会作为奖品赠送给在交流会中表现积极的听众。

此外，我们还请到了酷六网的专业摄影师对演讲过程进行全程拍摄，并配合各位讲师自身的屏幕录像，将在后期合成为适合独立观看的演讲视频，让不能到场的朋友在线或是下载后观看。

使用OpenOffice.org将各类文档转为PDF

jeffz@live.com (老赵) — Thu, 27 May 2010 04:37:24 GMT

最近在项目中遇到一个需求，是要将各类文档转换为PDF。这应该是个很常见的工作，而且我也只需要支持MS Word，Excel，PowerPoint等常见的文档格式就行了。于是有朋友就建议了，可以使用MS Office转嘛。当然也可以使用其他方法，例如装一些PDF打印机，把文档打印成pdf文件。不过这些做法在“授权”方面似乎都有些问题。当然，我也找了一些商业解决方案（如Aspose）保底，咋看之下它的授权方式也并不算贵。不过现在看来，OpenOffice.org已经能够满足我的需求了。如果您有更好的做法也请告诉我。

OpenOffice.org是个开源的办公套件，提供了与MS Word，Excel，PowerPoint等对应的多个软件，在很多时候倒也足够使用。更重要的是，它支持包括MS Office 2007在内的多种格式，并且能够将其导出为PDF文件，再加上它的授权方式是LGPL，在生产环境里使用自然也不会有什么明显的限制了。此外，OOo本身也有相当多的开发文档，我对完成这个工作还是很有信心的——但我没想到的是，这过程还真不如想象中那么顺利。

编译通过也不容易

首先，我安装了OpenOffice.org主程序以及SDK。SDK随带一些示例代码，其中DocumentHandling部分正好包含一个我需要的DocumentConverter功能。于是我打开Eclipse，倒入这个文件，很显然会出现无数错误提示：还没有引入合适的类库嘛。那么我该引用哪些jar包呢？根据其他一些搜索到的零碎的资料提示，我该引入的是一些放在~\Basis\program\classes下的几个jar包，比如unoil.jar、juh.jar……等等，这个包在什么地方？事实上，我在这么目录下唯独只找到unoil.jar这个独苗。莫名之余，我一股脑的将目录中的30多个jar包全部引入，可是错误依旧。

我就蒙了，在搜索引擎里不断地用juh.jar相关的关键字进行查询，希望可以找到一些提示，一无所获。然后我动用了系统中的文件搜索，在~/Basis目录中查找*.jar，还是没有发现juh.jar的踪影。于是我很沮丧，怎么第一步也这么不顺利。直到大约过了一个小时后，我才无意间在~\URE\java目录下发现了那几个关键的jar包。引入后我长吁一口气：示例代码终于编译通过了。概括来说，如果需要让DocumentConverter.java编译通过，需要引入一下三个jar包：

~\URE\java\juh.jar
~\URE\java\jurt.jar
~\Basis\program\classes\unoil.jar

真是痛恨文档和实际现象不符的情况，消耗时间不说，心情也变糟糕了。

整理示例代码

不得不说，DocumentConverter.java真不能算是段优秀的示例代码。首先，它并没有很好地起到示范的作用。我理想中的示例代码应该能够清晰地说明工作的方式和步骤，而不会添加太多额外的内容。这段示例代码的效果是“转化指定目录中的所有文件”，还用到了递归。再加上它没有import任何类型，每个类型在使用时都拖着长长的“com.sun.star”，这让原本就十分冗余的Java代码变得更为难以理解。更别说注释与代码本身的冲突，还有多余的类型强制转换等问题。为此，我根据文档说明，重新改写了一下示例代码，将整个过程拆分为多个步骤。

首先，我们打开并连接一个OOo程序，这需要创建一个XComponentContext对象：

private static XComponentContext createContext() throws Exception {
    // get the remote office component context
    return Bootstrap.bootstrap();
}

然后创建一个XComponentLoader对象：

private static XComponentLoader createLoader(XComponentContext context) throws Exception {
    // get the remote office service manager
    XMultiComponentFactory mcf = context.getServiceManager();
    Object desktop = mcf.createInstanceWithContext("com.sun.star.frame.Desktop", context);
    return UnoRuntime.queryInterface(XComponentLoader.class, desktop);
}

从Loader对象可以加载一篇文档：

private static Object loadDocument(XComponentLoader loader, String inputFilePath) throws Exception {
    // Preparing properties for loading the document
    PropertyValue[] propertyValues = new PropertyValue[1];
    propertyValues[0] = new PropertyValue();
    propertyValues[0].Name = "Hidden";
    propertyValues[0].Value = new Boolean(true);
    
    // Composing the URL by replacing all backslashs
    File inputFile = new File(inputFilePath);
    String inputUrl = "file:///" + inputFile.getAbsolutePath().replace('\\', '/');

    return loader.loadComponentFromURL(inputUrl, "_blank", 0, propertyValues);
}

接着自然就是文档转换了：

private static void convertDocument(Object doc, String outputFilePath, String convertType) throws Exception {
    // Preparing properties for converting the document
    PropertyValue[] propertyValues = new PropertyValue[2];
    // Setting the flag for overwriting
    propertyValues[0] = new PropertyValue();
    propertyValues[0].Name = "Overwrite";
    propertyValues[0].Value = new Boolean(true);
    // Setting the filter name
    propertyValues[1] = new PropertyValue();
    propertyValues[1].Name = "FilterName";
    propertyValues[1].Value = convertType;
    
    // Composing the URL by replacing all backslashs
    File outputFile = new File(outputFilePath);
    String outputUrl = "file:///" + outputFile.getAbsolutePath().replace('\\', '/');
    
    // Getting an object that will offer a simple way to store
    // a document to a URL.
    XStorable storable = UnoRuntime.queryInterface(XStorable.class, doc);
    // Storing and converting the document
    storable.storeAsURL(outputUrl, propertyValues);
}

最后还要关闭文档：

private static void closeDocument(Object doc) throws Exception {
    // Closing the converted document. Use XCloseable.clsoe if the
    // interface is supported, otherwise use XComponent.dispose
    XCloseable closeable = UnoRuntime.queryInterface(XCloseable.class, doc);
    
    if (closeable != null) {
    	closeable.close(false);
    } else {
        XComponent component = UnoRuntime.queryInterface(XComponent.class, doc);
        component.dispose();
    }
}

最后便是将上面四个步骤串联起来：

public static void main(String args[]) {
    String inputFilePath = "D:\\convert\\input.txt";
    String outputFilePath = "D:\\convert\\output.doc";
    
    // the given type to convert to
    String convertType = "swriter: MS Word 97";
    
    try {
        XComponentContext context = createContext();
        System.out.println("connected to a running office ...");
        
        XComponentLoader compLoader = createLoader(context);
        System.out.println("loader created ...");
        
        Object doc = loadDocument(compLoader, inputFilePath);
        System.out.println("document loaded ...");
        
        convertDocument(doc, outputFilePath, convertType);
        System.out.println("document converted ...");
        
        closeDocument(doc);
        System.out.println("document closed ...");
        
        System.exit(0);
    } catch (Exception e) {
        e.printStackTrace(System.err);
        System.exit(1);            
    }
}

总体来说，虽然OOo并没有提供优雅的API，但是它的主要“套路”还是比较容易摸索出来的：加载文档，使用UnoRuntime.queryInterface方法获取各种操作接口，而各种参数都通过PropertyValue数组来提供。如果您像我一样感觉不爽，重新作一层简单的封装也是十分容易的。

运行中的问题

到目前为止，我们只是重新整理了示例代码，还没有开始运行。当第一次运行的时候便发现有异常抛出：

com.sun.star.comp.helper.BootstrapException: no office executable found!
	at com.sun.star.comp.helper.Bootstrap.bootstrap(Bootstrap.java:246)
	at jeffz.practices.AnyToDoc.createContext(AnyToDoc.java:19)
	at jeffz.practices.AnyToDoc.main(AnyToDoc.java:87)

不过有异常信息之后，查找解决方案一般也很容易（但就我个人经验来说，还是有很多朋友会问“抛出XX异常该怎么办”之类的问题）。经过搜索，发现遇到这个问题的人还不少，他们把juh.jar等文件复制到OOo安装目录外（这在生产环境中几乎是必然的）之后便会产生这个异常，但如果直接引用OOo安装目录内的jar便不会有问题了——但是我目前是直接引用OOo安装目录的jar包，不是吗？但我转念一想，我当时为编译通过而挣扎的原因，不就是“juh.jar”等文件不在它本该在的位置吗？既然这个问题和jar包与OOo程序的相对路径有关，那么如果我把jar包放回“原来”的位置，这个问题可能就不存在了。

不过这些只是推测，我没有去进行尝试。因为既然在生产环境中还是会破坏路径问题，那我还是找一下这个问题的解决方案吧。最终在OOo的论坛上找到了答案：有人提供了一个补充包bootstrapconnector.jar，其中提供了一个方法可以让我们指定OOo的程序目录。也就是说，我们需要把之前的createContext改写成：

private static XComponentContext createContext() throws Exception {
    // get the remote office component context
    // return Bootstrap.bootstrap();
    String oooExeFolder = "C:/Program Files/OpenOffice.org 3/program/";
    return BootstrapSocketConnector.bootstrap(oooExeFolder);
}

当然，生产环境中您一般不会使用硬编码的方式制定路径，您可以把它放在配置文件或是系统变量里。再次运行即告成功。这段代码会将一个txt文件转化成旧有的Word格式，事实上您可以将txt替换成OOo所支持的任何一种格式，比如rtf，docs，odt等等。

那么接下来的问题便是，如何将目标格式改为PDF文件？很显然，目标格式是Word文件，是因为我们将类型字符串指定为“swriter: MS Word 97”，那么PDF格式是多少？这靠猜测是没法得出结果的，最后还是从一篇文档中得到了答案：writer_pdf_Export。事实上，这么做还是不够，代码还是会在storeAsURL方法中抛出异常，而且这是一个泛泛的ErrorCodeIOException，没有具体信息（message为空）。又一阵好找，才发现storeAsURL对应着OOo的“Save as”功能，而如果是“Export”功能，则应该调用storeToURL方法。

最后，我们终于成功地将其他格式转化为PDF文件了。

完整代码

在这里贴出“txt转pdf”完整的可运行的示例代码：

import java.lang._;
import java.io.File;
import ooo.connector.BootstrapSocketConnector;
import com.sun.star.lang.XComponent;
import com.sun.star.uno.XComponentContext;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.beans.PropertyValue;
import com.sun.star.frame.XComponentLoader;
import com.sun.star.frame.XStorable;
import com.sun.star.util.XCloseable;

object AnyToPdf extends Application {
  
  // get the remote office component context
  def createContext() : XComponentContext = {
    val oooExeFolder = "C:/Program Files/OpenOffice.org 3/program/"
    BootstrapSocketConnector.bootstrap(oooExeFolder)
  }
  
  def createComponentLoader(context: XComponentContext) : XComponentLoader = {
    // get the remote office service manager
    val mcf = context.getServiceManager()
    val desktop = mcf.createInstanceWithContext("com.sun.star.frame.Desktop", context)
    UnoRuntime.queryInterface(classOf[XComponentLoader], desktop)
  }
  
  def loadDocument(loader: XComponentLoader, inputFilePath: String) : Object = {
    // Preparing properties for loading the document
    val propertyValue = new PropertyValue()
    propertyValue.Name = "Hidden"
    propertyValue.Value = new Boolean(true)
    
    // Composing the URL by replacing all backslashs
    val inputFile = new File(inputFilePath)
    val inputUrl = "file:///" + inputFile.getAbsolutePath().replace('\\', '/')
    loader.loadComponentFromURL(inputUrl, "_blank", 0, Array(propertyValue))
  }
  
  def convertDocument(doc: Object, outputFilePath: String, convertType: String) {
    // Preparing properties for converting the document
    // Setting the flag for overwriting
    val overwriteValue = new PropertyValue()
    overwriteValue.Name = "Overwrite"
    overwriteValue.Value = new Boolean(true)
    // Setting the filter name
    val filterValue = new PropertyValue()
    filterValue.Name = "FilterName"
    filterValue.Value = convertType
    
    // Composing the URL by replacing all backslashs
    val outputFile = new File(outputFilePath)
    val outputUrl = "file:///" + outputFile.getAbsolutePath().replace('\\', '/')
    
    // Getting an object that will offer a simple way to store
    // a document to a URL.
    val storable = UnoRuntime.queryInterface(classOf[XStorable], doc)
    // Storing and converting the document
    storable.storeToURL(outputUrl, Array(overwriteValue, filterValue))
  }
  
  def closeDocument(doc: Object) {
    // Closing the converted document. Use XCloseable.clsoe if the
    // interface is supported, otherwise use XComponent.dispose
    val closeable = UnoRuntime.queryInterface(classOf[XCloseable], doc)
    if (closeable != null) {
      closeable.close(false)
    } else {
      val component = UnoRuntime.queryInterface(classOf[XComponent], doc)
      component.dispose()
    }
  }
  
  val inputFilePath = "D:\\convert\\input.txt"
  val outputFilePath = "D:\\convert\\output.pdf"
		
  // Getting the given type to convert to
  val convertType = "writer_pdf_Export"
  
  val context = createContext()
  println("connected to a running office ...")
  
  val loader = createComponentLoader(context)
  println("loader created ...")
  
  val doc = loadDocument(loader, inputFilePath)
  println("document loaded ...")
  
  convertDocument(doc, outputFilePath, convertType)
  println("document converted ...")
  
  closeDocument(doc)
  println("document closed ...")
}

很显然，这里不是我所厌恶的Java语言。这是一段Scala代码，就从最基本的代码使用上看，Scala也已经比Java代码要节省许多了。

总结

其实解决这个问题还是走了不少弯路的，究其原因可能是从示例代码出发去寻找解决方案，而并没有去系统地阅读各种资料。在这个过程中，我找到了一些比较重要的文档：

API/Tutorials/PDF export：对于PDF导出功能各种参数的详细解释。
Text Documents：关于文本文档相关操作的详细说明。
DocumentHanding：“文档操作”示例代码的解释，包括文档打印等等。

当然，最详细文档莫过于完整的开发人员指南了，如果您想要详细了解这方面的内容，这应该也属于必读内容之一。

有了OpenOffice.org，就相当于我们拥有了一套完整的文档操作类库，可以用来实现各种功能。除了转PDF以外，例如我们还可以将一篇数百万字的小说加载为文档，再每十页导出一份图片，方便用户在线预览顺便防点拷贝。此外，虽然我是在Windows下操作OOo，但是OOo和Java本身都是跨平台的，因此同样的代码也可以运行在Linux平台上。我目前正在尝试在Ubuntu Server上部署一份OOo和代码，如果有什么特别的情况，我也会另行记录。

事实上有一点我之前一直没有提到：如果您使用Windows及.NET进行开发，OOo也提供了C++/CLI接口，可以使用C#、F#进行编程，且代码与本文描述的几乎如出一辙（只要把queryInterface方法调用改成直接转换），在.NET 4.0中也可正常使用。

如果您有其他解决方案，也请一起交流一下。

盛大创新院赞助首届.NET技术交流会开始报名了！

jeffz@live.com (老赵) — Thu, 13 May 2010 06:30:10 GMT

自从上次在博客中提到盛大创新院将会赞助.NET技术会议已经过去了一个半月，如今这件事情终于落实了。我为此准备了数千字的申请书，但老大看也不看便表示支持。他的说法是，只要办得热烈，有影响力，那么这样的活动绝对支持。为此，各场次演讲内容及会场等诸多事宜之后，现在“首届.NET技术交流会”正式进入报名阶段了。~~人数不设上限，多多益善，怕只怕会场会显得空旷~~，目前报名人数已达200人，请抓紧时间报名。除了.NET社区的群众以外，也欢迎其他技术社区的朋友前来参与交流。事实上，我组织技术交流会的目的之一便是希望能够促进.NET社区与其他技术社区的交流及相互学习。

时间及议程安排

本次交流会定于2010年6月19日（周六）举行，具体时间如下。会议目前安排了四场演讲，除了与.NET技术直接相关的F#及C#话题以外，我们还邀请了大众点评网的核心架构师来分享他们在多年发展过程中的技术变迁过程。此外，我也联系了即将举办的Rails大会的主办方，邀请他们来分享关于Rails框架的内容。正如我之前说的那样，在以后每次技术会议上，我都会邀请其他社区的高手来讲解相关技术。

时间	议程
12:30 ~ 13:00	签到
13:00 ~ 14:00	F#语言对异步程序设计的支持
14:00 ~ 14:10	短休
14:10 ~ 15:10	Rails: Better Framework, Better Life
15:10 ~ 15:40	茶歇
15:40 ~ 16:40	C#语言开发模式及实用建议
16:40 ~ 16:50	短休
16:50 ~ 17: 50	大众点评网的技术变迁过程

演讲内容

以下是关于四场演讲的详细描述。

F#语言对异步程序设计的支持

Rails: Better Framework, Better Life

讲师：吕国宁，Intridea.com，高级工程师。超过三年的Ruby on Rails程序开发经验，先后供职于Red.com, ELCTech.com, 目前在Intridea从事ROR的咨询服务以及为客户提供解决方案。在工作之余热心国内ROR社区建设，长期致力于推动ROR社区在中国的发展，从2007年开始，作为组织者之一，在上海成立了Shanghaionrails组织，并筹办了国内第一，第二届RubyConfChina大会以及首届RailsConference。

简介：RoR是Ruby on Rails的缩写，是一个用于编写Web应用的框架。他基于Ruby语言，给开发人员提供了强大便利的框架支持。Ruby有很多优点，但是一直以来其流行范围仅局限于日本。2004年，当Rails框架横空出世，让人们认识到了一个更符合实际需要并且高效的web框架，在其出现不久就受到了业内的广泛关注。吕国宁将结合自己三年的Rails开发经验，给大家介绍一些Rails的优点，背后的设计文化，以及Rails的前景发展等内容。

C#语言开发模式及实用建议

讲师：陈黎夫，盛大创新院，研究员

简介：C#语言是微软.NET平台上的核心开发语言，从1.0到4.0的版本推进极其迅速，版本更替也带来了大量改进。在快速的发展过程中，C#的表达能力被一再强化，其功能愈发强大，语言本身也日趋复杂，这往往会让一些开发者在使用中产生迷茫，无法做到最优。希望能借此机会分享一下最新版本C#语言的开发模式以及实用建议。

大众点评网的技术变迁之路

讲师：王宏，大众点评网，架构师

地点

本次交流会举办地为上海市浦东新区碧波路888号畅星大厦（地铁二号线张江高科站下，步行10分钟可达）3楼会议厅举行，地图如下：

鸟瞰图：

畅星大厦外观：

会场实景照片：

会场容量可以容纳超过200人，希望到时候不会显得太过空旷。:)

报名信息

本次交流会~~现已开始报名，请填写报名表，报名截止日期为2010年6月13日~~已经截止，请等待后续消息。感谢大家支持！

MongoDB与Tokyo Tyrant性能比较（2）：并发写入操作

jeffz@live.com (老赵) — Fri, 26 Feb 2010 11:38:00 GMT

在上一次的测试中我们比较了MongoDB与Tokyo Tyrant的Table Database两种存储方式的性能。不过由于条件限制，我只能在自己的MBP上测试，而这至少会带来两个问题。首先，真实环境下客户端和服务器是通过内网连接的，它的性能比本地回环要慢不少，一些和网络传输性能有关的问题可能会体现不出。其次，由于无法进行并发测试（并发测试的客户端资源占用较高，放在同一台机器上准确性较差），这又和生产环境有很大区别了。因此，我前两天向同事借了台性能测试用的机器，希望可以得到更可靠的结果。

测试环境与数据

这次我使用了新的环境进行性能测试：

OS：CentOS release 5.3 (Final)
RAM：4GB
CPU：Intel(R) Xeon(R) CPU E5405 @ 2.00GHz (64 bit, 4 cores * 2)
其他：SCSI硬盘，ext3文件系统

客户端与服务器端配置相同，两台机器使用百兆网相连，测试时服务器保持空闲。

测试数据的结构与之前相同（包括索引），数据分布同样保持一致，每个线程插入的数量较少，但每次测试的总数均不低于上次（110万条）。

为了测试并发插入的性能，我稍微改写了测试脚本。首先，我为它增加init参数，它的作用是初始化存储结构（清除数据，建立索引），拿MongoDB的测试脚本为例：

# ruby mdb-insert.rb init
index for CreateTime created.
index for CategoryID created.
index for UserID created.
index for Tags created.
initialize completed.

此外，脚本还支持“分类范围”的指定，例如：

# ruby mdb-insert.rb 101 200

这表示我们将插入CategoryID为101至200的新闻，由于每个分类中均匀分布10至100条记录，因此只要范围的上下限保持10的倍数，这样平均每个分类有55条新闻，于是新闻ID也可以此计算出来。例如分类101至200的新闻，其ID便为5501至11000。您可以通过阅读代码了解这些细节。

为了并行测试，每次我就将同时执行多个脚本进行插入，每个脚本提供不同的参数。我使用类似这样的shell脚本来启动并行任务：

#!/bin/bash

# mdb-insert.sh

echo "=== initialize ==="
ruby mdb-insert.rb init

for((i=1;i<=5;i++))
    do

    let begin=$((4000 * ($i - 1) + 1))
    let end=$((4000 * $i))

    echo === start task $i ===
    ruby mdb-insert.rb $begin $end > logs/mdb-insert-$begin-$end.log &
done

这段脚本将启动5个任务，每个任务将插入4000个分类，即22万条记录。5个任务总共插入110万条记录，与前次持平。接下来的测试中，我在增加任务数量的同时也会适当降低每个任务插入的记录数目。最多我将启用100个任务，每个任务插入1000个分类，即所有任务共计插入550万条记录，是之前的5倍。

在所有的测试中，无论多少个任务都是同时启动，且几乎同时结束（与总耗时相比很小）。因此，在接下来的数据中我不会列出每个任务的开始及结束时间，如果您关心这部分数据，可以在文章结尾处可以获得本次测试生成的所有记录文件。

Tokyo Tyrant性能测试

第1次测试启动5个任务，每个任务4000个分类，共计插入110万条记录。结果如下（第1行粗体表示“万条记录”，每个数字的单位为“秒”，下同）：

与之前的现象类似，当数据库中的数据越多时，插入速度也会随之减慢：在每个任务插入前1万条记录时，耗时大约为5、6秒。但是到了中后期，每插入1万条数据则需要等待15至20，甚至30秒的时间。值得注意的是，虽然使用了较好的服务器，但是并行插入110万条记录的时间却比上次要来的多（这次耗时340秒，而之前是）。原因可能是客户端与服务器端的分离导致网络速度的下降。另一种可能我猜测是，根据Tokyo Cabinet的文档中提到文件读写锁的使用，因此每次只能插入一条记录，且插入（或更新）时无法读取数据，因而在并发环境下Tokyo Tyrant（它其实是Tokyo Cabinet上层的TCP服务器）的表现并不会有所提高。不过据读过Tokyo Cabinet代码的同事说，Tokyo Cabint在使用Table Database的时候锁粒度不会那么大，因此关于这点还需要寻找进一步的资料。

第2次测试启动10个任务，每个任务还是4000个分类，因此共计插入220万条记录。结果如下：

第2次测试的总数据量为第1次的2倍，而耗时却是第1次的3.5倍，这应该还是由于数据量增大而导致的插入性能降低。但是，我们目前还不能排除这和并发连接数有关的可能——虽然我们有理由相信这个性能问题只和数据量相关（稍后再说）。为了查明并发程度和性能是否有关系，我们再进行第3次测试。

第3次测试启动20个任务，每个任务2000个分类，因此共计仍旧是220万条记录。结果如下：

这个结果实在是非常能够说明问题：第3次的耗时与上一次几乎完全相同，这意味着加大并发量并不会影响TT的性能。这是因为TT在服务器端维护了一个线程池（现在的测试，也是默认情况下为8个线程），因此请求再多，同时进行的任务也是有限的，而累积的任务会排在队列中。这也是使用队列和固定数量工作线程的好处：即使压力再大，服务器端的吞吐量也能够一直保持较高水准，而客户端请求的响应时间随着请求数量增大而线性增长。如果没有队列，随着压力增大，服务器端吞吐量会剧烈下降（一般至少也是线性的），而客户端请求的响应时间增长更快，直至超时。

为此，我们也没有必要继续测试更多的并发数量了，因为即便是再多并发，TT的吞吐量（即插入记录的数目）也只是和数据库中记录数量相关。根据测试，我们可以总结出：

插入110万条记录的平均吞吐量为：大约3225条/秒
插入220万条记录的平均吞吐量为：大约1833条/秒
当数据库包含100万条数据时吞吐量为：1700~1800条/秒
当数据库包含200万条数据时吞吐量为：150~160条/秒

似乎随着数据量的增加，TT的吞吐量下降得也非常明显。这其中可能有索引的因素在里面，因此如果您想要得到适合自己的结果，最好可以亲自进行试验。

MongoDB性能测试

与TT相同，第1次测试启动5个任务，每个任务4000个分类，共计插入110万条记录。结果如下：

在5个并发任务的情况下，MongoDB的表现较TT要出彩不少。首先，随着数据库中已有记录的增加，插入速度并没有降低的迹象，可以说十分平稳。此外，在同样的客户端和服务器环境下，MongoDB插入110万条数据的耗时比TT的一半还要略少一些。而且，虽然网速带来的一定负面影响，但可能是由于服务器配置的提高，再加上并发写入的性能优势，此次测试比上次单机环境下的表现也要好上许多。

那么在数据量和并发继续增大的情况下MongoDB表现如何呢？于是第2次测试启动10个任务，每个任务还是4000个分类，共计插入220万条记录。结果如下：

第2次的数据量为第1次的2倍，而耗时则大约为2.08倍，两者基本保持一致，这说明了MongoDB在数据量和并发量增加的情况下，吞吐量几乎没有改变。

第3次测试依旧与TT相同，启用20个任务，每个任务2000个分类，共计插入220万条记录。结果如下：

在总数据量不变的情况下，我们又将并发量提高了一倍，但是MongoDB依旧表现出的稳定的吞吐量，总耗时与第2次测试几乎完全相同。

这样看来，似乎在MongoDB在内部也有个类似于TT的队列机制以保证一定的吞吐量。为了验证这个看法，我再次加大了数据量和并发量。在第4次测试中我启用了50个任务，每个任务还是2000个分类，这样插入的记录数据则达到了550万。结果如下：

在50个并发任务下，MongoDB终于略显疲态。第4次测试的数据量为第3次的2.5倍，但耗时却接近3.5倍。为了验证这是由于数据量增加，还是并发量提高引起的问题，我又进行了第最后一次测试。

第5个测试中启用了100个任务，但每个任务只写入1000个分类，则总条目数还是和第4次相同，为550万。结果如下：

请注意，由于每个任务插入1000个分类，即5.5万条记录，因此上表中最后一栏为5.5而不是6。随着并发量的增大，MongoDB的耗时继续增加了。由于这个表现和之前的预测不同，我又把第4次和第5次测试各执行了一遍，结果并没有太大区别，基本可以排除“环境异常”这样的可能。

经过5次测试的结果，我们可以得出MongoDB的性能指标：

5个并发，插入110万条记录的平均吞吐量：大约6600条/秒
10个并发，插入220万条记录的平均吞吐量：大约6300条/秒
20个并发，插入220万条记录的平均吞吐量：大约6300条/秒
50个并发，插入550万条记录的平均吞吐量：大约4500条/秒
100个并发，插入550万条记录的平均吞吐量：大约4100条/秒

总体来说，虽然在数据量和并发量增大的情况下MongoDB的吞吐量有所下降，但是MongoDB的表现比TT还是要抢眼不少，而且在绝对数值上还是相当出彩的。

其他信息

其他还有一些信息可能值得参考。

在进行测试时，我发现TT进程的CPU占有率比较低，除了少量时候出现80~150%以外（top命令的结果，8核服务器），绝大部分时间CPU占有率只有20~40%。MongoDB的CPU占有率比TT要高出不少，基本上保持在80~110%之间（数据量和并发量在这里影响不大）。但是总体来说CPU的占有率都很低，毕竟现在的测试属于IO密集型操作。

不过在内存占有率方面，两者的区别很大。在测试过程中（服务器内存4G），TT进程的内存占有率一直保持在20%一下，而MongoDB会缓步增加，最后保持在80%上下。

此外，在插入了550万条数据之后，MongoDB的数据文件增长到了6G。这个数字比上次测试的2G/110万稍有缓解，但还是比TT要大上许多。

最后再来谈谈为什么仅仅测试了“并发插入”而没有“更新”和“删除”：其实这也是通过使用场景而设计出来的测试用例。因为对于此类存储来说，大量并发插入的场景比较多，例如日志记录，用户行为记录，或是SNS应用中常见的News Feed等等。这些场景的特点就是需要数据的不断增长，而大量密集的更新则很少会出现──删除就更不用说了。至于并行的更新，我接下来也会进行测试的，只是可能会模拟一些实际的场景，例如在更新的同时进行不断地读取和插入吧。

所有测试代码，及完整测试结果：http://github.com/JeffreyZhao/mdb-tt-benchmark

MongoDB与Tokyo Tyrant性能比较（1）：基础CRU操作

jeffz@live.com (老赵) — Wed, 24 Feb 2010 15:45:00 GMT

以前的项目大都把数据存放在关系型数据库中，关系型数据库的优势在于使用普及，资料丰富，且有大量辅助类库来简化开发。当然它们的问题比较明显的，一是在数据量上升的情况下伸缩性比较差，且进行结构调整的代价比较高。因此现在有个所谓NoSQL的“运动”也逐渐普遍起来了，它便是借助一些非关系型存储方式来开发项目（个人认为其实将它解释为Not Only SQL更为合适）。因此在新项目里，我也想尝试一下使用之前一直只是“听说”的存储方式。

在和同事的交流过程中，我了解到他们的项目正在尝试使用Tokyo Tyrant（后称TT）进行存储，并且据说效果不错，因此我一开始也打算尝试使用TT进行主要存储，为此也花了一定时间为其编写.NET平台下的驱动程序。不过在驱动程序的开发过程中，我逐渐意识到TT的功能有着严重的限制，似乎并不适合作为接下来项目的主要存储方式。因此，我又将眼光转向了之前关注过的MongoDB上。MongoDB也是NoSQL的代表之一，是一个面向文档的，架构灵活（Schema-less）的存储方式，在仔细阅读相关资料之后，我发现它的功能与TT相比可谓天上地下，非常适合许搭建各类项目（关于这点以后有机会再谈）。

不过，既然选择NoSQL的原因是性能，那么他们的性能表现究竟如何呢？TT的性能表现在业界非常出名，而MongoDB的使用便相对较少了（当然，官网列举了不少案例，最近著名的开源网站SourceForge也打算使用MongoDB重新设计他们的网站）。为此，我决定亲手比较一下两者的性能表现。

测试环境及数据

由于缺乏合适的环境，因此我不得不在我的MBP上进行这次性能比较，参数如下：

OS：Mac OS X v10.6.2（Snow Leopard）
RAM：4GB / 1067MHz / DDR 3
CPU：2.53GHz Intel Core 2 Duo
64-bit Kernel and Extensions：Yes
TT在64 bit环境下编译，MongoDB使用64 bit版本。

在测试执行时，我尽量关闭多余的应用程序，避免其它因素造成影响。同样，由于条件限制，我只得把客户端和服务器跑在同一台机器上。测试代码使用Ruby编写，这是由于两者都有官方提供的驱动程序。此外，由于我对于两者的优化都不太熟悉，因此它们都使用了默认的配置。

关于测试数据，我将存入110万条“新闻”数据，包含以下字段：

ID：标识，32位整数，带索引
Title：标题，字符串
CategoryID：分类ID，32位整数，带索引
CreateTime：日期，保存为32位整数，带索引
UserID：用户ID，32位整数，带索引
Tags：标签集合，字符串数组，带索引
Source：来源，字符串
SourceUrl：来源URL，字符串
Status：状态，32位整数

为了相对接近真实的环境的数据分布特征（便于以后进行查询操作比较），我设计了这样的测试数据（具体可阅读代码）：

2万个分类，分别拥有10个至100条新闻，总共110万条记录。
1万个用户，根据分类id取模得到其归属。
创建时间从2010年1月1日起递增，每条记录增加1秒。
每条记录拥有2到6个Tag，除了其中一个之外，都从一个1.7万个Tag库中获取。
每条记录的字符串字段都不长（20-30字符）

由于TT只支持字符串的值（但可以建立数字索引，会将字符串当作数字来识别），因此事实上所有的值都会转化为字符串进行保存。此外，由于存在“根据Tag查找新闻”的业务，因此对于Tags字段也建立了索引，其中MongoDB直接支持对字符串数组的索引（索引其中每个元素），而在存入TT时则转化为空格分隔的字符串，并为其建立倒排索引（Token Inverted Index）以便进行全文查找。

在存储方式上，所有数据将放入MongoDB的同一个集合内，而TT则选用Table Database存储结构。在使用TT时，另一种做法是完全使用键值对来保存一条记录的各个字段，不过这样做会大大限制TT的功能，或是会为系统编写带来额外的复杂度，便不考虑Hash / B+ Tree / Fixed-length等存储方式了。

插入操作性能比较

具体代码在tt-insert.rb及mdb-insert.rb文件中。两段代码均使用一个连接，使用循环每次插入一条：由于如果每次都建立连接，会在TCP/IP连接的打开关闭上消耗大部分时间，由于实际项目中基本都会使用连接池等机制来复用连接，因此这方面便不多做考虑；再者，由于实际插入时几乎不可能批量操作，因此这里并不使用两者提供的批量插入功能。脚本每插入10万条记录便打印出所耗时间，结果如下：

从结果上看，MongoDB大约有10%的领先，不过总体来说两者的差距不大。值得一提的是，TT在数据量越大的情况下，每插入10万条记录的耗时越长（也从同事的使用过程中确认了这一点）。因此，一开始两者插入速度几乎没有差距，但是慢慢地TT便落后于MongoDB了。目前推测这可能是TT的Table Database存储结构特有的问题，不知道随着数据量的增长TT表现如何，因为对于一个大型系统来说，100多万条记录实际上只是一个很小的数目。

有同事推测，TT插入性能低是因为建立了Tags字段的倒排索引，于是我也测试了不在Tags字段上建索引的情况。令人惊讶的是，同样去除Tags字段的索引之后，MongoDB的性能提升超过20%，而TT的性能提升却微乎其微。

值得一提的是，放入相同的记录之后，TT的文件为400多M，但MongoDB则为整整2G。因此推测这是MongoDB进行空间预分配的结果，邮件列表上的这个讨论也证实了这一点。此外，上面每次测试都是从零开始的，经测试如果在插入前为MongoDB预分配文件空间，则性能还会有些许提高。

通过主键获取记录性能比较

具体代码在tt-get-by-key.rb及mdb-get-by-key.rb文件中。两段代码同样均使用一个连接，使用循环进行100万次Get操作，每次都随机获取一个110万以内的数字，并作为ID进行Get操作。同样，每10万次Get操作后打印出所耗时间，结果如下：

在Get操作方面，MongoDB有大约20%的领先。不过从实际情况分析，这方面的差距也不是太大，因为在项目中根据主键获取记录的操作8成以上都是落在缓存上的，因此在这方面对存储的要求并不高。

通过主键更新记录性能比较

具体代码在tt-update-by-key.rb及mdb-update-by-key.rb文件中。两段代码各自使用同一个连接，使用循环进行大量的更新操作。每次随机获取一个110万以内的数字，并作为ID更新其CreateTime、Title、Source、SourceUrl、Status五个字段。结果如下：

首先是MongoDB的三次测试结果，每次更新100万条数据。从数据上看，三次查询的性能越来越高，这个现象在重启服务器之后可以重现（三次测试之间并没有重启服务器）。

请注意，TT的三次测试均只更新了10万条记录（因为100万条记录耗时太长）。和MongoDB类似，一开始查询性能较差，但是会慢慢提高，这个现象在重启服务器后也能重现，于是猜测是缓存的结果。即便如此，TT的更新时的最高速度只有大约没秒1500次，而MongoDB却超过了每秒5000次。这是因为TT在功能上有硬伤：它无法像SQL的UPDATE语句那样更新某条记录的部分字段，因此必须全部取出，修改后再整体写入。而MongoDB支持高效的直接修改——这也成为MongoDB放在首页上的“招牌功能”。

因此，TT对于“更新某个分类下所有新闻的状态”这样的操作会很不适应，而它的这个限制导致我们很难实现如“乐观并发控制”这样的手段。此外，在实际应用中客户端与服务器不会使用本地连接，因此在生产环境中TT和MongoDB在这方面的差距可能会更明显一些。

总结

到目前为止，我们测试了TT和MongoDB在CRU三种基本操作下的性能，似乎MongoDB全面胜过Tokyo Tyrant。不过需要强调的是，这个测试还很不全面：它没有使用合适的环境，也没有对两者进行适当的优化。此外，两者在并发情况下，或是同时读写下的表现如何也是值得进一步考察的，我也会设计更多的测试用例。因此，这里的数据仅供参考，如果有合适的环境我也会重新进行测试。

本文所有代码：http://github.com/JeffreyZhao/mdb-tt-benchmark

从今日起正式加入水果党

jeffz@live.com (老赵) — Mon, 01 Feb 2010 16:08:00 GMT

想来我现在的笔记本也用了将近3年，虽然至今没有出现过任何问题，但更新换代似乎也不是件让人无法接受的事情——再加上老爸正好也需要一台笔记本，于是我想，不如就乘此机会升一下级吧。不过其实我本没有打算那么着急，只是两天前忽然出现了一个千载难逢的机会，一台十分便宜的MBP放在我面前，于是我当机立断，即刻入手。因此我在此庄严宣布：从今日起，我正式加入水果党。

以下是我今天新到的Mac Book Pro（MB471）。

有不少朋友问我：你怎么放弃.NET了？更有一些*nix界（不好说是自由/开源界，毕竟Mac也是个封闭的平台）的朋友认为，作为一个微软MVP，又是在国内.NET社区小有影响的人物忽然转投*nix平台，这又是微软平台衰败的一个证据。当然，我没想这么多。我只是觉得：好玩。

唉，毕竟Windows平台上玩了这么多年，虽然不可能什么都玩遍，但多少还是有些厌倦了。再者，的确有很多东西在Windows平台上玩起来不是那么方便。例如.NET平台的跨平台实现mono，如果没有一个非Windows平台作为运行环境，想要真正玩好也是十分不容易的——新的工作环境让我有机会验证一些想法，我又怎能不牢牢把握住这个机会呢？一直有人坚持认为mono只是个玩具，那么也就让我亲自尝试一下吧。至于其他平台，如Java、Ruby、Python亦或是Haskell等等，自然就更不在话下了——再者，如果我要尝试Mac平台开发的话，也只能用Mac了……

谁说Windows平台的程序员视野狭隘呢？我就爱玩各种东西。

不过，仅仅是从这个角度来讲，我买一台PC装一个Linux操作系统，或是用虚拟机也可以达到相同的目的。可惜总能听到一些搞技术的朋友对我说Mac有多么多么好，Windows有多么多么差。对于这样的言论，我当然不服气了。但是我既然没有用过Mac，又能如何给出令人信服的反对意见呢？因此我也想乘此机会体会一下Mac系统的优秀之处，无论它是否真的优于Windows，我终究会有一个理性认识。爱吵架的兄弟们，先等我个一年半载啊。

当然，我肯定还是会装一个双系统跑个Win 7什么的，因为我实在离不开可恶的网银和可爱的游戏。

按月统计博客园单个用户的发文数量

jeffz@live.com (老赵) — Sun, 10 Jan 2010 16:07:00 GMT

这几天在家闲着，便试着写一些小程序。之前有朋友问到“F#能不能写Web”，于是我也就打算这么一试。虽然我能肯定，用F#写Web应用程序不会是问题，不过倒真还没有做过这方面的尝试。我想，如果用F#写Web应用程序，那么它很重要的一点，应该是利用其在异步编程方面的强大特性。最后我决定，使用F#编写一个按月统计博客园单个用户发文数量的简单服务。尝试的结果是——还有些问题没有解决。不管怎么样，我先把其主体逻辑描述一下吧。

按月统计博客园单个用户的发文数量，这个并不困难，只要利用博客园的“按月汇总”页面就行了——前几天我也利用这个页面来捕获我所有文章ID，这次还是使用这个方法。由于这是一个打算公开的服务，为了性能着想我打算利用起博客园的gzip压缩，因此我们这里为WebClient类扩展一个异步获取数据流的GetDataAsync函数：

type WebClient with 

    member c.GetDataAsync(url) =
        async {
            do c.DownloadDataAsync(new Uri(url))
            let! args = Async.AwaitEvent(c.DownloadDataCompleted)
            return args.Result
        }

当得到了页面的数据流之后，我们便可以使用GZipStream将其解压缩了。如此，我们便可以写一个函数，生成一个异步工作流，其效果是返回某个月指定用户所有文章的URL：

let getPostUrlsAsync alias (beginMonth: DateTime) (endMonth: DateTime) = 

    if (beginMonth > endMonth) then
        failwith "beginMonth must smaller then or equals to endMonth"

    let getPostUrlsAsync' alias (m: DateTime) = 
        async {
            let webClient = new WebClient();
            webClient.Headers.Add(HttpRequestHeader.AcceptEncoding, "gzip")

            let url = sprintf "http://%s.cnblogs.com/archive/%i/%i.html" alias m.Year m.Month
            let! data = webClient.GetDataAsync(url)
            
            let rawStream = new MemoryStream(data)
            let gzipStream = new GZipStream(rawStream, CompressionMode.Decompress)
            let reader = new StreamReader(gzipStream)
            let html = reader.ReadToEnd()

            let regex = @"..."
            return [ for m in Regex.Matches(html, regex) -> m.Groups.Item(1).Value ]
        }

    ...

在getPostUrlsAsync'函数中，我们首先拼接出该用户月份汇总页的URL——使用子域名的方式。博客园有两种方式可以访问某个博客，一是子域名，二是普通的URL形式。在这里我使用子域名的访问方式是避免.NET类库中对单个域名2个连接的限制。现在这个服务可以同时统计不同用户的信息而不会冲突。不过对于单个用户，还是只能同时出现2个连接——嗯，这是个Feature，避免在虚拟主机上消耗太多资源的Feature。

上面还省略了一个正则表达式，其实它是这样的：

<a\s[^>]*href=["|'](http://www.cnblogs.com/\w+/archive/\d{4}/\d{2}/\d{2}/[^.]*\.html)["|'][^>]*>\s*阅读全文\s*</a>

这个正则表达式实在不容易找。博客园的不同皮肤的HTML可能截然相反，我原本以为都会有EditPosts.aspx?postid=12345这样的链接，但事实证明……有些模板中这样的链接是使用JavaScript生成的，于是“此路不通”。后来我又想通过“评论”链接来捕获URL，但发现有的皮肤使用#FeedBack，有的却使用#Comments。总之，很难统一起来便是了。

最后，我决定通过使用每篇文章中的“阅读全文”链接来识别一篇文章——便是这样，您从这个正则表达式中也可以发现，这是一个较为宽泛的Pattern，甚至href属性还要分单引号和双引号两种情况。这个方法有缺陷，因为对于一些非常短的文章，博客园是不会为其生成“阅读全文”链接的——不过，这也算是个Feature吧，太短的文章咱就不算了。:P

接下来便是从beginMonth和endMonth参数中收集任务，并进行“汇总”了：

let getPostUrlsAsync alias (beginMonth: DateTime) (endMonth: DateTime) = 

    ...

    let executeAsync tasks =
        let rec executeAsync' (tasks: (_ * Async<_>) list) acc = 
            async {
                match tasks with
                | [] -> return acc |> List.rev
                | (pre, task) :: ts ->
                    let! result = task
                    return! executeAsync' ts ((pre, result) :: acc)
            }
        
        executeAsync' tasks List.empty

    Seq.initInfinite (fun i -> endMonth.AddMonths(-i))
    |> Seq.takeWhile (fun m -> m >= beginMonth)
    |> Seq.map (fun m -> (m, getPostUrlsAsync' alias m))
    |> Seq.toList
    |> executeAsync

F#与Haskell不同，它不是延迟的语言，因此它的List必须是有限的，即时生成的。不过Seq便不同了，F#中的Seq可以认作是IEnumerable的对应物，可以是无限的，而Seq.initInfinite便是初始化这样一个无限的序列。不过Seq.takeWhile却只是取到这个序列大于等于beginMonth的那些元素——然后我们再将其映射成月份与“获取单月文章URL”这个异步工作流的“元组”。最后，再使用executeAsync将DateTime * Async<string list>汇总成Async<(DateTime * string list) list>类型。由于我打算把它部署在虚拟主机上，为了节省资源没有把它们并行处理——因此在最后执行时耗时会有些长，不过最后感觉下来，速度基本还可以接受。

最后，我们与上次相同，写个异步Handler用于处理请求：

#light

namespace CnBlogsMonitoring

open System
open System.Web

type PostsOfMonthsHandler() =
    let mutable m_context = null
    let mutable m_endWork = null

    interface IHttpAsyncHandler with
        member h.IsReusable = false
        member h.ProcessRequest(context) = failwith "not supported"

        member h.BeginProcessRequest(c, cb, state) =
            m_context <- c

            let alias = c.Request.QueryString.Item("alias").Trim()
            let bm = DateTime.ParseExact(c.Request.QueryString.Item("begin"), "yyyy/MM", null)
            let em = DateTime.ParseExact(c.Request.QueryString.Item("end"), "yyyy/MM", null)

            let monthDiff = (em.Month - bm.Month) + (em.Year - bm.Year) * 12
            if monthDiff > 12 then failwith "Please pick a range no larger than 12 months."

            let title = sprintf "%s: %i/%i ~ %i/%i" alias bm.Year bm.Month em.Year em.Month
            m_context.Items.Item("Title") <- title

            let work = PostMonitor.getPostUrlsAsync alias bm em
            let beginWork, endWork, _ = Async.AsBeginEnd work
            m_endWork <- new Func<_, _>(endWork)

            beginWork (cb, state)

        member h.EndProcessRequest(ar) =
            m_context.Items.Item("PostsOfMonths") <- m_endWork.Invoke ar
            m_context.Server.Transfer("PostsOfMonths.aspx")

在EndProcessRequest方法中，我们得到了统计结果。在这里我的处理方式是将请求Transfer到PostsOfMonths.aspx这个页面去显示HTML——传递数据的方式是利用HttpContext.Items集合。

在PostsOfMonths.aspx中，显示HTML的方式与普通页面毫无二致：

public partial class PostsOfMonths : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        this.Title = this.Context.Items["Title"].ToString();

        this.rptPostsOfMonths.DataSource = this.Context.Items["PostsOfMonths"];
        this.rptPostsOfMonths.DataBind();
    }
}

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <h1><%= this.Title %></h1>
    
    <asp:Repeater runat="server" ID="rptPostsOfMonths">
        <ItemTemplate>
            <h2><%# Eval("Item1", "{0:yyyy/MM}") %> - <%# Eval("Item2.Length") %> post(s)</h2>
            
            <asp:Repeater runat="server" DataSource='<%# Eval("Item2") %>'>
                <HeaderTemplate><ul></HeaderTemplate>
                <ItemTemplate>
                    <li>
                        <a href="<%# Container.DataItem %>"><%# Container.DataItem %></a>
                    </li>
                </ItemTemplate>
                <FooterTemplate></ul></FooterTemplate>
            </asp:Repeater>
        </ItemTemplate>
    </asp:Repeater>
</body>
</html>

从F#代码中我们知道，HttpContext.Items["PostsOfMonths"]的类型是(DateTime * string list) list，也就是说，绑定至rptPostsOfMonths中的每一项都是个DateTime * string list对象——写成C#的形式便是Tuple<DateTime, FSharpList<string>>，其中包含Item1和Item2两个属性，分别是DateTime和FSharpList<string>类型，而后者又会绑定至内层的Repeater中，最终生成整页的HTML。

那么我为什么不写个异步的WebForm页面呢？因为经过我的简单尝试，在WebClient.GetDataAsync扩展里的Async.AwaitEvent操作中会抛出InvalidOperationException异常：

Asynchronous operations are not allowed in this context. Page starting an asynchronous operation has to have the Async attribute set to true and an asynchronous operation can only be started on a page prior to PreRenderComplete event.

经过了多番检查和比对，我始终没有发现出了什么问题，因此最后还是使用了异步Handler的方式编写这个服务。按理说，异步Hander可以正常工作，异步页面也应该没有什么问题，具体原因我会继续探究一下。不过，如果只是编写一个同步页面的话，不会出现任何问题。

最后，我把这个简单服务部署到了免费的虚拟主机上（以前用的Hosting由于众所周知的原因，在国内已经无法使用了——现在这个只能用到1月底），您可以在文末访问到该服务的入口页：这是一个简单的静态页面，填好信息后点击Submit便会提交至那个异步Handler进行处理——稍等片刻，便会得到结果。F#的方便之处，在于它编译后的结果便是标准的.NET程序集，使用时也只是复制一些dll便可——无需额外支持。这样看来，有一个统一的虚拟机平台的确方便，例如GAE在支持Java平台之后便相当于直接支持Scala语言了。同理，在.NET平台上使用Rails（Ruby）、Django（Python）等框架似乎都不是个梦想。

谁说.NET封闭？我感觉没有比.NET更海纳百川的平台了，呵呵——这也是我喜欢.NET平台的最大原因。

服务入口：http://user868.netfx4lab.discountasp.net/PostsOfMonths.html

本文代码：http://gist.github.com/273556

五十种语言的“圣诞快乐”（下）：F#实现

jeffz@live.com (老赵) — Mon, 28 Dec 2009 03:18:00 GMT

不知道大家的圣诞节过的如何？有没有玩点啥有趣的东西？上次的文章中我们主要分析了使用Google Translate进行文字翻译的方式，并使用C#写了一个简单的的翻译程序，效果良好。不过，在平时开发过程中，对于此类问题我常用F#来解决这样的问题。那么使用F#来实现此类任务有什么优势吗？不错，我们现在便来看看这个问题。

简单的F#实现

话说F#和.NET框架可以无缝集成，因此理论上之前我们的C#代码怎么写，便可以使用F#来照着抄一遍。例如，我们先定义一个Sync模块，其中先定义一个获取全部目标语言的getLanguages函数：

#light

module Sync

open System
open System.Text.RegularExpressions
open System.Net
open System.Web
open System.Web.Script.Serialization
open System.Collections.Generic
open System.Text

type private LangMap = Dictionary<string, string>

let private getLanguages() = 
    let url =
        "http://translate.googleapis.com" +
        "/translate_a/l?client=te&hl=zh-CN&cb=_callbacks_._0g3mb650r"
    
    let webClient = new WebClient()
    let script = webClient.DownloadString(url)

    let json = Regex.Match(script, @"'tl':({.+})}\)").Groups.Item(1).Value
    let serializer = new JavaScriptSerializer()
    serializer.Deserialize<LangMap>(json)

这个函数与之前C#版本的GetLanguages方法可谓一模一样，其返回结果便是一个字典，存储了目标语言的代号和名称——当然，这边我为Dictionary<string, string>取了一个别名LangMap，这样使用起来感觉更为方便，语义也更加清晰。

同样的，我们“翻译”一遍之前的Translate方法，变成如今的translateText函数：

let private translateText (text:string) sl tl =
    let url = 
        "https://translate.googleapis.com" +
        "/translate_a/t?client=te&format=html&v=1.0"

    let encoded = text |> HttpUtility.UrlEncode
    let data = sprintf "q=%s&sl=%s&tl=%s&tc=1" encoded sl tl

    let webClient = new WebClient()
    webClient.Encoding <- Encoding.UTF8
    let userAgent = "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0;)"
    webClient.Headers.Add(HttpRequestHeader.UserAgent, userAgent)

    let json = webClient.UploadString(url, data)
    let serializer = new JavaScriptSerializer()
    serializer.Deserialize<string>(json)

而最终进行多种语言翻译的，则是使用公有的translate函数：

let translate text sl = 
    let languages = getLanguages()

    let translated =
        languages
        |> Seq.map (fun p -> translateText text sl p.Key)

    let names = languages  |> Seq.map (fun p -> p.Value)
    Seq.zip names translated |> Seq.toArray

首先，所有语言会存入一个叫做languages的容器中，它是一个字典，实现了IEnumerable<KeyValuePair<string, string>>，在F#中便是seq<KeyValuePair<string, string>>，因此我们使用Seq模块的map方法将其转化为翻译后的结果，并存放在translated中。然后，我们获得每种语言的名称，最终与翻译的结果zip即可。translate函数最终返回的是一个存放着元组的数组，元组的类型是string * string。

至于调用，自然是很容易的。F#控制台程序也需要定义main函数，如下：

[<EntryPoint>]
let main args =

    let output = 
        Sync.translate "圣诞快乐" "zh-CN"
        |> Array.map (fun (lang, text) -> sprintf "%s：o%s" lang text)

    File.WriteAllLines("output.txt", output)
    
    Console.ReadLine() |> ignore
    0

当然，如果我们只是把F#用成这样，那实在就没有多大价值了。

异步编程

刚才的代码放在名为Sync的模块中，很明显这是“同步”的。对于此类IO操作，使用同步IO是一件非常不明智的事情。当然，对于目前这样的小程序来说，使用同步IO并没有什么问题。但是您一会儿也会发现，异步IO对目前的情形也是十分有价值的。

异步IO除了“不阻塞”的含义在里面之外，我认为还需要包括“事件触发”这个含义在里面。例如，JDK很早就支持了异步IO，但是直到目前为止（JDK 6），它在Windows平台上的相关实现，依旧只是简单的“非阻塞”，而非基于Windows的异步IO机制IOCP。于此相对，它在Linux平台上的实现却使用了高效的epoll。因此，如Mina，Jetty等高性能IO通信框架在Windows下的表现要比Linux差很多——您会经常看到时不时有人以此来证明Windows性能低下，但我倒认为这只能证明Java的跨平台只是“功能”而不是“性能”，意义大打折扣。

至于跨平台的IO类库并非没有，例如著名的libevent便是一例。不过在JDK 7中“据说”会修复这方面问题，拭目以待。

对于在Windows平台下真正的异步IO机制IOCP，我之前在多篇文章中有所提及（包括与其有关的IO线程池）。在.NET平台上，各种类库的异步通信方式自然使用了IOCP，自不必提。但是，异步编程的性能虽然好，但它的最大问题还是“方便性”，最基础的一点，由于任务流需要分两部分进行，那么我们自然需要保留上下文吧？即便是如C#中提供了匿名函数，可以自动生成闭包来保持上下文，但是还是有其他问题——例如，异常处理怎么办？

当然，利用C#中的yield关键字可以简化这些问题，但是F#给我们更好的解决方案。F#应对异步编程提供了一个名为“异步工作流”的结构，它基于F#的“工作流”特性开发了一套异步类库，关于这一点在上次的Comet原型中也有提及。异步工作流的优势在于把一个“二段式”的异步调用合并在一起，这样在调用的时候便可以同步操作的方式进行。如此，无论是逻辑中的上下文信息还是异常处理都变得异常简单。

对于异步操作的“合并”，例如可以根据最常见的APM模式（即Begin/End）生成“单步”的工作流。不过对于WebClient来说，它的异步操作并非APM形式，而是基于“事件”。不过F#对此也提供了支持，因此我们可以为WebClient扩展两个函数：

type WebClient with
    member c.GetStringAsync(url) = 
        async {
            c.DownloadStringAsync(new Uri(url))
            let! args = c.DownloadStringCompleted |> Async.AwaitEvent
            return args.Result
        }

    member c.PostStringAsync(url, data) = 
        async {
            c.UploadStringAsync(new Uri(url), data)
            let! args = c.UploadStringCompleted |> Async.AwaitEvent
            return args.Result
        }

我们在F#中可以“打开”任意一个类型，为其添加新的成员——不过自然这只是如C#中扩展方法那样的语法糖而已。我们为WebClient添加了GetStringAsync与PostStringAsync两个方法，它们返回的都是结果为一个字符串的异步数据流（即Async<string>），执行这个异步数据流之后便可以得到最终的结果。值得注意的是，async块只是在构造一个逻辑块，并没有真正调用。

于是，我们的getLanguages函数也可进行改写：

let private getLanguages() = 
    async {
        let url =
            "http://translate.googleapis.com" +
            "/translate_a/l?client=te&hl=zh-CN&cb=_callbacks_._0g3mb650r"
        
        let webClient = new WebClient()
        // let script = webClient.DownloadString(url)
        let! script = webClient.GetStringAsync(url)

        let json = Regex.Match(script, @"'tl':({.+})}\)").Groups.Item(1).Value
        let serializer = new JavaScriptSerializer()
        // serializer.Deserialize<LangMap>(json)
        return serializer.Deserialize<LangMap>(json)
    }

您是否发现这段代码与之前的变化？没错，两者几乎一模一样。除了它变成了async构造块之外，唯一的区别只是被注释的两行代码。第一行代码中，原本我们使用的是同步的DownloadString函数，而现在我们则通过执行一个异步数据流（使用let!）来得到结果script——当然，执行的形式却是同步的。除此之外，最后返回结果需要使用return来标明。let!和return（以及其他的如return!）等操作符，都是F#编译器对“工作流”构造块（如async）使用中的“强制措施”，以此避免开发人员的误操作。

同样，translateText函数也将构造一个异步工作流：

let private translateText (text:string) sl tl =
    async {
        let url = 
            "https://translate.googleapis.com" +
            "/translate_a/t?client=te&format=html&v=1.0"

        let encoded = text |> HttpUtility.UrlEncode
        let data = sprintf "q=%s&sl=%s&tl=%s&tc=1" encoded sl tl

        let webClient = new WebClient()
        webClient.Encoding <- Encoding.UTF8
        let userAgent = "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0;)"
        webClient.Headers.Add(HttpRequestHeader.UserAgent, userAgent)

        let! json = webClient.PostStringAsync(url, data) // changed
        let serializer = new JavaScriptSerializer()
        return serializer.Deserialize<string>(json) // changed
    }

使用异步工作流的另一个好处在于，我们可以轻易地将异步工作流并行地执行。例如在目前的场景中，我们可以同时发起50多个异步IO请求，但同时却不占用任何线程——它们可能都在等着IO设备（即网卡）发送设备信号呢。于是乎，我们的translate函数便可以这样写：

let translate text sl = 
    async {
        let! languages = getLanguages()
        let! translated =
            languages
            |> Seq.map (fun p -> translateText text sl p.Key)
            |> Async.Parallel

        let names = languages |> Seq.map (fun p -> p.Value)
        return Seq.zip names translated |> Seq.toArray
    }

并这样调用：

let output = 
    Parallel.translate "圣诞快乐" "zh-CN"
    |> Async.RunSynchronously
    |> Array.map (fun (lang, text) -> sprintf "%s：%s" lang text)

这句代码中的Parallel便是指我们刚才开发的模块。这段代码的执行速度会比Sync模块要快很多，因此此时50多个翻译的请求并不是依次发出，而是同时发出，并通过响应IO设备的事件来工作。不阻塞，高效。

异步工作流的同步执行

之前的代码中，我们是将languages集合转化为一组translateText所生成的异步任务，然后由Async.Parallel合并成一个并行的异步任务。这种调用方式很简单，反而是如果您要将这组异步任务按照顺序一一执行起来比较麻烦。当然，这只是麻烦，并不困难，而且其实同样是非常自然的：

let translateSeq text sl = 
    let rec translateSeq' targets acc =
        async {
            match targets with
            | [] -> return acc |> List.rev
            | t :: ts -> 
                let! result = translateText text sl t
                return! translateSeq' ts (t :: acc)
        }

    async {
        let! languages = getLanguages()
        let targets = languages |> Seq.map (fun p -> p.Key) |> Seq.toList

        let! translated = translateSeq' targets List.empty
        let names = languages |> Seq.map (fun p -> p.Value)
        return Seq.zip names translated |> Seq.toArray
    }

您能解释一下这段代码的写法吗？

最后还是来看看执行效果吧。圣诞已过，新年将至。那么在这里就来祝各位兄弟们新年快乐吧！

所有代码

五十种语言的“圣诞快乐”（上）：分析与实现
五十种语言的“圣诞快乐”（下）：F#实现

五十种语言的“圣诞快乐”（上）：分析与实现

jeffz@live.com (老赵) — Fri, 25 Dec 2009 03:17:00 GMT

圣诞节到了，于是在某个邮件列表上收到了这样一封信，“五种语言的圣诞快乐”：

汉语版：圣诞快乐！
英语版：麦瑞克瑞死没死！
俄语版：买个萝卜切吧切吧炖了吧！
韩语版：空起哇撒起哇, 米死搭！
日语版：锅你得洗哇，碗你得洗哇，盆你得洗哇，锅碗盆你都得洗了哇！

后来有人贴了个更全的，于是有人猜测“这不是使用Google翻译做的吧？”哗，有意思的，我心想。以前也用过一个别人封装好的程序集，可以调用在线的Google Translate服务进行翻译。那么，我们现在自己来试试看吧。

使用Google Translate

Google Translate是一个在线工具，可以翻译五十多种语言。可惜的是，Google Translate并没有像Bing翻译那样直接提供RESTful和SOAP形式的API，不过这也给了我们一些探索的乐趣。目前Google Translate只提供一个脚本，您可以把它嵌入到网页中，这样便可以使用其翻译功能了。例如，您可以在页面上放置这样的内容：

<div id="google_translate_element">圣诞快乐</div>

<script>
    function googleTranslateElementInit() {
        new google.translate.TranslateElement({
            pageLanguage: 'zh-CN'
        }, 'google_translate_element');
    }
</script>

<script src="http://translate.google.com/translate_a/element.js?cb=googleTranslateElementInit"></script>

于是乎：

以上是我选择将其翻译为英语后的结果——当然Google Translate可以让你选择五十多种目标语言。

获取语言信息

使用Fiddler抓包后便可以发现，在页面加载时Google Translate的脚本首先会去加载所有它支持的语言：

GET /translate_a/l?client=te&hl=en&cb=_callbacks_._0g3matv3f HTTP/1.1
Accept: */*
Referer: http://localhost:46714/translate.html
Accept-Language: en-us
User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0; SLCC1; .NET CLR 2.0.50727; .NET CLR 3.0.30729; .NET CLR 3.5.30729; .NET4.0C; .NET4.0E; OfficeLiveConnector.1.3; OfficeLivePatch.0.0)
Accept-Encoding: gzip, deflate
Host: translate.googleapis.com
Connection: Keep-Alive

这样便会得到这样的结果：

_callbacks_._0g3matv3f({'sl':{'auto':'Detect language','af':'Afrikaans','sq':'Albanian','ar':'Arabic','be':'Belarusian','bg':'Bulgarian','ca':'Catalan','zh-CN':'Chinese','hr':'Croatian','cs':'Czech','da':'Danish','nl':'Dutch','en':'English','et':'Estonian','tl':'Filipino','fi':'Finnish','fr':'French','gl':'Galician','de':'German','el':'Greek','iw':'Hebrew','hi':'Hindi','hu':'Hungarian','is':'Icelandic','id':'Indonesian','ga':'Irish','it':'Italian','ja':'Japanese','ko':'Korean','lv':'Latvian','lt':'Lithuanian','mk':'Macedonian','ms':'Malay','mt':'Maltese','no':'Norwegian','fa':'Persian','pl':'Polish','pt':'Portuguese','ro':'Romanian','ru':'Russian','sr':'Serbian','sk':'Slovak','sl':'Slovenian','es':'Spanish','sw':'Swahili','sv':'Swedish','th':'Thai','tr':'Turkish','uk':'Ukrainian','vi':'Vietnamese','cy':'Welsh','yi':'Yiddish'},'tl':{'af':'Afrikaans','sq':'Albanian','ar':'Arabic','be':'Belarusian','bg':'Bulgarian','ca':'Catalan','zh-CN':'Chinese (Simplified)','zh-TW':'Chinese (Traditional)','hr':'Croatian','cs':'Czech','da':'Danish','nl':'Dutch','en':'English','et':'Estonian','tl':'Filipino','fi':'Finnish','fr':'French','gl':'Galician','de':'German','el':'Greek','iw':'Hebrew','hi':'Hindi','hu':'Hungarian','is':'Icelandic','id':'Indonesian','ga':'Irish','it':'Italian','ja':'Japanese','ko':'Korean','lv':'Latvian','lt':'Lithuanian','mk':'Macedonian','ms':'Malay','mt':'Maltese','no':'Norwegian','fa':'Persian','pl':'Polish','pt':'Portuguese','ro':'Romanian','ru':'Russian','sr':'Serbian','sk':'Slovak','sl':'Slovenian','es':'Spanish','sw':'Swahili','sv':'Swedish','th':'Thai','tr':'Turkish','uk':'Ukrainian','vi':'Vietnamese','cy':'Welsh','yi':'Yiddish'}})

不过，您一定发现了，这些数据为什么是英文的呢？根据经验，这是由浏览器的语言首选项决定的。因此，我将zh-CN加入语言列表中的最上方，在IE里可以在Tools – Internet Options的General标签中设置Languages：

此时再次刷新页面，就会发现界面变成了中文，而Google Translate也会使用另外的地址来加载语言信息：

GET /translate_a/l?client=te&hl=zh-CN&cb=_callbacks_._0g3mb650r HTTP/1.1
Accept: */*
Referer: http://localhost:46714/translate.html
Accept-Language: zh-CN,en-US;q=0.5
User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0; SLCC1; .NET CLR 2.0.50727; .NET CLR 3.0.30729; .NET CLR 3.5.30729; .NET4.0C; .NET4.0E; OfficeLiveConnector.1.3; OfficeLivePatch.0.0)
Accept-Encoding: gzip, deflate
Host: translate.googleapis.com
Connection: Keep-Alive

其得到的结果是：

_callbacks_._0g3mb650r({'sl':{'auto':'检测语言','sq':'阿尔巴尼亚语','ar':'阿拉伯语','ga':'爱尔兰语','et':'爱沙尼亚语','be':'白俄罗斯语','bg':'保加利亚语','is':'冰岛语','pl':'波兰语','fa':'波斯语','af':'布尔文(南非荷兰语)','da':'丹麦语','de':'德语','ru':'俄语','fr':'法语','tl':'菲律宾语','fi':'芬兰语','ko':'韩语','nl':'荷兰语','gl':'加利西亚语','ca':'加泰罗尼亚语','cs':'捷克语','hr':'克罗地亚语','lv':'拉脱维亚语','lt':'立陶宛语','ro':'罗马尼亚语','mt':'马耳他语','ms':'马来语','mk':'马其顿语','no':'挪威语','pt':'葡萄牙语','ja':'日语','sv':'瑞典语','sr':'塞尔维亚语','sk':'斯洛伐克语','sl':'斯洛文尼亚语','sw':'斯瓦希里语','th':'泰语','tr':'土耳其语','cy':'威尔士语','uk':'乌克兰语','es':'西班牙语','iw':'希伯来语','el':'希腊语','hu':'匈牙利语','it':'意大利语','yi':'意第绪语','hi':'印地语','id':'印尼语','en':'英语','vi':'越南语','zh-CN':'中文'},'tl':{'sq':'阿尔巴尼亚语','ar':'阿拉伯语','ga':'爱尔兰语','et':'爱沙尼亚语','be':'白俄罗斯语','bg':'保加利亚语','is':'冰岛语','pl':'波兰语','fa':'波斯语','af':'布尔文(南非荷兰语)','da':'丹麦语','de':'德语','ru':'俄语','fr':'法语','tl':'菲律宾语','fi':'芬兰语','ko':'韩语','nl':'荷兰语','gl':'加利西亚语','ca':'加泰罗尼亚语','cs':'捷克语','hr':'克罗地亚语','lv':'拉脱维亚语','lt':'立陶宛语','ro':'罗马尼亚语','mt':'马耳他语','ms':'马来语','mk':'马其顿语','no':'挪威语','pt':'葡萄牙语','ja':'日语','sv':'瑞典语','sr':'塞尔维亚语','sk':'斯洛伐克语','sl':'斯洛文尼亚语','sw':'斯瓦希里语','th':'泰语','tr':'土耳其语','cy':'威尔士语','uk':'乌克兰语','es':'西班牙语','iw':'希伯来语','el':'希腊语','hu':'匈牙利语','it':'意大利语','yi':'意第绪语','hi':'印地语','id':'印尼语','en':'英语','vi':'越南语','zh-TW':'中文(繁体)','zh-CN':'中文(简体)'}})

而其中标红的部分，便是tl（我猜测是Target Language的意思）所对应的JSON格式，我们可以使用以下代码来获取所有的语言信息：

private static Dictionary<string, string> GetLanguages()
{
    var url =
        "http://translate.googleapis.com" +
        "/translate_a/l?client=te&hl=zh-CN&cb=_callbacks_._0g3mb650r";

    var webClient = new WebClient();
    var script = webClient.DownloadString(url);

    var json = Regex.Match(script, @"'tl':({.+})}\)").Groups[1].Value;
    var serializer = new JavaScriptSerializer();
    return serializer.Deserialize<Dictionary<string, string>>(json);
}

进行翻译

点击页面上的下拉列表可以进行翻译。例如我们选择“英语”之后，Fiddler便会捕获到一个POST请求：

POST /translate_a/t?client=te&format=html&v=1.0 HTTP/1.1
Accept: */*
Accept-Language: zh-CN
Referer: http://translate.googleapis.com/translate_static/js/element/hrs.swf
x-flash-version: 10,0,32,18
Content-Type: application/x-www-form-urlencoded
Google-Translate-Referer: http://localhost:46714/translate.html
Content-Length: 58
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0; SLCC1; .NET CLR 2.0.50727; .NET CLR 3.0.30729; .NET CLR 3.5.30729; .NET4.0C; .NET4.0E; OfficeLiveConnector.1.3; OfficeLivePatch.0.0)
Host: translate.googleapis.com
Connection: Keep-Alive
Pragma: no-cache

q=%E5%9C%A3%E8%AF%9E%E5%BF%AB%E4%B9%90&sl=zh-CN&tl=en&tc=1

可以看到，需要翻译的文字将作为q被传输到服务器端。这个请求会得到翻译后的结果：

"Merry Christmas"

于是代码也就很容易写出了：

private static string Translate(string source, string sl, string tl)
{
    var url =
        "https://translate.googleapis.com" +
        "/translate_a/t?client=te&format=html&v=1.0";

    var data = String.Format(
        "q={0}&sl={1}&tl={2}&tc=1",
        HttpUtility.UrlEncode(source), sl, tl);

    var webClient = new WebClient();
    webClient.Encoding = Encoding.UTF8;
    webClient.Headers.Add(
        HttpRequestHeader.UserAgent,
        "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0;)");

    var json = webClient.UploadString(url, data);
    var serializer = new JavaScriptSerializer();
    return serializer.Deserialize<string>(json);
}

在试验过程中，您可以使用Fiddler的Request Builder功能来发起一些测试请求，这样便可以得知怎么样的Header信息可以获得正确的结果。例如在这里，我发现如果不添加User Agent信息，Google Translate便会返回一些非常奇怪的内容。

组合

既然有了以上两个方法，输出翻译结果也再简单不过了：

var languages = GetLanguages();

var targetLanguages = languages.Select(
    p => String.Format(
        "{0}: {1}",
        p.Value,
        Translate("圣诞快乐", "zh-CN", p.Key)));

File.WriteAllLines("output.txt", targetLanguages.ToArray());

由于语言非常古怪，因此无法在Console上输出，我只能将其直接写到UTF-8的文件中去——最后的结果还是相当有趣的。

完整代码

五十种语言的“圣诞快乐”（上）：分析与实现
五十种语言的“圣诞快乐”（下）：F#实现

数十行F#打造简易Comet聊天服务

jeffz@live.com (老赵) — Fri, 11 Dec 2009 04:00:00 GMT

普通的Web应用程序，都是靠大量HTTP短连接维持的。如实现一个聊天服务时，客户端会不断轮询服务器端索要新消息。这种做法的优势在于简单有效，因此广为目前的聊天服务所采用。不过Comet技术与之不同，简单地说，Comet便是指服务器推（Server-Push）技术。它的实现方式是（这里只讨论基于浏览器的Web平台）在浏览器与服务器之间建立一个长连接，待获得消息之后立即返回。否则持续等待，直至超时。客户端得到消息或超时之后，又会立即建立另一个长连接。Comet技术的最大优势，自然就是很高的即使性。

如果要在ASP.NET平台上实现Comet技术，那么自然需要在服务器端使用异步请求处理。如果是普通处理方式的话，每个请求都会占用一个工作线程，要知道Comet是“长连接”，因此不需要多少客户端便会占用大量的线程，这对资源消耗是巨大的。如果是异步请求的话，虽然客户端和服务器端之间一直保持着连接，但是客户端在等待消息的时候是不占用线程的，直到“超时”或“消息到达”时才继续执行。

以前也有人实现过基于ASP.NET的Comet服务原型，不过是使用C#的。而现在我们用F#来实现这个功能。您会发现F#对于此类异步场景有其独特的优势。

F#常用的工作单元是“模块”，其中定义了大量函数或字段。例如我们要打造一个聊天服务的话，我便定义了一个Chat模块：

#light

module internal Comet.Chating.Chat

open System
open System.Collections.Concurrent

type ChatMsg = {
    From: string;
    Text: string;
}

let private agentCache = new ConcurrentDictionary<string, MailboxProcessor<ChatMsg>>()

let private agentFactory = new Func<string, MailboxProcessor<ChatMsg>>(fun _ -> 
    MailboxProcessor.Start(fun o -> async { o |> ignore }))

let private GetAgent name = agentCache.GetOrAdd(name, agentFactory)

在这里我构建了一个名为ChatMsg的Record类型，一个ChatMsg对象便是一条消息。然后，我使用一个名为agentCache的ConcurrentDictionary对象来保存每个用户所对应的聊天队列——MailboxProcessor。它是F#核心库中内置的，用于实现消息传递式并发的组件，非常轻量级，因此我为每个用户分配一个也只使用很少的资源。GetAgent函数的作用是根据用户的名称获取对应的MailboxProcessor对象，自不必多说。

Chat模块中还定义了send和receive两个公开方法，如下：

let send fromName toName msg = 
    let agent = GetAgent toName
    { From = fromName; Text = msg; } |> agent.Post

let receive name = 
    let rec receive' (agent: MailboxProcessor<ChatMsg>) messages = 
        async {
            let! msg = agent.TryReceive 0
            match msg with
            | None -> return messages
            | Some s -> return! receive' agent (s :: messages)
        }

    let agent = GetAgent name

    async {
        let! messages = receive' agent List.empty
        if (not messages.IsEmpty) then return messages
        else
            let! msg = agent.TryReceive 3000
            match msg with
            | None -> return []
            | Some s -> return [s]
    }

send方法接受3个参数，没有返回值，它的实现只是简单地构造一个ChatMsg对象，并塞入对应的MailboxProcessor。不过receive方法是这里最关键的部分（没有之一）。receive函数的作用是接受并返回MailboxProcessor中已有的对象，或者等待3秒钟后超时——这么说其实不太妥当，因为receive方法其实只是构造了一个“做这件事情”的Async Workflow，而还没有真正执行它。至于它是如何执行的，我们稍候再谈。

receive函数的逻辑是这样的：首先我们构造一个辅助函数receive’来“尝试获取”队列中已有的所有消息。receive’是一个递归函数，每次获取一个，并递归获取剩余的消息。agent.TryReceive函数接受0，表示查询队列，并立即返回一个Option<ChatMsg>结果，如果这个结果为None，则表示队列已为空。于是在receive这个主函数中，便先使用receive’函数获取已有消息，如果存在则立即返回，否则便接收3秒钟内获得的第一个消息，如果3秒结束还没有收到则返回None。

在receive和receive’函数中都使用了let!获取agent.TryReceive函数的结果。let!是F#中构造Workflow的关键字，它起到了“语法糖”的作用。例如，以下的Async Workflow：

async {
    let req = WebRequest.Create("http://www.cnblogs.com/")
    let! resp = req.GetResponseAsync()
    let stream = resp.GetResponseStream()
    let reader = new StreamReader(stream)
    let! html = reader.ReadToEndAsync()
    html
}

事实上在“解糖”后就变成了：

async.Delay(fun () ->
    async.Let(WebRequest.Create("http://www.cnblogs.com/"), (fun req ->
        async.Bind(req.GetResponseAsync(), (fun resp ->
            async.Let(resp.GetResponseStream(), (fun stream ->
                async.Let(new StreamReader(stream), (fun reader ->
                    async.Bind(reader.ReadToEndAsync(), (fun html ->
                        async.Return(html))))))))))

let!关键字则会转化为Bind函数调用，Bind调用有两个参数，第一个参数为Async<’a>类型，它便负责一个“回调”，待回调后才执行一个匿名函数——也就是Bind函数的第二个参数。可见，let!关键字的一个重要作用，便是将流程的“控制权”转交给“系统”，待合适的时候再继续执行下去。这便是关键，因为这样的话，在接受一个消息的时候，这等待的3秒钟是不占用任何线程的，也就是真正的纯异步。但是如果观察代码——难道不是纯粹的顺序型写法吗？

这就是F#的神奇之处。

在ASP.NET处理时需要Handler，于是在Send阶段便是简单的IHttpHandler：

#light

namespace Comet.Chating

open Comet
open System
open System.Web

type SendHandler() =

    interface IHttpHandler with
        member h.IsReusable = false
        member h.ProcessRequest(context) = 
            let fromName = context.Request.Form.Item("from");
            let toName = context.Request.Form.Item("to")
            let msg = context.Request.Form.Item("msg")
            Chat.send fromName toName msg
            context.Response.Write "sent"

而Receive阶段则是个异步的IHttpAsyncHandler：

#light

namespace Comet.Chating

open Comet
open System
open System.Collections.Generic
open System.Web
open System.Web.Script.Serialization

type ReceiveHandler() =

    let mutable m_context = null
    let mutable m_endReceive = null

    interface IHttpAsyncHandler with
        member h.IsReusable = false
        member h.ProcessRequest(context) = failwith "not supported"

        member h.BeginProcessRequest(c, cb, state) =
            m_context <- c

            let name = c.Request.QueryString.Item("name")
            let receive = Chat.receive name
            let beginReceive, e, _ = Async.AsBeginEnd receive
            m_endReceive <- new Func<_, _>(e)

            beginWork (cb, state)

        member h.EndProcessRequest(ar) =
            let convert (m: Chat.ChatMsg) =
                let o = new Dictionary<_, _>();
                o.Add("from", m.From)
                o.Add("text", m.Text)
                o

            let result = m_endReceive.Invoke ar
            let serializer = new JavaScriptSerializer()
            result
            |> List.map convert
            |> serializer.Serialize
            |> m_context.Response.Write

这里的关键是Async.AsBeginEnd函数，它将Chat.receive函数生成的Async Workflow转化成一组标准APM形式的begin/end对，然后我们只要把BeginProcessRequest和EndProcessReqeust的职责直接交给即可。剩下的，便是一些序列化成JSON的工作了。

于是我们可以新建一个Web项目，引用F#工程，在Web.config里配置两个Handler，再准备一个Chat.aspx页面即可。您可以在文末的链接中查看该页面的代码，也可以在这里试用其效果。作为演示页面，您其实只能“自己给自己”发送消息，其主要目的是查看其响应时间而已。例如，以下便是使用效果一例：

2 - receiving...
3026 - received nothing (3024ms)
3026 - receiving...
6055 - received nothing (3028ms)
6055 - receiving...
7256 - sending 123654...
7268 - received: 123654 (1213ms)
7268 - receiving...
10281 - received nothing (3013ms)
10281 - receiving...
13298 - received nothing (3017ms)
13298 - receiving...
13679 - sending 123456...
13698 - received: 123456 (400ms)
13698 - receiving...
16716 - received nothing (3018ms)
16716 - receiving...
18256 - sending hello world...
18265 - received: hello world (1549ms)
18266 - receiving...
21281 - received nothing (3015ms)
21281 - receiving...

可见，如果没有收到消息，那么receive操作会在3秒钟后返回。当send一条消息后，先前的receive操作便会立即获得消息了，即无需等待3秒便可提前返回。这便是Comet的效果。

至于性能，我写了一个客户端小程序，用于模拟大量用户同时聊天，每个用户每隔1秒便给另外5个用户发送一条消息，然后查看这条消息收到时产生多少的延迟。经过本机测试（2.4GHz双核，2G内存），当超过2K个在线用户时（即2000个长连接）延迟便超过了1秒——到20K还差不多。这个性能其实并不理想。不过，我这个测试也很一般。因为测试环境相当马虎，大量程序（如N个VS）基本上已经完全用满了所有的物理内存，测试客户端和服务器也是同一台机器，甚至代码也是Debug编译的……而根据监视，测试用的客户端小程序CPU占用超过50%，而服务器进程对应的w3wp.exe的CPU占用却小于10%。因此，我们可以这样推断，其实服务器端的性能并没有用足，也有可能是MailboxProcessor的调度方式不甚理想。至于具体是什么原因，我还在调查之中。

最后我想说的是，这个Comet实现只是一个原型，我最想说明的问题其实是F#在异步编程中的优势。目前我写的一些程序，例如一些网络爬虫，都已经使用F#进行开发了，因为它的Async Workflow实在是过于好用，为我省了太多力气。同时我还想证明，“语言特性”并非不重要，它对于编程的简化也是至关重要的。在我看来，“类库”也好，“框架”也罢都是可以补充的，但是语言特性是个无法突破的“限制”。例如，异步编程对于F#来说简化了不少，这是因为我们可以使用顺序的方式编写异步程序。在C#中略有不足，但还有yield可以起到相当作用，因此我们可以使用CCR和AsyncEnumerator简化异步操作。但如果您使用的是Java这种劣质语言……因此，放弃Java，使用Scala吧。

值得一提的是，Async Workflow并不是F#的语言特性，F#的语言特性是Workflow，而Async Workflow其实只是实现了一个Workflow Builder，也就是那个async { ... }，以此来简化异步编程而已。PDC 09上关于F#对异步编程的支持也有相应的介绍。

本文代码

再谈Attribute性能优化方式：使用CCI Metadata

jeffz@live.com (老赵) — Fri, 20 Nov 2009 02:47:00 GMT

Attribute使用了反射，密集调用时会带来较大开销，因此我们上次提出了一些优化方式，这样就不会产生性能方面的问题了。这个优化方式的关键，主要是使用直接获得构造Attribute的元数据，然后自定义它们的生成方式并缓存，这样就避免了每次获取元数据及反射构造Attribute的开销。我从一开始就抱有这个优化的“思路”，但是上篇文章中最终的做法是受到了heros同学的提示才得出的，因为我一开始还根本不知道CustomAttributeData这个已然内置的类库。我当时在探索的方向是使用CCI Metadata读取程序集中与Attribute相关的元数据。

我们知道，Attribute的数据是在编译期就确定的，它虽然涉及到构造函数，涉及到属性赋值，但是无论是构造函数的参数还是属性的值，都是在编译期已然确定的——例如常量，例如typeof。代码在编译成程序集之后，这些数据就存放在程序集的元数据中，我们可以直接通过既定的格式“读取”而不用“加载”到程序中。

那么谁会去读取它呢？需要的程序就会去读，例如：编译器。编译器在编译一段代码时，需要了解代码引用了哪些程序集，是否使用了程序集中正确的成员。被引用的程序集可能很多又很大，因此不可能“加载”进来再来判断，因此它读取的其实便是程序集的“元数据”。还是以Attribute打个比方，如果我的代码使用了某个Attribute，那么编译器便会通过“元数据”去查看这个Attribute的AttributeUsageAttribute标记，检查它的AllowMultiple属性，以此判断我的用法是否正确。其他一些使用场景还包括程序集的静态检查工具等等，例如著名的FxCop。那么FxCop是如何读取程序集元数据的呢？它便使用了CCI相关组件。

CCI（Common Compiler Infrastructure）相关组件有两个：CCI Metadata和CCI Code and AST。这两个组件由微软研究院构建，现在都已经在CodePlex上开源。CCI Metadata的作用是用于读取和写入CLR程序集和pdb文件。它的作用和System.Reflection和System.Reflection.Emit有些类似，但它们最关键的一点不同是CCI Metadata直接读取“文件”，而System.Reflection需要“加载”。与CCI Code and AST组件功能相对应的就类似于System.CodeDom了，它会将一个程序集和pdb文件读取成层级化的，树状的对象结构。当然，它也不用加载程序集。从理论上说，CCI的这两个组件构成了.NET Reflector的基础功能。换句话说，你有需要像.NET Reflector那样读取程序集的原数据和IL代码，甚至要去简单了解IL的含义吗？那么可以参考CCI的这两个组件。

不过，微软似乎从来没有想过要发布这两个组件，毕竟太小众了，而且一旦发布压力就大了，例如要在升级前后保证API的兼容性等等。从它们的源代码来，至今还在不断修改（这星期还都有check in）。不过它们也不是没有稳定的发布，它便是CCI Samples项目，我们可以下载那个80几兆的压缩包，其中包括了所有的源代码、构建信息，文档和开发工具（如xUnit）——还有多余svn的托管数据（删除这些数据后其实只有不到40兆，真是浪费）。在下载了代码之后，便可以打开其中的解决方案（其中高亮的GeneralXp项目是我自己的试验项目，本不包含在解决方案中）：

Metadata目录中包含的便是CCI Metadata项目，而直接放在解决方案中的便是CCI Code and AST了。在这里，我们并不关心具体的Code和AST，因为我们只需要知道Attribute的数据，属于元数据，因此我们只需要使用CCI Metadata。

假设我们需要获取的是这样的Attribute信息：

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class TestAttribute : Attribute
{
    public TestAttribute(string s)
    {
        Console.WriteLine(s);
    }

    public TestAttribute(Type type)
    {
        Console.WriteLine(type);
    }
}

[Test(typeof(string))]
[Test("Hello World")]
public class SomeClass { }

首先，我们需要创建一个HostEnvironment：

internal class HostEnvironment : MetadataReaderHost
{
    private PeReader peReader;

    internal HostEnvironment()
        : base(new NameTable(), 4)
    {
        this.peReader = new PeReader(this);
    }

    public override IUnit LoadUnitFrom(string location)
    {
        var document = BinaryDocument.GetBinaryDocumentForFile(location, this);
        var unit = this.peReader.OpenModule(document);
        this.RegisterAsLatest(unit);
        return unit;
    }
}

然后，便可以用它来获得构建Attribute对象的工厂委托：

static void Main(string[] args)
{
    var type = typeof(SomeClass);
    var attrType = typeof(TestAttribute);

    // 打开SomeClass所在程序集
    HostEnvironment host = new HostEnvironment();
    var assemblyFile = type.Assembly.Location;
    var assembly = host.LoadUnitFrom(assemblyFile) as IAssembly;

    // 找到SomeClass的原数据
    var typeDef = assembly.GetAllTypes().Single(
        t => TypeHelper.GetTypeName(t) == type.FullName);

    // 获得TestAttribute元数据
    var attrDefs = typeDef.Attributes.Where(
        t => TypeHelper.GetTypeName(t.Type) == attrType.FullName);

    // 构建工厂委托
    var factories = attrDefs.Select(a => GetAttributeFactory(a)).ToList();
    factories.ForEach(f => f());

    Console.WriteLine("press enter to continue...");
    Console.ReadLine();
}

static Func<Attribute> GetAttributeFactory(ICustomAttribute attrDef)
{
    var type = Type.GetType(TypeHelper.GetTypeName(attrDef.Type));
    var args = attrDef.Arguments.Select(a => GetArgumentValue(a)).ToArray();

    return () => (Attribute)Activator.CreateInstance(type, args);
}

static object GetArgumentValue(IMetadataExpression expression)
{
    // 如果这个参数是常量
    var constant = expression as IMetadataConstant;
    if (constant != null) return constant.Value;

    // 如果这个参数是typeof
    var typeGet = expression as IMetadataTypeOf;
    if (typeGet != null)
    {
        return Type.GetType(TypeHelper.GetTypeName(typeGet.TypeToGet));
    }

    throw new NotSupportedException();
}

这段代码是可以工作的（不过还不支持对Attribute参数的设置）。但是，如果您想要我解释API的使用方式或者更具体的细节，我也说不出，而且要不是MetadataHelper中的那些辅助函数（如TypeHelper类），我根本也无法在短时间内写出这段代码。

由于CCI并不会加载程序集，因此所有对的元数据的访问都是陌生的类型，例如使用ITypeReference来表示一个类型，ICustomAttribute表示一个Attribute定义，以及IMetadataExpression来表示一个表达式。由于我现在已经知道了CustomAttributeData这个方便好用的类库，因此也已经没有深入CCI的动力了。如果您感兴趣，也不妨研究并分享一下。这方面的内容似乎全世界范围内都很少见。

嗯，没错，您一定发现了，这篇文章其实只是记录了一个花絮。

二十行C#代码打造Ruby Markup Builder

jeffz@live.com (老赵) — Mon, 26 Oct 2009 16:47:00 GMT

从.NET诞生之日起就有了XML类库，但是从使用上来说非常不方便。例如我们需要构造一个XML文档时，使用DOM API就要这样搞：

var xmlDoc = new XmlDocument();
var rootEle = xmlDoc.CreateElement("persons");
xmlDoc.AppendChild(rootEle);

var person1 = xmlDoc.CreateElement("person");
person1.InnerText = "Tom";
var person1Age = xmlDoc.CreateAttribute("age");
person1Age.Value = "10";
person1.Attributes.Append(person1Age);
rootEle.AppendChild(person1);

var person2 = xmlDoc.CreateElement("person");
person2.InnerText = "Jerry";
var person2Age = xmlDoc.CreateAttribute("age");
person2Age.Value = "8";
person2.Attributes.Append(person2Age);
rootEle.AppendChild(person2);

别看这么多行代码，但实际上它只构造了这么简单的一个XML：

<persons>
  <person age="10">Tom</person>
  <person age="8">Jerry</person>
</persons>

我承认，DOM API的确非常严谨（如XmlDocument和XmlElement的归属关系），非常符合定义，也非常的面向对象，但是这易用性也实在太差了。记得在03还是04年的时候，我为在为项目做一个编辑XML文档的WinForm应用程序，当时也不像现在那么容易想到“偷懒”的法门，而VS 2003也不像VS 2005/2008那么好用，因此可谓做的劳心费神。这个情况在.NET 2.0中也没有得到改变，直到有一天，LINQ to XML随.NET 3.5横空出世，于是乎XML的生活一下子变得美好了很多。例如上面的功能只需寥寥数行便可以实现：

var xmlDoc = new XElement("persons",
    new XElement("person",
        "Tom",
        new XAttribute("age", 10)),
    new XElement("person",
        "Jerry",
        new XAttribute("age", 8)));

虽然LINQ to XML一直是所谓C# 3.0中LINQ特性的一部分，与LINQ to SQL，LINQ to Object及LINQ to……某个别的并列，但我始终认为LINQ to XML实则还是LINQ to Object的一种特殊形式，只是它用于操作XML而已。它的一切都是System.Xml.Linq命名空间下相关类库（如XElement）在起作用，不关LINQ什么事情。XElement等相关类型大大简化了我们的开发，与DOM API相比，无论是XML的构造还是读取都容易了许多。不过俗话说得好：“不怕不识货，就怕货比货”，这样的API与Ruby Markup Builder相比还是有明显差距。请看：

builder = Builder::XmlMarkup.new
xml = builder.persons { |b|
    b.person("Tom", :age => "10")
    b.person("Jerry", :age => "8")
}

请看上面这段代码，它自然没有使用Ruby语言的标准着色方式。我着色的目的是体现这个构造方式中的“噪音”——也就是与XML内容无关的部分。从中可以发现，Ruby不愧是一种噪音较少的语言，如果您尝试使用这个方式来观察C#中LINQ to XML的做法，就会发现两者之间的确有明显的差距。当然，如果使用VB.NET的XML Literal可能噪音也很少，但是在我看来，XML Literal在XML构造方面的表现有些罗嗦，例如它需要开发人员同时提供元素的开始标签和闭合标签，可能在IDE的帮助下此类代码输入较为简单，但是代码还是略显冗余。

但是我们这些可怜的C#程序员难道只有在一边眼馋的份吗？不见得，我们也可以来“享受”一把：

dynamic b = new XmlMarkupBuilder();
XElement xml =
    b.persons(
        b.person("Tom", age: 10),
        b.person("Jerry", age: 8));

哇，这是什么，怎么代码那么简单。很明显，从dynamic关键字上可以看出，这是C# 4.0中新增的功能。您可能会想“原来.NET 4.0对XML又有增强了”……其实并非如此，这是我们自己扩展的功能。不过这应该算是更好的消息，因为这说明我们已经有能力自行扩展，自行设计这样的API了——这可是“渔”，比“鱼”可要值钱多了。而实现这样的功能也只需要短短二十几行C#代码：

public class XmlMarkupBuilder : DynamicObject
{
    public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
    {
        XElement xml = new XElement(binder.Name);

        var attrCount = binder.CallInfo.ArgumentNames.Count;
        var elementCount = args.Length - attrCount;

        for (int i = 0; i < elementCount; i++)
        {
            xml.Add(args[i]);
        }

        for (var i = 0; i < attrCount; i++)
        {
            var attrName = binder.CallInfo.ArgumentNames[i];
            if (attrName[0] == '@') attrName = attrName.Substring(1);

            xml.Add(new XAttribute(attrName, args[i + elementCount]));
        }

        result = xml;
        return true;
    }
}

DynamicObject是个特殊的对象，简单地说它的行为可以被“扩展”——是如动态语言般真正的扩展，而非静态的多态。当我们使用dynamic修饰变量后，在它之上的方法调用会由编译器和DLR配合出不一样的行为。例如，我们在调用一个方法的时候，DLR会先检查这个动态对象上是否存在符合这个签名的方法，存在则最好，否则便会调用TryInvokeMember来“执行”一个动态方法，而它的参数便是此次调用的全部信息。这样的做法被称为“Method Missing”操作，事实上Ruby Markup Builder也是使用Ruby对象中的这个特性来实现“调用什么方法，便生成什么元素”的功能。此外，我们还可以这么用：

var persons = new [] { new Person("Tom", 10), new Person("Jerry", 8) };
XElement xml2 = 
    b.persons(
        from p in persons
        select b.person(p.Name, age: p.Age));

XmlMarkupBuilder对LINQ的直接支持得益于XElement无与伦比的“包容性”（因此我认为LINQ to XML其实只是LINQ to Object + 类库）。至于age: 10这样的代码，其实是使用了C# 4.0的新特性：命名参数（Named Parameters）——C#还真把什么都为我们准备好了。

即便是大部分DynamicObject的示例都喜欢拿XML操作开涮（但还是没有出现我这篇的用法，所以我还是“原创”），但事实上这个功能可发挥的余地非常之大。例如，陈猫同学提到他想用这个功能来简化Silverlight中的JSON操作，刚“喜得贵女”的Phil Haack同学在上个月也提到一个设想，它在ASP.NET MVC中使用dynamic关键字来修饰View的Model，这样在访问Model的属性时变可附加一些约定好的操作。例如，Model.Content表示读取Content属性的内容，而Model._Content则表示在读取Content之后自动进行HTML编码。这无疑简化了我们的开发——当然，强类型的各种优势就不复存在了。

而这个功能对我的意义在于，我又找到了一种设计API的方式，它可以使类库变得简单好用——就好比上面的XmlMarkupBuilder一样。虽然，这个示例的功能非常简单，但是这也足以证明C# 4.0中的dynamic特性并不仅仅是“方便Interop操作”或是“简化反射”这么简单，如果我们可以发挥想象能力，加以充分利用同时又不滥用，我们的程序开发生活就会变得越来越美好。

最后……我还是承认了吧，这篇文章其实是标题党，真正Ruby Markup Builder功能非常强大而复杂，我们的XmlMarkupBuilder类只能算是冰山一角而已。

尝试使用IKVM运行Lucene 2.9.0版

jeffz@live.com (老赵) — Fri, 09 Oct 2009 07:26:00 GMT

上月末Lucene发布了2.9.0版，这个版本的改进比较明显，主要是各方面性能的增强，以及对数字字段范围查询的直接支持。这个版本还有个重要的意义，就是它标记了Lucene 3在API上的改变，及早跟进的话对Lucene 3的未来接受程度会比较好。Lucene的更新很慢，而移植到.NET平台上的Lucene.NET的二进制发布则更是一直停留在07年三月的2.0版本。虽然我们可以通过svn获取到Lucene.Net 2.3.2的源代码自行编译，但这次我还是想直接使用最新的2.9.0版本。

至于如何在.NET平台上调用Java代码，我想过各种方式，例如我最初设想使用Java => JNI => C++/CLI => C#的“曲线救国”方式，也考虑过最保险的借助HTTP做Proxy的方式。不过最后在RednaxelaFX的建议下，我决定趁这个机会尝试一下IKVM.NET（下文称为IKVM）。IKVM的目的是在.NET平台（包括mono）上实现一个Java执行环境（也就是JVM），它可以将jar包直接运行在.NET平台上，将Java语言的源文件编译为.NET的程序集，而现在我们使用它的另一个功能，直接把Lucene 2.9.0的二进制jar包转化为.NET下的dll。

IKVM在我博客的侧边栏上停留了很久，不过我一直认为它还不太成熟于是没有怎么去接触。现在从Case Studies上来看，IKVM的可用性似乎还是有一定保障的。IKVM目前实现了JDK 1.6，也可谓紧跟Java脚步。对于这种转化，首先要看中的应该是“正确性”，对于纯粹内存中的对象来说，我猜想应该不会有什么正确性方面的问题。而IO操作就相对值得斟酌了，例如对于文件锁的处理，对于数据流的读写，即使差1个字节可能也会造成大问题。不过，就我初步使用下来的感受，效果比想象中要好很多。在我测试的场景下，使用IKVM Lucene和Java Lucene的索引可以互相读写，没有发生任何问题。当然，这还需要更进一步的测试，这也是我写这篇文章的目的。

在保证了正确性之后，要关注的便是性能了。根据我的推测，由于IKVM需要在Java生成的.NET程序集和BCL之间加上一层Runtime和JDK，因此其性能几乎一定会比Java原有的程序要差。不过，对于Lucene这种项目来说，算法才是性能的关键。例如，有人测试Lucene 2.9.0在某些情况下会比2.4有15倍左右的性能提升。不过由于没有很好的测试数据和场景，目前我只进行了最最简单的，不涉及磁盘IO的性能比较。

性能比较的场景很简单，我准备了《神雕侠侣》全文作为索引数据，2兆多的文本文件，反复使用StandardAnalyzer向RAMDirectory中添加索引，并在以下四种环境下统计索引100遍所消耗的时间（统计时都会对JIT进行“预热”）。

在.NET平台下使用Lucene.Net 2.3.2（需获取源代码自行编译）。
在.NET平台下使用IKVM运行Lucene 2.9.0。
在Java平台下使用默认的Client VM运行Lucene 2.9.0。
在Java平台下使用Server VM（加-server参数）运行Lucene 2.9.0。

我将所有的测试数据、类库、源文件都打包了，感兴趣的朋友可以下载以后查看。压缩包内的DotNet和Java目录中有着相似的内容：

lib目录：保存所需的类库（dll或jar文件）
src目录：保存测试用源代码（cs或java文件）
build.bat：调用csc或javac编译src下的源文件，将结果输出至bin目录
clean.bat：清除编译结果（即删除build文件）
run.bat：运行测试程序

在执行build.bat文件的时候，需要保证PATH中包含了正确的目录，可以访问到csc或者javac。在使用run.bat运行测试程序时，也可以添加参数进入不同的分支。例如对.NET的测试中：

...\DotNet> build

...
...

...\DotNet> :: 测试Lucene.Net 2.3.2
...\DotNet> run

...
...

...\DotNet> :: 测试IKVM Lucene 2.9.0
...\DotNet> run -ikvm

...

而在Java的测试中：

...\Java> build

...
...

...\Java> :: Client VM
...\Java> run

...
...

...\Java> :: Server VM
...\Java> run -server

...

在我的笔记本上（Windows 7，双核2.0 Ghz CPU，2G RAM），执行结果如下：

以上图表展示的是每种环境下各执行3次的平均耗时。可见，性能从高到低依次如下：

Java Server VM + Lucene 2.9.0
.NET + Lucene.Net 2.3.2
Java Client VM + Lucene 2.9.0
.NET + IKVM + Lucene 2.9.0

从结果上看，Java Server VM的表现最好，而且领先幅度较大，相对于IKVM有35%左右的性能优势。不过这个结果让我非常满意，因为在我看来，这完全处在一个可以接受的范围之内，绝大部分系统根本不会在乎这点性能差距。Java平台的优势是类库数量，如果IKVM可以仅靠这点性能损失换来.NET对Java类库的使用能力，天下没有更合算的事情了。

不过让我更加感兴趣的是Java Server VM + Lucene 2.9.0和.NET + Lucene .Net 2.3.2的比较结果，我承认这个差距让我始料未及，因为就我过去的经验，相同的.NET和Java应用程序，.NET的性能会领先Java。在简单思考过后，我猜想有以下的几点可能：

Lucene 2.9.0的算法本身比Lucene 2.3.2效率高。
JVM的Memory Consistency Model比CLR来的宽松，因而高效。
JVM的JIT优化比CLR做的好。

据HotSpot的白皮书称，Server VM与Client VM的除了Heap大小，GC等参数方面不同以外，最大的区别在于Server的JIT会尝试更多的优化手段，这会导致较多的启动时间，以此换来更好的执行效率：

The Client VM compiler does not try to execute many of the more complex optimizations performed by the compiler in the Server VM, but in exchange, it requires less time to analyze and compile a piece of code. This means the Client VM can start up faster and requires a smaller memory footprint.
The Server VM contains an advanced adaptive compiler that supports many of the same types of optimizations performed by optimizing C++ compilers, as well as some optimizations that cannot be done by traditional compilers, such as aggressive inlining across virtual method invocations. This is a competitive and performance advantage over static compilers. Adaptive optimization technology is very flexible in its approach, and typically outperforms even advanced static analysis and compilation techniques.

而编译器及虚拟机大牛RednaxelaFX在推特上也告诉我：

话说GC方面CLR或许非常先进，但JIT方面就还是HotSpot强（和复杂）一些了。CLR没办法inline虚方法或者接口上的方法的调用，HotSpot却可以……总之这种对比的结果要看你测试的代码的性质

至于具体的情况，RednaxelaFX建议查看HotSpot和CLR在JIT之后的Native Code，这并非我所擅长的东西，于是就希望R大可以给出更详细的结果了。:)

最后，便是本文的目的了：目前的测试缺少实际价值，那么您有兴趣和我一起做一个更接近生产环境的实验吗？或者说，您在生产环境中是如何使用Lucene的呢？

将Windows Live Writer打造为“所见即所得”编辑器

jeffz@live.com (老赵) — Mon, 17 Aug 2009 16:14:00 GMT

前言

Windows Live Writer（下称WLW）是博客写作利器，自从它发布之后，我几乎再也不使用博客园的在线编辑器写博客了。WLW的最大优势之一，便是可以自动获取目标博客的样式，然后让用户在特定的样式环境下编写文章。不过平心而论，WLW的“自动获取样式”功能并不怎么实用，因为在很多时候它都无法正确地获取到适合编辑的样式。这并不是WLW的错，因为不同网页的样式各有不同，我们有时候很难单独“取出”页面的一部分，同时保持着良好的样式——甚至有些样式还会牵涉到JavaScript。事实上，您目前看到的博客样式便无法由WLW自动得到，但是经过一定“手工打造”，我们还是可以在一个良好的样式环境中编写博客的。例如，以下便是我编写博客时的状态：

它和您目前所看到样式是不是几乎一模一样？

事实上，我最近才忽然意识到，我们其实可以将其作为一个“HTML编辑器”，而不是一个“博客编辑器”使用。也就是说，我们可以利用它在特定样式环境下编写HTML内容。由于WLW已经具备了比较常用的功能，且生成出来的HTML代码非常干净，因此它的还是一个比较合适的HTML编辑器。事实上，我正打算以后就用WLW为InfoQ中文站写稿。因此目前这篇文章将会提供一个指南，希望可以帮助您打造一个合适的编辑环境。

补充一点：在这篇文章中，我们会多次提及“所见即所得”编辑方式，它在这里表示了“带有丰富样式”的编辑方式，而不是指最基础的编辑功能。

为InfoQ中文站打造合适的编辑器

首先，您需要下载并安装Windows Live Writer。在进行下一步之前，最好再创建一个博客。因为我并没有在“全新”的环境下进行过尝试，因此严格来说，我无法百分之一百保证全新环境下进行操作不会出现问题。

完成了第一步之后，您可以点此下载一个补丁包，您会发现其中包含两个文件：

InfoQ-Edit.reg注册表文件
BlogTemplates目录

然后，依次进行以下几个步骤：

打开注册表编辑器（regedit.exe），备份HKEY_CURRENT_USER\Software\Microsoft\Windows Live\Writer\Weblogs节点下的内容。
将InfoQ-Edit.reg文件中的内容倒入注册表。
将BlogTemplates目录复制到C:\Users\%your_account%\AppData\Roaming\Windows Live Writer中去（可能会随着您的系统有所不同，请注意AppData可能是隐藏文件夹）。如果已经存在了BlogTemplates目录，直接覆盖即可。

打开Windows Live Writer，您会发现目前处在一个名为“InfoQ中文站”的博客中（如果没有，请在Blogs菜单中选择“InfoQ中文站”），但还是处于普通编辑模式下。现在，请选择View菜单下的Edit using theme选项（或使用Ctrl + F11），稍等片刻（正在下载样式文件），大公告成！如果没有意外的话，效果应该是这样的：

尝试着修改标题和内容吧。自然，您是无法发布文章的，您可以将编辑模式切换至HTML，并将这些HTML复制到线上的编辑器里再发布。

接下来，我们就来进行一些简单分析。希望分析过后，您可以自由地将WLW打造成自己想要的样子——至少可以自定义编辑模板吧。另外，如果您在以上那些操作之后没有得到预期效果，也可以检查一下到底出了什么问题。

注册表信息

很明显，WLW是由注册表配合文件进行定制的，我们先从注册表这边入手。简单地说，注册表保存了您在WLW中定义的帐户信息。

InfoQ-Edit.reg文件向注册表内倒入多个数据。首先，它在HKCU\Software\Microsoft\Windows Live\Writer\Weblogs节点下定义了一个名为DefaultWeblog的字符串值，其中包含了默认帐户的GUID。默认帐户即您打开WLW之后所在的博客帐户。每个博客帐户都会在Weblogs节点下出现一个新的节点，节点的名称便是这个帐户的GUID。因此，我们下面关注的便是Weblogs节点下的db500b71-6eda-40d1-a6e3-9c196c68225f节点，它便表示了刚导入的“InfoQ中文站”这个帐户。

在这里我们也不会关注这个节点下的太多内容，您可以自行进行分析，大部分的数据我想还是比较容易猜到是什么作用的。因此，现在请将注意力放在EditorTemplate节点中，其中包含三个值：

DisplayWebLayoutWarning：1则表示在切换到“所见即所得”编辑方式时是否出现警告文字。我已经将其设为0，即不进行提示。
EditUsingStyles：1则表示使用“所见即所得”进行编辑，它反映的便是WLW菜单View中Edit using theme的状态。
LastEditView：表示上次关闭博客帐号时所处的状态，如Normal表示“普通编辑方式”，WebLayout则表示“所见即所得”编辑方式。

EditorTemplate节点还包含了子节点，其中包含两个值：

Framed：处于“所见即所得”编辑状态时所使用的模板文件名（目前是Edit.htm）。
Webpage：处于Preview状态时所使用的模板文件名（目前是Preview.htm）。

Framed和Webpage的区别在于，前者可能只提供了一个“编辑区”样式（如第一张图片中，我使用的博客编辑样式），而后者用于预览编辑效果，因此则可能是个完整页面。不过在您刚才安装的补丁中，您会发现Edit.htm和Preview.htm的内容完全相同。所以您会发现，即时是在编辑的时候，我们也可以看到InfoQ页面上几乎完整的内容。

模板内容

在注册表中定义的只是模板的“文件名”，而真正的模板是存放在硬盘上的。没错，就是在C:\Users\%your_account%\AppData\Roaming\Windows Live Writer\BlogTemplates中（可能随着系统有所不同），其中应该已经包含了用博客帐户的GUID为名称的文件夹。进入，您就会发现Edit.htm和Preview.htm两个文件。

这两个文件其实都是普通的文件夹，只不过包含了两个站位符{post-title}和{post-body}，作用不言自明。如之前所说那样，Edit.htm可能只包含了简单的输入区域，因此对于我的博客其中就包含了这样的代码：

<div id="container">
    <div id="wrapper">
        <div id="content">
            <div id="post" class="post">
                <h2>{post-title}</h2>
                <div class="entry">{post-body}</div>
            </div>
        </div>
    </div>
</div>

那么样式呢？与普通网页一样，样式是也是通过模板文件中的<link />节点引入，或直接写在HTML的<style />节点中的。至于引入的CSS文件的位置，可以是远端，也可以是本地。不过如果您选择引入本地的CSS，则需要提供一个绝对路径，例如：

<link rel="stylesheet" type="text/css" href="file:///C:/Users/.../common.css" />

不过在目前的InfoQ的模板中，我在页面上直接引入了在线的CSS。因此，在切换至“所见即所得”编辑模式时可能需要等待一段时间，此时WLW正在下载CSS文件。如果您需要提高访问速度，则不妨将所有的CSS文件下载至本地，再修改Edit.htm中<link />节点中引入的地址即可。

总结

还有什么需要总结的呢？把工具进行合适的定制可以大幅提高我们的工作效率。例如，现在我们可以直接在写文章时看到样式（包括代码，图片浮动等等），而不用发表为“草稿”再去页面上浏览了，对于我这种博客样式的完美主义者非常有帮助。

再说，定制工具难道不也是程序员的乐趣之一吗？

在网页里添加Web Live Messenger对话框

jeffz@live.com (老赵) — Fri, 09 Nov 2007 16:37:00 GMT

Live Messenger对话框

时常在某些朋友的blog中看到一个可供聊天的对话框，它能让正在浏览这个站点的用户进行聊天。不过在我看来，这个功能形同鸡肋——谁会知道哪些人正在浏览，又有哪些人可以聊天呢？不过今天在浏览LoveCherry的blog时发现在左侧边栏里出现了一个可供聊天的Live Messenger对话框，顿时让我产生了兴趣。不过知道这个东东的人似乎还不多，因此只能动用搜索引擎了（在这里想再说一句多余的话，因为我时常会收到一些类似于“ASP.NET AJAX框架哪里可以下载”之类的问题，所以我建议那些朋友一定要养成先搜再问的习惯）。那么我们就先来看看这个东西具体是什么样的吧。

首先，我们可以访问这个页面（http://settings.messenger.live.com/applications/CreateHtml.aspx），从中可以看出微软提供了两种方式供用户使用Live Messenger的Web聊天功能。

提供一个链接（），点击它则会弹出一个页面可供聊天——于是别人就可以通过这个页面与您联系了。值得一提的是，图标也会根据用户当时的状态不同而改变。
提供了一段代码，在页面上直接放入一块较小的区域显示聊天页面。很显然，这是一个iframe。

在进行了简单的试验（使用Web Live Messenger和自己的Live Messenger聊天）之后，发现这个小玩意儿的功能还是比较可圈可点的。

可以选择是否允许匿名用户使用Web Live Messenger（http://settings.messenger.live.com/applications/WebSettings.aspx）。
性能很不错，基本上没有明显延迟，当然这可能和用户本身的网络条件有关。
聊天的体验比想象中高很多，我们可以在Web Live Messenger的界面上发现“最近一条信息收于XXXX年X月X日 XX:XX:XX”以及“XXXX正在输入消息”的字样。此外，我们聊天中使用的特殊字体和表情符号也能正确显示。
我尝试通过Web Live Messenger找出对方的IM帐号，但似乎它对于这点有着很好的保护，这意味着如果用户将Web Live Messenger放在blog上，可以避免因为泄露Email地址而遭受垃圾邮件地攻击。

试验了之后，我决定将其放在我的blog中，不过到底该怎么放呢？

Live Demo

现在访问LoveCherry的blog会发现他已经将Web Live Messenger从边栏撤下了。边栏实在太窄，如果使用一个稍微长一些的Nick就会被顶的很高，而且由于一行能显示的文字太少，用户体验也很差。最后，我使用了“传统”网页内嵌聊天对话框的做法。如果您现在正在浏览我的blog，就会发现页面的右下角出现了一个矩形的Windows Live Messenger的图片，点击它则会显示出一个300*400的Web Live Messenger聊天对话框。如果您觉得这个对话框挡着页面上的内容了，就可以点击对话框左上角的关闭按钮，这样页面上又只剩下了右下角的矩形图片了。同时，我选择了淡入淡出的效果来显示/隐藏Web Live Messenger聊天对话框。这么做的目的只有一个，那就是让用户体验更酷一些。:)

现在大家可以试验一下Web Live Messenger的聊天功能了。不过请大家能够访问http://settings.messenger.live.com/applications/CreateHtml.aspx，在页面中和自己的Live Messenger进行聊天。如果您直接在我的blog上测试Web Live Messenger，我实在会忙不过来。:(

实现

实现并不复杂，我总共用了大约2个小时，其中还包括学习了一些jQuery的功能所花的时间。唉，没想到我居然到现在才第一次使用这个如此了得的JavaScript框架。不得不说，如果您正在寻找一款方便您开发前端应用程序的JavaScript框架，并且希望它足够的小，那么jQuery很可能就是您需要的。与它强大的功能不相称的是迷你的体积。一个经过混淆，还没有Gzip压缩的jQuery脚本文件才26K大小，但是它带给你的便利可以帮您节省大量的工作。

那么我们现在就开始吧，首先，我们需要让Web Live Messenger的聊天对话框能够永远显示在页面的可视范围之内。要实现这个功能，关键还是在于对页面中元素尺寸的计算。请看如下代码：

以上getClientBounds方法通过判断浏览器类型来得到页面显示区域的精确尺寸，而resetLiveMessengerPosition方法根据liveMessengerContainer元素的尺寸重设该容器在浏览器中的位置。这两个方法谈不上“技术”，而更像是一种“经验”，它们都是我属于所收藏的JavaScript代码，如果大家需要的话也可以保留，或者需要时再来我的blog查找（其实我以前也有文章用到过这些方法）。需要注意的是，如果您使用了的是IE浏览器，在某些的页面上可能会需要通过document.documentElement.clientWidth来获得代码（clientHeight也一样），具体原因我正在调查，大家在使用时也请注意这点。

哎？那么resetLiveMessengerPosition方法该在什么时候调用呢？先不着急，我们再来实现Web Live Messenger的显示/隐藏，以及淡入淡出效果——为什么放在一起实现了？因为我们用到了jQuery框架。请看如下代码：

<div id="liveMessengerContainer" style="position:absolute;">
    <div style="border: solid 1px black; width:160;
         height: 39px; cursor:pointer;
         background-image:url(Messenger_Header_bg.gif)"
         id="liveMessengerThumb">
        <img src="Messenger_logo_beta.gif"
             alt="使用Live Messenger联系我"
             style="margin: 10px 10px 0px 9px;"/>
    </div>
    <table border="0" cellpadding="0" cellspacing="0"
           id="liveMessengerPanel">
        <tr>
            <td valign="top">
                <img id="hideLiveMessengerPanel"
                     style="cursor:pointer; margin-right: 3px;"
                     src="Messenger_close_sm.gif" alt="关闭" />
            </td>
            <td>
                <iframe
                    src="..." width="300" frameborder="0"
                    style="border: solid 1px black; width: 300px;
                    height: 400px;"></iframe>
            </td>
        </tr>
    </table>
<div>

<script language="javascript" type="text/javascript">
    $("#liveMessengerPanel").hide();

    $(document).ready(function(){
        $(window).scroll(resetLiveMessengerPosition);
        $(window).resize(resetLiveMessengerPosition);

        resetLiveMessengerPosition();

        $("#liveMessengerThumb").click(function(){
            $("#liveMessengerThumb").fadeOut(500, function(){
                $("#liveMessengerPanel").fadeIn(500, function(){
                    resetLiveMessengerPosition();
                });
                resetLiveMessengerPosition();
            });
        });

        $("#hideLiveMessengerPanel").click(function(){
            $("#liveMessengerPanel").fadeOut(500, function(){
                $("#liveMessengerThumb").fadeIn(500, function(){
                    resetLiveMessengerPosition();
                });
                resetLiveMessengerPosition();
            });
        });
    });
<script>

liveMessengerContainer容器中的内容我就不进行太多解释了。同样略过的还有jQuery的基本使用，不过相信有一定JavaScript基础的朋友也能比较轻松地看懂。以上JavaScript代码的第一句隐藏了聊天对话框，接着在jQuery中经典的$(document).ready事件中对以有的元素进行操作。首先，我们要求在用户移动了滚动条（scroll），或者改变了浏览器大小（resize）时重新设置容器的位置。需要注意的是，我们接着需要显式调用resetLiveMessengerPosition方法来对容器的位置进行初始化。然后jQuery开始展现了它的神奇之处，短短几行代码即完成了淡入淡出的切换功能，让人叹为观止。

至此，在页面中嵌入一个Web Live Messenger的工作就完成了。欢迎大家提出意见和建议，帮助我改进这个功能。

Gadget，又见Gadget - 浅尝Windows Live Contacts Gadget

jeffz@live.com (老赵) — Sun, 08 Oct 2006 08:43:00 GMT

前言

自从Windows Live推出开始，微软就加大了对于开发人员的“笼络”。上到Windows Live Gadgets和Windows Live Search Macro，下到Windows Live Toolbar和Messenger，每个产品纷纷通过某种方式提供API，这似乎已经是Windows Live系列产品的一个mandatory feature。迎合Web 2.0的Mashup理念，将中心转移到用户/开发人员，微软在这点上可谓煞费苦心。

这种做法似乎颇为有效，至少Gadgets在刚出现时将我“一举击溃”，让我“义无反顾”地投身到Gadgets开发队伍中去。不过随着不断地深入，我的热情也渐渐消退。如果说Gadget的一些不足还可以在以后弥补的话（事实上现在的确已经相当不错了），而一些“硬伤”则会很难有所改进。例如，Gadgets都会在一个iframe中执行，这个sandbox提供了强大的安全保证，却也对于Gagdet表现本身做了无比的限制。另外，例如Windows Live Spaces Gadgets取消了set/getPreference功能，也几乎让其存在的价值打了很大的折扣。因此Book List Gadget for Windows Live Spaces（这是我为了弥补中国市场Windows Live Spaces开发的Gadget，使用了Amazon的API）也成为了我以“个人身份”开发的最后一个Gadget。

说得有点远了，收回。近日在Windows Live Dev里发现了一个新的Feature（其实已经出现一个多月了）：Windows Live Contacts Gadget (Beta)，一试之下，颇为有趣。

Windows Live Contacts Gadget可能是一个创举，它能够将Windows Live Account上的联系人信息提供给任意第三方使用。任意第三方的产品可以轻易地结合这些联系人信息进行开发（后面将会看到它与Windows Live Local结合的范例）。要做到这点，从技术上来讲，要解决的问题主要就是Cross Domain Data Transfer。Windows Live Contacts Gadget使用了一个它称之为channel的技术巧妙地解决了这一点，虽然我觉得还不完美。不过现在不讨论太多技术，我也只是做了一个尝试，所以先来看一个Quick Start吧。

Quick Start

要使用Windows Live Contacts很简单，按照一下几步即可：

1、添加channel文件：

将http://dev.live.com/scripts/AddressManager/channel.htm复制到网站的根目录下。例如网站Domain是http://www.jeffzlive.net，则channel文件则是http://www.jeffzlive.net/channel.htm。

2、引入必须的Javascript：

在代码中添加如下的Javascript引用：

<script type="text/javascript" src="http://dev.live.com/scripts/AddressManager/ContactSelectorPartner.js"></script>
<script type="text/javascript" src="http://dev.live.com/scripts/AddressManager/proxy.js"></script>

3、构造一个所需的HTML元素，作为Windows Live Contacts Gadget的容器：

在代码里添加如下的的HTML元素：

<div id="ContactsGadgetSite" style="width:250px;height:350px"></div>
<div id="ContactsDisplay"></div>

第一个元素ContactsGadgetSite是做为Gadget的容器存在的，因此对于它的大小有一定要求，其最小宽度为172px，最小高度为232px。第二个元素ContactsDisplay则是用来显示信息，在这个Quick Start中会使用到。

4、添加调用代码：

在某处添加如下代码，执行这段代码将初始化Windows Live Contacts Gadget：

<script type="text/javascript">
    var CP = new Microsoft.Gadget.ContactSelectorPartner(
        document.getElementById("ContactsGadgetSite"),
        "http://www.jeffzlive.net/privacyStatement.html", //privacy statement URL
        "name,email", //comma delimited list of requested columns to return
        receiveData, //callback function
        "http://www.jeffzlive.net/channel.htm");  // communication endpoint in your domain
</script>

其中第三个参数所需要的联系人的信息，用逗号分割。可以使用的参数是：name（姓名或昵称，如果没有填写的话则使用passport account的E-mail。）、email（主要E-mail、如果没有填写，则使用个人E-mail或Business E-mail）、phone（主要电话号码）、firstname、 middlename、lastname、nickname、passportname(用户的Mirosoft Passport ID)、emailpersonal、emailbusiness、emailother、phonepersonal、phonebusiness、phonemobile、phonepager、phonefax、phoneother、personalstreet、personalcity、personalstate、personalcountry、personalpostalcode、businessname、businessstreet、businesscity、businessstate、businesscountry、businesspostalcode、websitepersonal、websitebusiness。

5、添加回调函数：

添加回调函数的定义，例如：

<script language="javascript">
    function receiveData(p_command, p_contacts)
    {
        var msg;
        switch (p_command)
        {
            case "SIGN_OUT":
                msg = "user is not signed in to live.com";
                break;
            case "SIGN_IN":
                msg = "user is signed in to live.com";
                break; // user is signed in
            case "DATA":      // here comes the data!
                var msg = "Done! " + p_contacts.length + " records received. <br>";
                for (var i = 0; i < p_contacts.length; i++)
                {
                    msg += "<p>";
                    msg += "Name: " + p_contacts[i].name + "<br>";
                    msg += "Email: " + p_contacts[i].email;
                    msg += "</p>";
                }
                break;
        }

        document.getElementById("ContactsDisplay").innerHTML = msg;
    }
</script>

p_contacts是请求的联系人数组。只有当p_command为“DATA”时，p_contacts才会有数据。

到这里，这个Quick Start就完成了。

使用效果

1、打开Quick Start，如果您没有登陆Windows Live，则会看到下面的提示。

请点击Sign in并在弹出窗口内登陆。

2、登陆Windows Live后出现的页面：

3、选择一项或多项，并点击Send select contacts按钮，则会弹出窗口：

4、点击Send按钮，则页面中的回调函数则会被执行，页面中会显示信息：

从上面的例子里可以看出Windows Live Contacts Gadget的大致功能。我另外也部属了一个Mapping your contacts在我的Web Host上，可以看出使用Windows Live Local与Windows Live Contacts Gadget进行Mashup有多么的简单。

点击这里查看Quick Start。

缺点

可是缺点依旧存在，而且其严重程度可能导致了Windows Live Contacts Gadget无法让人接受。目前我认为最严重的问题是：

1、如果联系人多，浏览器会出现比较长时间的假死现象。
2、浏览器的“历史”被严重摧残。Windows Live Contacts Gadgets使用了iframe，因此这几乎是无法避免的缺陷。

事实上问题不止这些，官方也提供了Known Issues的列表，详情请见：http://dev.live.com/contactsgadget/knownissues.aspx

Windows Live Contacts Gadget要真正成功的话，真可谓“路漫漫其修远兮”……

参考

Windows Live Dev - Windows Live Contacts Gadget (Beta)
http://dev.live.com/contactsgadget/

Momentary Gouts of Reason
http://blogs.msdn.com/dthorpe/archive/2006/08/18/706422.aspx

Building a Mashup with the Windows Live Contacts Gadget and Virtual Earth
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnlive/html/mashupWLContacts.asp?_r=1

技术尝鲜 - 老赵点滴 - 追求编程之美

HTML Metro开发里的数据绑定（1）：WinJS.Binding.List

相关文章

在.NET平台下使用C#交互式控制台（上）：简介

“花钱”购买App Hub Membership终于成功了

HTC 7 Mozart T8698（Windows Phone 7）初体验

第三届nBazaar技术交流会开始报名

志愿者招募

时间及议程安排

演讲内容

针对iPad平台的高性能网站架构

分布式版本管理

企业开发领域的语言特性

使用.NET构建轻量级分布式框架

地点

报名信息

关于即将到来的“演出季”以及Jscex类库

使用Narcissus解析JavaScript代码

PDC 2010：C#与Visual Basic的未来（下）

相关文章

服务器端执行JavaScript代码

PDC 2010：C#与Visual Basic的未来（中）

相关文章

PDC 2010：C#与Visual Basic的未来（上）

相关文章

在Visual Studio中使用MonoTouch开发iOS应用程序（下）：开发体验

新建项目

编辑界面

配置Visual Studio

编写代码

单元测试及其他

相关文章

在Visual Studio中使用MonoTouch开发iOS应用程序（上）：环境配置

什么是MonoTouch

在Windows和Mac OS X中共享文件

安装MonoTouch

相关文章

Win7 + VirtualBox安装Mac OS X雪豹操作系统图文详解

准备

创建虚拟机配置

安装系统

更新系统

调整分辨率

其他

总结

盛大创新院赞助第二届.NET技术交流会 - 演讲录像及下载

响应式编程与响应式框架

大话程序员可用的算法

Windows内核技术介绍

面向对象与生活

相关文章

异步编程与响应式框架

前言

异步编程的难点

推模型与拉模型

LINQ to Observable

更多扩展

响应式框架的JavaScript版本

总结

盛大创新院赞助第二届.NET技术交流会 - 各场演讲幻灯片

响应式编程与响应式框架

大话程序员可用的算法

Windows内核技术介绍

面向对象与生活

相关文章

盛大创新院赞助第二届.NET技术交流会即将召开

相关文章

盛大创新院赞助第二届.NET技术交流会开始报名了！

时间及议程安排

演讲内容

响应式编程与响应式框架

大话程序员可用的算法

面向对象与生活

Windows内核技术介绍

地点

报名信息

相关文章

NDC 2010视频下载：看看其他微软平台程序员们都在做什么

盛大创新院赞助首届.NET技术交流会 - 演讲录像及下载

F#语言对异步程序设计的支持