博客园_CoolCode

教你如何成为一名不合格的程序员

2011-06-16T14:57:00Z

本文教你如何成为一名不合格的程序员，已经成为或即将成为或具有该潜质的童鞋可以看看，复习一下，也请不吝赐教。其他的认为一辈子都无法达到这种境界的童鞋，可以以此文作为茶余饭后的笑料。

1. 永远要两次跳进同一个坑里。

2. 让你的Leader重复他/她说过的话。

3. 每件事情只做好一半，但要跟Leader说：差不多了。

4. 永远不要对自己做过的事负责。

5. 要写出连自己都看不懂的代码，这样才显得自己与众不同。

6. 编码规范神马的都是浮云，哥的代码才是标准：变量名用abc，方法名大小写等都是即兴表演。

7. 不管什么问题绝对不要跟Leader说，以免他/她知道你的不足。

8. 你的编程知识已经可以应付一切项目了，啥学习或培训都不用啦，空余时间泡妞玩游戏已经够累啦。

9. 多犯一些低级错误，反正Leader也是闲着没事干，让他/她看看我的“杰作”刺激一下神经多好啊，不是吗？

10. 如果运气不好不小心参加了公司的开发培训，在课堂上左耳进右耳出就可以了，然后在开发过程中不断去提问吧。

11. 像神父传教一样多向周围的程序员宣传“技术无用论”。

12. 上班时间打打酱油，下班时间加加班，这是必须的！

13. 干完一项任务别告诉Leader，一旦让他/她知道就会分配其他任务来的。

14. 拿着一个锤子干活就足够了，其他神马的都是钉子而已。

15. 别去看人家的博客，甭管它有多优秀；买书籍？又不能当饭吃！等有问题，在论坛上发帖跪求就KO了。

16. 你不会写的代码都是因为Leader没有提供一个可以供你Copy的版本而已。

17. 提交一些不能编译的代码到代码服务器吧，很有趣的。

18. 注释是多余的。

19. 未来想做项目经理，所以不用学技术，开发前不用搞什么计划，开发后也不用总结。

20. 多信信什么什么哥之类的，他能让你原地复活，挂几次也不怕，就是不要常挂在一个公司上。

本文链接

QueryBuilder ：打造优雅的Linq To SQL动态查询(支持EF、.Net4)

2011-06-08T13:58:00Z

大概两年前我写了篇《QueryBuilder ：打造优雅的Linq To SQL动态查询》，赢得不少厚爱，如今它还是我博客访问量最高的一篇（即使只有可怜的5500点击量，比一些大牛们少一位数）。时过境迁、岁月不饶人，当年得意之作现在看起来不值一文。收集一下朋友的反馈，主要有下列问题：

不支持 Entity Framework
不支持.Net 4
Equals(c=>c.xx, null) 之前是被忽略掉，实际上应该解析成 c.xx is null。
Between 没有考虑字符串的情况，例如 Between(c=>c.xx, ”A” , ”Z”) 则解析会报错。
部分不支持Nullable类型
其他没实现的功能：大于、小于、或…

——现在——

QueryBuilder已经发生翻天覆地的变化，但对于使用者来说，使用接口还是一成不变的，并且完全兼容上一版本。当然，它依旧是开源&免费的！

var queryBuilder = QueryBuilder.Create<Orders>()
    .Like(c => c.Customers.ContactName, txtCustomer.Text)
    .Like(c => c.Customers.CompanyName, txtCustomer.Text)
    .Between(c => c.OrderDate, DateTime.Parse(txtDateFrom.Text), DateTime.Parse(txtDateTo.Text))
    .Equals(c => c.EmployeeID, int.Parse(ddlEmployee.SelectedValue))
    .In(c => c.ShipCountry, selectedCountries);

技术分析

Lambda表达式的参数作用域

难点在于不同查询条件之间的参数作用域是相对独立的，如果直接使用 Expression.AndAlso来拼接是行不通的。

上一版本用Expression.Invoke解决，但Invoke在EF下不支持。

解决办法是改用 ExpressionVisitor，重写VisitParameter，返回新的参数表达式。

public class ParameterExpressionVisitor : ExpressionVisitor
{
    private ParameterExpression newParameterExpression;

    public ParameterExpressionVisitor(ParameterExpression p)
    {
        newParameterExpression = p;
    }

    public Expression ChangeParameter(Expression exp)
    {
        return Visit(exp);
    }

    protected override Expression VisitParameter(ParameterExpression p)
    {
        return newParameterExpression;
    }
}

也即是获取第一个Lambda表达式的参数，把后面的表达式用该参数替换。

private static Expression GetMemberExpression<T, P>(IQueryBuilder<T> q, Expression<Func<T, P>> property)
{
    if (q.Parameters == null || q.Parameters.Length == 0)
    {
        q.Parameters = property.GetParameters();
        return property.Body;
    }
     
    ParameterExpressionVisitor visitor =new ParameterExpressionVisitor(q.Parameters[0]);

    Expression memberExpr = visitor.ChangeParameter(property.Body);

    return memberExpr;
}

In操作

旧版本的In操作不支持EF，改成通过反射获取泛型方法。

……
       Expression<Func<P[], P, bool>> InExpression = (list, el) => list.Contains(el);
        var methodExp = InExpression;
        var invoke = Expression.Invoke(methodExp, constant, property.Body);
        Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(invoke, parameter);
……

其中有重载的泛型方法的获取比较麻烦，大家可以观摩一下代码，看看有无好建议。

//var method = typeof(Enumerable).GetMethod("Contains");  //因为有重载，这样获取不到
private static MethodInfo method_Contains =
                (from m in typeof(Enumerable).GetMethods()
                 where m.Name.Equals("Contains")
                     && m.IsGenericMethod
                     && m.GetGenericArguments().Length == 1
                     && m.GetParameters().Length == 2
                 select m
                ).First();

Like操作

旧版本的Like操作使用SqlMethods.Like，也不支持EF。新版本改成字符串的Contains。

typeof(string).GetMethod("Contains", new Type[] { typeof(string) })

Between操作

旧版本的Between不支持字符串，例如 Between(c=>c.xx, ”A” , ”Z”) 则解析会报错。新版本增加新的扩展方法单独处理字符串的情况。

Between<T>(this IQueryBuilder<T> q, Expression<Func<T, string>> property, string from, string to)

小结

很难得两年写的东东在今时今日还能保持原有接口不变并成功重构啊，已经激动到内牛满面&裸奔ing…

源代码下载 CoolCode.Linq.V2.rar

参考

http://www.cnblogs.com/coolcode/archive/2009/09/28/IQueryBuilder.html

本文链接

从换纸尿片到项目管理

2011-05-16T17:54:00Z

客户

小霸王（闺女的别称），出生10天。

原始需求

为小霸王换纸尿片。

需求细化

换纸尿片，擦干净屁股，不能着凉，舒服。

客户满意度

小霸王不哭，屁股要干净。

项目角色

在前几个项目，我都是担任助理工程师，如在换尿片项目中端水、拿垃圾桶等细活。但由于参与整个项目过程，慢慢领会项目各阶段的奥秘，立马晋升成项目经理，现已成功实施3个项目经验，也是客户满意度最高的几个。

约束条件

小霸王怕冻；不懂技术语言，只会发3个音——咿呀哇。无法把握客户需求有一部分原因是，当她哇哇叫时，是要换尿片呢还是要喝奶呢。因为对于客户看来，换尿片和喝奶都是同一样东西，因此她表达都一样，需要不断细化才能准确把握真正的需求点。

项目风险

预估项目风险有利于降低项目风险。换尿片的风险其一是小霸王容易着凉，会导致整个项目失败，是最高风险；其二是换纸尿片时，小霸王的黄金可能会漏出来，导致项目成本增加——拖地。

项目启动会

小霸王叫了，确认换尿片角色——我担任项目经理，兼项目实施；小霸王妈妈担任高级换尿片工程师。

团队激励

换纸尿片项目是客户面前最关注的一个项目，成功实施会向全省BB推广。

项目估算

工作量：2人8分钟；资源：2人、取暖器、爽身粉、盆子、暖水、垃圾桶、纸尿片、毛巾、手帕（擦屁股用）。专家评估法：关羽阿妈评估5分钟、刘备阿妈评估9分钟、张飞阿妈评估10分钟，最后汇总得出结果是8分钟。

需求分析

小霸王怕冷，要关好窗户，开取暖器以防着凉。擦屁股在保证擦干净的前提下，力度得适中，擦的舒服。

技术准备

准备取暖器、爽身粉、暖水、垃圾桶、纸尿片，关好窗户，并精通尿片使用指南。

项目设计

关窗，取暖器温度适中，暖水接近体温。脱小霸王的裤子、原纸尿片放入垃圾桶，用暖水擦屁股，用毛巾擦干，刷爽身粉，换上新的纸尿片，穿裤子，关暖气、开窗，清理现场。

项目实施

按设计流程和要求实施，并增加环节：在整个换尿片过程，用各种办法分散小霸王的注意力。如果实施过程不合客户的要求，她会发飙，哇哇乱叫——老爸！你手脚还不快点，想要我的小命是不？！

团队协作

小霸王妈妈抽掉旧尿片后，反馈并说明可以进行擦屁股流程。

客户验收

小霸王愉快地睡觉。

项目总结

这个换尿片项目等到客户的一致好评，准确把握客户需求，成功控制取暖器的温度和擦屁股的力度。

过程改进

降低成本，如在保证小霸王舒适度的前提下减少纸尿片的支出；提高效率：减少换尿片的时间。

团队建设

提高团队协作能力，换纸尿片各环节的配合；提高工作效率，快速地帮小霸王宽衣穿衣。

知识库管理

项目成员总结项目经验并且文档化，启动新成员。如本文。

产品化

出书《高效换尿片的45个习惯》、《走出换尿片的作坊》，开发换尿片机器人等。

温馨提示

暂无小孩的朋友等将来有小孩后再来看这篇文章会更有意思。

感想

今日换纸尿片突发奇想，激发项目管理的灵感，兴高采烈，赶紧磨墨写文，存此流芳百世。

本文链接

基层管理杂谈

2011-05-12T17:27:00Z

几乎每种行业都有基层主管（或基层管理人员），而软件行业的基层主管一般是项目经理、技术经理、开发经理、组长等。其职责是资源协调、风险预估、项目管控、团队建设，说白一点大多数的企业现状就是项目负责人带领团队攻下一个又一个项目的过程。很多公司以项目成败作为项目负责人考核的唯一标准，因为项目规模、成本、客户满意度等容易量化，并且是直接跟公司的利润有很大关系；而相反团队建设却难以衡量，如何衡量一个普通技工晋升成高级技工到底是基层主管的培养还是原员工本身就具备高级技工的技能。因此，难免出现以项目额度论英雄的局面，这样往往造成一将功成万骨枯的悲壮场面，并不利于团队的发展。卡耐基曾经说过，带走我的员工，把我的工厂留下，不久后工厂就会长满杂草；拿走我的工厂，把我的员工留下，不久后我们还会有个更好的工厂。我的观点是，从短期目标来看，项目成功是解决温饱问题的指标，如果温饱问题未解决，还如何谈吃得好，如团队经常疯狂加班赶项目就是温饱尚未解决的一种表现；从长远角度来看，团队建设是迈向“吃得好”的改进过程，或着说是一种手段。

一只狮子带领一群绵羊的团队会战胜由一只绵羊带领一群狮子的团队

如果你是一只绵羊，配备一群狮子般的团队也是枉然。说到这里，我曾经从一个电视节目看到十多只年轻狮子攻击一头河马，由于缺乏领队，结果导致河马成功逃过一劫并且一头狮子牺牲这样难以置信的场面。后来，同样这群狮子在一只经验丰富的狮子带领下，战胜比河马更强壮更凶猛的对手。

基层主管往往来自基层的优秀员工，在成功转型之前必须先把自己的宝剑磨利。

在NBA赛场上，5个科比组成的球队可能会输给联盟任何一只球队

一个项目一般需要若干个成员组成团队——售前、需求、设计、开发、测试、部署等。而现实情况往往是，要么项目急、要么人员未到位，或者两种情况都有，那么开发人员由于在公司所占比例大，可能会兼做需求和测试。这样造成的后果是，需求把握不明确，测试不到位导致软件质量差，客户不断投诉。

正如下象棋一样，必须了解各种棋子的角色和作用，以及它们应该摆放的位置。否则拿车当兵使，后果可想而知。

当项目出现危机，基层主管的第一反应是？

如果第一反应是“这个问题是哪个兔崽子造成的”，意味着该主管的思维是先追究责任。有一次，需要向客户演示现有的开发成果，由于各种原因导致离演示的前一天发现很多功能都未完善，如果照这样演示给客户看的话简直是演猴戏。当时，基层主管唯有向上汇报，而高级主管的第一反应是，评估完善这些功能需要多少时间？现在增加资源是否能够缩短工期？需要哪些资源才能完成？并且在该项目所有成员目前表示，他不想追究任何一个人的错误，首要任务是先分析如何能够解决问题。事后，他再向基层主管了解如何改进才能避免同类问题的发生，通过这种方式相当于给基层主管上了一次深刻的管理课程。

聆听团队的意见

善于聆听是良好沟通的铺垫。如果你的团队成员在他岗位上老老实实的干了几个月，突然他有一天告诉你（或者从其他成员了解到），他觉得自己的工作没意思。这其实不完全是分工的问题，很大程度上是沟通出现问题。试问，他是觉得没意思，而不是不合适，即他胜任这份工作，可惜觉得缺少了什么，可能是缺少锻炼机会、想换个项目等等。主动去了解团队成员的意向，因为把他们放在感兴趣的岗位会发挥他们潜在的能力。当然并不是每个人都能找到适合自己的岗位，恰当的给予激励会鼓舞士气，保持工作的热情。某些基层主管把开空头支票当激励，结果失信于团队。

最大限度地发挥团队的力量是每个基层主管的职责

最大限度地发挥团队的力量的前提是得深入了解每个团队成员的技能和喜好。特别是软件工程师，很多不善于语言表达也不会表现自己，更多的需要基层主管去观察。如A君喜欢钻研技术但是缺乏经验，如果有技术难度较高地先分配给他，帮他分析解决方案，更重要的是给他信心。

不要说我以为

基层主管不同于普通员工，一旦犯错就勇于承担。如果说“我以为…，想不到会…，结果造成…”，是一种借口，是不成熟的表现。

让团队主动反馈

基层主管要了解他管理的不是一群机器，是一支优秀的队伍。如果把团队训练成机器，最终会累死基层主管。例如，你需要挨个挨个的去问他们工作进展的怎么样，或者索性让他们写日报周报来反馈。这样得到的结果就是一切看起来很美好，而实际情况就可能隐藏一个个定时炸弹。如果并非团队成员的主动反馈，“被反馈”往往是走走形式，例如某某说“A功能完成了，B功能差不多了”。到了第二天、第三天还是“B功能差不多了”。主动反馈是简要说说工作的问题和解决方法，如某某说“A功能解决方案是…，B功能遇到…问题，C功能预计明天可完成”，并且更重要的是，不是等到你去问他才反馈。

总结

以上纯粹是自己对基层管理的个人看法，也是自己一些微薄经验的一个小结，思维有点混乱。这里抛砖引玉，希望听到更多的建议。

本文链接

面试者与面试官

2011-03-15T14:45:00Z

目前公司挺缺人才，其实一直都缺。一个多星期下来，我面试了不少开发人员，他们的表现实在不敢恭维。想起一年前这个时候，作为应聘者的我再怎么逊也不至于这样，一年前的面试故事请猛击这里。

作为初入职场，特别是对于刚踏入社会的热血青年，其实很希望，即使是得到那么一丁点的指引，也足以让他们少奋斗一段历程。作为过来人，我为那些工作一两年仍然停留学生阶段的朋友感到惋惜，与其勉强为了专业对口而从事自己不擅长的工作，倒不如索性转行来得痛快。

下面总结面试者和面试官两者应该具备的基本要求——

面试者应该了解

1. 笔试题做得好，不代表什么；但做不好，往往给面试官第一印象就不太好。即使卷面不合格，也不用妄自菲薄，因为说不定做得比你差的大有人在。

2. 自我介绍不要三言两语就结束，即使是刚毕业的大学生也不至于这样吧？

3. 你不用长得帅气或迷人，但请保持应有的仪态和谈吐。

4. 永远永远不要把你的简历折得皱巴巴，因为它是你的敲门砖。

5. 尽量保持微笑，以及眼睛注视对方，特别是当面试官提问的时候。

6. 专业基础知识一定要扎实，不要告诉面试官你因为工作的原因而忘记了，因为这些知识不应该是用来记的。

7. 当面试官问你是否掌握某方面技术，不要明明没了解过也说自己掌握，否则被问了一个很基础问题就哑口无言。

8. 最好不要被动回答问题，面试官其实很想听听你独到的想法。

9. 最好准备两个以上问题，礼貌地向面试官提问。

10. 最后，如果你面试失败，其实有可能你不适合这个公司而已。

作为面试官，希望在这里抛砖引玉

1. 永远记住：发掘面试者的潜能是你的职责。

2. 私人问题不要问，唯一一个例外就是：问面试者为何离开上一家公司。

3. 不要带有感情色彩去面试，如果那天实在无法调整自己的情绪，把这重任交给其他人。

4. 对于不合格的面试者，绝对不要有半点吝惜。

5. 在面试者眼里，面试官代表公司形象，不要表现强势不可一世，否则毁了公司形象。

6. 不要招聘心术不正之人，甭管他技术胜人一筹。

7. 了解面试者自我学习和解决问题的能力。

8. 不要光凭笔试题目为面试者打分。

9. 真正有才华的人凤毛麟角，因此给自己更为面试者开一条路：你要招的只是合格者而已，将他与公司同等职位的人作比较是最合适不过。

10. 最好一点，也是最重要一点：不要以为只有面试者在面试前要准备，面试官也不例外。

每年招聘或应聘的高峰期又如期而至了，祝找工作的如愿以偿，招聘的招到千里马或潜力股。

本文链接

敏捷全球之旅 - 广州

2010-11-07T15:11:00Z

今天广州天气阳光明媚，我很高兴能参加“敏捷全球之旅”的讲座，亲临Scrum大师Vernon Stinebaker（中文名：史文林）的精彩演讲。趁着身上尚有敏捷的“余温”，记录一下今天的体会。

Vernon Stinebaker 的背景

博克软件杭州的技术与架构总监。他是目前国内仅有的两位Scrum联盟的认证Scrum培训师（CST）之一，具有资格通过培训颁发CSM及CSPO认证。

Vernon 能讲一口流利的普通话，但他在中国已经待了很长时间，学会了中国人的谦虚文化，只说自己“会讲一点普通话”。这次讲座为了不让外国嘉宾打瞌睡，他全程中英双语作演讲，将自己对Scrum的看法以及自身运用Scrum的经历分享给大家。

Scrum

他强调的Scrum的几个特点

1. 持续集成

2. 每日例会一定要站起来开

3. Sprint Review

4. 强调人

其他讲师

后续几位讲师的演讲的主题也不错。如李华北的“CMMI中的敏捷方法”介绍CMMI和敏捷的异同，以及两者可以并存改善软件过程；陈庆春的“敏捷需求面面观”提到软件的45%功能最终客户是不会用到的；谭小鹏的“需求-想得到你的心很难”提出需求并不是简单的事情，同时也结合自己的经验介绍如何取得用户的有效需求……

疑问

会后和几位同事交流了这次讲座的体会，普遍产生一些疑问：

1. 敏捷是否适合自身公司？

2. 敏捷是否会带来高项目成本？

3. 敏捷的纪律性问题会带来风险吗？

4. TDD适合哪些类型项目？

据我所知，有两家中小型公司已经在用Scrum（尚处于Scrum的入门阶段），目前情况比较乐观，至少没有产生以上的问题。TDD基本上还没见到谁在用。

随便说说

反观自己，已经3个月没更新博客了。一方面，是我关注的知识越来越多；另一方面，确实我的工作越来越忙。希望日后能挤出那么一点时间，多抛几块砖上来。

顺便推荐《Scrum敏捷项目管理》是本不错的书！

本文链接

jquery.jstree 增加节点的双击事件

2010-07-26T11:59:00Z

jstree

本文基于 jsTree 1.0-rc1 版本增加节点的双击事件。

jsTree 是基于jquery的树插件，支持拖放、复制、删除、快捷键、多选、自定义节点图标、自定义右键菜单、跨页面保存状态等等，总之我想到的它基本上都有了，而且最值得表扬的是它让人感觉一点都不慢哦。

jsTree有节点选择事件，即

.bind("select_node.jstree", function(e, data) {
             //alert(data.rslt.obj.attr("id") + ":" + data.rslt.obj.attr("rel"));
        })

其实我认为它更像是节点的单击事件，因为每次点节点的时候它都会触发，不管之前该节点是否已经被选中。

近日做个文件管理的东东，需要用到节点的双击事件，如双击某个节点打开该节点的编辑页面。

jstree虽然有双击事件，但是并非针对节点的，而是你双击树所在区域就会触发，如上图任何一个地方。

离节点双击事件最接近的应该就是节点选择事件，因此又是“照葫芦画瓢”啦。

分析

在第833行 this.get_container() 后是节点的单击事件

.delegate("a", "click.jstree", $.proxy(function (event) {
                        event.preventDefault();
                        this.select_node(event.currentTarget, true, event);
                    }, this))

同样我再这里插入节点双击事件

.delegate("a", "dblclick.jstree", $.proxy(function(event) {
    event.preventDefault();
    this.dblclick_node(event.currentTarget, true, event);
    }, this))

接着，我再实现 dblclick_node 方法就可以了。

在第928行找到 select_node 的代码，比较复杂。但里面90%对于双击来说是没有用处的，如处理单选、多选、保存选择结果到cookies等。因此 dblclick_node 方法的实现要比 select_node 简单很多。

dblclick_node: function(obj, check, e) {
    obj = this._get_node(obj);
    if (obj == -1 || !obj || !obj.length) { return false; } 
    this.__callback({ "obj": obj }); 
},

OK，就这样了。

使用例子

跟 select_node 用法一样

.bind("dblclick_node.jstree", function(e, data) {
             //alert(data.rslt.obj.attr("id") + ":" + data.rslt.obj.attr("rel"));
        })

改造后的代码下载

jquery.jstree.js

顺便说说

jstree 跟另一个插件jquery validate 是水火不容的，当两者共存时，jstree虽然也可以构造树出来，但如僵尸一般不能展开。这里mark一个，日后试试能否修改。

本文链接

当 ADO.NET 遇上 dynamic

2010-07-18T09:46:00Z

传说中的dynamic

dynamic是个不合群、不按规则办事的家伙，可以说是个异形，但更恐怖的是它又是无所不知的，任何事情都难不了它（咳咳，它似乎与Lambda表达式是死对头）。这令人想起《死亡日记》的怪异侦探L，行为怪异而智力超人，以至于离奇的案件不得不交给了他。dynamic可以看成是一切类型的化身，但并不是仅限于此，它像《未来战士》续集里面的T-1000型液体金属的终结者。噢~~~~似乎扯的有点远了

饱经风雨而不倒的ADO.NET

ADO.NET 从来做事都有理有据，而且又异常专注于自身领域，是个professional的牛人，令人想起《美丽心灵》里面的博弈论和微分几何学领域潜心研究以致获得诺贝尔经济学奖的数学家—— 约翰·福布斯·纳什教授（咳咳，纳什教授是个妄想型精神分裂的～～～嗯，这个以后再说）。

关于ADO.NET 的例子

1. 执行SQL语句

using (DbCommand command = connection.CreateCommand())
{
    command.CommandText = "select Top 10 * from Orders";
    command.CommandType = CommandType.Text;
     
    using (IDataReader reader = command.ExecuteReader())
    {
        while (reader.Read())
        {
            Console.WriteLine("OrderID: {0}, OrderDate: {1}",
                reader.GetInt32(reader.GetOrdinal("OrderID")),
                reader.GetDateTime(reader.GetOrdinal("OrderDate")));
        }
    }
}

2. 调用存储过程

command.CommandText = "CustOrdersOrders";
         command.CommandType = CommandType.StoredProcedure;
         command.Parameters.Add(new SqlParameter("CustomerID", "ALFKI"));
         //略去...

当 ADO.NET 遇上 dynamic

某年某月ADO.NET不幸遇到dynamic，从此循规蹈矩的生活不复存在。dynamic说它可以帮助 ADO.NET 丢掉 DataSet 的包袱，而且在不用创建数据实体的情况下，实现查询结果垮不同方法传递；更加强大的地方是可以与存储过程无缝连接，即像调用一般方法一样调用存储过程而不用写额外代码。我的神哪～～～ ADO.NET 听了dynamic一番游说后，心底下不禁惊讶一下。dynamic又说，实现刚才所说的工程只要借你手下的两大猛将 SqlConnection 和 SqlCommand 助我一臂之力即可。

dynamic真有如此奇技？ ADO.NET 虽有怀疑，但它想到曾经看过一部叫《阿甘正传》的电影，里面的阿甘虽然是弱智人，但参军时练就乒乓奇技，后来还和中国国手同台竞技。想到这，ADO.NET 认为不能因为对方弱智就不相信对方的话，这是很不礼貌很不绅士的人才会做的事，所以它相信了dynamic。

dynamic 果真不负众望，三两脚猫功夫就交出成果了。

dynamic重构后的数据库操作

using (dynamic command = connection.CreateDynamicCommand())
{
    //执行查询SQL
    IEnumerable<dynamic> toptenOrders = command("select Top 10 * from Orders");
    foreach (dynamic order in toptenOrders)
    {
        Console.WriteLine("OrderID: {0}, OrderDate: {1}", order.OrderID, order.OrderDate);
    }

    //执行带参数的SQL
    IEnumerable<dynamic> customerOrders = command("select * from Orders where CustomerID = @CustomerID",
            CustomerID: "ALFKI");
    foreach (dynamic order in customerOrders)
    {
        Console.WriteLine("OrderID: {0}, OrderDate: {1}", order.OrderID, order.OrderDate);
    }

    //调用存储过程
    IEnumerable<dynamic> orders = command.CustOrdersOrders(CustomerID: "ALFKI");
    foreach (dynamic order in orders)
    {
        Console.WriteLine("OrderID: {0}, OrderDate: {1}", order.OrderID, order.OrderDate);
    }
}

要知道 ADO.NET 可不是.NET菜鸟，它看到 command("select Top 10 * from Orders"); 第一感觉认为吃了dynamic药的command有可能是委托类型，而看到后面的 command.CustOrdersOrders(CustomerID: "ALFKI"); 不得不否决了前面的看法。dynamic到底是什么东西？可以这样认为，dynamic什么东西都是；也可以认为，dynamic不是什么东西！

ADO.NET 知道任何.NET写的再高深的代码在reflector下都会现出原形，通过对 command 解剖，立刻明白原来自己跟《美丽心灵》的纳什教授一样纠缠于一种不存在的幻想不能自拔，reflector告诉我们：dynamic实际上是不存在的！

还是鲁迅叔叔说的好，世界上本没有dynamic，只是微软对委托封装得太牛了，也便有了dynamic。

结语

聪明的你知道command是怎么实现了吗？不妨先想想，然后展开下面的代码看看是否与你想的一致。

点此展开代码

注：本文存储过程部分参考了微型ORM.

public static class Extensions
{
    public static DynamicCommand CreateDynamicCommand(this DbConnection connection)
    {
        return new DynamicCommand(connection);
    }
}

    /// <summary>
    /// 动态Command
    /// </summary>
    public class DynamicCommand : DynamicObject, IDisposable
    {
        public DbConnection Connection { get; set; }

        public DynamicCommand(DbConnection connection)
        {
            this.Connection = connection;
        }

        //实现SQL语句查询
        public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
        {
            if (args.Length == 0) throw new ArgumentException("args must has value");

            result = Execute(args[0].ToString(), CommandType.Text, binder.CallInfo.ArgumentNames, args.Skip(1).ToArray());

            return true;
        }

        //实现存储过程
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            if (binder.CallInfo.ArgumentNames.Count != binder.CallInfo.ArgumentCount)
            {
                throw new ArgumentException("All parameters must be named");
            }
            
            result = Execute(binder.Name, CommandType.StoredProcedure, binder.CallInfo.ArgumentNames, args);

            return true;
        }

        /// <summary>
        /// 执行SQL查询
        /// </summary>
        /// <param name="commandText"></param>
        /// <param name="commandType"></param>
        /// <param name="names"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private object Execute(string commandText, CommandType commandType, IEnumerable<string> names, object[] args)
        {
            bool manageConnectionLifespan = (this.Connection.State == ConnectionState.Closed);

            if (manageConnectionLifespan) this.Connection.Open();

            try
            {
                using (var cmd = this.Connection.CreateCommand())
                {
                    cmd.CommandType = commandType;
                    cmd.CommandText = commandText;
                    for (int i = 0; i < args.Length; i++)
                    {
                        DbParameter param = cmd.CreateParameter();
                        param.ParameterName = "@" + names.ElementAt(i);
                        param.Value = args[i] == null ? DBNull.Value : args[i];
                        cmd.Parameters.Add(param);
                    }

                    return ExecuteList(cmd);
                }
            }
            finally
            {
                if (manageConnectionLifespan)
                {
                    this.Connection.Close();
                }
            }
        }

        /// <summary>
        /// 执行SQL命令，返回查询结果列表
        /// </summary>
        /// <param name="command"></param>
        /// <returns></returns>
        private static IEnumerable<dynamic> ExecuteList(DbCommand command)
        {
            List<DynamicEntity> resultList = new List<DynamicEntity>();
            using (DbDataReader reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    DynamicEntity entity = new DynamicEntity();
                    for (int i = 0; i < reader.FieldCount; i++)
                    {
                        entity.SetMember(reader.GetName(i), reader.GetValue(i));
                    }
                    resultList.Add(entity);
                }
            }
            return resultList;
        }

    }

/// <summary>
/// 动态实体
/// </summary>
internal class DynamicEntity : DynamicObject
{
    /// <summary>
    /// 属性和值的字典表
    /// </summary>
    private Dictionary<string, object> values = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        if (values.ContainsKey(binder.Name))
        {
            result = values[binder.Name];
        }
        else
        {
            throw new System.MissingMemberException("The property " + binder.Name + " does not exist");
        }

        return true;
    }

    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        SetMember(binder.Name, value);
        return true;
    }

    public override IEnumerable<string> GetDynamicMemberNames()
    {
        return values.Keys;
    }

    internal void SetMember(string propertyName, object value)
    {
        if (object.ReferenceEquals(value, DBNull.Value))
        {
            values[propertyName] = null;
        }
        else
        {
            values[propertyName] = value;
        }
    }
}

本文链接

Linq To SQL 批量更新方法汇总

2010-07-11T12:49:00Z

方法一、官方例子

地球人都知道的，也是不少 Linq To SQL 反对者认为效率低下的一种方法。

NorthwindDataContext db = new NorthwindDataContext();
var customers = db.Customers.Where(c => c.CustomerID.StartsWith("BL"));
foreach (var customer in customers)
{
    customer.Address = "Guangzhou";
    customer.ContactName = "CoolCode";
    customer.CompanyName = "Microsoft";
}
db.SubmitChanges();

这种方法必须要查询出要更新的数据，确实有点不雅，也是Linq To SQL 略显尴尬的一面。

方法二、使用ExpressionVisitor获取Lambda表达式生成的SQL条件语句

此方法是基于Jeffrey Zhao 的《扩展LINQ to SQL：使用Lambda Expression批量删除数据》，从该文章得到一点启发，继而有了批量更新。使用示例：

db.Customers.Update(c => c.CustomerID == "Bruce",
                     c => new Customer
                     {
                         Address = "Guangzhou",
                         ContactName = "CoolCode",
                         CompanyName = "Microsoft"
                     });

方法原型：

/// <summary>
/// 批量更新
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="table">表</param>
/// <param name="predicate">查询条件表达式</param>
/// <param name="updater">更新表达式</param>
/// <returns>影响的行数</returns>
public static int Update<T>(this Table<T> table, Expression<Func<T, bool>> predicate, Expression<Func<T,T>> updater) where T : class

实现原理：扩展Table<T>，解释表达式树成SQL语句。其中解释表达式树包括和更新表达式，后者相对容易处理，例如表达式：

c => new Customer { Address = "Guangzhou", ContactName = "CoolCode", CompanyName = "Microsoft" }

解释成

Address = @Address, ContactName = @ContactName, CompanyName = @CompanyName

而相应的值（"Guangzhou", "CoolCode", "Microsoft" ）作为SQL参数传递。

实现这一步，其实就是从表达式 Expression<Func<T,T>> 中取到初始化的属性名字和值就可以，具体做法可以使用Expression Tree Viewer来辅助，从下图可以了解到 Expression<Func<T,T>> 的树形结构。

然后我按上面的结构图“照葫芦画瓢”就得到要更新的属性名字和值：

//获取Update的赋值语句
var updateMemberExpr = (MemberInitExpression)updater.Body;
var updateMemberCollection = updateMemberExpr.Bindings.Cast<MemberAssignment>().Select(c => new
{
    Name = c.Member.Name,
    Value = ((ConstantExpression)c.Expression).Value
});

而解释where条件就相对没这么轻松了。

这里同 Jeffrey Zhao 的批量删除一样，同样是借助 ExpressionVisitor 来解释。ExpressionVisitor 是 Expression Tree 的遍历器，它自身不会帮你生成任何东西，通过继承 ExpressionVisitor 就可以取表达式的任何信息，本文就是通过让 ConditionBuilder 继承ExpressionVisitor 而生成 Where 条件的 SQL。

注：Jeffrey Zhao 的批量删除一文提供的源代码中，ConditionBuilder 并不支持生成Like操作，如字符串的 StartsWith，Contains，EndsWith 并不能生成这样的SQL： Like ‘xxx%’, Like ‘%xxx%’ , Like ‘%xxx’ 。我通过分析 ExpressionVisitor ，也不难发现只要override VisitMethodCall 这个方法即可实现上述功能。

protected override Expression VisitMethodCall(MethodCallExpression m)
{
    if (m == null) return m;

    string format;
    switch (m.Method.Name)
    {
        case "StartsWith":
            format = "({0} LIKE {1}+'%')";
            break;

        case "Contains":
            format = "({0} LIKE '%'+{1}+'%')";
            break;

        case "EndsWith":
            format = "({0} LIKE '%'+{1})";
            break;

        default:
            throw new NotSupportedException(m.NodeType + " is not supported!");
    }

    this.Visit(m.Object);
    this.Visit(m.Arguments[0]);
    string right = this.m_conditionParts.Pop();
    string left = this.m_conditionParts.Pop();
    this.m_conditionParts.Push(String.Format(format, left, right));

    return m;
}

到此刻，已经解决了解释表达式树的难题，那么实现通过表达式树生成完整的 Update SQL语句这个设想也不是什么难事了。

/// <summary>
/// 批量更新
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="table">表</param>
/// <param name="predicate">查询条件表达式</param>
/// <param name="updater">更新表达式</param>
/// <returns>影响的行数</returns>
public static int Update<T>(this Table<T> table, Expression<Func<T, bool>> predicate, Expression<Func<T,T>> updater) where T : class
{
    //获取表名
    string tableName = table.Context.Mapping.GetTable(typeof(T)).TableName;

    //查询条件表达式转换成SQL的条件语句
    ConditionBuilder builder = new ConditionBuilder();
    builder.Build(predicate.Body);
    string sqlCondition = builder.Condition;

    //获取Update的赋值语句
    var updateMemberExpr = (MemberInitExpression)updater.Body;
    var updateMemberCollection = updateMemberExpr.Bindings.Cast<MemberAssignment>().Select(c => new
    {
        Name = c.Member.Name,
        Value = ((ConstantExpression)c.Expression).Value
    });

    int i = builder.Arguments.Length;
    string sqlUpdateBlock = string.Join(", ", updateMemberCollection.Select(c => string.Format("[{0}]={1}", c.Name, "{" + (i++) + "}")).ToArray());

    //SQL命令
    string commandText = string.Format("UPDATE {0} SET {1} WHERE {2}", tableName, sqlUpdateBlock, sqlCondition);

    //获取SQL参数数组 (包括查询参数和赋值参数)
    var args = builder.Arguments.Union(updateMemberCollection.Select(c => c.Value)).ToArray();

    //执行
    return table.Context.ExecuteCommand(commandText, args);
}

例如上面提到的示例所生成的 Updae SQL语句是：

UPDATE dbo.Customers SET [Address]={1}, [ContactName]={2}, [CompanyName]={3} WHERE ([CustomerID] = {0})

相应参数："Bruce", "Guangzhou", "CoolCode", "Microsoft"

据不完全统计，实际开发中用的 Update SQL 90%是很简单的，以上扩展基本上符合要求。

方法三、使用 LinqToSQL 自身的解析器来获取Lambda表达式生成的SQL条件语句

该方法与方法二基本上是同一思路，只是在获取Lambda表达式生成的SQL条件上有点不一样。

通过 DataContext 的 GetCommand 可以获取到 DbCommand，所以通过生成的SQL查询语句中截取Where后面的条件，再用方法二生成Update 的赋值语句，两者拼凑起来即可。

该方法比方法二支持更多Lambda表达式（实际上就是所有LinqToSQL支持的）生成SQL条件。

/// <summary>
    /// 批量更新
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="table">表</param>
    /// <param name="predicate">查询条件表达式</param>
    /// <param name="updater">更新表达式</param>
    /// <returns>影响的行数</returns>
    public static int Update<T>(this Table<T> table, Expression<Func<T, bool>> predicate, Expression<Func<T,T>> updater) where T : class
    {
        //获取表名
        string tableName = table.Context.Mapping.GetTable(typeof(T)).TableName;
        DbCommand command = table.Context.GetCommand(table.Where(predicate));
        string sqlCondition = command.CommandText;
        sqlCondition = sqlCondition.Substring(sqlCondition.LastIndexOf("WHERE ", StringComparison.InvariantCultureIgnoreCase) + 6);

        //获取Update的赋值语句
        var updateMemberExpr = (MemberInitExpression)updater.Body;
        var updateMemberCollection = updateMemberExpr.Bindings.Cast<MemberAssignment>().Select(c =>
        {
            var p = command.CreateParameter();
            p.ParameterName = c.Member.Name;
            p.Value = ((ConstantExpression)c.Expression).Value;
            return p;
        })
        .ToArray();

        string sqlUpdateBlock = string.Join(", ", updateMemberCollection.Select(c => string.Format("[{0}]=@{0}", c.ParameterName)).ToArray());

        //SQL命令
        string commandText = string.Format("UPDATE {0} SET {1} FROM {0} AS t0 WHERE {2}", tableName, sqlUpdateBlock, sqlCondition);

        //获取SQL参数数组 (包括查询参数和赋值参数)
        command.Parameters.AddRange(updateMemberCollection);
        command.CommandText = commandText; 

        //执行 
        try
        {
            if (command.Connection.State != ConnectionState.Open)
            {
                command.Connection.Open();
            }
            return command.ExecuteNonQuery();
        }
        finally
        {
            command.Connection.Close();
            command.Dispose();
        }
    }

同样使用文章开头的示例，生成的 Update SQL 跟方法二略有不同：

UPDATE dbo.Customers SET [Address]=@Address, [ContactName]=@ContactName, [CompanyName]=@CompanyName FROM dbo.Customers AS t0 WHERE [t0].[CustomerID] = @p0

方法四、支持多表关联的复杂条件

要知道，前面提到的方法二和三都不支持多表关联的复杂条件。可以用一个示例让大家更清楚为什么——

例如，更新CustomerID=“Bruce”的用户的所有订单的送货日前是一个月后。

db.Orders.Update(c => c.Customer.CustomerID == "Bruce",
                    c => new Order
                    {
                         ShippedDate =  DateTime.Now.AddMonths(1)
                    });

应该生成的 Update SQL 语句是：

UPDATE [dbo].[Orders] SET [ShippedDate] = @p1
FROM [dbo].[Orders] AS [t0]
    LEFT OUTER JOIN [dbo].[Customers] AS [t1] ON [t1].[CustomerID] = [t0].[CustomerID]
WHERE [t1].[CustomerID] = @p0
--@p0 = 'Bruce', @p1 = '2010-08-11'

但遗憾的是无论用方法二或三都会抛异常，因为两者皆没法解释多表关联生成的语句： “LEFT OUTER JOIN [dbo].[Customers] AS [t1] ON [t1].[CustomerID] = [t0].[CustomerID] ”

一位叫 Terry Aney 的朋友在《Batch Updates and Deletes with LINQ to SQL》这篇博文中解决了这个问题。使用他提供的UpdateBatch 方法生成的 Update SQL 是：

UPDATE [dbo].[Orders]
    SET [ShippedDate] = @p1
FROM [dbo].[Orders] AS j0 INNER JOIN (
    SELECT [t0].[OrderID]
    FROM [dbo].[Orders] AS [t0]
        LEFT OUTER JOIN [dbo].[Customers] AS [t1] ON [t1].[CustomerID] = [t0].[CustomerID]
    WHERE [t1].[CustomerID] = @p0
) AS j1 ON (j0.[OrderID] = j1.[OrderID])

-- @p0: Input NVarChar (Size = 5; Prec = 0; Scale = 0) [Bruce]
-- @p1: Input DateTime (Size = 0; Prec = 0; Scale = 0) [2010/8/11 19:51:59]

虽然跟我刚才手写的SQL略有不同，但 Update 的逻辑是对的。有兴趣的朋友不妨试试，Terry Aney在他的文章里有很详尽的介绍，这里不再详述。

.Net4 Expression Tree 入门(4): 求N以内的所有质数

2010-05-26T06:59:00Z

.Net4 Expression Tree 入门(1): Hello World!

.Net4 Expression Tree 入门(2): IfThen, SwitchCase

.Net4 Expression Tree 入门(3): Loop 循环

前面已经介绍了.Net4 Expression Tree的分支与循环，是时候综合起来写一个稍微复杂一点的实例了。

求N以内的所有质数

一般的写法

static List<int> GetPrimes_SimpleMethod(int to)
{
    var res = new List<int>();
    for (int n = 2; n <= to; n++)
    {
        bool found = false;

        for (int d = 2; d <= Math.Sqrt(n); d++)
        {
            if (n % d == 0)
            {
                found = true;
                break;
            }
        }

        if (!found)
            res.Add(n);
    }
    return res;
}

暂且不用考虑以上算法的时间复杂度、性能什么的，因为只是为了学习 Expression Tree 而已。之前都说过，Expression 里是没有For这些常用方法的，只有Loop，因此为了更方便构造 Expression Tree，需要对上面代码稍微修改成没for的形式。

如

for (int n = 2; n <= to; n++)
{
    // do sth…
}

改成 while形式：

int n = 2;
while (true)
{
    if (!(n <= to))
        break;
    // do sth…
    n++;
}

求N以内的所有质数的“NoFor” 写法

【纯粹是为了更方便构造 Expression Tree，否则相信没人用while(true)这样写法】

static List<int> GetPrimes_NoFor(int to)
{
    var res = new List<int>();
    int n = 2;
    while (true)
    {
        if (!(n <= to))
            break;
        bool found = false;

        int d = 2;
        while (true)
        {
            if (!(d <= Math.Sqrt(n)))
                break;

            if (n % d == 0)
            {
                found = true;
                break;
            }

            d++;
        }

        if (!found)
            res.Add(n);

        n++;
    }
    return res;
}

上述代码与表达式的对比列表

原始代码	表达式
var res = new List<int>();	Expression.Assign( res, Expression.New(typeof(List<int>)) )
int n = 2;	Expression.Assign( n, Expression.Constant(2) )
while (true) { if (!(n <= to)) break;	Expression.Loop( Expression.Block( Expression.IfThen( Expression.Not( Expression.LessThanOrEqual( n, to ) ), Expression.Break(breakOuter) )
Math.Sqrt(n)	Expression.Call( null, typeof(Math).GetMethod("Sqrt"), Expression.Convert( n, typeof(double) ) )
d++;	Expression.PostIncrementAssign(d)
res.Add(n);	Expression.Call( res, typeof(List<int>).GetMethod("Add"), n )

最终构建表达式的代码很长，有兴趣的不妨自己试着写写，这里不贴上来，可以参考这篇外文《STATEMENT TREES WITH LESS PAIN – FOLLOW-UP ON SYSTEM.LINQ.EXPRESSIONS V4.0》。

你是否也因为Expression 里没有for这个方法而感到不爽？一切循环都得改成loop这种形式？Expression构建是不是很麻烦罗嗦？为什么Expression一切方法皆是static的…等等。

如果改成下面这种形式会不会好点？

原始代码	表达式
var res = new List<int>();	res.Assign(Expression.New(typeof(List<int>)))
int n = 2;	n.Assign(2)
n ++;	n.PostIncrementAssign()
for (int n = 2; n <= to; n++)	Expression.For(n, n.Assign(2), n <= to, n.PostIncrementAssign()
res.Add(n);	res.Method("Add", n)

这样会不会更简洁？欢迎作进一步交流。我会在下一篇随笔里分析如何实现以上形式的写法。

本文链接

博客园_CoolCode

教你如何成为一名不合格的程序员

QueryBuilder ： 打造优雅的Linq To SQL动态查询(支持EF、.Net4)

从换纸尿片到项目管理

基层管理杂谈

面试者与面试官

敏捷全球之旅 - 广州

jquery.jstree 增加节点的双击事件

当 ADO.NET 遇上 dynamic

Linq To SQL 批量更新方法汇总

.Net4 Expression Tree 入门(4): 求N以内的所有质数

QueryBuilder ：打造优雅的Linq To SQL动态查询(支持EF、.Net4)