博客园_飞仙时空

H公司数据同步的总结

2011-09-19T13:32:00Z

客户的原始需求

收到H公司的需求信息：他们现在有三个系统：HR系统、OA系统、一卡通系统，各个系统的主要优势如下：

HR：有强大的组织架构和人事信息的管理
OA：有优秀的流程支持，可以让数据根据既定规则在不同的人员之间流转处理，或做数据自动处理
一卡通：有良好的工卡、饭卡统一管理，充值管理，考勤管理等的功能

此三个系统需要做数据同步，同步需求如下：

HR跟OA：OA从HR单向获取组织架构、人事数据，当HR有数据变更，OA把变更数据拿过来，更新OA的相应数据
HR跟一卡通：如上，类似HR跟OA
OA跟一卡通：OA上有请假、加班、出差的审批流程，审批通过的请假、加班、出差数据写入一卡通。一卡通结合从OA获取的请假、加班、出差数据，以及自身功能采集的打卡数据，进行考勤计算。对于异常的数据送到OA，在OA走考勤异常申请流程，审批完毕后（通过或不通过），把结果写回一卡通。

下图是同步的数据流图，箭头方向是数据流的方向。我方是OA厂商，橙色部分所示。

H公司的要求是用Web Service方式同步，一个月内上线，各厂商先给出同步方案。

需求调研

第一次调研

按约定时间三方厂商赶到客户现场，到场人员角色如下

H公司：项目总负责人、技术人员、其他人员
OA：1位实施工程师，1位开发工程师
HR：1位实施工程师
一卡通：1位开发（兼实施）工程师

三方系统结构

HR：Java + SQL Server 2000 + Tomcat，BS/CS双结构
OA：ASP.Net + SQL Server 2005 + IIS，BS结构
一卡通：C# + SQL Server 2005，CS结构

根据各系统的结构，OA跟一卡通用数据库同步，不建议用Web Service 方式；OA跟HR可用用数据库或者Web Service方式。我们各厂商都希望完全用数据库方式同步，可以省事。

对比各方的数据表。确认各方必须的字段，以保证系统能正常运行。确认同步所需要的业务字段，这是客户的需要。

我方跟一卡通公司的同步相对简单，双方都有开发人员在，经过两三个小时的讨论与确认，双方的接口以及同步模型基本敲定。

HR公司来的是实施人员，对系统的底层结构不甚了解，很多问题不能深入讨论。HR系统的技术文档里有相关的Web Service接口介绍，但是限于对HR系统自身数据的增删改查。现在H公司数百个部门、数万个人员，不可能每次同步都把所有部门、所有人员的数据全给OA，再对比哪些数据有变更，然后处理，这样性能太差了。如果要他们提供差异数据，他们的接口必须要重新开发。

此次调研我方给出的同步方式是：OA跟一卡通用数据库同步。OA跟HR若用数据库同步可以在一个月内上线，如果用Web Service方式，则需要两个月。

客户最终接受的同步方式是OA跟一卡通用数据库同步，OA跟HR、一卡通跟HR都用Web Service 的方式，可以接受推迟一个月上线。

后来，H公司转发来HR公司的一份同步方案。同步原理是：HR把差异数据放到数据库的中间表，定时扫描中间表，发现有差异数据，就发送HR的数据库链接方式给外部系统（OA ），外部系统（OA）直接读取HR的数据库中间表。

我看了之后，心里面暗笑，这样的方式，Web Service的同步只是一个幌子，实际还是数据库的同步。但考虑到用户的紧急性，技术我放行了，"只要能尽快上线，功能与时间第一，其它次之"。

第二次调研

一卡通公司在上海，其他各方都在广州，这时一卡通的开发人员已经回上海。此次调研的出席人员如下：

H公司：项目总负责人、技术人员、其他人员
HR：1位技术顾问、1位开发人员
OA：1位开发工程师

HR公司的两位人员明显事前没做什么准备，没有一个完整的同步模型。我带着事前准备的同步方案，这样我显得比较主动。我的同步模型是：首先做手工同步，OA已经被H公司应用多年，数据肯定不能够清空，然后从HR系统来拿全新的数据。这样我要做中间表，存放HR系统与OA系统的主键对应关系，手工同步的作用就是填充双方系统的既有对应关系。其次是差异同步，HR新增数据，OA也跟着新增数据，并在OA中间表插入对应关系；若HR修改数据，OA从中间表找到相应记录，更改之；若HR删除数据，OA从中间表找到相应记录，只做记录，但不删除。

系统相关结构如下：

OA的部门与机构分开在两张表，HR的部门与机构在同一张表，用不同的状态区别。
HR有三个完全独立的数据库，每个数据库有自己的机构、部门、人员。三套机构、部门略有差异，大部分数据是冗余的；而H公司的人员分布在三个数据库中。

此次调研确定了：

HR通知OA有数据变更的格式，包含OA连接HR数据库的格式；
HR中间表的名称、表列及数据格式；
OA接收HR通知的接口；
OA返回同步结果给HR的格式；
OA按严格的时间顺序 模拟HRP的数据变化来更新OA的数据，组织、人员、人员兼任部门职位信息，HRP给我们的必须是按更新时间排序的，OA用归并算法来同步这些数据；
数据约束：HR的某些部门不传给OA；HR目前有两个部门，"总部"与"分部"，二者在HR是并列的机构，但在OA中只有一个机构"总部"，"分部"降了一级，作为总部的一个子部门；
若OA同步过程出现错误，则停止同步，避免同步的错误越来越大；
同步模型就上图的方式。

从我的主动与HR的被动，我想：到客户现场务必要事先做好准备，否则丢失的是客户对自己能力的信任和对公司能力的信任。事前我曾花了近三天时间写了同步方案，有些是实用的，有些是华而不实的，不实用的东西尽量不写，否则只是徒劳，而有用的东西尽量详实。

流水帐差异还是全表差异

流水帐差异 是指主表与中间表是一对多的关系，每发生一次数据变更，就往中间表写入一条数据，中间表的数据行多于主表的数据行，例如组织表organization的部门"人力资源部"的ID为11，则11这条记录会在中间表出现多次，出现一次代表"人力资源部"的一次数据变更。

全表差异 指主表与中间表是一对一关系，每发生一次数据变更，就覆盖中间表的对应数据。

HR提供的方案是组织、人员中间表都用全表差异的方式。我第一印象是不妥，可能会导致我们OA数据混乱，我一时举不出反例，但是潜意识里认为这样的数据不安全。冥思苦想很久，如果HR在10点新增了部门A，11点在A下增加了部门subA，12点修改部门A的名字为AA，这个12点覆盖了之前的10点。此时，OA从HR同步数据，发现11点增加了部门subA，但是找不到它的父部门，因为HR标识其父部门在12点新增（修改）。

所以，组织只能用流水帐差异的方式。HR的开发人员似乎特钟情与全表差异的方式，人员中间表还希望用这种方式。但是，他们的人员没有主键，只能用工号充当，而工号又后变更，全表差异也给推翻了，还得用流水帐差异的方式。

别人提供的技术方案未必是正确的，可能是误导，甚至错误的。还需自己进行技术论证。这个同步项目本身的确存在较多这种似是而非的陷阱，需要格外小心，稍不慎则犯错。

第三次调研

经过之前的调研，OA跟HR的同步正风风火火地开发，大概是此同步项目启动后的一个月，一卡通的开发人员才来到广州。

OA跟一卡通的同步方案跟第一次调研的一致，本次调研确认每个接口的签名，主要体现是存储过程与视图，包括存储过程的名称、参数的名称及参数类型，视图的名称、其列名称、列类型。

HR系统的人员不能提供唯一键，唯一可做标识的是工号，然而工号又可能会变更，还好H公司的工号不会重复利用，否则数据就可能混乱。

由于工号勉强做唯一标志，而工号又会变更，我抛出了一个问题：HR改工号后，若OA从HR同步成新工号，而一卡通未同步成功还是旧工号。此时OA与一卡通同步，就会找不到人员匹配。H公司决定：OA先从HR同步数据，OA同步成功后，一卡通才从HR同步数据。OA向一卡通发数据时需发新工号与旧工号，若一卡通匹配不了新工号就匹配旧工号；一卡通向OA发数据时，只发一个工号，OA用新工号与旧工号匹配之。

现在回想，人员似乎可以补用GUID来唯一标识之。

HR、OA、一卡通三个厂商之间互相讨论，到方案敲定，时间已是晚上六点。各有一份自己与其他两个厂商的同步方案文档，各写各的。H公司要求我们三方把三份文档整合成一份，由于一卡通的开发人员第二天要赶回上海的公司，整合文档一定要在当天出来。文档整合使用"Ctrl-C" "Ctrl-V"很容易，麻烦的是文档的排版，折磨到将近十点才完毕，更名为《H公司三方系统同步方案》。

开发与测试

经过第二次调研后，OA跟HR的同步开发工作就紧锣密鼓地进行。我跟HR的开发人员一个星期几乎有两三天在H公司上班。H公司也很重视此项目，专门分配了两个人员来协助我们，搭了三套虚拟机，各安装一个厂商的程序，模拟他们的现实环境。

HR公司的艰难

HR系统只能用一个"怪异"来形容：

数据库不能用SQL Server的备份还原功能来加载到虚拟机，而要用程序来恢复，数据库上10G，程序创建一次数据库将近1小时，然后报错，如是折腾了三天都失败，最后好像是从正式环境下复制数据库文件到虚拟机的相应目录，数据库的部署才成功。
数据散布在三个数据库中，同样是人力资源部，在库1的编号是0105，在库2的编号可能是0106，在库3中可能是0207。OA只与HR的库1对应，若同属于人力资源部的杨过与郭靖，库1中杨过的部门编码是0105是正确的，库2中郭靖的部门编码给OA的不应当是0106，而应该是0105，否则会造成OA数据混乱。我想光是将数据整合成一致的对外接口都够他们受了，并且维护也不是简单的事情，这不是我方的任务，管他的。
所有表都没有主键。组织表organization 的唯一标识是组织编码，但是部门（组织）移动后这个编码是会变更的。我建议HR在组织表新增一个自增列，来创建唯一ID。人员散布在三个库中，无法用自增列，因为自增列在不同的库中会重复，只有将就着用工号。
HR公司是个代理商，开发人员没有HR系统的源代码，只能在系统外围做处理

开发初期，接口频繁变动，一个月后，接口基本稳定，HR与OA同步的某些模块已经初步实现。此时一卡通公司开始参与进来，经过上面的"第三次调研"，一卡通的开发人员把电子文档发回公司。第二天一大早我接到H公司项目负责人Z的电话，问我实现方案是否怎么变了，何时变了。我告诉她在第一次调研后HR发来的文档就已经变了。接着我收到H公司转发来的一卡通的Email。Email内容痛陈HR与OA的同步方案是非数据库非Web Service 同步的四不象，复杂有加，实用不足，逻辑存缺陷，安全有隐患，并提供了他们的同步方案，请H公司重新做技术审核云云。洋洋洒洒两三千字，图文并茂，措辞犀利，我打从心底里面佩服作者的文笔功力。

文章不是专门针对我的，我没有太大歉意，但是我没有特意指出这个问题给H公司，我有连带责任。我原先是希望尽早实现功能，让客户尽早上线。如此看来，我的算盘打错了，欲速则不达，现在推翻之前的工作重来，项目进展更慢了。

我反思：客户不是傻子，不要忽悠客户，到头来只是忽悠自己。我同时也纳闷，早在H公司转发HR公司邮件的时候，他们也收到邮件，怎么当时不指出此问题的严重性，而留待至今。

OA接口的开发

HR的同步方案被一卡通推翻后，H公司跟HR公司重新确认了同步方案，如上图所示。我花了5个工作日来重新实现被推翻的功能。同时我重构了程序，原先很多工作都放在程序上做，程序写得很长，后来我又把大部分工作挪到数据库级别来做，数据库密集的工作，应该让数据库来直接处理。程序变短了，逻辑更清晰：

调用HR的Web Service接口获取差异数据XML，
把XML转换成DataTable，
迭代DataTable来做同步操作
把同步结果返回给HR系统

然而存储过程变长了：

根据HR发来的数据，检索对应的OA数据
数据容错校验
若容错校验通过，同步数据到OA

这样的结果是，程序的责任减轻，只是做了数据获取与数据传递（到数据库）和记录日志的作用，很容易保证程序的正确。而存储过程的责任加重，问题的出现也基本在此。存储过程写得够长的，我出来，逻辑结构也很清晰，该注释的也注释了，人员的同步与兼任部门职位的同步也容易调试。但是组织的同步一直折磨着我，特别是HR系统中"总部"与"分部"是并列关系，在OA变为机构与子部门之间的父子关系，我翻来覆去改动了多次，依然无法保证数据的正确对应关系。SQL脚本的不易调试，如何验证我的存储过程是正确的，或者说如何证明我的存储过程是错误的。最后我写存储过程来测试存储过程，这也不失是一种很好的单元测试方法。

OA跟一卡通的开发工作大概用了3个工作日便完成，运用链接服务器从OA数据库链接到一卡通的数据，调用它们的存储过程和视图。唯一困扰的是在Sql ServerManagement Studio中直接远程调用一卡通的数据库对象时很顺利，但是放在作业中让Sql Agent自动调度时出现诸如"安全上下文"的错误，折腾了两天没解决，在公司经理的指导下，配置一个Windows帐号来启用Sql Agent服务后，并给该帐号Sql Server的相应权限，问题得以解决。

部署

客户的机房里面运行着重要的程序、存放着重要的数据，稍不小心就有可能把程序搞垮，或把数据弄坏，尽管客户事前已经做过备份，一旦出现不可回退的误操作，还原现场也需要耗费大量的时间。所以，一个好的部署方案应该有序、不出差错，这需要事前充足的准备，列一个清晰的部署计划列表，第一步做什么、第二部做什么，井然有序。先把此部署列表给客户，好让他们清楚整个部署过程，消除心中疑虑，知道部署人员在干什么，将要干什么，这样客户会更好地支持部署人员的工作。这些我们都基本做到了。

结语

如何对待不合理需求

H公司最初给的上线时间要求是一个月，当时李经理指导我把此同步项目当作正常的二次开发项目对待，调研、需求分析、详细设计、代码开发、测试、试运行、部署，但是这样的项目周期远超过客户的时间要求一个月，我自身也疑惑，到底以哪个时间为参考；后来一卡通也提到，延迟上线造成的不便可以通过其它途径来弥补。客户的要求的时间限定只是一个参考，否则软件不能交付、或者交付了有严重问题的软件，你客户敢用吗？客户的时间需求也是一项需求（应该算非功能性需求吧），当需求不合理时，尝试说服客户，否则后果还是客户自己承受。

文档的规范

H公司和一卡通的文档很规范，尤其是一卡通，常常图文并茂，图形很漂亮。

工作范围

接口是静态的，怎么处理接口是动态的，OA跟一卡通双方技术讨论的时候，都只提接口的事，没有任一方提出谁来处理这接口，谁来创建SQL Server作业调度对方接口。而我的心态是我来做，毕竟做过了就是经验，对我自己或对公司都是一种经验，以后可以借鉴。

The end

本文链接

VB2010新特性之——标识语言版本的新命令行选项/langversion (Visual Basic)

2011-05-18T16:23:00Z

VB2010新特性之——标识语言版本的新命令行选项/langversion (Visual Basic)

命令行选项/langversion设置编译器，使它只接受指定VB版本的语法。

/langversion:version

参数 version：必须。指定编译期间使用的语言版本，值只能是：9, 9.0, 10, 或10.0。
备注：选项/langversion指定编译器接受的语法，如果您指定语言版本为9.0，一旦遇到10.0或更高版本的新语法，就会产生编译器错误。

若您面向不同的.NET框架开发程序，可以使用这个选项。例如，您面向.NET Framework 3.5, 可以使用这个选项来保证您不使用10.0版本的语法。

您只能在命令行下使用选项/langversion，详细请看Targeting a Specific .NET Framework Version or Profile。

本文链接

为什么开发人员不能估算时间？

2011-05-14T17:09:00Z

Why can't developers estimate time?

为什么开发人员不能估算时间？

We can't estimate the time for any individual task in software development because the nature of the work is creating new knowledge.

在软件开发中，我们不能估算单项任务所需的时间，因为工作的本质是创造新的知识。

The goal of software development is to automate processes. Once a process is automated, it can be run repeatedly, and in most cases, in a predictable time. Source code is like a manufacturing blueprint, the computer is like a manufacturing plant, the inputs (data) are like raw materials, and the outputs (data) are like finished goods. To use another analogy, the reason Starbucks makes drinks so quickly and repeatably is because they invested a lot of time in the design of the process, which was (and is, ongoing) a complex and expensive task. Individual Starbucks franchises don't have to re-discover this process, they just buy the blueprint. I'll leave it as an exercise to the reader to infer my opinion of the Costa coffee-making process.

软件开发的目标是使流程自动化，流程一旦自动化，多数情况下可以在可预测的时间内重复执行。源代码就像蓝图，计算机像工厂，输入（数据）像原材料，输出（数据）像成品。另一个比喻是，星巴克可高效地重复生产饮料，原因是他们投入了大量的时间去做流程设计，这曾经（仍然、继续）是一项复杂且高消耗的任务。星巴克的个人经营者不需要重新研发此流程，他们只需要购买蓝图即可。至于Costa咖啡制作流程的隐喻，且让读者来推测我的看法。

It's not actually always a problem that development time is unpredictable, because the flipside is that so is the value returned. A successful piece of software can make or save vastly more than its cost. Tom DeMarco argues for focussing on the high value projects for exactly this reason. Note that this does require a value-generation mindset, rather than the currently-prevalent cost-control mindset. This is a non-trivial problem.

开发时间不可预计不一定导致问题，因为另一方面你有价值回报。一款成功的软件可以创造或节省远远大于成本的价值，因此，Tom DeMarco 呼吁要把重点放在高价值回报的项目。注意，这需要一种创造价值的理念，而不是当前流行的成本控制的理念。这是一个值得正视的问题。

By far the best explanation I've read of variability and how to exploit it for value is Don Reinertsen's Principles of Product Development Flow, which is pretty much the adopted "PatchSpace Bible" for day-to-day process management. And when I say "by far the best", I mean by an order of magnitude above pretty much everything else I've read, apart from the Theory of Constraints literature.

至今为止，关于变数和如何将它转化为价值的最好解析是Don Reinertsen的《产品开发流程的原则》，它是日常流程管理中最应该被采用的圣经（PatchSpace Bible）。我说的"至今为止"，意思是我的认知范围中的最好，而不是根据什么原则。

Here is the data from my last development project. (Histogram generated in R with 5-hour buckets: the horizontal axis shows the duration in hours for the user stories - 0-5 hours, 5-10 hours, etc; the vertical axis is the number of stories that took that duration). We worked in 90 minute intervals and journaled the work on Wave, so we knew task durations to a pretty fine resolution. (We did this for both client communication and billing purposes.) The result: our development times were about as predictable as radioactive decay, but they were very consistently radioactive. Correlation with estimates was so poor I refused to estimate individual tasks, as it would have been wilfully misleading, but we had enough data to make sensible aggregates.

下面是我最近一个项目的数据，直方图的每一柱横跨五小时：横坐标指示用户素材（user stories）的工作量，0-5小时，5-10小时等；纵坐标指示相应的用户素材的数量。我们每工作90分钟做一次记录，所以我们对任务的工作时间有清楚的认识（我们这样做源于客户交流与开账单）。结果是：我们的开发时间的可预测就像放射性衰变那样，但它们始终如一放射。估算的精确度如此差，会严重误导人，以致我拒绝估算单项任务，但我们有足够的数据来对总体任务做明智的估算。

Rule of thumb: take the estimates of a developer, double it and add a bit

经验法则：采取开发人员的评估时间，翻倍再加一点

The double-and-add-a-bit rule is interesting. When managers do this, how often are tasks completed early? We generally pay much more attention to overruns than underruns. If a team is not completing half of its tasks early, it is padding the estimates, and that means trading development cycle time for project schedule. Cycle time is usually much more valuable than predictability, as it means getting to market sooner. Again, see Reinertsen's work, the numbers can come out an order of magnitude apart.

"翻倍再加一点"的规则很有意思。若管理者这样做，任务提前完成的概率有多大？我们通常更注重高估时间而不是低估时间。如果团队不能尽早完成一半任务，很可能将超出估算，这意味着要拿项目计划的开发周期做代价。开发周期（Cycle time）比可预测性（predictability）更有价值，它意味着更早把产品推向市场。借用Reinertsen的结论，可能相差一个数量级。

Also, this is the basis for Critical Chain project management, which halves the "safe" estimates to condense the timescale, and puts the remaining time (padding on individual tasks) at the end, as a "project buffer". This means that Parkinson's Law doesn't cause individual tasks to expand unduly. I'm unconvinced that Critical Chain is an appropriate method for software though, as the actual content of development work can change significantly, as feedback and learning improves the plan.

并且，这是关键链（Critical Chain）项目管理的基础，把"安全"估算减半来压缩时间跨度，把后期的剩余时间（单项任务的增补时间）作为"项目缓冲期"。这意味着Parkinson法则不会引起单项任务过度延期。我不赞同关键链是一种软件的适当方法，由于开发工作的实际内容可能差异极大，反馈、学习可以改善工作计划。

People in general just make shit up

大部分人都是在忽悠（make shit up）

It's not just developers that are bad with estimates either. Everyone at some point is just winging it because it's something they've never done before and won't be able to successfully make a judgement until they have.

不仅仅是开发人员才估算失准，某种程度上人人都会失准，因为事情之前没有做过，难以做正确的估算，除非已经做过。

As a community we need to get away from this. If we don't know, we don't know, and we need to say it. Clients who see regular progress on tasks they were made aware were risky (and chose to invest in) have much more trust in their team than clients whose teams make shit up. It's true! Srsly. Don't just take my word for it, though - read David Anderson's Kanban.

作为一个团体，我们须要避免这种情况。如果我们不清楚，我们就真不清楚，我们要说出来。对于意识到有风险（并选择投资）的任务，看见正常的进度的客户比被团队忽悠的客户对团队更加信任。这是真的！但是，不要总相信我的话——请看David Anderson的Kanban。

Estimating is a very important skill and should be taught more in junior dev roles

估算是一项重要的技能，应该多教育初级开发人员

I propose an alternative: what we need to do is teach to junior devs the meaning of done. If estimation problems are bad enough, finding out at some indeterminate point in the future that something went out unfinished (possibly in a rush to meet a commitment … I mean - estimate!) blows not only that estimate out of the water, but the schedule of all the current work in process too. This is very common, and can cause a significant loss of a development team's capacity.

我提议一个替代方案：我们需要教育初级开发人员"完成"的意思。如果估算糟糕透顶，找出不确定的地方：将来当任务没有完成，不仅影响该任务本身，还影响正在进行的所有任务。这非常普遍，并可能导致开发团队的能力造成重大损失。

本文链接

[翻译]SQL Server 未公开的两个存储过程sp_MSforeachtable 和 sp_MSforeachdb

2011-05-10T15:50:00Z

SQL Server 未公开的两个存储过程sp_MSforeachtable 和 sp_MSforeachdb

您是否曾经写过代码来处理数据库中的所有表？处理一个 SQL Server实例中的所有数据库的代码又该如何写？然则，您是否知道有多种方法可以解决这问题？您可以创建一个游标cursor包含所有数据表，或者包含SQL Server实例的所有数据库；或者使用非公开（undocumented）的存储过程。本文将向您阐述非公开的存储过程的工作方式，以及应用实例向您展示如何使用它们。非公开的存储过程比之游标更易用。

概述

Microsoft 提供了两个非公开化的存储过程，让您可以迭代处理数据库中的所有表，或者SQL Server 实例中的所有数据库。第一个存储过程是"sp_MSforeachtable"，让您可以轻易地使用代码处理数据库中的所有表；另一个是"sp_MSforeachdb"，处理SQL Server 实例中的所有数据库。让我们深入地了解这两个存储过程。

sp_MSforeachtable

"sp_MSforeachtable"没有在在线文档中出现，它存在于master数据库中，可以对给定数据库的所有表执行单条或多条T-SQL命令，请看下面的例子。

假如，您需要创建一个临时表，记录当前数据库拥有的表的表名、行记录数。为了实现此功能，您需要执行这样的命令："select '<mytable>', count(*) from <mytable>"。其中"<mytable>"替换为数据库中的每个表名，并将结果插入到临时表。下面我们用游标与非公开的"sp_MSforeachtable"来分别实现。

使用游标的方式：

下面是输出结果:

下面代码应用非公开的"sp_MSforeachtable"生成相同的结果：

下面是结果:

可见，使用游标与sp_MSforeachtable可生成相同的结果，您认为哪种方式更具可读性，更简单？下面来详细介绍sp_MSforeachtable的语法：

exec @RETURN_VALUE=sp_MSforeachtable @command1, @replacechar, @command2,

@command3, @whereand, @precommand, @postcommand

说明:

@RETURN_VALUE – 返回值
@command1 – 类型是nvarchar(2000)，sp_MSforeachtable最先执行的命令
@replacechar – 处理过程中，将命令行的这个字符替换为具体的表名（默认是"?"）
@command2\@command3:对每个数据表，都会执行这两条命令，@command2在@command1之后执行，@command3在@command2之后执行
@whereand – 类型是varchar(2000),提供额外的约束来过滤 sysobjects 表的行
@precommand - 类型是varchar(2000)，在处理任何表之前执行此命令
@postcommand - 类型是varchar(2000)，在处理完所有表之后执行此命令

下面几个例子演示此存储过程的用法，处理所有表或者部分表。

下面查询以字母 p 开头的表，使用参数 @whereand 设置过滤条件，代码如下：

下面是结果:

上面的代码使用了参数 @command1 与 @whereand，参数 @whereand 用来设置 WHERE 条件，筛选出以字母 p 开头的表名，我设置了参数值为"and o.name like ''p%''"。如果您希望使用多个条件约束，如以 p 开头或者以 a 开头，设置参数值为：

and o.name like ''p%'' or o.name like ''a%''

如果语句有问题，将 name 的前缀去掉，如下：

and name like ''p%'' or name like ''a%''

注意，上面例子的参数 @command1 使用了"?"，它叫做替换字符（replacement character），默认被所有表名替换。如果您需要在命令中使用"?"作为内容而不是被表名替换的替换字符，那么可以使用参数 @replacechar 来设置替换字符。下面例子使用"{"作为替换字符。

下面是结果:

还有两个参数 @precommand 与 @postcommand，看下面例子，把上面例子中的所有语句整合为一个简洁的存储过程调用。

注意上面例子用了全局临时表 ##rowcount，如果用临时表 #rowcount会报错。参数 @precommand 创建全局临时表，只执行了一次，并先于 @command1 的语句执行。@postcommmand 的语句待迭代处理完所有表后执行，也仅执行一次，用于显示结果并删除临时表。

sp_MSforeachdb

sp_MSforeachdb 同样也是在 master 数据库中，它迭代SQL Server 实例中的每个数据库，以执行T-SQL 语句，如"DBCCCHECKDB"，在看看它的语法

exec @RETURN_VALUE = sp_MSforeachdb @command1, @replacechar,

@command2, @command3, @precommand, @postcommand

说明:

@RETURN_VALUE – 返回值
@command1 – 类型是 nvarchar(2000),最先执行的命令
@replacechar – 替换字符，命令字符串中被替换为实际的数据库名（默认是"?"）
@command2\@command3:对每个数据库，都会执行这两条命令，@command2在@command1之后执行，@command3在@command2之后执行
@precommand - 类型是varchar(2000)，在处理任何数据库之前执行此命令
@postcommand - 类型是varchar(2000)，在处理完所有数据库之后执行此命令

sp_MSforeachdb 的参数与sp_MSforeachtable 的参数类似，因此，不再特意介绍这些参数。

请看下面的简单例子，此例子将进行数据库备份，然后对每个数据库做"DBCC CHECKDB"：

这里我用了三条不同的命令，第一条打印正在处理的数据库名。sp_MSforeachtable 有一个参数用来过滤需要处理的数据表，但是sp_MSforeachdb没有类似的过滤参数。由于SQL Server 不支持对 tempdb 的备份，因此我要跳过tempdb，这是我在每条命令使用 IF 的原因。第二条命令进行数据库备份，最后一条命令对除 tempdb 之外的数据库运行"DBCC CHECKDB"。

运行上面命令之前要先创建目录"c:\temp",下面是部分输出结果：

使用SQL Server非公开存储过程的说明

当使用这些非公开的存储过程时您须小心，并进行测试。由于未公开，意味着Microsoft在任何版本的升级或者补丁包都可能对它们进行修改，并且不做任何告知。因此，您需要在所有的SQL Server版本做全面的测试，测试以验证您的代码是否在新版本中仍然正常运行。

结语

正如您所见，这两个非公开的存储过程比游标易用，以后您可以用它们来迭代处理数据表或数据库。但是请谨记，这两个存储过程是非公开的，Microsoft很可能会随时改变它们的功能。

参考

SQL Server Undocumented Stored Procedures sp_MSforeachtable and sp_MSforeachdb

sp_MSforeachtable

本文链接

获取应用程序的根Url

2011-02-21T10:22:00Z

获取应用程序的根Url

VB代码

    Public Function ApplicationRootUrl() As String
        Dim req As HttpRequest = HttpContext.Current.Request
        Return req.Url.GetLeftPart(System.UriPartial.Authority) + req.ApplicationPath & "/"
    End Function

    '调用方式如下：
    ApplicationRootUrl() & "prg/if/ifShowMsgAddUp.aspx"

    '结果：http://localhost:8010/iOffice/prg/if/ifShowMsgAddUp.aspx

本文链接

Lambda 表达式 Lambda Expressions (Visual Basic)

2010-05-19T17:51:00Z

Lambda 表达式 Lambda Expressions (Visual Basic)

Lambda 表达式是一个不带名字的函数（function）或子过程（sub），可以用在任何接收委托的地方。Lambda 表达式可以是函数，也可以是子过程，可以是单行的，也可以写成多行。您可以把当前范围的值传递给 lambda 表达式。

注意，RemoveHandler 语句是一个例外，您不可以给委托参数传入一个 lambda 表达式

您使用 Function 或 Sub 关键字创建 lambda 表达式，就像创建普通函数和子过程一样。不过，lambda 表达式包含在一个语句中。

下面例子是一个 lambda 表达式，将参数自增 1 后返回。此例子展示单行和多行的 function 式 lambda 表达式语法

Dim increment1 = Function(x) x + 1
Dim increment2 = Function(x)
Return x + 2
End Function

' Write the value 2.
Console.WriteLine(increment1(1))

' Write the value 4.
Console.WriteLine(increment2(2))

下面例子是一个 lambda 表达式，演示子过程的单行和多行 lambda 表达式语法，把值写到控制台。

Dim writeline1 = Sub(x) Console.WriteLine(x)
Dim writeline2 = Sub(x)
Console.WriteLine(x)
End Sub

' Write "Hello".
writeline1("Hello")

' Write "World"
writeline2("World")

注意到前面的例子中，lambda 表达式赋值给了变量。当您引用该变量时，就调用该 lambda 表达式。您还可以声明 lambda 表达式的同时调用它，看下面的例子。

Console.WriteLine((Function(num As Integer) num + 1)(5))
lambda 表达式可以作为函数的返回值（例子在本文后面的上下文章节中），或者作为实参传送给委托类型的参数，像下面列子一样。
Module Module2

Sub Main()
' 下面代码会打印 Success, 因为 4 是偶数.
testResult(4, Function(num) num Mod 2 = 0)

' 下面代码会打印 Failure, 因为 5 不大于 10.
testResult(5, Function(num) num > 10)
End Sub

' Sub testResult 接收两个参数，一个 integer 和一个 function 委托，该委托接收 integer 值返回 boolean 值。
' 如果函数接收 integer 的实参并返回 True，则输出 Success，否则输出 Failure。

Sub testResult(ByVal value As Integer, ByVal fun As Func(Of Integer, Boolean))
If fun(value) Then
Console.WriteLine("Success")
Else
Console.WriteLine("Failure")
End If
End Sub

End Module

Lambda 表达式语法

Lambda 的语法类似于标准的函数或子过程，区别如下：

Lambda 表达式没有名字
Lambda 表达式没有修饰符（modifier），如 Overloads 或 Overrides
单行 lambda 函数的返回值类型不使用 As 子句标识，而是从 lambda 表达式主体计算所得值中推断。例如，lambda 表达式的主体是 cust.City = "London"，则其返回值类型是 Boolean。
多行 lambda 函数，可以使用 As 子句标识返回类型，或者省略掉 As 子句而自动推断返回类型。当多行 lambda 函数省略掉 As 子句，返回值的类型推断为所有 Return 子句的主导类型。主导类型是数组文本中所有其它类型可以扩大到的唯一类型。如果这个唯一类型不能决定，则主导类型是 Object。例如，返回值列表提供给数组文本包含的值类型有 Integer、Long、Double，则最终数组是 Double 类型。Integer 和 Long 扩大为 Double，且唯一是 Double。这样，Double 就是主导类型。查看详细，请看 Widening and Narrowing Conversions。
单行函数的主体必须是一个有返回值的表达式，而不是一个语句。单行函数没有 Return 语句，其返回值是函数体中表达式的值。
单行子过程的主体必须是一个单行语句。
单行函数或子过程没有 End Function 或 End Sub 语句。
您可以用 As 关键字标识 lambda 表达式参数的类型，或者自动推断该类型。要么所有参数类型都标识，要是所有都自动推断。
Optional 和 Paramarray 参数不被允许
泛型参数不被允许

上下文

lambda 表达式跟定义它的上下文共享作用范围。它跟容纳范围（containing scope）的内部的其它代码有相同的访问权限，包括访问成员变量、函数或子过程、Me、参数、和本地变量。

访问容纳范围（containing scope）的本地变量和参数可以超出该范围的生命期。只要委托引用的 lambda 表达式不被垃圾收集器收集，就可以访问保持的原始环境的变量。在下面的例子中，变量 target 是 makeTheGame 的本地变量，lambda 表达式 playTheGame 定义在 makeTheGame 中。注意到作为返回值的 lambda 表达式，在 Main子过程中赋值给 takeAGuess，仍然可以访问本地变量 target。

Module Module6

Sub Main()
'变量 takeAGuess 是一个 Boolean 函数，它存储在 makeTheGame 中设置的目标数字
Dim takeAGuess As gameDelegate = makeTheGame()

' 设置循环来玩游戏
Dim guess As Integer
Dim gameOver = False
While Not gameOver
guess = CInt(InputBox("Enter a number between 1 and 10 (0 to quit)", "Guessing Game", "0"))
' 输入 0 表示退出游戏
If guess = 0 Then
gameOver = True
Else
    ' 测试您的猜测，并告知您是否正确。takeAGuess 方法因不同的猜测值而被多次调用
    ' Main 过程访问不了目标值，且它没有被传入。
gameOver = takeAGuess(guess)
Console.WriteLine("Guess of " & guess & " is " & gameOver)
End If
End While

End Sub

Delegate Function gameDelegate(ByVal aGuess As Integer) As Boolean

Public Function makeTheGame() As gameDelegate

' 生成目标数字，介于 1 和 10。注意到 target 是一个本地变量，
' 当从 makeTheGame 返回后，它就不能被直接访问了。
Randomize()
Dim target As Integer = CInt(Int(10 * Rnd() + 1))

' Print the answer if you want to be sure the game is not cheating
' by changing the target at each guess.
Console.WriteLine("(Peeking at the answer) The target is " & target)

    ' 本游戏返回 lambda 表达式，该 lambda 表达式承载了创建它的上下文的环境，
    ' 这个环境包含 target 变量（target number）。注意到仅有当前猜测（current guess）
    ' 才是返回 lambda 表达式的参数，而不是 target。

' 猜测值跟目标值是否匹配
Dim playTheGame = Function(guess As Integer) guess = target

Return playTheGame

End Function

End Module

下面例子演示嵌套 lambda 表达式的大范围访问权。当作为返回值的 lambda 表达式在 Main 中被调用（aDel），它访问这些元素。

定义它的类的字段：aField
定义它的类的属性：aProp
定义它的方法 functionWithNestedLambda 的参数： level1
functionWithNestedLambda 的本地变量：lovalVar
外部 lambda 表达式的参数：level2

Module Module3

Sub Main()

    ' 创建类的一个实例，属性值 Prop 设为 1
    Dim lambdaScopeDemoInstance =
        New LambdaScopeDemoClass With {.Prop = 1}

    ' 变量 aDel 被绑定到 functionWithNestedLambda 返回的嵌套的 lambda 表达式
    Dim aDel As aDelegate =
        lambdaScopeDemoInstance.functionWithNestedLambda(2)

    ' 现在返回的嵌套的 lambda 表达式被调用，4 变成参数 level3 的值
    Console.WriteLine("First value returned by aDel: " & aDel(4))

    ' 改变某些值，以验证 lambda 表达式是否可访问变量，不仅他们的原始值
    lambdaScopeDemoInstance.aField = 20
    lambdaScopeDemoInstance.Prop = 30
    Console.WriteLine("Second value returned by aDel: " & aDel(40))
End Sub

Delegate Function aDelegate(
    ByVal delParameter As Integer) As Integer

Public Class LambdaScopeDemoClass
    Public aField As Integer = 6
    Dim aProp As Integer

    Property Prop() As Integer
        Get
            Return aProp
        End Get
        Set(ByVal value As Integer)
            aProp = value
        End Set
    End Property

    Public Function functionWithNestedLambda(
            ByVal level1 As Integer) As aDelegate

        Dim localVar As Integer = 5

        ' 当嵌套的 lambda 表达式作为 Main 的 aDel 第一次运行，变量有这些值：
        ' level1 = 2
        ' level2 = 3, Return 语句中，调用 aLambda 后
        ' level3 = 4, aDel 在 Main 中调用后
        ' locarVar = 5
        ' aField = 6
        ' aProp = 1
        ' 第二次执行, 更改了两个变量:
        ' aField = 20
        ' aProp = 30
        ' level3 = 40
        Dim aLambda = Function(level2 As Integer) _
            Function(level3 As Integer) _
                level1 + level2 + level3 + localVar + aField + aProp


         '函数返回嵌套的 lambda，3 作为参数 level2 的值
        Return aLambda(3)
    End Function

End Class
End Module

转换到委托类型

一个 lambda 表达式可以隐式地转换为兼容的委托类型。有关兼容性的普遍问题（general requirements for compatibility），请看 Relaxed Delegate Conversion。例如，下面代码展示一个 lambda 表达式隐式转换为匹配的委托签名 Func(Of Integer, Boolean)。

' 明确地声明一个委托
Delegate Function MultipleOfTen(ByVal num As Integer) As Boolean

' 这个函数匹配委托
Function IsMultipleOfTen(ByVal num As Integer) As Boolean
    Return num Mod 10 = 0
End Function

' 这个方法接收一个委托类型的输入参数，checkDelegate 参数也可以是类型 Func(Of Integer, Boolean)
Sub CheckForMultipleOfTen(ByVal values As Integer(),
        ByRef checkDelegate As MultipleOfTen)
    For Each value In values
        If checkDelegate(value) Then
            Console.WriteLine(value & " is a multiple of ten.")
        Else
            Console.WriteLine(value & " is not a multiple of ten.")
        End If
    Next
End Sub

' 这个方法演示显式地定义的委托（explicitly defined delegate）和 lambda 表达式传给同样的输入参数。
Sub CheckValues()
    Dim values = {5, 10, 11, 20, 40, 30, 100, 3}
    CheckForMultipleOfTen(values, AddressOf IsMultipleOfTen)
    CheckForMultipleOfTen(values, Function(num) num Mod 10 = 0)
End Sub

下面代码演示 lambda 表达式隐式地转换为匹配的委托签名 Sub(Of Double, String, Double)。

Module Module1
    Delegate Sub StoreCalculation(ByVal value As Double,
        ByVal calcType As String,
        ByVal result As Double)

    Sub Main()
        ' 创建 DataTable 存储信息
        Dim valuesTable = New DataTable("Calculations")
        valuesTable.Columns.Add("Value", GetType(Double))
        valuesTable.Columns.Add("Calculation", GetType(String))
        valuesTable.Columns.Add("Result", GetType(Double))

        ' 定义 lambda 子过程写信息到 DataTable.
        Dim writeToValuesTable = Sub(value As Double, calcType As String, result As Double)
            Dim row = valuesTable.NewRow()
            row(0) = value
            row(1) = calcType
            row(2) = result
            valuesTable.Rows.Add(row)
        End Sub

        ' 定义原值
        Dim s = {1, 2, 3, 4, 5, 6, 7, 8, 9}

        ' 执行计算
        Array.ForEach(s, Sub(c) CalculateSquare(c, writeToValuesTable))
        Array.ForEach(s, Sub(c) CalculateSquareRoot(c, writeToValuesTable))

        ' 显示数据
        Console.WriteLine("Value" & vbTab & "Calculation" & vbTab & "Result")
        For Each row As DataRow In valuesTable.Rows
            Console.WriteLine(row(0).ToString() & vbTab &
            row(1).ToString() & vbTab &
            row(2).ToString())
        Next

    End Sub

    Sub CalculateSquare(ByVal number As Double, ByVal writeTo As StoreCalculation)
        writeTo(number, "Square ", number ^ 2)
    End Sub

    Sub CalculateSquareRoot(ByVal number As Double, ByVal writeTo As StoreCalculation)
        writeTo(number, "Square Root", Math.Sqrt(number))
    End Sub
End Module

当您将 lambda 表达式赋值给委托或者将它们作为实参传给过程时，您可以标识参数名称，但省略他们的数据类型，让类型从委托中取。

例子

下面例子定义一个 lambda 表达式，如果 nullable 参数被赋值则返回 True，否则返回 False。

Dim notNothing =
Function(num? As Integer) num IsNot Nothing
Dim arg As Integer = 14
Console.WriteLine("Does the argument have an assigned value?")
Console.WriteLine(notNothing(arg))

下面例子定义一个 lambda 表达式，返回数组最后一个元素的索引。

Dim numbers() = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
Dim lastIndex =
Function(intArray() As Integer) intArray.Length - 1
For i = 0 To lastIndex(numbers)
numbers(i) += 1
Next

原文：http://msdn.microsoft.com/en-us/library/bb531253(v=VS.100).aspx

本文链接

集合初始化器概览(Visual Basic)

2010-05-18T15:50:00Z

集合初始化器概览 Collection Initializers Overview (Visual Basic)

集合初始化器提供简化的语法，使得创建集合的同时，可以用初始的集合值来填充它。当从既有的集合值创建新集合时，集合初始化器显得特别有用，例如，菜单列表或者编目（categories）、初始的数值集合、静态字符串列表如月份名称，或者地理位置如验证所用的州郡列表。

标识集合初始化器的方式是，用 From 关键字，后面紧跟着大括号"{}"。这类似于数组文本语法（array literal syntax）。下面代码展示用集合初始化器创建集合的各种方式：

' 创建 String数组
Dim winterMonths = {"December", "January", "February"}

' 创建 Integer 数组
Dim numbers = {1, 2, 3, 4, 5}

' 创建菜单选项列表，需要List(Of MenuOption)的一个扩展方法 Add
Dim menuOptions = New List(Of MenuOption) From {{1, "Home"},
{2, "Products"},
{3, "News"},
{4, "Contact Us"}}

注意：C# 也提供集合初始化器，其功能如 VB 的一样。欲知更多关于 C# 集合初始化器，请看Object and Collection Initializers (C# Programming Guide)。

语法

集合初始化器由紧跟着 From 关键字、包含在大括号中、以逗号分隔的列表组成，如以下代码：

Dim names As New List(Of String) From {"Christa", "Brian", "Tim"}

当你创建一个集合，如 List(Of T) 或者Dictionary(Of TKey, TValue)，必须在集合初始化器前提供集合类型，如以下代码：

Public Class AppMenu
Public Property Items As List(Of String) =
New List(Of String) From {"Home", "About", "Contact"}
End Class

注意：集合初始化器不可跟对象初始化器（object initializer）一起使用。

用集合初始化器创建集合

使用集合初始化器创建集合时，集合初始化器提供的每个值都将传递给适当的 Add 方法。例如，您用集合初始化器创建一个 List(Of T)，集合初始化器的每个值都传递给 Add 方法。若您想用集合初始化器创建集合，指定的类型必须是正确的集合类型（valid collection type）。正确集合类型的例子包含，实现了IEnumerable(Of T)接口的的类，或者是继承自 CollectionBase 类。指定的类型必需暴露满足格式的 Add 方法。

Add 方法必须在调用集合初始化器的上下文中可见。如果您在可以访问非公有方法的地方使用集合初始化器，Add 方法不必须是 Public。

Add 方法必须是实例方法，或者共享方法，又或者扩展方法。

基于重载解决规则（overload resolution rules），对于集合初始化器提供的类型，必须存在可以匹配Add 方法。

例如，下面代码演示如何运用集合初始化器创建一个List(Of Customer) 。当代码运行时，每个 Customer 对象传递给泛型的 Add（Customer）

Dim customers = New List(Of Customer) From
{
    New Customer("City Power & Light", "http://www.cpandl.com/"),
    New Customer("Wide World Importers", "http://www.wideworldimporters.com/"),
    New Customer("Lucerne Publishing", "http://www.lucernepublishing.com/")
}

如下代码演示不使用集合初始化器的等价物：

Dim customers = New List(Of Customer)
customers.Add(New Customer("City Power & Light", "http://www.cpandl.com/"))
customers.Add(New Customer("Wide World Importers", "http://www.wideworldimporters.com/"))
customers.Add(New Customer("Lucerne Publishing", "http://www.lucernepublishing.com/"))

如果集合有一个 Add 方法的参数跟 Customer 类的构造函数的参数一致，您可以将Add 方法的参数值嵌套到集合初始化器中，这在下一节中讨论。如果集合没有这样一个 Add 方法，您可以创建一个扩展方法。如何给集合添加扩展方法的例子，参见 How to: Create an Add Extension Method Used by a Collection Initializer。如何创建带集合初始化器的自定义集合（custom collection），参见 Create a Collection Used by a Collection Initializer。

嵌套的集合初始化器

您可以在集合初始化器中嵌套值，以标识集合中一个特定的 Add 方法的重载版本。传递到 Add 方法的值必须包含在大括号中，并且以逗号分隔，就像在数组文本或集合初始化器中一样。

使用嵌套值创建集合，嵌套值列表的每个元素作为参数传递到匹配该元素类型的 Add 方法。例如，下面代码例子创建一个Dictionary(Of TKey, TValue)，key 为 Integer 类型而 value 为 string 类型，嵌套值列表的每个元素匹配 Dictionary 的 Add 方法。

Dim days = New Dictionary(Of Integer, String) From
{{0, "Sunday"}, {1, "Monday"}}

上面代码等同于下面的代码：

Dim days = New Dictionary(Of Integer, String)
days.Add(0, "Sunday")
days.Add(1, "Monday")

只有嵌套值列表的第一级嵌套，才传递到集合的 Add 方法。深层嵌套作为数组文本（array literal），嵌套值列表不会跟集合的任何 Add 方法匹配。

本文链接

宽松委托转换（Relaxed delegate conversion）

2010-05-18T13:56:00Z

宽松委托转换（Relaxed delegate conversion）在 Visual Basic 2008 中引入，允许您将子过程或函数赋值给委托或处理器（handlers），尽管它们的签名不一致。因而，绑定到委托变得与绑定方法调用（method invocation）一样。

参数和返回类型

用宽松转换取代精确签名匹配，当 Option Strict 选项要设置为 On 时，需要满足以下两条件：

* 条件1 传参

从委托的每个参数到赋值函数或子过程（assigned function or Sub）的相对应参数，必须存在扩大转换（widening conversion）。在下面的例子中，委托 Del1 有一个 Integer 类型的参数，赋值 lambda 表达式（assigned lambda expressions）的参数 m 的类型必须可以从 Integer 扩大转换，如 Long 或 Double。

   ' 定义委托 Del1.
      Delegate Function Del1(ByVal arg As Integer) As Integer


      ' Option Strict 为 on 或 off，都是正确的 lambda 表达式赋值

      ' 整型匹配
      Dim d1 As Del1 = Function(m As Integer) 3

      ' Integer 扩大为 Long
      Dim d2 As Del1 = Function(m As Long) 3

      ' Integer 扩大为 Double
      Dim d3 As Del1 = Function(m As Double) 3


      只有 Option Strict 设置为 Off 的时候，才允许缩小转换（Narrowing conversion。


      ' 仅当 Option Strict 为 off 才正确:

      Dim d4 As Del1 = Function(m As String) CInt(m)
      Dim d5 As Del1 = Function(m As Short) m

*条件2 返回值

跟参数相反，从赋值函数或子过程（assigned function or Sub）的返回值类型到委托的返回值类型必须存在扩大转换。下面的例子中，因为委托 Del1的返回类型是 Integer，所以每个赋值 lambda 表达式（assigned lambda expression）必须（可以）扩大到 Integer。

   ' 当 Option Strict 为on 时是正确返回值:

      ' 整型匹配.
      Dim d6 As Del1 = Function(m As Integer) m

      ' Short 扩大为 Integer.
      Dim d7 As Del1 = Function(m As Long) CShort(m)

      ' Byte 扩大为 Integer.
      Dim d8 As Del1 = Function(m As Double) CByte(m)

如果 Option Strict 设置为 Off，传参和返回值没有扩大转换的限制。

' 仅当 Option Strict 设为 Off 时才正确.

' Integer 型参数没有扩展为 Short
Dim d9 As Del1 = Function(n As Short) n

' 返回值 Long 型没有扩展为 Integer
Dim d10 As Del1 = Function(n As Integer) CLng(n)

忽略参数规格

宽松委托（Relaxed delegate）允许您完全忽略赋值方法（assigned method）的参数规格

' 定义委托 Del2, 带两个参数
Delegate Function Del2(ByVal arg1 As Integer, ByVal arg2 As String) As Integer

' 赋值 lambda 表达式没有参数，尽管 Del2 有两个参数。因为在本例子中赋值函数（assigned function）
' 是 lambda 表达式，Option Strict 可以是 On 或者 Off。比较 d16 的声明，赋予了标准的方法。
Dim d11 As Del2 = Function() 3

' 参数仍然要传值，不过类型在委托中定义
Console.WriteLine(d11(5, "five"))

' 错误
' Console.WriteLine(d11())
' Console.WriteLine(d11(5))

注意，您不能只列某些参数，而忽略其它参数。

' 错误
'Dim d12 As Del2 = Function(p As Integer) p

忽略参数的特性很有用，特别是在事件处理器（event handler）方面，有很多复杂参数时，而某些参数不使用。这样，处理器直接访问事件所注册控件的状态，并且忽略参数。当不存在歧义时，宽松委托允许您忽略参数。下面的例子，标准的 OnClick 方法可以重写做 RelaxedOnClick。

Sub OnClick(ByVal sender As Object, ByVal e As EventArgs) Handles b.Click
MessageBox.Show("Hello World from" + b.Text)
End Sub

Sub RelaxedOnClick() Handles b.Click
MessageBox.Show("Hello World from" + b.Text)
End Sub

AddressOf 例子

前面例子使用 lambda 表达式，使得类型的关系很明显。然而，同样的关系可以用关键字 AddressOf、Handles、AddHandler 作委托赋值（delegate assignment），类型关系就不那么明显了。

下面的例子，函数 f1, f2, f3, 和 f4 可以赋值给 Del1。

' 声明函数委托 Del1.
Delegate Function Del1(ByVal arg As Integer) As Integer

' Definitions of f1, f2, f3, and f4.
Function f1(ByVal m As Integer) As Integer
End Function

Function f2(ByVal m As Long) As Integer
End Function

Function f3(ByVal m As Integer) As Short
End Function

Function f4() As Integer
End Function

' 给函数委托 Del1 赋值

' 正确的 AddressOf 赋值，Option Strict 可为 on 或 off:

' Integer parameters of delegate and function match.
Dim d13 As Del1 = AddressOf f1

' 整型委托参数扩大为 Long.
Dim d14 As Del1 = AddressOf f2

' f3 的 Short 返回类型扩大为 Integer.
Dim d15 As Del1 = AddressOf f3

以下例子仅当 Option Strict 为 Off 是才正确。

' 如果 Option Strict 设置 Off，f4 的参数规范可以省略
Dim d16 As Del1 = AddressOf f4

' 函数 d16 仍然需要一个参数，在 Del1 定义的
Console.WriteLine(d16(5))

' Not valid.
'Console.WriteLine(d16())
'Console.WriteLine(d16(5, 3))

丢弃函数返回值

宽松委托转换（Relaxed delegate conversion）允许您将一个函数（Function）赋值给子过程委托（Sub delegate），忽略掉函数的返回值。但是您不能够将子过程（Sub）赋值给函数委托（Function Delegate）。下面的例子，函数 doubler 的地址复制给 Sub 委托 Del3。

' 定义 Sub 委托 Del3.
Delegate Sub Del3(ByVal arg1 As Integer)

' 定义函数 doubler, 显示并返回整型参数的值
Function doubler(ByVal p As Integer) As Integer
    Dim times2 = 2 * p
    Console.WriteLine("Value of p: " & p)
    Console.WriteLine("Double p:   " & times2)
    Return times2
End Function

' 您可以把函数赋值给 Sub 委托:
Dim d17 As Del3 = AddressOf doubler

' 您可以向普通 Sub 过程一样调用 d17
d17(5)

' 您不可以将 d17 作为函数调用，它是一个 Sub 过程，没有返回值。
' 错误
'Console.WriteLine(d17(5))

本文链接

VB2010 的隐式续行（Implicit Line Continuation）

2010-05-17T11:32:00Z

VB2010 的隐式续行（Implicit Line Continuation）

许多情况下,您可以让 VB 后一行继续前一行的语句，而不必使用下划线（_）。下面列举出隐式续行语法的使用情形。

1、逗号“，”之后

Public Function GetUsername(ByVal username As String,
                            ByVal delimiter As Char,
                            ByVal position As Integer) As String

    Return username.Split(delimiter)(position)
End Function

2、左括号之后，或右括号之前：

Dim username = GetUsername(
    Security.Principal.WindowsIdentity.GetCurrent().Name,
    CChar("\"),
    1
  )

3、左大括号之后，或者右大括号之前：

Dim customer = New Customer With {
  .Name = "Terry Adams",
  .Company = "Adventure Works",
  .Email = "terry@www.adventure-works.com"
}

4、XML 文本中的开嵌入表达式（open embedded expression）“<%=”之后，或者闭嵌入表达式（close of an embedded expression）“%>”之前：

Dim customerXml = <Customer>
                      <Name>
                          <%=
                              customer.Name
                          %>
                      </Name>
                      <Email>
                          <%=
                              customer.Email
                          %>
                      </Email>
                  </Customer>

5、字符串连接符“&”之后

cmd.CommandText =
    "SELECT * FROM Titles JOIN Publishers " &
    "ON Publishers.PubId = Titles.PubID " &
    "WHERE Publishers.State = 'CA'"

6、赋值符号之后，如(=, &=, :=, +=, -=, *=, /=, \=, ^=, <<=, >>=)

Dim fileStream =
My.Computer.FileSystem.
OpenTextFileReader(filePath)

7、表达式中二元运算符之后，如(+, -, /, *, Mod, <>, <, >, <=, >=, ^, >>, <<, And, AndAlso, Or, OrElse, Like, Xor)

Dim memoryInUse =
  My.Computer.Info.TotalPhysicalMemory +
  My.Computer.Info.TotalVirtualMemory -
  My.Computer.Info.AvailablePhysicalMemory -
  My.Computer.Info.AvailableVirtualMemory

8、Is 或 IsNot 运算符后

If TypeOf inStream Is
  IO.FileStream AndAlso
  inStream IsNot
  Nothing Then

    ReadFile(inStream)

End If

9、成员修饰符（member qualifier character）“.”之后，并且在成员名称之前。然而，当您使用 With 语句或者给类型的初始化列表（initialization list）提供成员时，必须在成员修饰符“.”后面加上下划线“_”。当您使用 With 语句或对象初始化列表（object initialization lists）时，可以在赋值符号（如“=”）后面换行。

Dim fileStream =
  My.Computer.FileSystem.
    OpenTextFileReader(filePath)

...

' 不允许这样:
' Dim aType = New With { .
'    PropertyName = "Value"

' 可以这样:
Dim aType = New With {.PropertyName =
    "Value"}

Dim log As New EventLog()

' 不可以这样:
' With log
'    .
'      Source = "Application"
' End With

' 可以这样:
With log
    .Source =
      "Application"
End With

10、XML 轴属性修饰符（XML axis property qualifier）后面，如“.”、“.@”、“...”的后面。然而，当你使用 With 关键字时，标识成员修饰符，你必须包含下划线。

Dim customerName = customerXml.
<Name>.Value

Dim customerEmail = customerXml...
<Email>.Value

11、标识属性类（Attribute）时，小于号(<)之后或者大于号(>)之前。还有标识属性类时，大于号后面也可隐藏连接符。但是，当您标识程序集级别或者模块级别的属性类时，必须用连接符“_”。

<
Serializable()
>
Public Class Customer
    Public Property Name As String
    Public Property Company As String
    Public Property Email As String
End Class

12、查询运算符（query operators）之前或之后，包括 Aggregate, Distinct, From, Group By, Group Join, Join, Let, Order By, Select, Skip, Skip While, Take, Take While, Where, In, Into, On, Ascending, and Descending。若查询运算符由多个单词构成，您不可以在它们中间换行，如Order By, Group Join, Take While, 和 Skip While。

Dim vsProcesses = From proc In
                    Process.GetProcesses
                  Where proc.MainWindowTitle.Contains("Visual Studio")
                  Select proc.ProcessName, proc.Id,
                         proc.MainWindowTitle

13、For Each 语句的 In 关键字后

For Each p In
  vsProcesses

    Console.WriteLine("{0}" & vbTab & "{1}" & vbTab & "{2}",
      p.ProcessName,
      p.Id,
      p.MainWindowTitle)
Next

14、集合初始化器的 From 关键字后

Dim days = New List(Of String) From
  {
   "Mo", "Tu", "We", "Th", "F", "Sa", "Su"
  }

原文参见：http://msdn.microsoft.com/en-us/library/865x40k4.aspx

本文链接

自动实现属性

2010-05-15T12:30:00Z

自动实现属性Auto-Implemented Properties (Visual Basic)

自动实现属性允许您快速定义类的属性，而不用编写代码来获取和设置属性。当您编写了自动实现属性，Visual Basic 编译器不仅自动创建 Get 和 Set 子过程，还创建私有字段（private field）来存储属性变量（property variable）。

有了自动实现属性，属性和默认值就可以在单行代码中声明。下面代码演示了3个属性的声明（declaration）。

Public Property Name As String

Public Property Owner As String = "DefaultName"

Public Property Items As New List(Of String) From {"M", "T", "W"}

Public Property ID As New Guid()

自动实现属性等同于属性值存储在私有字段的属性，下面代码演示自动实现属性。

Property Prop2 As String = "Empty"

下面代码展示上面自动实现属性的等价形式：

Private _Prop2 As String = "Empty"

Property Prop2 As String

Get

Return _Prop2

End Get

Set(ByVal value As String)

_Prop2 = value

End Set

End Property

背后字段Backing Field

当你声明一个自动实现属性，Visual Basic 自动创建一个称为背后字段（backing field）的隐藏私有字段来存储属性值。背后字段的名称是自定义属性名加了下划线。例如，定义一个名为 ID 的自动实现属性，背后字段就是 _ID，如果您的类中包含成员 _ID，将产生名字冲突，Visual Basic 会报告编译错误。

背后字段有下面的特性：

背后字段的访问修饰符（access modifier）总是 private，尽管属性有其它的存储级别，如 public。
如果属性标识为Shared，背后字段也是Shared。
修饰属性的属性类（Attribute）不会应用到背后字段。
背后字段可以在类的代码中访问，或在调试工具如 Watch 窗口中访问。然而，背后字段不会在智能提示列表中显示。

初始化自动实现属性

任何可以初始化字段的表达式，都能用来初始化自动实现属性。当你初始化自动实现属性时，表达式被计算，然后传给属性的 Set 子过程。下面代码展示包含初始值的自动实现属性。

Property FirstName As String = "James"

Property PartNo As Integer = 44302

Property Orders As New List(Of Order)(500)

若自动实现属性是接口（Interface）或者标识为 MustOverride的类的成员，不可以初始化。

若自动实现属性是结构体（Structure ）的成员，只有自动实现属性标识为 Shared 时才可初始化。

若将自动实现属性声明为数组，不可以给数组标识精确边界。然而，您可以用数组初始化器（array initializer）来赋值，像下面这样：

Property Grades As Integer() = {90, 73}

Property Temperatures As Integer() = New Integer() {68, 54, 71}

必须用标准语法的属性定义

自动实现属性非常方便，而且适用于许多编程场合。然而有许多情形，您不能使用自动实现属性，而必须使用标准的或者扩展的（expanded）属性语法。

您如果想做下面的事情，必须使用扩展的属性定义语法：

在 Get 或 Set 子过程中添加代码。例如，你在设置电话号码属性值前，希望验证字符串是否包含正确位数。
给 Get 和 Set 子过程标识不同的访问性（accessibility）。例如，你想把 Set 子过程标识为 Private 而把 Get 子过程标识为 Public。
创建 WriteOnly 或 ReadOnly 的属性。
使用参数化的属性（包含默认属性）。您必须声明一个扩展的属性来给属性标识参数，或者给 Set 子过程标识额外参数。
给背后字段限定属性类（attribute）。
给背后字段提供 XML 注释。

扩展自动实现属性

如果您希望将自动实现属性转换为包含 Get 或 Set 子过程的扩展属性，Visual Basic 代码编辑器可以给属性自动生成 Get 和 Set 子过程和 End Property 语句。做法是：将光标定位在属性语句的下一空白行，输入 G（Get首字母）或 S（Set首字母），等智能提示框弹出后再按下 Enter 键。若在只读或只写属性语句尾部按下 Enter 键，Visual Basic 代码编辑器自动生成 Get 或 Set 子过程。

本文链接