博客园_Sean's Code Garden!

异步控制器, 从ASP.NET MVC 2到4

2012-02-02T15:23:00Z

前言

这篇文章主要针对即将到来的ASP.NET MVC4中的异步控制器做一个回顾和展望, 并未涉及到讨论异步控制器的使用场合, 如果对异步控制器何时使用仍然纠结的同学, 这次可能会让你们失望了, 不过关于这方面的讨论和分析其实蛮多的, 大家也可以自行搜索.好了,废话少说,上正文.

异步控制器

在MS越来越提倡异步操作的时代, ASP.NET MVC中的异步操作却一直显得比较落伍, 对于开发人员来说, 实现一个异步控制器往往要比普通的控制器花费更多的代码. 这个特性是在ASP.NET MVC 2中被引入的, 之后就没怎么改过,直到现在, 随着C# 5和 async/await的即将到来, 异步控制器现在已经跟普通的控制器操作代码一样的简练啦. 现在(当然得等ASP.NET MVC4,.NET 4.5和C# 5正式的发布之后), 你可以写出下面这样简洁的代码啦:

public async Task<ViewResult> FooBar() 
{
 return View(await DoSomething("Some Action"));
}

怎样? 真的是很简单的吧~~

展望固然重要, 不过在这之前, 也请大家随着我来回顾下一步控制器在ASP.NET MVC 2到4中的实现, 对比往往更能让人印象深刻.

注意:下面关于ASP.NET MVC 4的例子都是基于ASP.NET MVC Developer Preview. 在正式版中, 这种实现可能会有所变化.

在ASP.NET MVC 2/3中的异步控制器

在ASP.NET MVC 2/3 中, 要实现一个一步控制器,你将不得不实现两个方法, 一个叫XXXAsync, 另外一个叫XXXCompleted, 同时你的控制器还要改成继承自AsyncController, 关于这个的实现和讲解已经有很多现成的例子, 这里我就直接从MSDN上搬过来一个例子吧.

要看异步控制器, 我们首先看看同样功能的同步实现, 大家应该都很熟悉了:

public class PortalController: Controller
 {
    public ActionResult News(string city)
   {
     NewsService newsService = new NewsService();
     ViewStringModel headlines =       newsService.GetHeadlines(city);
     return View(headlines);
    }
 }

我们再来看其异步实现方式:

public class PortalController : AsyncController
 {
 public void NewsAsync(string city)
 {
 AsyncManager.OutstandingOperations.Increment();
 var newsService = new NewsService();
 newsService.GetHeadlinesCompleted += (sender, e) =>
 {
 AsyncManager.Parameters["headlines"] = e.Value;
 AsyncManager.OutstandingOperations.Decrement();
 };
 newsService.GetHeadlinesAsync(city);
 }
 public ActionResult NewsCompleted(string[] headlines)
 {
 return View("News", new ViewStringModel
 {
 NewsHeadlines = headlines
 });
 }
 }

看看上面的实现, 不得不承认, 相对同步控制器, 异步Action开发人员要做的工作还是要多一些的. 但在.NET4.0的大环境中, 我们也只能用这种方式来实现了.

当然, MSDN的例子是标准的分层的实现例子, 在这个例子中,你将不得不实现自己的Service层, 如果你只是想简单的调用异步Action, 有没有方便的办法呢? 答案是有的, 在.NET 4.0中,微软带来了Task类, 感兴趣的同学可以猛击这里. 有了Task,如果你只是想简单的一个函数里面做异步操作也是可以滴:

public class PortalController : AsyncController 
{
 public void NewsAsync(string city)
 {
 AsyncManager.OutstandingOperations.Increment();
 var task = Task.Factory.StartNew(() => RunThread(city));
 task.ContinueWith(t =>
 {
 AsyncManager.Parameters["headlines"] = t.Result;
 AsyncManager.OutstandingOperations.Decrement();
 });
 }
 
 public ActionResult NewsCompleted(string[] headlines)
 {
 return View("News", new ViewStringModel
 {
 NewsHeadlines = headlines
 });
 }
 private string RunThread(string input)
 {
 Thread.Sleep(5000);
 return input;
 }
 }

当然, 代码并没有减少太多, 不过也算是一种不太复杂的实现, 虽然没那么好看, 但也不至于太难看.

下面我们再来看看ASP.NET MVC 4中的异步控制器吧.

ASP.NET 4 Developer preview中的异步控制器

在抛弃了对.NET 3的支持之后, ASP.NET MVC 4 彻底拥抱了Task类库, 你不需要再蛋疼的给每个Action写两个方法, 也无需傻傻的手动对异步Action计数器增减了(AsyncManager.OutstandingOperations.Increment()), 现在的你只需拿起手指, 轻轻敲几下, 其他的事情都由系统帮你完成.

public class PortalController : AsyncController 
{
 public Task<ViewResult> News( string city)  
 {
 return Task.Factory.StartNew(() => RunThread(city))
 .ContinueWith(t =>
  {
 return View(new ViewStringModel()
 {
 Text = t.Result
 });
 });
 }
 private string RunThread(string input)
 {
 Thread.Sleep(5000);
 return input;
 }
 }

是不是好多了?Lamda可以让一切更爽:

public Task<ViewResult> News(string city) {
 return Task.Factory.StartNew(() => RunThread(city))
 .ContinueWith(t => View(new ViewStringModel{ Text = t.Result }));
 }

那么, 是不是到这里就要说再见了呢? 不是的, 请继续往下看.

伟大的async/await

虽然还未到正式发布的时候, 不过如果我们跟着微软的目光往前更进一步, 在ASP.NET和C# 5中, 或者我们从这里可以给.NET 4增加Async 的功能, 在有了async和await这两个关键词之后, 异步编码就更简单啦, 这其中也包括异步控制器的相关操作:

public class PortalController : AsyncController {
 public async Task<ViewResult> News(string city)
 {
 return View(new ViewStringModel()
 {  
 Text = await NewThread(city)
 });
 }  
 private async Task<string> NewThread(string input)  
 {  
 Thread.Sleep(5000);  
 return input; 
 }
 }

总结

由于有了async和await关键字以及Task类库的帮助, 在可预见的未来里, 我们操作异步控制器就可以像操作普通的控制器一样了, 但就像其他的众多新增的.NET特性一样, 能力越大, 责任也就越大, 方便也往往意味着滥用. 异步控制器固然好, 但也并非每种场合都适合用它, 不恰当的使用它往往会导致服务器需要在不同的线程之间切换, 而这也带来了更多额外的开销. 在开发领域, 我们尤其要注意性能往往比其他任何东西都重要, 因此, 请在确实能提高性能和用户相应的情况下使用异步控制器.

本文链接

你知道为啥++[[]][+[]]+[+[]] = 10?

2011-12-31T11:41:00Z

前言

这个世界总有那么些人喜欢较真,喜欢研究,这不, 在StackOverflow上,有人就很认真的提了这个问题, 幸运的是, 程序员永远是这个世界上最乐于帮助别人的人群之一, 于是, 真有人很热情的blabla的解释了原因.

想看源地址的可以去这里: http://stackoverflow.com/questions/7202157/can-you-explain-why-10

问题

++[[]][+[]]+[+[]]

在js中, 如果我们这样给一个变量赋值,不难发现它确实能返回一个值,而且还是10, 另外你可以在这里看到更多更多类似这样的测试结果.

那么, 为什么会返回值呢?为什么又是10呢?

原因

很多热心人士都给出了自己的解释, 这里我就不一一列举了, 我只翻译下最佳答案(他解释得最为详细).

1. 解决问题的最好的方式之一就是分解它, 然后分而治之, 这里也一样, 首先上述表达式可以分解为:

++[[]][+[]]
+
[+[]]

  2. 在js中, 表达式+[]===0的结果为真, 这其实跟js编译器的设计有关的, 由于Js是弱类型语言,因此在我们想对某个对象进行一个操作时,js引擎总是会尝试先将这个对象转换为符合指定操作的对象类型然后再执行操作,在这里+会把后面[]转换为0然后执行别的结果,那么,上面的表达式可以进一步简化为下面这样子:
++[[]][0]
+
[0]
由于[[]][0]表示取得数组[[]]的第一个元素, 因此我们可以得到:

[[]][0]返回该数组的内部数组([]),然而, 如果我们直接说[[]][0]===[]却不对, 为了避免错误的表述, 这里我们不放先称这个内部数组为A.

++[[]][0] == A+1, 因为在js中,++表示自增1.

++[[]][0] === +(A+1), 或者从另方面说,前面的结果永远是一个数字(js中,进行+1并不一定能保证结果是数字,但++得到的结果却永远是数字)

3. 让我们继续上面的步骤对表达式进一步简化, 这里我们把A替换为[],然后得到简化的结果:

+([]+1)
+
[0]

在js中, 后面这个表达式的结果仍然为真: []+1 ==="1", 因为空数组转换为字符串等同于"", 根据这个特点,我们可以得到下面的结论:

+([] +1) === +("" +1);
+([] +1) === +("1");
+([] +1) === 1.

4. 于是, 表达式可以进一步简化为下面这个结果:

+
[0]

我们不难发现[0] =="0"的结果同样为真, 这又是为啥呢? 其实原因跟上面一样的, 执行+的操作的时候, js引擎发现[0]是一个包含一个元素0的数组,因此,它会先将这个数组转换为字符串, 这样才能执行+操作(数组能匹配tostring的方法,但默认没有转换为数字的方式), 因此[0]会将其内部的所有元素拼接为一个字符串"0".

5. 好了, 到了揭晓答案的时刻啦, 通过上面的层层抽丝剥茧, 我们最终发现, 那么一大堆东西其实最后就是这样滴(数字+字符串=字符串):

1
+
"0"
=== "10"

Bazinga!!!

关于+[]

问题到这里结束了么? 应该没有,因为不少同学可能仍然对上面的解释有些疑问, 那么下面我们来补充下"+[]"把

首先看看一元操作符"+"的说明:

11.4.6 Unary + Operator

The unary + operator converts its operand to Number type.

The production UnaryExpression : + UnaryExpression is evaluated as follows:

Let expr be the result of evaluating UnaryExpression.

Return ToNumber(GetValue(expr)).

ToNumber()的说明:

Object

Apply the following steps:

Let primValue be ToPrimitive(input argument, hint String).

Return ToString(primValue).

ToPrimitive() 的说明:

Object

Return a default value for the Object. The default value of an object is retrieved by calling the [[DefaultValue]] internal method of the object, passing the optional hint PreferredType. The behaviour of the [[DefaultValue]] internal method is defined by this specification for all native ECMAScript objects in 8.12.8.

[[DefaultValue]] 的说明:

8.12.8 [[DefaultValue]] (hint)

When the [[DefaultValue]] internal method of O is called with hint String, the following steps are taken:

Let toString be the result of calling the [[Get]] internal method of object O with argument "toString".

If IsCallable(toString) is true then,

a. Let str be the result of calling the [[Call]] internal method of toString, with O as the this value and an empty argument list.

b. If str is a primitive value, return str.

关于数组的.toString方法的说明:

15.4.4.2 Array.prototype.toString ( )

When the toString method is called, the following steps are taken:

Let array be the result of calling ToObject on the this value.

Let func be the result of calling the [[Get]] internal method of array with argument "join".

If IsCallable(func) is false, then let func be the standard built-in method Object.prototype.toString (15.2.4.2).

Return the result of calling the [[Call]] internal method of func providing array as the this value and an empty arguments list.

根据上面一堆堆的blabla, 我们就可以得出结论啦:+[] 等于+"",因为 [].join() === "".

这里, 我们再次回到关于+的定义:

11.4.6 Unary + Operator

The unary + operator converts its operand to Number type.

The production UnaryExpression : + UnaryExpression is evaluated as follows:

Let expr be the result of evaluating UnaryExpression.

Return ToNumber(GetValue(expr)).

""的ToNumber方法可参照下面的解释:

The MV of StringNumericLiteral ::: [empty] is 0.

因此呢, +"" === 0, 从而, +[] ===0.

附言

在这个提供分享和数字化的世界, 我们每天可能看到和学习了很多很多东西, 然后学习是一回事, 真正能学以致用, 将其在工作中融会贯通却又是另外一回事. 我们学习的最终目的是解决问题和创造新的东西, 但怎么利用已有的知识去解决问题却需要我们不断总结和思考.

因此我这里翻译这篇文章也不是仅仅给大家一个乐子, 更期待的是希望你和我能在新的一年中更好的去学会如果利用已知的和已有的资源去解决暂时可能的难题.

因为工作原因,很久没写东西, 在这个岁末旦初的时机终于再次提笔, 虽然只是翻译, 但也算是对自己有所帮助吧, 希望也能给你带来一些帮助.

水平有限, 如果有翻译或者解释不对的地方,还请大家多多谅解, 有砖请轻拍哈~~

最后, 也祝愿园友元旦快乐,年终奖多多把!

本文链接

我为啥喜欢WinPhone

2011-08-30T15:34:00Z

从观望到入手到现在的淡然, 使用WinPhone差不多也近半年了. 也算是对WinPhone有些自己的看法, 数次在CB那种口水遍布的地方看到各种否定->驳"XXX->驳"驳XXX我都是很淡定的, 萝卜青菜,各有所爱, 特别是面对一个基本颠覆了以往的手机用户体验的手机来说, 有反对的声音在所难免,不过今天在看到有园友在园子里对WP吐槽(.NET的地盘啊~~), 觉得这样看来貌似大家对WP的偏见挺深的,就写篇文章来说说我的看法吧, 使用时间, 开发时间时间都有限, 如有不足甚至是错误的地方,还请大家轻拍为好~~

用户篇

其实看网上目前大部分吐槽的都是WP的界面过于单调. 主界面就一个, 只能放些大块块, 程序列表也一个, 如果你应用太多,会觉得找起来很烦. 而且对于很多追求花式的用户来说, 堂堂一个系统居然就只有两个界面可以跳来跳去, 其他的地方就只有进入应用了, 未免太过单调, 因此, 在一些尝过鲜的用户看来, 这玩意儿太单调了. 跟Android动辄4,5个主程序界面滑来滑去完全不可相提并论. 这Metro用着真是嘴里淡出个鸟来, 没意思.

我刚用的时候也觉得应用列表只能滑来滑去太过繁杂, 当时想如果应用多了这个该怎么办呢(尼玛怎么跟广告的情节这么像)? 又没搜索(Mango已经支持搜索了). 但在使用了一段时间之后, 发现这玩意儿完全就是没必要的担心(当然是就我的使用习惯来说). 实际上虽然我安装的应用很多, 但平时常用的却很少,虽然没有2/8原则那么夸张, 不过大部分常用的应用放在主界面完全够用, 根本就不用担心主界面Tile过多导致超长的问题, 而且在用习惯了之后,基本要用哪个应用,该滑多大力度才能到达应用的图标也是相当熟悉, 所以,你有没有这个问题, 我反正是没有这个纠结的.

不支持应用级别的多任务(实际系统的应用一直都是支持的,比如播放音乐等等)这个设定在mango之前确实比较坑爹(这点微软心底应该都觉得被Apple摆了一刀吧), 微软当初的意图是为了保证内存CPU能够完全提供给用户当前的应用,从而使用户体验最好, 不过后面发现这个设定实在太坑爹.因此Mango之后这项设定做了很漂亮的修改, 因此, 如果你抱怨这个, 我想你大可以等等再说, 毕竟作为一家大企业, 愿意下定决心推到一款已经存在7年之久的系统(我也算是WinMobile老用户了)完全重新开始, 恐怕目前也只有微软这样的企业有这样的气魄的.

至于方向键,翻页之类的, 我只能说, 在触摸屏时代, 这些设计早已过时, 对, 我说的不仅仅是方向键, 也包括翻页. 如果你有不同看法,大可以看看DZone, twitter, 校内等等的消息设定, 对实时信息流目前主流的处理是动态加载到当前的列表中, 而实时性不高或者需要详细内容翻页的设置则是使用目前基本所有触屏都通用的左右划拉来实现, 这点不论Android, IPhone还是其他任何一款触摸系统都是如此,很少有人去舍触屏的长而加两个很丑的分页按钮的(当然你硬是要在应用里面加又有谁敢阻挡你呢?).

编程语言的问题, 说实话我都不觉得这是个问题, 为啥不支持Flex,Java? Google现在可就是因为Java郁闷着呢, 你还想让微软来趟这趟浑水, 而且坊间人士常说Java,C#本一家, 即使你想招徕潜在的Java开发者, 这点不是问题, 问题是他们是否愿意. 以目前C#和VB的开发者数量来说, 其实微软担心的并不是潜在的开发者数量, 而是真正愿意积极投入的开发者(现在观望者众多), 所以在这块微软确实做了很多功夫(包括且不仅包括面向IOS和Android的object-c和java对应WinPhone API白皮书). 另一方面, 拿数据说话, WinPhone的应用增长数量确实比IPhone要慢些, 不过相对Android要高,10年10月正式上线, 今年7月份突破25000, 这份答卷也算不错的了. 也许你会说, 应用数量神马的都是浮云, 我关心的是中文应用数量, 确实,目前中文应用数量相对仍然薄弱, 不过目前QQ, QQ浏览器, Baidu浏览器, 各种常用的软件基本Market上面都有了, 而且, 各位看官, 这可是在Market中文市场还没有正式宣布支持的情况下的数量啊(目前微软不支持大陆开发者注册和购买). 当然, 我这其实在找客观理由, 作为用户, 如果你觉得自己想用的工具不够, 现在确实还不到中国用户使用Win Phone的最佳时机(另一方面, 不知道你想到没有, 对用户不利,那么对你我这样的个体开发户呢).

另一方面, 跟Android和IOS不一样的地方是, 微软对待普通应用和游戏是不一样的, 它们早已通过应用列表和XBox游戏列表分开. 另一方面, WinPhone的联系人通过内置Live,FB,Twitter账号早已做到社交和手机真正的一体啦, 而国内的微博很早就可以通过和Live账号绑定的方式做到一体化, renren也在最近和微软达成的合作协议. 因此, 可以说, 微软的意图和设计理念其实很明显, 它是想像地铁指示牌那样清晰准确的让用户快速到达自己的目的地, 得到自己想要的信息, 我去应用列表找应用,去游戏列表玩游戏, 去联系人玩社交等等等等(不妨看看WinPhone的广告,蛮有意思的). 而不是像Android和IOS那样的应用超市(或者说应用摆摊), 用户看到的琳琅满目的应用图标摆在界面上. 信息是有了, 但需要用户仔细挑选. 我并非在此贬低这两种其中的任何一种, 这个世界有包容的文化, 也有包容的处事方式. IOS(Android很大程度上模仿了它, 但模仿得足够好)提供的是一个超市那样的窗口, 由用户按类别或者使用习惯摆好每个柜台, 然后使用的时候从相应的柜台查找就是, 而WinPhone的设计思路则是来自于地铁指示, 微软认为, 手机只是我们生活的一部分, 它的角色是提供信息, 交流信息, 而不是让我们被其所累, 因此它尝试以Metro这种方式来实现自己的设计理念. 哪种更好, 在于你更习惯或者更加认同哪种方式.

还有就是WinPhone内置的Office系列, 虽然现今的很多应用都可以做到, 不过微软内置的这款Office我是相当喜欢, 无论缩放还是编辑(内置的手写确实很棒), 体验都相当不错, 这点相信其他的移动OS很难媲美的. 即使你只是简单记录下所闻所见所得, Note也比其他的很多应用都好, 它不仅支持书写, 还支持录音. 最后还能同步到服务器, 而这些都是系统内置的服务.你喜不喜欢, 我反正是很喜欢的!

当然, 作为一款年轻甚至找不到前辈设计理念借鉴的手机, WinPhone仍然有很多不足, 这点微软自己也承认, 因此你看到的每一次重大更新微软都会带来所谓成千上万的新特性, 其实很多早就应该在那里, 它只是来晚了而已. 不过不管怎么变,这种设计理念不会改变, 这是它的魂, 你来,你用, 然后你习惯了这种方式, 它很方便, 解放了你很多事情, 你不习惯, 也不奇怪, 就换一台别的系统手机而已, 不用带着什么深仇大恨一样, 仅仅是你不同意它的思维方式, 就这么简单.

开发者篇

我为啥觉得WinPhone很棒, 其实一方面也是当年被微软骗上了.NET的贼船(玩笑). 另一方面,毕竟微软在开发圈也混了这么多年, 所以一个免费却强大的VSExpress,一个好用的模拟器(虽然还没到完美, 仍然有些奇怪的小问题), 这些都比Eclipse+ Android模拟器要好用得多(当然Eclipse死忠不这么看也很正常, 谁没个自己的编程习惯呢), IOS最终还是没买Mac, 只试过一小段时间的虚拟机Mac, 没权利评价, 不过XCode现在要收费了. 基本上普通的应用只要你有了设计思路, 加上一些.NET和XAML编程基础, 折腾个能跑的东西花不了多少时间 (至于执行效率, 那就是后话, 哪种平台都必然会有调优的问题), 不过得益于当年微软Silverlight和XNA多年的开发社区积累, 加上足够的API,和MSDN详尽细致的实例和文档说明, 因此, 大部分WinPhone开发人员学习曲线都比其他两个平台要小得多.

至于今天园友吐槽的应用设计限制,我想是他没有理解或者亲身去体验过WinPhone开发所致, AppBar上面的图标大小都是一样的, 所有要求大小,高度神马的都是一样的,同样, 由于WinPhone主题只有黑和白,所以相应要求你的AppBar上面的Icon必须是白色或者黑色的的. 我想说, 如果你自己去做一个应用或者使用了应用, 你就会明白这个是必须的, 试想, 你见过你操作系统里面的右键菜单有各式各样的按钮菜单么, 你见过Mac下面那排图标大小不一样的么? 除了这些基本的按钮因为要保持一致所以有所要求外, 只要你能让你的用户觉得就应该那样或者这样操作,你怎么做都行, 不过因为有个体验一致的问题,所以微软才建议你根据Metro的设计思路来做应用, 但这并非强制(如系统建议如果是Panorama,微软通常建议你不要加AppBar,不过其实我们通常就这么干,而且还动态换来换去), 虽然系统是非黑即白, 不过你愿意折腾的话, 你想怎么花花绿绿都没人说你(用户抱怨另说). 而且为了省去开发制作图标的辛苦,所以微软还特定给开发人员定制了一套常用的图标(如导航, 电话,蓝牙等等).

同样的道理,作为一款新系统, 微软的接口提供可谓相当的小气, 这点完全不能跟当年的WinMobile相提并论, 可以说,当年的Mobile, 除了内核不能改之外, 基本没有你不能改的东西. 所以自从HTC开了先河之后, 你可以在WinPhone论坛看到各种各样的皮肤制作工具, 各种各样的插件, 各种各样自由定制的应用. 再看看今天, Mango之前甚至连摄像头都不能调用, 现在都没办法调用就是电话接听钩子(微软说是为了安全, 那就UAC下嘛, 经过用户许可也不可以么?), 所以导致到现在WinPhone都没办法做到挂靠来电事件然后获取来电号码的功能, 甚至来通话历史列表都拿不到, 其他的更别多说了, 还有访问存储卡这都不可以. 不过我们总算看到微软一直慢慢开放, 比如现在拿所有的联系人列表, 日程表等看似敏感的信息终于是可以了,还有今天园友吐槽的设置WIFI网络的问题, 实际现在只需要一个接口调用,就可以直接在应用内设置网路连接方式啦, 这点还算不错, 现在也有了可以早就应该有的后台服务和后台音乐播放功能了, 可以说现在用户基本的服务, 微软提供的接口都能做到. 相信微软不是傻子, 如何在用户隐私和丰富的功能接口提供之间权衡, 他们会很快掌握的.

最后,一句话, 如果你并非大的工作室，现在切入这个平台是值得的, 园子里的朋友相信大部分都熟悉C#, 你不妨去试试装个SDK, 我这里说上千言万语都比不上你动下手亲自体验一把, 哪怕你现在手头没有实体机都毫无关系, 我相信你会很快爱上在它上面开发的(后面的痛苦开发过程我可不负责, IT人,痛苦是其宿命).

总结

任何一款操作系统, 总有人爱有人恨, 其实挺正常的, 不过手机这玩意只是个工具, 我们犯不着提升到咬牙切齿的地步, 不喜欢, 换了就是. 想想如果这世界清一色都是IOS和Android那种思路的IOS系统(现今Android的那套换肤其实当年黑莓和WinMobile早就玩烂了, 架子和灵魂都是一样的), 我们的行事思维也太固化了. 有这么一个与众不同的手机操作系统存在, 至少也让你,你的朋友和家人有更多的选择, 不是么?

其实看系统好坏和看人是一样的, 切忌先入为主, 带着看前人的角度去看新人. 想想如果你对某人说, 张三那么帅,它的耳朵是那样的, 为啥你不是这样的. 要知道耳朵是身体的一部分, 必须和整个身体协调才能算美. 系统也一样.

PS:我非MS死忠,现在工作语言也是PHP,WinPhone也只是纯业余爱好而已，所以请勿给我乱贴标签。

本文链接

WinPhone开发阶段总结

2011-08-08T17:13:00Z

首先,这篇文章基本没什么技术含量,它主要是我对最近业余时间的WinPhone开发工作的一个总结.而且以我以往的学习经验来说，这篇文章很可能对读者中的大部分人都毫无用处，因为所谓学习方法因人而异,这我深有体会,所以这里我贴出自己关于WinPhone开发工作的一个阶段性总结只是希望里面哪怕能有一点点对你有所启示,那应该就算这篇文章的最大成功了.

自从去年工作方向由.NET转向PHP之后,C#基本就只能算我的一个业余爱好了,虽然仍然关注着这个圈子,也喜欢着这门语言,不过毕竟不是工作,没有实践,自己实在是感觉写不出怎样深刻的东西来,不过好在有了微软的WinPhone,纠结了几个月之后终于还是下手了HD7,也开始了自己WinPhone开发者的纯业余生活.到现在,虽然做的东西仍然很简单,但终于有了看得见的东西出来,我的手机号码归属地应用和中国地铁应用总算是成功挂到Market上了, 因此想想还是对这个阶段的开发工作做个总结比较好, 希望能给大家以参考.

额,好像我总是如此啰嗦,还是上正文吧.

1.写一行代码胜于看十页书.
    可能是因为之前已经有一定WPF/SL的经验,因此开发WinPhone应用时,除了微软官方的UI交互指南(因为WinPhone的UI设计理念确实和以前的应用不一样),我并未看一页书.大部分问题都是在遇到的时候才去网上查找资料解决的,当然,这并非说我没有查阅任何资料,实际上,直到现在,我每天仍然都会在WindowsPhoneGeek,MSDN和博客园上逛逛,看到不错的文章或者代码也会动手实践下.
    因此,以我的感受来说,对大部分的有一定的C#开发经验的园友来说,其实WinPhone的应用开发都不会太有难度以至于完全无法动手(当然,如果你做的是超级复杂的东西就另说啦),而且我始终认为从实际写代码中遇到问题->解决问题的过程所收获的经验要比从书本中别人讲解的经验要深刻得多.如果你真的对WinPhone开发有兴趣,那么从现在开始就动手吧,不用纠结于去看哪本书,就我从目前介绍WinPhone开发的书本目录介绍来看,这些书本一定都是第一章和第二章都是毫无意义的(第一章介绍WinPhone的设计理念,第二章介绍VS的WinPhone开发环境部署,对很多人来说,很是浪费纸张).动手不仅能更快发现你应用中存在的设计问题,还能解决实际运行中你永远无法想到的意外.
   当然,我并非反对看书,我的建议是如果你真想学WinPhone开发,那就多动手吧,这样你能更快进去开发的过程.

2.不要一开始就想把应用的功能做得够大够强够完美.
   不要一开始就想着做一个超级复杂,让人能一看就过目不忘的完美应用,这个我在开发过程中确实深有体会.其实我一开始并非想做上面的归属地应用和地铁路线图应用,而是一个斗地主的游戏,并且由于那时候WinPhone还不支持Socket,因此我一开始就计划设计一个足够聪明的AI系统,还为此复习了下很早之前丢掉的AI书籍,但越做下去发现越没信心做好,挫败感也越强.于是在经历了一个星期的空手而归之后,我开始进行反思,发现自己的AI知识实在是太过贫乏,这也不是我的优势所在,而且我的目的是至少前面一个应用是用来练手的,现在所做的工作实在不像,于是在下周开始果断放弃之前的工作,而该从手机归属地应用开始,一个界面简单,而是够实用.这样决定之后后面的工作就顺利了,并且有了第一个实用的工具第二个的思路也有了.这样在经历了一个多月的工作之后,终于还是将两个应用提交了,虽然知道所做仍然还是很浅薄,但看到能有东西挂在market上面的那种感觉确实完全不一样的.

3. 做出应用的特色, 但不一定要复杂.
    好的应用不一定要非常强大,老实说, 归属地应用确实简单,就一个界面,四个按钮,其他没啥了.但我从Nokia3230到Samsung i900再到现在的HD7,我一直都认为这个功能是我们日常生活中一个不可缺的功能.而且有了核心的功能你就可以围绕它做更多的文章了.这样做到后面也许你会发现你一开始很简单的一个东西到后面可能会越来越强大.
    反之,如果一开始想太多,各种扩展,各种架构,那你反而可能一直在徘徊, 在浪费时间,结果到头来一无是处.
    所以,如果你有了想法,并觉得这个想法确实会对别人的使用有很不错的帮助,那就开始动手吧,哪怕它实现起来并无太大技术含量.

4. MVVM? 框架?
   是否使用MVVM框架?这个问题我觉得因人而异,但你更应该看哪种方式你更顺手,我其实蛮喜欢SL的INotifyPropertyChanged,我甚至想要是C# 5中能实现属性自动双向绑定的特性(比如在要双向绑定的属性上加个特性[Bind(Ways.DoubleWay)])那C#该有多好哦.不过我对Command确实不太感冒(~~明显是因为境界不够),因此在实现时我保留了ViewModels,但对于事件还是用自己习惯的Click方式来实现,虽然这让MainPage.cs里的代码看起来太多太乱,不过现阶段来看这更有利于我书写代码的效率,同时修改代码我也更加习惯.因此我的建议是在初期你应该将很快提交能很好工作的应用这个目标放在首位,至于框架,以你自己习惯的方式来进行吧.哪种更有效则更适合你.
   当然,上面的话也并非说我们可以一直这样,每个人都会在阶段性的工作之后对之前的代码进行总结,MVVM确实是SL/WPF一个不错的代码架构方式,同时它在单元测试时也更优异.因此,在总结的时候,你需要对之前的工作做一个权衡,而不是不经思考,一成不变的用最初的思考方式进行下去.

5. 从实例开始
   如果纠结于如何开始编写应用的话,那我建议你不妨从这里(http://create.msdn.com/en-US/education/catalog/)下一个示例代码开始.绝对不要小瞧这些实例代码的,我已经看到Market上面N多人直接把各种实例代码(比如BlackJack)改改就放上去了.这些代码不仅能给你一个比较标准的代码结构,而且能迅速带你进入正常的应用运行流程,这种过程我觉得比你在枯燥的书本上看一章要好得多.你可以看看GameStateManagementSample这样的例子,里面的架子基本上都已经帮你搭好了,菜单有了,主界面有了,唯一缺失的TODO就是player和enemy,这些只需要你按照自己设想的去填充就好了.微软别的不说,在对开发人员的引导方面,确实是做得不错的.

6. 给用户提供做够多的反馈通道
   可能你的应用开始的功能非常简单,但你要相信用户,很多你看不到的东西,他们都能看到和想到,因为用户不像你,你只有一个脑袋,但他们则是千千万万个聪明的脑袋,他们可能遇到你没遇到过的问题,这些都是用户反馈的好处,所以,一定记得在你的应用里面留下至少一个反馈的通道.我的第一个应用并没有留下自己的email链接进行反馈,因此看到的大部分反馈都是来自于review里面的.于是从中国地铁开始,我在关于页面中留下自己的邮箱,并提供了很方便的邮件编写链接.这之后我收到了两个很不错的反馈建议(如果他们有看到,我在这里谢谢所有提供反馈的WinPhoner).虽然最近因为工作的关系没办法马上发布新版本,不过我会尽快提交.

7. 不要一开始就考虑赚钱
   如果你一开始时抱着赚钱的想法来做Win Phone开发的话,那我想你很可能会有两个结果,一是因为失望而热情丧失并最终离开,二是因为需要纠结于怎样才能做出别人愿意花钱的应用而一事无成.当然,你也可能会成功,但对个人开发者来说,我建议大家一开始不要抱有太高期望值,你就把做应用当成一件结交朋友,锻炼能力的事情就够了.看到应用的发布,看到别人给你应用不错的评价,看到能给别人带来实打实的帮助,那种愉悦感也是相当不错的,至少能在以后的生活中给予你自己更多的信心,我个人认为这些东西有时候比那点点钱来得更快.

8. 保护好你自己的核心代码
   老实说,微软在代码保护上做得并不好,虽然没用过,但我曾在论坛上看到已经有人做出工具可以直接下载XAP文件,也看到很多win phone论坛放出了各种付费应用的破解文件.对.net应用来说,得到了XAP文件,如果你一点保护没做,基本就是赤裸裸的了,因此,虽然你永远无法防住那些真正想要偷窃你代码的无德份子,但一些基本的工作你还是得做,特别是如果你的应用基本没有需要与服务器交互的功能的时候. 当然,如果你的大部分核心逻辑都放在服务端这个问题就不用太担心了.
   虽然如此,大家也不必太看重劳动果实偷窃这种事情,这样的人毕竟是少数.所以虽然很不幸,我的两个应用的优势都是本地数据存储, 我一开始有担心自己的劳动成果会被偷走(貌似也确实怀疑有人偷走过,当然我没有证据),也因此降低过热情,但想开了就淡定了.应用这玩意,本来自己的就是免费的,别人要偷也卖不了钱,那就偷去吧.这里我给大家的建议也是如此,你一定要做好最坏的打算,接受它但也不要放弃希望,这世界总有些事我们无法阻挡,但我们还能阻挡大部分的事情,不是么?

好像我其实本来还有更多的体会,没有记东西的习惯,以后记起来再加上吧.下面写些工作总结吧.
1. 生成代码时不要不设置项目的Netual Language,也不要设置成中文,至少目前不要这样设置,不然你在提交应用的时候会得到完全摸不着头脑的错误提示.如下图:

2. Paint.NET是个好工具,http://www.iconfinder.com/是个不错的图标网站
作为一个程序员,UI设计是个相当大的烦恼,这直接导致我对游戏类应用只能想想,无法动手.不过在设计图标的时候,Paint.NET确实很有帮助,虽然它没有PS那么强大,但对图层之间的操作还是相当方便的,所以我的两个应用的图标基本是先从iconfinder或者网上上面找个相关的图标,然后进行一些文字插入和混合,最终虽然图标仍然不好看,但总算有个东西了.所以你如果没有个设计老婆或者合伙人的话,那么你可以考虑使用下上面的工具凑活凑活吧.下面我给大家展示我自己的拙作(实在毫无艺术细胞,见笑了):

上面就是我这差不多一个多月的业余工作总结,总体来说,离开.NET有一年多了,这次因为WinPhone而回归. 总体来说, WinPhone对个人开发者来说(工作室我没搞过,没资格谈论),如果你一开始野心并不是太大,从一开始一个小却有用的思路做起,那么这个生态环境其实也蛮适合你的.不需要太多的书籍(很多书籍也都是些重复的初级内容,没什么价值,甚至有些还不如MSDN或者Windows Phone Developer Tools Documentation), 只要你愿意,从现在动手,那么说不定有一天你真能收获意外之喜哦.

总结下来目前能记起来的东西就这么多,忘掉的太多,技术方面的东西基本没有(有机会的话我会在后面把自己代码中认为稍稍拿得出手的东西跑出来给大家参考下),更多的是自己的一些工作思路的总结,希望能对你们有一点点帮助就行,如果能做到抛砖引玉那就更好啦!

然后是广告时间啦, 呵呵,两个很简单的应用(Chinese Phone Address Finder/ Chinese Subway),首先,当然是得到你们更多的反馈了, 应用里面有邮箱地址,你们随时可以发邮件给我反馈, 还有就是, 俺最大的愿望就是能攒到明年的年费99刀, 你们要在用这两个应用实在很闲,可以考虑多点几下上面的广告哦,多谢啦,当然,不奢望,大家随意就行! 另外, 我在慢慢熟悉这个环境之后,也会努力做出更多希望能对大家有所帮助的工具来.

再然后就是给大家一些信息,那就是虽然普及度无法和其他平台相比,但国内的Win Phone用户也是有一定数量的,我的归属地应用发布差不多20天左右,已经有了2k+的下载量(虽然到后期增长很缓慢), 相信那些热门的应用下载量应该会更大, 这多少算个不错的消息.

最后唏嘘下, 从了解园子到现在差不多应该有4-5年了吧(真记不清了)看到园子里的活跃园友每年都不一样,心里总有些感叹.这个圈子陪了我挺多年的,一直都是当看客,没处理,心中确实有愧.真心希望各位园友都能从这里得到成长,成熟.

本文链接

C#与闭包

2011-08-04T14:35:00Z

首先想说明一点,虽然有这样那样的不好的心态(比如中文技术书),但总体来说,国内的技术人员还是喜欢分享和教导别人的,这点我的个人感受和之前在园子里看到的朋友的感受恰恰相反.个人认为其实国内很多技术网友都是很热心的,可能因为语言问题同一个技术热点会稍稍落后国外一些,但一些成熟的或者基础的概念都可以找到很细致的中文介绍,特别是关于闭包,因为它的字面解释确实很绕,所以基本所有试图解释这一名词的同学都是尽量用自己认为最通俗易懂的方式来进行讲解.闲话扯远了,这里我就用C#语言来给大家解释下闭包吧.

其实要提到闭包,我们还得先提下变量作用域和变量的生命周期.
在C#里面,变量作用域有三种,一种是属于类的,我们常称之为field,第二种则属于函数的,我们通常称之为局部变量,还有一种,其实也是属于函数的,不过它的作用范围更小,它只属于函数局部的代码片段,这种同样称之为局部变量.这三种变量的生命周期基本都可以用一句话来说明,每个变量都属于它所寄存的对象,即变量随着其寄存对象生而生和消亡.对应三种作用域我们可以这样说,类里面的变量是随着类的实例化而生,同时伴随着类对象的资源回收而消亡(当然这里不包括非实例化的static和const对象).而函数(或代码片段)的变量也随着函数(或代码片段)调用开始而生,伴随函数(或代码片段)调用结束而自动由GC释放，它内部变量生命周期满足先进后出的特性。

那么这里有没有例外呢?
答案是有的,不过在提这点之前,我还需要给各位另外一个名词.都说c#就是MS版本的java,这话在.net 1.0可能可以这么说,但自2.0之后C#就可以自豪的说它绝非java了,这里面委托有很大的功劳,如果用过java和C#的人并且尝试过写winform程序时全部手写实现代码的人就会有这样一个感受,同样的click事件,在java中必须要无端的套个匿名类,但在c#中,你是可以直接将函数名+=到事件之后而不需要显示写上匿名委托的对象类型的,因为编译器会帮你做这部分工作,在3.0和以后的版本之中,微软将委托的用法更是发挥的淋漓精致,无论是简洁的Lamda还是通俗易懂的LINQ,都是源自委托的.

你可能要问,委托和我们今天要讲的闭包又有什么关系呢?
我们知道,c#,java和javascript,ruby,python这些语言不同,在c#和java的世界里面,原子对象就是类(当然还有struct和基本变量),而不是很多动态语言中的函数,我们可以实例化一个类,实例化一个变量,但不可以直接new 一个函数.也就是表面上看,我们是没办法像js那样将函数进行实例化和传递的.这也是为什么直到Java 7闭包才被姗姗来迟的加入java特性中。但对C#来说这些只是表象,我刚学c#的时候,看到最多的解释委托的话就是:委托啊,就相当于c++里面的函数指针啦.这句话虽然笼统,但确实有一定道理,通过委托特别是匿名委托这层对象的包装,我们就可以突破无法将函数当做对象传递的限制了.

好像这里还是没讲到闭包和委托的关系,好吧,我太啰嗦了,下面从概念开始讲.
闭包其实就是使用的变量已经脱离其作用域,却由于和作用域存在上下文关系,从而可以在当前环境中继续使用其上文环境中所定义的一种函数对象.
好拗口,程序员,还是用示例来说明更好理解.
首先来个最简单的javascript中常常见到的关于闭包的例子:

function f1(){
　　　　var n=999;
　　　　return function(){
　　　　　　alert(n); // 999
            return n;
　　　　}
　　}
    var a =f1();
    alert(a());

这段代码翻译成C#代码就是这样：

public class TCloser
    {
        public Func<int> T1()
        {
            var n = 999;
            return () =>
            {
                Console.WriteLine(n);
                return n;
            };
        }
    }
   
    class Program{
        static void Main(){
            var a =new TCloser();
            var b = a.T1();
            Console.WriteLine(b());
        }
    }

从上面的代码我们不难看到,变量n实际上是属于函数T1的局部变量，它本来生命周期应该是伴随着函数T1的调用结束而被释放掉的，但这里我们却在返回的委托b中仍然能调用它，这里正是闭包所展示出来的威力，因为T1调用返回的匿名委托的代码片段中我们用到了n,而在编译器看来，这些都是合法的，因为返回的委托b和函数T1存在上下文关系，也就是说匿名委托b是允许使用它所在的函数或者类里面的局部变量的，于是编译器通过一系列动作(具体动作我们后面再说)使b中调用的函数T1的局部变量自动闭合，从而使该局部变量满足新的作用范围。
    因此如果你看到.net中的闭包，你就可以像js中那样理解它，由于返回的匿名函数对象是在函数T1中生成的，因此相当于它是属于T1的一个属性。如果你把T1的对象级别往上提升一个层次就很好理解了，这里就相当于T1是一个类，而返回的匿名对象则是T1的一个属性，对属性而言，它可以调用它所寄存的对象T1的任何其他属性或者方法，包括T1寄存的对象TCloser内部的其他属性。如果这个匿名函数会被返回给其他对象调用，那么编译器会自动将匿名函数所用到的方法T1中的局部变量的生命周转期自动提升并与匿名函数的生命周期相同，这样就称之为闭合。

    也许你会说，这个返回的委托包含的变量n只是编译器通过某种方式隐藏的对这个委托对象的一个同样对象的赋值吧，那么我们再对比下面两个方法：

public class TCloser{
public Func<int> T1()
    {
        var n = 999;
        Func<int> result = () =>
        {
            return n;
        };

        n = 10;
        return result;
    }

    public dynamic T2()
    {
        var n = 999;
        dynamic result =new { A = n };
        n = 10;
        return result;
    }
    static void Main(){
        var a = new TCloser();
        var b = a.T1();
        var c = a.T2();
        Console.WriteLine(b());
        Console.WriteLine(c.A);
    }
}

最后输出结果是什么呢？答案是10和999，因为闭包的特性，这里匿名函数中所使用的变量就是实际T1中的变量，与之相反的是，匿名对象result里面的A只是初始化时被赋予了变量n的值，它并不是n，所以后面n改变之后A并未随之而改变。这正是闭包的魔力所在。

    你可能会好奇.net本身并不支持函数对象，那么这样的特性又是从何而来呢？答案是编译器，我们一看IL代码便会明白了。
    首先我给出c#代码：

public class TCloser {
        public Func<int> T1(){
            var n = 10;
            return () =>
            {
                return n;
            };
        }

        public Func<int> T4(){
            return () =>
            {
                var n = 10;
                return n;
            };
        }
    }

这两个返回的匿名函数的唯一区别就是返回的委托中变量n的作用域不一样而已，T1中变量n是属于T1的，而在T4中，n则是属于匿名函数本身的。但我们看看IL代码就会发现这里面的大不同了：

.method public hidebysig instance class [mscorlib]System.Func`1<int32> T1() cil managed{
    .maxstack 3
    .locals init (
        [0] class ConsoleApplication1.TCloser/<>c__DisplayClass1 CS$<>8__locals2,
        [1] class [mscorlib]System.Func`1<int32> CS$1$0000)
    L_0000: newobj instance void ConsoleApplication1.TCloser/<>c__DisplayClass1::.ctor()
    L_0005: stloc.0
    L_0006: nop
    L_0007: ldloc.0
    L_0008: ldc.i4.s 10
    L_000a: stfld int32 ConsoleApplication1.TCloser/<>c__DisplayClass1::n
    L_000f: ldloc.0
    L_0010: ldftn instance int32 ConsoleApplication1.TCloser/<>c__DisplayClass1::<T1>b__0()
    L_0016: newobj instance void [mscorlib]System.Func`1<int32>::.ctor(object, native int)
    L_001b: stloc.1
    L_001c: br.s L_001e
    L_001e: ldloc.1
    L_001f: ret
}

.method public hidebysig instance class [mscorlib]System.Func`1<int32> T4() cil managed
{
    .maxstack 3
    .locals init (
        [0] class [mscorlib]System.Func`1<int32> CS$1$0000)
    L_0000: nop
    L_0001: ldsfld class [mscorlib]System.Func`1<int32> ConsoleApplication1.TCloser::CS$<>9__CachedAnonymousMethodDelegate4
    L_0006: brtrue.s L_001b
    L_0008: ldnull
    L_0009: ldftn int32 ConsoleApplication1.TCloser::<T4>b__3()
    L_000f: newobj instance void [mscorlib]System.Func`1<int32>::.ctor(object, native int)
    L_0014: stsfld class [mscorlib]System.Func`1<int32> ConsoleApplication1.TCloser::CS$<>9__CachedAnonymousMethodDelegate4
    L_0019: br.s L_001b
    L_001b: ldsfld class [mscorlib]System.Func`1<int32> ConsoleApplication1.TCloser::CS$<>9__CachedAnonymousMethodDelegate4
    L_0020: stloc.0
    L_0021: br.s L_0023
    L_0023: ldloc.0
    L_0024: ret
}

看IL代码你就会很容易发现其中究竟了，在T1中，函数对返回的匿名委托构造的是一个类，名称为newobj instance void ConsoleApplication1.TCloser/<>c__DisplayClass1::.ctor()，而在T4中，则是仍然是一个普通的Func委托，只不过级别变为类级别了而已。
那我们接着看看T1中声明的类c__DisplayClass1是何方神圣：

.class auto ansi sealed nested private beforefieldinit <>c__DisplayClass1
    extends [mscorlib]System.Object{
    .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor()
    .method public hidebysig specialname rtspecialname instance void .ctor() cil managed{}
    .method public hidebysig instance int32 <T1>b__0() cil managed{}
    .field public int32 n
}

看到这里想必你已经明白了,在C#中,原来闭包只是编译器玩的花招而已,它仍然没有脱离.NET对象生命周期的规则，它将需要修改作用域的变量直接封装到返回的类中变成类的一个属性n,从而保证了变量的生命周期不会随函数T1调用结束而结束，因为变量n在这里已经成了返回的类的一个属性了。

看到这里我想大家应该大体上了解C#闭包的来龙去脉了吧，C#中，闭包其实和类中其他属性、方法是一样的，它们的原则都是下一层可以畅快的调用上一层定义的各种设定，但上一层则不具备访问下一层设定的能力。即类中方法里的变量可以自由访问类中的所有属性和方法，而闭包又可以访问它的上一层即方法中的各种设定。但类不可以访问方法的局部变量，同理，方法也不可以访问其内部定义的匿名函数所定义的局部变量。

这正是C#中的闭包，它通过超越java语言的委托打下了闭包的第一步基础，随后又通过各种语法糖和编译器来实现如今在.NET世界全面开花的Lamda和LINQ.也使得我们能够编写出更加简洁优雅的代码。

附：后面是吐槽，与上文无关，大家可以略过，这篇文章其实两年之前在给同事讲C#闭包的时候就有想法整理出来和大家分享了，不过因为生活，工作，或许主要还是自己太懒的原因而拖着没动笔，到今天早上看到园友抱怨国内教书育人的氛围才最终决定利用晚上时间把它整理，然后放出来。我个人认为国内技术圈子的氛围尚可，虽然仍然很多浮躁和易怒在圈子里徘徊。但我们想想国内IT人的生存空间就容易理解了。每天最理想的情况朝9晚6的干活，晚上加班，周末加班这些都是常事，而对我们而言，只要想写出一些经过细细思考的东西都至少需要2个小时以上，而且最好中间不要有人来打扰，这也就注定我们在白天工作时候很难完全有时间静下来组织语言，刨掉这些时间，留给我们自己的生活时间又有多少呢？所以我每次看到有园友发表帖子的时间是晚上1点，2点甚至更晚，都毫不意外，
我们并非专业写手，也不像国外IT人那样有充足的闲暇时光可以钻研自己的最爱，我们赚着他们的零头，买着比他们本子价格更贵的笔记本，担着比他们更高房价的压力来生活，这样的生活条件下我们这些可爱的社区(不仅限于cnblogs,javaeye,phpchina等)Geek们仍然如此活跃和热情，你还能抱怨什么呢？你要知道你看到的每篇文章(如果是工作人士的话)都是他们晚上从9点写到12点的生活点滴啊。

所以，以后不要抱怨国内IT氛围吧,相对这个社会其他各行各业的浮躁，我觉得我们的IT圈子已经是很乐于分享的一个群体了。而且除了因为“天下武功,源自欧美,滞后于英语国家”的缘故，我们有些技术确实要晚些才能跟上国外社区的脚步，但对于一些基础知识的解释，已经有很多中文的文章解释得很不错了。像我以前在理解闭包的时候, javaeye上看到的一大堆，像WIKI,像阮一峰的文章，我个人认为对中文用户是足够了。当然，这只是我个人的观点，大家不必较劲。

最后一点抱怨就是国内大大小小的抄袭网站,我想这也是影响我们中文用户查询资料的一个重要因素吧。以前曾经尝试过在baidu,google上搜索自己的文章，但结果相当令人失望,那些抄袭的网站从来都不在乎内容，因为这些可以通过抄来解决，而且不必带原文链接，不必表明作者。好像东西就是他们自己的一样，他们唯一在乎的就是SEO。这也导致我在使用google搜索的时候时常看到同一篇文章出现在某一页的所有搜索结果中，当然，网址是千奇百怪，实在让人无奈。有些网站即使标明了出处和作者，但用心略有险恶的不是给的链接，而是文字。而且,在这些抄袭者中,最让我感到悲哀的是大名鼎鼎的败毒文库,我至少看到不下5篇败毒文库里的文章是来自JE或者CSDN的,但在文库里面只有个文档，你看不到任何作者提示或者原文链接,也许有人会说，这也可能是作者自己上传的呀,但我个人认为这种可能性太小了,以国内IT人的风格,对败毒即使谈不上厌恶,也很少有主动去巴巴的，试想，一个国内最大的互联网公司都不尊重IT人的劳动(但愿我是错的吧),你又能对其他人说什么呢? 同样看看国外，就我看到的DZone, WindowsPhoneGeek等,每个都是很明确的给出原文的链接，基本上我很少看到有引用别人文章不给原文链接的文章的。而正是这些不尊重作者劳动的网站对国内互联网资料搜索造成大量的垃圾信息。

引用：
维基百科 http://zh.wikipedia.org/wiki/%E9%97%AD%E5%8C%85_%28%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6%29
博客园 http://www.cnblogs.com/frankfang/archive/2011/08/03/2125663.html

本文链接

.NET 4.0新增命名空间：System.Collections.Concurrent

2010-03-08T16:35:00Z

集合类的需求总是源源不断，因此，不管是1.0到2.0的泛型，还是3.0到4.0的并行(本文的并行指Concurrent,非Parallel)，.NET每个版本总会伴随着一些集合类的增长。由于并行计算现在已经越来越流行，这里我将对.NET 4.0中新增的命名空间System.Collections.Concurrent和它下面的类做一些简单的介绍。

为什么需要Concurrent?

相信不少朋友都有多线程编程的经历吧，不过在.NET 4.0以前，多线程编程下很容易出问题，先看个简单的例子吧。

static void main()
{
    myList = new List<string>();
    for (int i = 0; i < 1000; i++)
    {
        myList.Add(i.ToString());
    }
    new Thread(T2).Start();
    new Thread(T3).Start();
}

static IList<string> myList;
static void T2()
{
    Thread.Sleep(100);
    for (int i = 0; i < 50; i++)
    {
        myList.Remove(i.ToString());
    }
}
static void T3()
{
    foreach (var a in myList)
    {
        Console.WriteLine(a);
    }
}

在这个例子中，我们首先初始化一个长度为1000数组，然后我们开启两个线程，一个进行删除操作，另外个则进行简单的读操作。运行代码的话你会发现程序会抛出InvalidOperationException,因为系统集合在被读的同时被修改了，因此列举操作可能不能执行。

当然在4.0以前我们也有办法避免这种类似的操作，比如我们可以对要操作的对象加锁。即我们可以在对myList集合进行读写操作之前对其添加代码lock (myList)。

然而这种方式毕竟不够简洁，并且在更复杂的情况下它可能会显得非常繁琐。这时候支持并行操作的集合应运而生了。

有哪些Concurrent集合？

在System.Collections.Concurrent公开的类并不多，他们分别在两个不同的dll中存在，其中在System.dll中仅仅一个BlockingCollection<T>和ConcurrentBag<T>，在mscorlib.dll中则稍多一些，他们分别是ConcurrentQueue<T>, ConcurrentStack<T>, ConcurrentDictionary<TKey, TValue>。不过对于日常开发来说，他们基本够用。下面我们来一个个看下这些类的构造吧。

首先看看mscorlib中的几个类，这些类其实我们在.NET 2.0中已经接触过它们的普通版本，因此它们功能基本不变，因此你仍然可以像以前那样使用普通版本的哈希表，队列和堆栈来使用它们。

不过并行类不仅仅简单以前的集合类改造成线程安全的并行类，它同时还提供了一些更丰富的功能，由于Lamda表达式的引入，现在在ConcurrentDictionary<TKey, TValue>你可以通过AddOrUpdate或GetOrAdd添加自己的值生成方案。这使得我们在生成键值对的时候更加方便和简单了。如：

ConcurrentDictionary<int, string> td = new ConcurrentDictionary<int, string>();
Func<int, string> genVar = (i) => i.ToString();
Task.Factory.StartNew(() =>
{
    for (int i = 0; i < 1000; i++)
    {
        td.GetOrAdd(i, genVar);
    }
});
Task.Factory.StartNew(() =>
{
    Func<int, string, string> updateVar = (key, oldVar) => oldVar + key;
    td.AddOrUpdate(0, genVar, updateVar);
    Console.WriteLine(td[0]);
}).Wait();

我们可以看到，现在我们在取值的时候，如果哈希表中没有该值的话我们可以自己生成，或者我们在添加新的值的时候如果碰到重复键值的时候也可以很方便的解决掉了。相对以前在添加或者查找数据时痛苦的判断，这种方式更加简洁和方便。

其他几个类相对来说函数使用变化不大，唯一区别比较大的也是在Concurrent命名空间中很常见的各种try函数操作。

接着我们来看看在System.dll中的并行集合，这里面的两个类在以前的.NET中是没有的。首先看看ConcurrentBag<T>，顾名思义，这个类提供并行数据包的功能，这个类相对来说构造比较简单，它继承自四个接口：IProducerConsumerCollection<T>, IEnumerable<T>, ICollection, IEnumerable，后面三个集合类常用的接口我们当然很熟悉，而且由于实现了IEnumerable<T>接口，ConcurrentBag<T>也支持LINQ操作。不过这里有个特殊的接口IProducerConsumerCollection<T>我们以前没有见过，虽然是个新的接口，但故名思意，这个接口提供了生产者/消费者的集合操作，它提供了四个基本的方法：CopyTo(T[],int), ToArray(), TryAdd(T), TryTake(out T)。其中我们主要关注后面的两个方法，TryAdd是添加元素操作，而TryTake则是取元素操作。不过在ConcurrentBag中，TryAdd方法被设置为protected,外部对象需要通过Add操作来添加元素。另外，取元素的话，除了TryTake之外，我们还可以通过TryPeek来取集合当前的最后一个元素而不删除它。下面来看看例子：

static void main()
{
    ConcurrentBag<string> bag = new ConcurrentBag<string>();
    Task.Factory.StartNew(() =>
    {
        for (int i = 0; i < 1000; i++)
        {
            bag.Add(i.ToString());
        }
        bag.Add("Last");
    });

    Task.Factory.StartNew(() =>
    {
        foreach (string item in bag)
        {
            Console.WriteLine(item);
        }
    }).Wait();
}

BlockingCollection<T>相对来说，要稍微复杂一些，它实现了四个接口：IEnumerable<T>, ICollection, IEnumerable, IDisposable，因此该集合同样支持LINQ，不仅如此，它也提供了比ConcurrentBag更加丰富的功能。如CompleteAdding和超时设置的TryAdd和TryTake方法等等。

总结

随着多线程和并行编程的要求越来越多，相信在未来，.NET家族新增的这些类将会在我们的日常编程生活中越来越常见，所以掌握它们也显得越来越又必要了。

本文链接

.NET程序员学PHP:常见编程错误

2010-03-07T07:21:00Z

这篇文件我将继续PHP之旅，并对网上找到的一些PHP中常见的错误进行收集和总结，希望对大家有所帮助。

1. 小错误也能酿大祸

你碰到过仅仅因为一个小小的分号而导致程序出现大问题的情况么？在PHP中如果你while循环的条件后面加上了分号的时候会导致PHP陷入死循环，而且这种错误设置都不会被PHP异常处理系统捕获。我们先看看代码吧：

$i = 0;
while($i < 20); {
    //some code here
    $i++;
}
echo $i;

这段代码不会导致系统报告错误，然而却会导致系统进入死循环并且最终因为无法及时响应而返回执行超时的错误。

不过在C#中同样的会在编译时就被编译器捕获，并且编译器会知道这是个空循环的错误。当然如果用户一定犯傻写出另外的死循环编译器就没办法了，如：

int i = 0;
while (i < 20) ;

这种情况编译器不会报错。

2. 忘了在break或continue后面加上分号。

同样是小小的符号导致巨大的差异，看下面的代码先：

for($i = 0; $i < 10; $i++) {
    for($j = 0; $j < 10; $j++) {
        if($i == 0)
        break
        print $j;
    }
}

这段代码最终只会输出0的结果，然后退出循环，然而我们的意愿原本是输出除0外的其他数字。当然如果我们使用规范的方式(如在if条件判断之后加大括号)这个错误很容易避免。

3.单引号还是双引号?

这条严格以上说不能算错误，首先看下面的两行代码：

echo ‘it\’s ok’;
echo “it’s not”;

PHP不像C#,单引号和双引号都可以用来表示字符串，因此很多PHP新手往往分不清什么时候该用哪种符号来包裹字符串，或者干脆想用什么就用什么符号。不过单引号和双引号在PHP中是有使用技巧的。如果一个字符串由双引号开始，那么只有双引号被分析器解析。这样，你就可以在双引号串中包含任何其他字符，甚至单引号和PHP变量。e.g.

$var1=’Sean Zhu’;
echo ‘Hello, $var1. I’m Mike!’;//输出：Hello, $var1. I’m Mike!
echo “Hello, $var1. I’m Mike!”;//输出：Hello, Sean Zhu. I’m Mike!

然而正所谓能力越大，消耗越大，双引号拥有复杂的功能也意味着编译器处理它也要花费更多的时间，因此如果我们仅仅想输出简单的字符串的话，最好还是使用单引号。

4. 对浮点数进行比较

作为一个.NET程序员，如果看到下面的代码，你知道它的结果么？

<?php
$a=0.1+0.2;
$b=0.3;
if($a==$b){
echo 'a equals b';
}
else{
echo 'a dosen\'t equal b';
}
?>

在.NET中我们可以毫无犹豫的知道它输出的是a=b的答案，然而这里是PHP的世界，所以永远不要相信浮点数结果精确到了最后一位，也永远不要比较两个浮点数是否相等。

5. 只要method_exists()返回结果为true我们就能调用该它么？

PHP不像C#, 由于C#是一门静态语言，所以我们可以放心大胆的调用任何方法(只要编译器说没问题)，然而在php中只要你没执行到最终的方法那一步，一切都还是未知数。因此我们有时候在调用方法之前需要做些额外的检查工作，method_exist()就是其中之一，然而如果方法是protected或者private，该方法同样也会返回true。

6. 使用未初始化的数组

看看下面的代码有什么问题？

<?php
foreach($items as $item) {
$itemIds[] = $item->getId();
}
?>

.NET程序员是永远不会犯上面的错误的，因为编译器会帮我们做检查，然而作为一个PHP程序员，我们始终都要记得给数组初始化：$itemIds = Array(); 可能你会说，上面的代码不初始化也不会有什么问题啊。是的，在正常情况下，只要$items数组里面的元素大于1的时候，这段代码确实没什么问题，然而，如果$items对象为空或者里面元素数量为0，这段代码就有问题了。

7. include(“pages/” . $_GET["pg1"]);

.NET程序员虽然也会遇到各种各样的注入攻击，但至少这个攻击他们不会遇到。实际上，不仅仅是$_GET()参数我们应该检查，其他的如$_POST和$_REQUEST同样具有非常高的危险性。如果始终对用户信任的话，你可能会在不知不觉中加载了别人的代码却浑然不知。

8. 给数组索引添加引号

echo $array[my_key]; //一般能正常工作，但不应该使用
echo $array['my_key']; //正确的方式

PHP编译器会认为没有引号的字符串是一个已经定义的常量，然后它会去符号表中查找这个常量，只有找不到的时候，它才会把这个键值转换为真正的字符串，这就是上面代码为什么也能工作的原因

9. strpos / stripos 函数使用不当。

这个函数在.NET中也有类似的：string.IndexOf()，但在.NET中我们一般不会犯这个初级错误,我们来看看下面的代码有什么问题吧。

if (strpos(‘Spring Brother is cool, isn’t it?’, ‘Spring Brother’)) {
echo “Spring Brother is cool”;
} else {
echo “Spring Brother is NOT cool”;
}

猜猜输出结果是什么？对的，它会输出"Spring Brother is NOT cool”, 因为就像.NET中一样，由于索引从0开始，strpos返回的是0，0会转换为false。而在.net中，如果程序员不进行强制转换，这种错误很容易显现出来。

解决这种初级错误的方式也很简单，常用方式有以下两种：

if (strpos(‘Spring Brother is cool, isn’t it?’, ‘Spring Brother) !== false) {
//或者
if (strpos(‘Spring Brother is cool, isn’t it?’, ‘Spring Brother’)>= 0 ) {

10. 使用==比较类型。

这种错误其实跟js中的比较一样，由于PHP和js都是弱类型的语言，因此有时我们比较两个对象时可能遇到意想不到的事情。看下面的代码：

$a = 1;
$b = ‘1′;
$c = 1;
$a == $b // true
$a === $b // false
$a === $c // true

我们可以看到，即使$a和$b本来不是同一个对象，但这里==比较返回的结果却是true，因此如果想要对对象做更严格的类型比较时最好用===和!==比较符。

11. empty()方法和魔术方法__get一起使用。

魔术方法很好用，不过当它和empty方法一起使用的时候我们需要格外小心，先上代码：

class Example {
    public function __get($name) {
        return 'this should not show up as empty';
    }
}
function t7(){
    $e = new Example();
    if(empty($e->something))
    echo 'something条件为真';

    $var = $e->something;
    if(empty($var))
    echo '$var条件为真';
}
t7();

我们会发现第一个条件为真，然而同样的值在第二个条件中却为假了。

12. 未对Session中的敏感数据进行任何保护

一个常见的PHP安全错误就是未对存放在Session中的敏感数据进行任何类型的加密处理。在某种程度上这就相当于把用户的密码等信息裸露在网络当中，某些黑客可以通过Sesion伪造等技术来窃取用户的密码信息。

本文链接

.NET程序员学PHP:static关键字

2010-03-03T16:42:00Z

学习PHP也有一段时间了，有些东西觉得还是需要总结一些，对于.NET程序员来说，PHP中有很多概念都跟以前的理解不一样，这里我们将重点分析下static关键字。

static关键字在C#编程中非常常见，它用来修饰符声明属于类型本身而不是属于特定对象的静态成员。static 修饰符可用于类、字段、方法、属性、运算符、事件和构造函数，但不能用于索引器、析构函数或类以外的类型。声明为static的类、函数和变量将不能引用实例方法或变量，另外在C#中一旦类被添加了static修饰符，则其内部所有变量和方法都必须是静态的。静态变量和方法必须通过类名进行引用而不能通过实例对象引用。

那么static关键字在php中与C#中都有些什么不同呢？

声明范围。

相对C#来说，PHP中static变量的使用范围要更广一些，我们不仅可以在类，方法或变量前面添加static修饰符，我们甚至还能给函数内部变量添加static关键字。添加了static修饰符的变量即使在该函数执行完毕值仍然不会丢失，也就是说，在下一次调用这个函数时，变量仍然记得原来的值。如：

<?php
function test(){
    static $var1=1;
    $var1+=2;
    echo $var1.'&nbsp';
}
test();
test();
test();
?>

代码会输出：3 5 7

这里有一点需要注意的是，变量的赋值操作只会在变量第一次初始化时会被调用，在之后函数的执行过程中，这个操作不会被调用。

由于PHP中函数同样是一等公民，所以不同于C#，我们可以直接定义函数，并直接在代码的任何地方调用，这一点跟javascript倒是有些相似。因此这时候函数静态变量会比定义全局变量更加有用，它可以避免变量重复定义导致冲突。而由于C#中函数无法直接定义和调用，它必须寄宿在类中，所以如果函数需要静态变量，我们只需要在类中定义便能达到相同效果。

调用方式

C#中，我们调用静态成员的方式非常简单和一致，因为静态成员不属于实例对象，所以无论是方法还是变量，C#对其静态成员的访问方式一律是通过类名.方法(变量)进行。并且在C#中，静态函数是不能被设置为虚方法或者覆盖的。而PHP对此则提供了更为灵活多样的支持。

首先，我们知道PHP中调用实例方法都是通过如：someobj->someFun()调用，那么我们调用静态函数是否也能像C#那样通过SomeClass->someFun()调用呢？答案是否定的，在PHP中，对静态成员的调用只能通过::的方式进行，如：SomeClass::someFun()。

<?php
class TestC{
    public static $var1=1;
    public $var2=1;
    function t1(){
        self::$var1+=2;
        echo self::$var1.'&nbsp';
        echo $this->var2.'&nbsp';
    }
    public static function t2(){
        self::$var1+=2;
        echo self::$var1.'&nbsp';
    }
}
$t=new TestC();
$t->t1();
TestC::t2();

结果输出为：3 1 5

另外一点和C#中不同的是，在类中的方法中，如果我们需要调用静态变量，必须通过self::$somVar静态变量(注意变量前面的$符号,实例变量不需要)，而调用静态方法则为self::someFun()(这里不需要$符号)。如上例。

另外，与C#最大的不同之处就是，PHP中，子类是可以覆盖父类的静态函数或变量的，不仅如此，(站在C#程序员的角度来看，我觉得PHP这点反而将事情搞复杂了)，由于默认self::staticFun()调用的是子类的静态函数，这个时候如果我们想调用父类的静态变量怎么办呢？这里PHP提供了额外的parent来调用基类的静态成员。如：

<?php
class Test1{
    public static $var1=1;
    public static function t2(){
        self::$var1+=2;
        echo self::$var1.'&nbsp';
    }
}
class Test2 extends Test1{
    static $var1=‘Hello’;
    static function t2(){
        parent::t2();
        echo self::$var1.'&nbsp';
    }
}
Test1::t2();
Test2::t2();
?>

结果输出为：3 5 Hello

最好，根据上面的例子我们很容易想到，子类访问父类可以使用parent关键字，那么父类如何访问子类的静态方法呢？这里给出static的另外一个用法，这里如果将调用的静态方法前面的作用域换成static的话，PHP会根据该类的继承层次来计算最终的静态方法。如：

<?php
class Test1{
    function t1(){
        static::t2();
    }
    public static function t2(){
        echo self::'Test1&nbsp';
    }
}
class Test2 extends Test1{
    static function t2(){
        echo self::'Test2&nbsp';
    }
}
$t=new Test2();
$t->t1();
Test2::t2();
?>

结果输出为：Test2 Test2。

这里t实例在t1方法调用t2静态方法时，会根据其实例找到最终的静态方法并输出Test2。

生命周期

由于.NET和PHP本质的不同，所以static在两种语言中运行时会有明显的不同，在.NET中，static是伴随程序生命周期而存在的，也就是说任何.NET程序，不管是ASP.NET Web程序还是普通的WinForm程序，只要程序启动之后，static的值就会被一直保留，比如我们访问一个Web站点时，如果里面有个int的访问计数的静态变量表示访问人数，只要IIS和该进程没有停止，静态变量值就不会被重置。但在PHP中，static值仅在用户的一次访问过程中存在，也就是说，static的生命周期为从用户发送请求到服务器端返回最终视图结果的整个过程，在这之后，所有的静态变量都会被服务器释放掉，直到下次用户发送新的请求重新初始化。

总结

从上面的分析，我们不难看出，对于静态成员的使用，PHP提供了比C#更为强大的功能或灵活性，但从我的角度来看，这种灵活性不见得就更好，从某种角度来看，如果类的继承层次过于复杂，它可能会让我产生混淆。当然，同样的工具不同人使用效果会完全不一样，既然PHP提供了更多样的选择，那么相信如果使用恰当的话，PHP中的static可能会提供比C#中更为强大而简便的使用方式。

本文链接

PHP:使用'./include.php'替换'include.php’

2010-03-02T12:45:00Z

最近在学PHP,习惯性的喜欢把它与.NET作些比较，发现其中一个不同就是对其他文件中对象的引用问题。我们知道，java中有包的概念，而.NET中则有更加方便的DLL程序集引用的概念，通过这些以打包形式组合在一起的对象集合，我们可以很方便的在自己的类中引用其他地方定义的类或其他对象，但由于PHP中没有相应的概念，所以在需要引用其他文件中定义的对象时，PHP程序员最常用的两个函数莫过于require_once和include了，通过这两个函数，我们可以使用其他类库中定义的类等对象。但很多人在使用包含相同目录下的其他文件时，仅仅简单使用下面的代码进行文件引用：

include('include.php');

当然这种方式并没有错误，只不过在效率上它比下面的方式要稍稍差些：

include(realpath(dirname(_FILE_)).DIRECTORY_SEPARATOR.'include.php');

这种方式我们可能需要输入更多一些，但相对于前面那种需要PHP引擎去include_path 中迭代查找所有名称为'include.php’才能查找到相应对象来说，dirname(__FILE__)这种绝对路径的指定会让系统迅速定位到相应文件。

在PHP中常量__FILE__ 其实跟C#中的AppDomain.CurrentDomain.BaseDirectory非常类似，它返回的是当前代码正在执行的代码所在文件的绝对路径。而函数dirname()则返回其父文件夹路径。

另外一个更查找效率高，并且书写简单的方式是include('./include.php')，这相当于告诉系统查找当前路径下的'include.php’文件。

在大型系统中我们常常使用另外一个更好的方式，我们常常在路由文件或其他初始化文件中加入如下代码：

define('APP_PATH',realpath(dirname(_FILE_)));

这相当于给系统添加了一个全局变量来指出系统根目录，当我们后面需要引用某具体路径下的文件时我们就可以使用如下代码了：

include(APP_PATH.DIRECTORY_SEPARATOR.'models'.’User.php’);

希望这个小小的总结能对你有所帮助！

注：刚刚发现PHP 5.3之后有个Phar新特性，据说和java的jar包概念一样，不过网上资料不多，还没实际用过。找到个介绍它的文章:http://www.ibm.com/developerworks/cn/opensource/os-php-5.3new4/index.html

本文链接

C# Tips-2

2010-03-01T15:20:00Z

上次写过一些平常开发中总结的小技巧，这次继续补充一部分。

1. 多个Using简化书写。

我们经常会遇到需要使用多个using对象的时候，这时候我们可能这样写代码：

using (Class1 c1 = new Class1(someParam1))
{
using (Class2 c2 = new Class2(someParam2))
{
//TODO:在这里添加功能代码
}
}

实际上，我们可以简化书写：

using (Class1 c1 = new Class1(someParam1),Class2 c2 = new Class2(someParam2))
{
//TODO:在这里添加功能代码
}

2. 很多时候，我们在判断某字符串是否是某几个指定字符串之一，可能会写出下面的代码:

bool NameExists(string name) {
return name == “张三” || name == “李四” || name == “王五” ||name == “赵六”;
}

但3.0以后这里其实有更加简单的写法：

bool NameExists(string name){
return new[] { “张三”, “李四”, “王五”, “赵六” }.Contains(name);
}

或者如果这种判断很频繁的话，我们还可以使用扩展方法:

public static bool In(this string name, params string[] names)
{
            foreach (string specialName in names)
            {
                if (name != specialName) return false;
            }
            return true;
}

var name="test";
Console.Write(name.In("张三",“李四”, “王五”, “赵六”);

3. 在比较字符串时，我们有时会忽略大小写比较，你可能会这样写代码：str1.ToUpper() == str2.ToUpper(), 不过实际上string对象已经提供了很多更好的方法，如: str1.Equals ( str2, StringComparison.OrdinalIgnoreCase)

4. ??用于在对象为空时指定默认值，我们可以使用这个特性做多个默认值的绑定

string result = var1 ?? var2 ?? var3 ?? String.Empty;

5. 这种用法并不推荐，不过你确实可以使用中文等非英语语言对类或者方法进行命名，如：

public string 方法1(){
return “XXXXXXX”;
}

不仅如此，你甚至还可以使用转义符来命名：

public string 测试\u9999哈(){
            return "aaa";
}

实际调用的方法名为：测试香哈();

6. 在C#中我们同样可以创建类似JS的匿名行内函数，如：

var var1 = new Func<String>(() =>{
return “测试测试”;
})();

希望这些总结对读者同样会有所帮助。

本文链接