博客园_2012 gogogo！！！！！！！！！

PowerDesigner教程系列概念数据模型

2012-05-13T08:12:00Z

目标:
本文主要介绍PowerDesigner中概念数据模型 CDM的基本概念。

一、概念数据模型概述
数据模型是现实世界中数据特征的抽象。数据模型应该满足三个方面的要求：
1）能够比较真实地模拟现实世界
2）容易为人所理解
3）便于计算机实现

概念数据模型也称信息模型，它以实体－联系(Entity-RelationShip,简称E-R)理论为基础，并对这一理论进行了扩充。它从用户的观点出发对信息进行建模，主要用于数据库的概念级设计。

通常人们先将现实世界抽象为概念世界，然后再将概念世界转为机器世界。换句话说，就是先将现实世界中的客观对象抽象为实体(Entity)和联系(Relationship),它并不依赖于具体的计算机系统或某个DBMS系统，这种模型就是我们所说的CDM;然后再将CDM转换为计算机上某个DBMS所支持的数据模型，这样的模型就是物理数据模型,即PDM。

CDM是一组严格定义的模型元素的集合，这些模型元素精确地描述了系统的静态特性、动态特性以及完整性约束条件等，其中包括了数据结构、数据操作和完整性约束三部分。
1）数据结构表达为实体和属性;
2）数据操作表达为实体中的记录的插入、删除、修改、查询等操作;
3）完整性约束表达为数据的自身完整性约束（如数据类型、检查、规则等）和数据间的参照完整性约束（如联系、继承联系等）;

二、实体、属性及标识符的定义
实体（Entity），也称为实例，对应现实世界中可区别于其他对象的“事件”或“事物”。例如，学校中的每个学生，医院中的每个手术。
每个实体都有用来描述实体特征的一组性质，称之为属性，一个实体由若干个属性来描述。如学生实体可由学号、姓名、性别、出生年月、所在系别、入学年份等属性组成。

实体集（Entity Set）是具体相同类型及相同性质实体的集合。例如学校所有学生的集合可定义为“学生”实体集，“学生”实体集中的每个实体均具有学号、姓名、性别、出生年月、所在系别、入学年份等性质。

实体类型（Entity Type）是实体集中每个实体所具有的共同性质的集合，例如“患者”实体类型为：患者｛门诊号，姓名，性别，年龄，身份证号.............｝。实体是实体类型的一个实例，在含义明确的情况下，实体、实体类型通常互换使用。

实体类型中的每个实体包含唯一标识它的一个或一组属性，这些属性称为实体类型的标识符（Identifier），如“学号”是学生实体类型的标识符，“姓名”、“出生日期”、“信址”共同组成“公民”实体类型的标识符。

有些实体类型可以有几组属性充当标识符，选定其中一组属性作为实体类型的主标识符，其他的作为次标识符。

三、实体、属性及标识符的表达

待续！

目标：
本文主要介绍PowerDesigner概念数据模型以及实体、属性创建。

一、新建概念数据模型
1）选择File-->New,弹出如图所示对话框，选择CDM模型（即概念数据模型）建立模型。

2）完成概念数据模型的创建。以下图示，对当前的工作空间进行简单介绍。（以后再更详细说明）

3）选择新增的CDM模型，右击，在弹出的菜单中选择“Properties”属性项，弹出如图所示对话框。在“General”标签里可以输入所建模型的名称、代码、描述、创建者、版本以及默认的图表等等信息。在“Notes”标签里可以输入相关描述及说明信息。当然再有更多的标签，可以点击 "More>>"按钮，这里就不再进行详细解释。

二、创建新实体
1）在CDM的图形窗口中，单击工具选项版上的Entity工具，再单击图形窗口的空白处，在单击的位置就出现一个实体符号。点击Pointer工具或右击鼠标，释放Entitiy工具。如图所示

2）双击刚创建的实体符号，打开下列图标窗口，在此窗口“General”标签中可以输入实体的名称、代码、描述等信息。

三、添加实体属性
1）在上述窗口的“Attribute”选项标签上可以添加属性，如下图所示。

注意：
数据项中的“添加属性”和“重用已有数据项”这两项功能与模型中Data Item的Unique code 和Allow reuse选项有关。
P列表示该属性是否为主标识符;D列表示该属性是否在图形窗口中显示;M列表示该属性是否为强制的，即该列是否为空值。

如果一个实体属性为强制的，那么，这个属性在每条记录中都必须被赋值，不能为空。

2）在上图所示窗口中，点击插入属性按钮，弹出属性对话框，如下图所示。

注意：这里涉及到域的概念，即一种标准的数据结构，它可应用至数据项或实体的属性上。在以下的教程中将另立章节详细说明。

待续。

目标：
本文主要介绍属性的标准检查约束、如何定义属性的附加检查。

一、定义属性的标准检查约束
标准检查约束是一组确保属性有效的表达式。在实体属性的特性窗口，打开如图所示的检查选项卡。

在这个选项卡可以定义属性的标准检查约束，窗口中每项的参数的含义，如下

参数	说明
Minimum	属性可接受的最小数
Maximum	属性可接受的最大数
Default	属性不赋值时，系统提供的默认值
Unit	单位，如公里、吨、元
Format	属性的数据显示格式
Lowercase	属性的赋值全部变为小写字母
Uppercase	属性的赋值全部变为大写字母
Cannot modify	该属性一旦赋值不能再修改
List Of Values	属性赋值列表，除列表中的值，不能有其他的值
Label	属性列表值的标签

二、定义属性的附加检查
当Standard checks 或Rules 不能满足检查的要求时，可以在Additional Checks选项卡的Server子页上，通过SQL语句中使用%MINMAX%、%LISTVAL%、%RULES%、%UPPER%、%LOWER%几个变量来定义Standard和Rule,如图所示

%MINMAX%、%LISTVAL%、%UPPER%、%LOWER%
在Standard Check中定义的Minimum 和Maximum、List values 、uppervalues、lowervalues

%RULES%
在Rules特性窗口Expression选项卡中定义的有效性规则表达式

待续。

目标：
本文主要介绍如何定义实体的主、次标识符。

一、标识符
标识符是实体中一个或多个属性的集合，可用来唯一标识实体中的一个实例。要强调的是，CDM中的标识符等价于PDM中的主键或候选键。
每个实体都必须至少有一个标识符。如果实体只有一个标识符，则它为实体的主标识符。如果实体有多个标识符，则其中一个被指定为主标识符，其余的标识符就是次标识符了。

二、如果定义主、次标识符
1）选择某个实体双击弹出实体的属性对话框。在Identifiers选项卡上可以进行实体标识符的定义。如下图所示

2）选择第一行“主标识符”，点击属性按钮或双击第一行“主标识符”，弹出属性对话框，如图所示

3）选择"Attributes"选项卡，再点击“Add Attributes”工具，弹出如图所示窗口，选择某个属性作为标识符就行了。

待续。

目标：
本文主要介绍数据项、新增数据项、数据项的唯一性代码选项和重用选项等。

一、数据项
数据项（Data Item）是信息存储的最小单位，它可以附加在实体上作为实体的属性。
注意：模型中允许存在没有附加至任何实体上的数据项。

二、新建数据项
1）使用“Model”---> Data Items 菜单，在打开的窗口中显示已有的数据项的列表，点击 “Add a Row”按钮，创建一个新数据项，如图所示

2）当然您可以继续设置具体数据项的Code、DataType、Length等等信息。这里就不再详细说明了。

三、数据项的唯一性代码选项和重用选项
使用Tools--->Model Options->Model Settings。在Data Item组框中定义数据项的唯一性代码选项(Unique Code)与重用选项（Allow Reuse）。
注意：
如果选择Unique Code复选框，每个数据项在同一个命名空间有唯一的代码，而选择Allow reuse ，一个数据项可以充当多个实体的属性。

四、在实体中添加数据项
1）双击一个实体符号，打开该实体的属性窗口。
2）单击Attributes选项卡，打开如下图所示窗口

注意：
Add a DataItem 与 Reuse a DataItem的区别在于
Add a DataItem 情况下，选择一个已经存在的数据项，系统会自动复制所选择的数据项。如果您设置了UniqueCode选项，那系统在复制过程中，新数据项的Code会自动生成一个唯一的号码，否则与所选择的数据项完全一致。

Reuse a DataItem情况下，只引用不新增，就是引用那些已经存在的数据项，作为新实体的数据项。

待续。

目标：本文主要介绍联系的定义及使用。

一、联系
联系（Relationship）是指实体集这间或实体集内部实例之间的连接。

实体之间可以通过联系来相互关联。与实体和实体集对应，联系也可以分为联系和联系集，联系集是实体集之间的联系，联系是实体之间的联系，联系是具有方向性的。联系和联系集在含义明确的情况之下均可称为联系。

按照实体类型中实例之间的数量对应关系，通常可将联系分为4类，即一对一（ONE TO ONE）联系、一对多（ONE TO MANY）联系、多对一（MANY TO ONE）联系和多对多联系（MANY TO MANY）。

二、建立联系
在CDM工具选项板中除了公共的工具外，还包括如下图所示的其它对象产生工具。

在图形窗口中创建两个实体后，单击“实体间建立联系”工具，单击一个实体，在按下鼠标左键的同时把光标拖至别一个实体上并释放鼠标左键，这样就在两个实体间创建了联系，右键单击图形窗口，释放Relationship工具。如下图所示

三、四种基本的联系
即一对一（ONE TO ONE）联系、一对多（ONE TO MANY）联系、多对一（MANY TO ONE）联系和多对多联系（MANY TO MANY）。如图所示

四、其他几类特殊联系

除了4种基本的联系之外，实体集与实体集之间还存在标定联系（Identify Relationship）、非标定联系（Non-Identify RelationShip）和递归联系（Recursive Relationship）。

标定联系：
每个实体类型都有自己的标识符，如果两个实体集之间发生联系，其中一个实体类型的标识符进入另一个实体类型并与该实体类型中的标识符共同组成其标识符时，这种联系则称为标定联系，也叫依赖联系。反之称为非标定联系，也叫非依赖联系。
注意：
在非标定联系中，一个实体集中的部分实例依赖于另一个实例集中的实例，在这种依赖联系中，每个实体必须至少有一个标识符。而在标定联系中，一个实体集中的全部实例完全依赖于另个实体集中的实例，在这种依赖联系中一个实体必须至少有一个标识符，而另一个实体却可以没有自己的标识符。没有标识符的实体用它所依赖的实体的标识符作为自己的标识符。

换句话来理解，在标定联系中，一个实体（选课）依赖一个实体（学生），那么（学生）实体必须至少有一个标识符，而（选课）实体可以没有自己的标识符，没有标标识符的实体可以用实体（学生）的标识符作为自己的标识符。

递归联系：
递归联系是实体集内部实例之间的一种联系，通常形象地称为自反联系。同一实体类型中不同实体集之间的联系也称为递归联系。

例如：在“职工”实体集中存在很多的职工，这些职工之间必须存在一种领导与被领导的关系。又如“学生”实体信中的实体包含“班长”子实体集与“普通学生”子实体集，这两个子实体集之间的联系就是一种递归联系。创建递归联系时，只需要单击“实体间建立联系”工具从实体的一部分拖至该实体的别一个部分即可。如图

五、定义联系的特性

在两个实体间建立了联系后，双击联系线，打开联系特性窗口，如图所示。

六、定义联系的角色名
在联系的两个方向上各自包含有一个分组框，其中的参数只对这个方向起作用，Role Name为角色名，描述该方向联系的作用，一般用一个动词或动宾组表。
如：“学生 to 课目 ” 组框中应该填写“拥有”，而在“课目To 学生”组框中填写“属于”。（在此只是举例说明，可能有些用词不太合理）。

七、定义联系的强制性
Mandatory 表洋这个方向联系的强制关系。选中这个复选框，则在联系线上产生一个联系线垂直的竖线。不选择这个复选框则表示联系这个方向上是可选的，在联系线上产生一个小圆圈。

八、有关联系的基数
联系具有方向性，每个方向上都有一个基数。

举例，
“系”与“学生”两个实体之间的联系是一对多联系，换句话说“学生”和“系”之间的联系是多对一联系。而且一个学生必须属于一个系，并且只能属于一个系，不能属于零个系，所以从“学生”实体至“系”实体的基数为“1,1”，从联系的另一方向考虑，一个系可以拥有多个学生，也可以没有任何学生，即零个学生，所以该方向联系的基数就为“0,n”,如图所示

待续。

新年开篇说明：

很感谢大伙对此系列教程的关注，因为工作的很多原因，一直没时间静下心来整理新的教程，担心没有自己没有理解清楚写出来误导大伙，故一拖再一拖，几年过去了，最近又收到很多网友的邮件要求继续写下去，没能一一回复，还望谅解。以后每周抽出时间写一篇，篇幅长一点，仅此答谢广大关注的网友。

目标：本文主要介绍继承联系定义及使用。

一、定义

实体之间除了我们之前所讲的联系外，还存在分类关系、继承关系。在CDM中我们统称分类关系、继承关系为继承联系。

通过特殊化或概化方法产生的实体类型之间的联系称为继承联系。

特殊化：在实体集内部分组并把这些分组存放在不同的实体类型中的过程称为实体集的特殊化。

概化：从多个实体集的公共属性中抽象出一个公共实体类型的过程为实体集的概化。

继承联系的一端是具有普遍性的实体集，为父实体集，另一端连接的是具体特殊的一个或多个实体集，为子实体集。

例如：“银行账户”是“借记卡账户”与“信用卡账户”的父实体，相反“借记卡账户”与“信用卡账户”是“银行账户”的子实体。

另外在继承联系中，还可以分为互斥性继承联系和非互斥性继承联系。

互斥性继承联系：父实体中的一个实例只能在一个子实体中。例如：“帐户”主实体下的“个人账户”与“公司账户”两个子实体之间的联系是互斥的。

非互斥性继承联系：父实体中的一个实例可以在多个子实体中。例如：“职工”父实体下的“干部”与“教师”子实体之间属于非互斥继承联系，教师有可能也是干部，干部有可能也是教师。

这里我就不再图示了，望大伙要认真理解概念。

二、 创建继承联系

注意：PowerDesigner 15 的版本，工具栏上的Inheritance图标默认是禁用的。打开方法如下：

Tools->Model Options->Model Settings->Notation 设为“E/R+Merise”就行了。

图示 1

图示 2

在CDM中创建两个实体，A与B,单击工具选项板上的继承工具连接A与B实体。图示1

A是父实体，B是子实体。再创建实体C以同样的方法连接到C实体上。如图2所示，表示B、C与A之间存在继承联系。

三、 定义互斥性继承联系

双击继承联系的半圆符号，打开继承联系的属性窗口。如图3所示

图示 3

Mutually exclusive children 表示父实体中的一条记录只能在一个子实体上出现，子实体之间存在互斥的关系。

Complete 表示父实体的所有实例必须是子实体之一，例如：“人”实体有“男人”和“女人”两个子实体，每个“人”实体的实例可以是“男人”或“女人”。

四、 定义继承联系的生成模式

图示 4

定义由CDM生成PDM或者生成OOM中的class图的生成模式。

说明：

Generate parent：表示继承联系中的父实体会生成PDM中的表或Class图中的类。

Generate children：

1）选择Inherit all attributes 表示继承联系中的子实体生成PDM中的表或Class图中的类，并且继承父实体中的所有实体属性

2）选择Inherit only primary attributes,表示继承联系中子实体生成PDM中的表或Class图中的类，但只继承父实体中的标识符属性。

五、 继承联系状态表

图示 5

目标：本文主要介绍域的概念以及使用。

一、概念

域：实际上就是一个取值范围，也可扩展为一个数据类型。域可以定义检查约束、取值范围、最大值、最小值、默认值等。

域是通过用户自定义类型实现的，定义一个域的后，可以实多个实体的属性共享，这也模型设计中非常重要。

例如：“服务生”、“客户”、“操作员”三个实体中都有“姓名”属性，我们就可以定义一个“姓名”域，分别附加到三个实体中，修改域的同时，使用域的实体的相关属性也会随之更新。所图所示

二、域的定义

菜单Model->Domains,在弹出窗口“List of Domains”中,增加新的域。如图所示

三、附加域到实体属性

打开实体的属性选项卡，如图所示，从Domain下拉列表中选择一个域

注：设置域与数据项的分离关系，Tools->Model Options ->Model，设置“Domain/Attribute”,Enforce non-divergence 下的Data type(数据类型、长度、精度)、Check（检查约束）、Rules（业务规则）、Mandatory等。如果都不选，则表示设置域与数据项是可分离的。默认为Data type 不可分离，可自行设置。如下图所示

四、附加域到数据项上

菜单Model->Data Items,在弹出窗口“List Data Items”中，添加数据项以及附加域,所图所示

本文链接

怎么成为优秀的软件模型设计者?

2012-05-13T08:11:00Z

http://www.doc88.com/p-295590413178.html

作者：Scott Ambler著，乐林峰译
本文选自：www.umlchina.com
2002年03月25日

我们期待自己成为一个优秀的软件模型设计者，但是，要怎样做，又从哪里开始呢？

将下列原则应用到你的软件工程中，你会获得立杆见影的成果。

1. 人远比技术重要

你开发软件是为了供别人使用，没有人使用的软件只是没有意义的数据的集合而已。许多在软件方面很有成就的行家在他们事业的初期却表现平平，因为他们那时侯将主要精力都集中在技术上。显然，构件（components），EJB（Enterprise Java Beans）和代理（agent）是很有趣的东西。但是对于用户来说，如果你设计的软件很难使用或者不能满足他们的需求，后台用再好的技术也于事无补。多花点时间到软件需求和设计一个使用户能很容易理解的界面上。

2. 理解你要实现的东西

好的软件设计人员把大多数时间花费在建立系统模型上，偶尔写一些源代码，但那只不过是为了验证设计过程中所遇到的问题。这将使他们的设计方案更加可行。

3. 谦虚是必须的品格

你不可能知道一切，你甚至要很努力才能获得足够用的知识。软件开发是一项复杂而艰巨的工作，因为软件开发所用到的工具和技术是在不断更新的。而且，一个人也不可能了解软件开发的所有过程。在日常生活中你每天接触到的新鲜事物可能不会太多。但是对于从事软件开发的人来说，每天可以学习很多新东西（如果愿意的话）。

4. 需求就是需求

如果你没有任何需求，你就不要动手开发任何软件。成功的软件取决于时间（在用户要求的时间内完成）、预算和是否满足用户的需求。如果你不能确切知道用户需要的是什么，或者软件的需求定义，那么你的工程注定会失败。

5. 需求其实很少改变，改变的是你对需求的理解

Object ToolSmiths公司（www.objecttoolsmiths.com）的Doug Smith常喜欢说：“分析是一门科学，设计是一门艺术”。他的意思是说在众多的“正确”分析模型中只存在一个最“正确”分析模型可以完全满足解决某个具体问题的需要（我理解的意思是需求分析需要一丝不苟、精确的完成,而设计的时候反而可以发挥创造力和想象力 - 译者注）。

如果需求经常改动，很可能是你没有作好需求分析，并不是需求真的改变了。

你可以抱怨用户不能告诉你他们想得到什么，但是不要忘记，收集需求信息是你工作。

你可以说是新来的开发人员把事情搞得一团糟，但是，你应该确定在工程的第一天就告诉他们应该做什么和怎样去做。

如果你觉得公司不让你与用户充分接触，那只能说明公司的管理层并不是真正支持你的项目。

你可以抱怨公司有关软件工程的管理制度不合理，但你必须了解大多同行公司是怎么做的。

你可以借口说你们的竞争对手的成功是因为他们有了一个新的理念，但是为什么你没先想到呢？

需求真正改变的情况很少，但是没有做好需求分析工作的理由却很多。

6. 经常阅读

在这个每日都在发生变化的产业中，你不可能在已取得的成就上陶醉太久。

每个月至少读2、3本专业杂志或者1本专业书籍。保持不落伍需要付出很多的时间和金钱，但会使你成为一个很有实力的竞争者。

7. 降低软件模块间的耦合度

高耦合度的系统是很难维护的。一处的修改引起另一处甚至更多处的变动。

你可以通过以下方法降低程序的耦合度：隐藏实现细节，强制构件接口定义，不使用公用数据结构，不让应用程序直接操作数据库（我的经验法则是：当应用程序员在写SQL代码的时候，你的程序的耦合度就已经很高了）。

耦合度低的软件可以很容易被重用、维护和扩充。

8. 提高软件的内聚性

如果一个软件的模块只实现一个功能，那么该模块具有高内聚性。高内聚性的软件更容易维护和改进。

判断一个模块是否有高的内聚性，看一看你是否能够用一个简单的句子描述它的功能就行了。如果你用了一段话或者你需要使用类似“和”、“或”等连词，则说明你需要将该模块细化。

只有高内聚性的模块才可能被重用。

9. 考虑软件的移植性

移植是软件开发中一项具体而又实际的工作，不要相信某些软件工具的广告宣传（比如java 的宣传口号write once run many ? 译者注）。

即使仅仅对软件进行常规升级，也要把这看得和向另一个操作系统或数据库移植一样重要。

记得从16位Windows移植到32位windows的“乐趣”吗？当你使用了某个操作系统的特性，如它的进程间通信(IPC)策略，或用某数据库专有语言写了存储过程。你的软件和那个特定的产品结合度就已经很高了。

好的软件设计者把那些特有的实现细节打包隐藏起来，所以，当那些特性该变的时候，你的仅仅需要更新那个包就可以了。

10. 接受变化

这是一句老话了：唯一不变的只有变化。

你应该将所有系统将可能发生的变化以及潜在需求记录下来,以便将来能够实现（参见“Architecting for Change”，Thinking Objectively, May 1999）

通过在建模期间考虑这些假设的情况，你就有可能开发出足够强壮且容易维护的软件。设计强壮的软件是你最基本的目标。

11. 不要低估对软件规模的需求

Internet 带给我们的最大的教训是你必须在软件开发的最初阶段就考虑软件规模的可扩充性。

今天只有100人的部门使用的应用程序，明天可能会被有好几万人的组织使用，下月，通过因特网可能会有几百万人使用它。

在软件设计的初期，根据在用例模型中定义的必须支持的基本事务处理，确定软件的基本功能。然后，在建造系统的时候再逐步加入比较常用的功能。

在设计的开始考虑软件的规模需求，避免在用户群突然增大的情况下，重写软件。

12. 性能仅仅是很多设计因素之一

关注软件设计中的一个重要因素--性能，这好象也是用户最关心的事情。一个性能不佳的软件将不可避免被重写。

但是你的设计还必须具有可靠性，可用性，便携性和可扩展性。你应该在工程开始就应该定义并区分好这些因素，以便在工作中恰当使用。性能可以是，也可以不是优先级最高的因素，我的观点是，给每个设计因素应有的考虑。

13. 管理接口

“UML User Guide”（Grady Booch，Ivar Jacobson和Jim Rumbaugh ,Addison Wesley, 1999）中指出，你应该在开发阶段的早期就定义软件模块之间的接口。

这有助于你的开发人员全面理解软件的设计结构并取得一致意见，让各模块开发小组相对独立的工作。一旦模块的接口确定之后，模块怎样实现就不是很重要了。

从根本上说，如果你不能够定义你的模块“从外部看上去会是什么样子”，你肯定也不清楚模块内要实现什么。

14. 走近路需要更长的时间

在软件开发中没有捷径可以走。

缩短你的在需求分析上花的时间，结果只能是开发出来的软件不能满足用户的需求，必须被重写。

在软件建模上每节省一周，在将来的编码阶段可能会多花几周时间，因为你在全面思考之前就动手写程序。

你为了节省一天的测试时间而漏掉了一个bug，在将来的维护阶段，可能需要花几周甚至几个月的时间去修复。与其如此，还不如重新安排一下项目计划。

避免走捷径，只做一次但要做对（do it once by doing it right）。

15. 别信赖任何人

产品和服务销售公司不是你的朋友，你的大部分员工和高层管理人员也不是。

大部分产品供应商希望把你牢牢绑在他们的产品上，可能是操作系统，数据库或者某个开发工具。

大部分的顾问和承包商只关心你的钱并不是你的工程（停止向他们付款，看一看他们会在周围呆多长时间）。

大部分程序员认为他们自己比其他人更优秀，他们可能抛弃你设计的模型而用自己认为更好的。

只有良好的沟通才能解决这些问题。

要明确的是，不要只依靠一家产品或服务提供商，即使你的公司（或组织）已经在建模、文档和过程等方面向那个公司投入了很多钱。

16. 证明你的设计在实践中可行

在设计的时候应当先建立一个技术原型，或者称为“端到端”原型。以证明你的设计是能够工作的。

你应该在开发工作的早期做这些事情，因为，如果软件的设计方案是不可行的，在编码实现阶段无论采取什么措施都于事无补。技术原型将证明你的设计的可行性，从而，你的设计将更容易获得支持。

17. 应用已知的模式

目前，我们有大量现成的分析和设计模式以及问题的解决方案可以使用。

一般来说，好的模型设计和开发人员，都会避免重新设计已经成熟的并被广泛应用的东西。http://www.ambysoft.com/processPatternsPage.html收藏了许多开发模式的信息。

18. 研究每个模型的长处和弱点

目前有很多种类的模型可以使用,如下图所示。用例捕获的是系统行为需求，数据模型则描述支持一个系统运行所需要的数据构成。你可能会试图在用例中加入实际数据描述，但是，这对开发者不是非常有用。同样，数据模型对描述软件需求来说是无用的。每个模型在你建模过程中有其相应的位置，但是，你需要明白在什么地方，什么时候使用它们。

19. 在现有任务中应用多个模型

当你收集需求的时候，考虑使用用例模型，用户界面模型和领域级的类模型。

当你设计软件的时候，应该考虑制作类模型，顺序图、状态图、协作图和最终的软件实际物理模型。

程序设计人员应该慢慢意识到，仅仅使用一个模型而实现的软件要么不能够很好地满足用户的需求，要么很难扩展。

20. 教育你的听众

你花了很大力气建立一个很成熟的系统模型，而你的听众却不能理解它们，甚至更糟－连为什么要先建立模型都不知道。那么你的工作是毫无意义的。

教给你开发人员基本的建模知识；否则，他们会只看看你画的漂亮图表，然后继续编写不规范的程序。

另外，你还需要告诉你的用户一些需求建模的基础知识。给他们解释你的用例(uses case)和用户界面模型，以使他们能够明白你要表达地东西。当每个人都能使用一个通用的设计语言的时候（比如UML-译者注），你的团队才能实现真正的合作。

21. 带工具的傻瓜还是傻瓜

你给我CAD/CAM工具，请我设计一座桥。但是，如果那座桥建成的话，我肯定不想当第一个从桥上过的人，因为我对建筑一窍不通。

使用一个很优秀的CASE工具并不能使你成为一个建模专家，只能使你成为一个优秀CASE工具的使用者。成为一个优秀的建模专家需要多年的积累，不会是一周针对某个价值几千美元工具的培训。一个优秀的CASE工具是很重要，但你必须学习使用它，并能够使用它设计它支持的模型。

22. 理解完整的过程

好的设计人员应该理解整个软件过程，尽管他们可能不是精通全部实现细节。

软件开发是一个很复杂的过程，还记得《object-oriented software process》第36页的内容吗？除了编程、建模、测试等你擅长工作外，还有很多工作要做。

好的设计者需要考虑全局。必须从长远考虑如何使软件满足用户需要，如何提供维护和技术支持等。

23. 常做测试，早做测试

如果测试对你的软件来说是无所谓的，那么你的软件多半也没什么必要被开发出来。

建立一个技术原型供技术评审使用，以检验你的软件模型。

在软件生命周期中，越晚发现的错误越难修改，修改成本越昂贵。尽可能早的做测试是很值得的。

24. 把你的工作归档

不值得归档的工作往往也不值得做。归档你的设想，以及根据设想做出的决定；归档软件模型中很重要但不很明显的部分。给每个模型一些概要描述以使别人很快明白模型所表达的内容。

25. 技术会变，基本原理不会

如果有人说“使用某种开发语言、某个工具或某某技术，我们就不需要再做需求分析，建模，编码或测试”。不要相信，这只说明他还缺乏经验。抛开技术和人的因素，实际上软件开发的基本原理自20世纪70年代以来就没有改变过。你必须还定义需求，建模，编码，测试，配置，面对风险，发布产品，管理工作人员等等。

软件建模技术是需要多年的实际工作才能完全掌握的。好在你可以从我的建议开始，完善你们自己的软件开发经验。

以鸡汤开始，加入自己的蔬菜。然后，开始享受你自己的丰盛晚餐吧。

本文链接

[转]PowerDesigner使用教程 —— 概念数据模型

2012-05-13T07:44:00Z

一、概念数据模型概述

    概念数据模型也称信息模型，它以实体－联系(Entity-RelationShip,简称E-R)理论为基础，并对这一理论进行了扩充。它从用户的观点出发对信息进行建模，主要用于数据库的概念级设计。

    通常人们先将现实世界抽象为概念世界，然后再将概念世界转为机器世界。换句话说，就是先将现实世界中的客观对象抽象为实体(Entity)和联系 (Relationship),它并不依赖于具体的计算机系统或某个DBMS系统，这种模型就是我们所说的CDM;然后再将CDM转换为计算机上某个 DBMS所支持的数据模型，这样的模型就是物理数据模型,即PDM。

    CDM是一组严格定义的模型元素的集合，这些模型元素精确地描述了系统的静态特性、动态特性以及完整性约束条件等，其中包括了数据结构、数据操作和完整性约束三部分。
1）数据结构表达为实体和属性;
2）数据操作表达为实体中的记录的插入、删除、修改、查询等操作;
3）完整性约束表达为数据的自身完整性约束（如数据类型、检查、规则等）和数据间的参照完整性约束（如联系、继承联系等）;

二、实体、属性及标识符的定义

    实体（Entity），也称为实例，对应现实世界中可区别于其他对象的“事件”或“事物”。例如，学校中的每个学生，医院中的每个手术。每个实体都有用来描述实体特征的一组性质，称之为属性，一个实体由若干个属性来描述。如学生实体可由学号、姓名、性别、出生年月、所在系别、入学年份等属性组成。

    实体集（Entity Set）是具体相同类型及相同性质实体的集合。例如学校所有学生的集合可定义为“学生”实体集，“学生”实体集中的每个实体均具有学号、姓名、性别、出生年月、所在系别、入学年份等性质。

    实体类型（Entity Type）是实体集中每个实体所具有的共同性质的集合，例如“患者”实体类型为：患者｛门诊号，姓名，性别，年龄，身份证号.............｝。实体是实体类型的一个实例，在含义明确的情况下，实体、实体类型通常互换使用。实体类型中的每个实体包含唯一标识它的一个或一组属性，这些属性称为实体类型的标识符（Identifier），如“学号”是学生实体类型的标识符，“姓名”、“出生日期”、“信址”共同组成“公民”实体类型的标识符。有些实体类型可以有几组属性充当标识符，选定其中一组属性作为实体类型的主标识符，其他的作为次标识符。

三、实体、属性及标识符的表达

四、新建概念数据模型

1）选择File-->New,弹出如图所示对话框，选择CDM模型（即概念数据模型）建立模型。

2）完成概念数据模型的创建。以下图示，对当前的工作空间进行简单介绍。（以后再更详细说明）

3）选择新增的CDM模型，右击，在弹出的菜单中选择“Properties”属性项，弹出如图所示对话框。在“General”标签里可以输入所建模型的名称、代码、描述、创建者、版本以及默认的图表等等信息。在“Notes”标签里可以输入相关描述及说明信息。当然再有更多的标签，可以点击 "More>>"按钮，这里就不再进行详细解释。

五、定义实体

1、创建实体
1）在CDM的图形窗口中，单击工具选项版上的Entity工具，再单击图形窗口的空白处，在单击的位置就出现一个实体符号。点击Pointer工具或右击鼠标，释放Entitiy工具。如图所示

2）双击刚创建的实体符号，打开下列图标窗口，在此窗口“General”标签中可以输入实体的名称、代码、描述等信息。

Name：是用来在模型中标识一个实体，一般用于模型在界面中的显示（这个可以通过更改选项设置进行改变）。在一个模型当中，实体的名字不能重复。

Code：在模型转化时一般作为对象的物理名称，比如把实体属性的Code转化为数据库中的列名，当然我们现在不必为了这个实体将来叫什么而费神，一般采取与Name一致即可。

Generate：默认是选择状态，如果取消，则在转化为其他模型时，会忽略这个实体。

2、添加实体属性
1）在上述窗口的“Attribute”选项标签上可以添加属性，如下图所示。

注意：
数据项中的“添加属性”和“重用已有数据项”这两项功能与模型中Data Item的Unique code 和Allow reuse选项有关。
P列表示该属性是否为主标识符;D列表示该属性是否在图形窗口中显示;M列表示该属性是否为强制的，即该列是否为空值。

如果一个实体属性为强制的，那么，这个属性在每条记录中都必须被赋值，不能为空。

按“Crtl+U”呼出“定制列过滤器”的窗口，可以根据自己的喜好和实际需要选择那些列出现在窗口中，那些隐藏。使用快捷键 “Crtl+E”可以允许或者禁止当前过滤器。

2）在上图所示窗口中，点击插入属性按钮，弹出属性对话框，如下图所示。

3、定义属性的检查约束

1）定义属性的标准检查
标准检查约束是一组确保属性有效的表达式。在实体属性的特性窗口，打开如图所示的检查选项卡。

在这个选项卡可以定义属性的标准检查约束，窗口中每项的参数的含义，如下

参数	说明
Minimum	属性可接受的最小数
Maximum	属性可接受的最大数
Default	属性不赋值时，系统提供的默认值
Unit	单位，如公里、吨、元
Format	属性的数据显示格式
Lowercase	属性的赋值全部变为小写字母
Uppercase	属性的赋值全部变为大写字母
Cannot modify	该属性一旦赋值不能再修改
List Of Values	属性赋值列表，除列表中的值，不能有其他的值
Label	属性列表值的标签

2）定义属性的附加检查
当Standard checks 或Rules 不能满足检查的要求时，可以在Additional Checks选项卡的Server子页上，通过SQL语句中使用%MINMAX%、%LISTVAL%、%RULES%、%UPPER%、%LOWER% 几个变量来定义Standard和Rule,如图所示

%MINMAX%、%LISTVAL%、%UPPER%、%LOWER%
在Standard Check中定义的Minimum 和Maximum、List values 、uppervalues、lowervalues

%RULES%
在Rules特性窗口Expression选项卡中定义的有效性规则表达式

六、标识符

标识符是实体中一个或多个属性的集合，可用来唯一标识实体中的一个实例。要强调的是，CDM中的标识符等价于PDM中的主键或候选键。每个实体都必须至少有一个标识符。如果实体只有一个标识符，则它为实体的主标识符。如果实体有多个标识符，则其中一个被指定为主标识符，其余的标识符就是次标识符了。

1、定义主、次标识符
1）选择某个实体双击弹出实体的属性对话框。在Identifiers选项卡上可以进行实体标识符的定义。如下图所示

2）选择第一行“主标识符”，点击属性按钮或双击第一行“主标识符”，弹出属性对话框，如图所示

3）选择"Attributes"选项卡，再点击“Add Attributes”工具，弹出如图所示窗口，选择某个属性作为标识符就行了。

七、数据项

数据项（Data Item）是信息存储的最小单位，它可以附加在实体上作为实体的属性。
注意：模型中允许存在没有附加至任何实体上的数据项。

1、新建数据项
1）使用“Model”---> Data Items 菜单，在打开的窗口中显示已有的数据项的列表，点击 “Add a Row”按钮，创建一个新数据项，如图所示

2）当然您可以继续设置具体数据项的Code、DataType、Length等等信息。这里就不再详细说明了。

2、数据项的唯一性代码选项和重用选项
使用Tools--->Model Options->Model Settings。在Data Item组框中定义数据项的唯一性代码选项(Unique Code)与重用选项（Allow Reuse）。
注意：
如果选择Unique Code复选框，每个数据项在同一个命名空间有唯一的代码，而选择Allow reuse ，一个数据项可以充当多个实体的属性。

3、在实体中添加数据项
1）双击一个实体符号，打开该实体的属性窗口。
2）单击Attributes选项卡，打开如下图所示窗口

注意：
Add a DataItem 与 Reuse a DataItem的区别在于
Add a DataItem 情况下，选择一个已经存在的数据项，系统会自动复制所选择的数据项。如果您设置了UniqueCode选项，那系统在复制过程中，新数据项的Code会自动生成一个唯一的号码，否则与所选择的数据项完全一致。

Reuse a DataItem情况下，只引用不新增，就是引用那些已经存在的数据项，作为新实体的数据项。

八、联系

    联系（Relationship）是指实体集这间或实体集内部实例之间的连接。

    实体之间可以通过联系来相互关联。与实体和实体集对应，联系也可以分为联系和联系集，联系集是实体集之间的联系，联系是实体之间的联系，联系是具有方向性的。联系和联系集在含义明确的情况之下均可称为联系。

    按照实体类型中实例之间的数量对应关系，通常可将联系分为4类，即一对一（ONE TO ONE）联系、一对多（ONE TO MANY）联系、多对一（MANY TO ONE）联系和多对多联系（MANY TO MANY）。

1、建立联系
在CDM工具选项板中除了公共的工具外，还包括如下图所示的其它对象产生工具。

在图形窗口中创建两个实体后，单击“实体间建立联系”工具，单击一个实体，在按下鼠标左键的同时把光标拖至别一个实体上并释放鼠标左键，这样就在两个实体间创建了联系，右键单击图形窗口，释放Relationship工具。如下图所示

500)this.width=500;">

在两个实体间建立了联系后，双击联系线，打开联系特性窗口，如图所示。

2、四种基本的联系
即一对一（ONE TO ONE）联系、一对多（ONE TO MANY）联系、多对一（MANY TO ONE）联系和多对多联系（MANY TO MANY）。如图所示

3、其他几类特殊联系

除了4种基本的联系之外，实体集与实体集之间还存在标定联系（Identify Relationship）、非标定联系（Non-Identify RelationShip）和递归联系（Recursive Relationship）。

标定联系：
每个实体类型都有自己的标识符，如果两个实体集之间发生联系，其中一个实体类型的标识符进入另一个实体类型并与该实体类型中的标识符共同组成其标识符时，这种联系则称为标定联系，也叫依赖联系。反之称为非标定联系，也叫非依赖联系。
注意：
在非标定联系中，一个实体集中的部分实例依赖于另一个实例集中的实例，在这种依赖联系中，每个实体必须至少有一个标识符。而在标定联系中，一个实体集中的全部实例完全依赖于另个实体集中的实例，在这种依赖联系中一个实体必须至少有一个标识符，而另一个实体却可以没有自己的标识符。没有标识符的实体用它所依赖的实体的标识符作为自己的标识符。

换句话来理解，在标定联系中，一个实体（选课）依赖一个实体（学生），那么（学生）实体必须至少有一个标识符，而（选课）实体可以没有自己的标识符，没有标标识符的实体可以用实体（学生）的标识符作为自己的标识符。

递归联系：
递归联系是实体集内部实例之间的一种联系，通常形象地称为自反联系。同一实体类型中不同实体集之间的联系也称为递归联系。

例如：在“职工”实体集中存在很多的职工，这些职工之间必须存在一种领导与被领导的关系。又如“学生”实体信中的实体包含“班长”子实体集与“普通学生”子实体集，这两个子实体集之间的联系就是一种递归联系。创建递归联系时，只需要单击“实体间建立联系”工具从实体的一部分拖至该实体的别一个部分即可。如图

3、 定义联系的特性

双击关系（Relationship）的符号，进入关系的属性页，在Detail项目中，我们可以对两个实体的关系进行详细的定义，如下图：

General 项目
一般最好为关系取一个贴切的名字，本例的业务关系描述如下：一个部门有多个员工，我们使用“Has”作为这个关系的名字。
同样的我们也可以描述为：多个员工属于一个部门，可不可以使用“Belong to”作为关系名字呢？一般不推荐这样做，在概念图中有一个约定，关系的名字采用从“1,n”中“1”所在的方向向“n”所在一方进行读取的语义。本例即 “1”在部门一方，从部门一方向雇员一方读取语义，即：部门有（Has）多个员工。
Detail 项目

假定对于实体部门（Department）和雇员（Employee），具有如下关系：
一个部门可以有多个雇员，新成立的部门也可以暂时没有任何雇员；
一个雇员必须属于一个部门，并且同时只能属于一个部门；
根据以上关系，我们修改属性页，部门－雇员的方向采用默认的0,n，雇员－部门的方向修改为强制约束（Mandatory），或者从下拉框中选择“1,1”，如下图：

最后定义完成的关系（Relationship）在概念图中表示如下：

注：在Power Designer中，关系符号靠近实体端的一个“横线”代表强制性约束，“空心圆圈”代表无强制约束，即这一方可以无对象关联；“非分岔”线代表为“1” 的关系，“分岔”线代表“多”的关系。以上四个符号共可以组合出16种关系（包含反向）。其中“多对多”的关系一般通过给出一个中间实体来进行分解，所以在许多概念图中，是看不到实际的“多对多”的关系存在的。

另外在关系的属性中还有两项：Dominant role 和Dependent，可以表示更复杂的关系，会在后面讲到。

使用依赖关系(Dependent)

还是使用上面的例子，我们假定这样的业务描述：雇员享有假期，雇员每次休假，需要记录雇员休假的起始日与结束日，假期以天为单位，一个雇员和一个开始日唯一确定一个假期。根据这个业务描述，我们知道，对于假期而言，其必须依存于实体“Employee”而存在，即一个休假，必定有一个主体雇员。我们在上一个模型的基础之上，添加一个实体，名称是“Holiday”，定义假期的属性开始日与结束日，这里并不需要重复定义一个雇员编号，而是替代的，使用依赖关系，来表示实体“Holiday”依赖于实体“Employee”，关系定义如下图：

　
在实体“Holiday”中，我们需要设置开始日为主键标识符，开始日与其依赖实体中的雇员编号一起作为实体“Holiday”的标识符，用来唯一确定一个假期。这种依赖关系在概念图中表现如下：

　
从途中可以看出，在实体“Holiday”一端多了一个朝外的三角▲箭头，这个含义就是这个实体“的依赖于三角箭头所指的另外一个实体，在转化出来的物理模型当中，实体“Employee”的empNo，在Holiday实体中不仅会作为一个外键，还同时会作为主键出现（与startData一起作为复合主键）。

使用Dominant role

当两个实体之间的关系是1..1 时（尽管这种关系比较少见，常见于面向对象的设计方法当中，依赖实体中的主键通常与外健重合），你需要明确指定这两个实体，哪一个是父实体，哪一个是依赖实体，否则，系统在由概念模型转化为物理模型时，将不能确定需要在哪一端生成外键，这时就需要用到“Dominant role”选项，这个选项只有在1..1 的关系中才允许进行设置。我们假定这样的业务描述，企业中的部分雇员拥有一个系统帐号，并且是唯一的一个帐号，这些雇员需要保存一些额外的信息，比如帐号名称、密码等等。我们添加了一个新的实体“User”，其与雇员之间为1..1 的关系，由于一个用户帐号必定属于一个雇员，而一个雇员则可能没有用户帐号，所以我们定义实体“Employee”支配实体“User”。同时，由于 “User”依赖于“Employee”而存在，所以再定义一个由前者到后者的依赖关系，如下图：

　

Dominant role 选项中，箭头所指的实体为被支配的实体，即作为依赖实体。在模型图中，支配实体的一方会出现一个用圆括号括起来的大写字母“D”。

　

转化出来的物理模型中，表User中，empNo作为单独的主键，同时也是引用Employee表的一个外键。

处理多对多(n..n)的关系

在概念模型中，一般很少看见两个实体之间是直接的n..n 的关系，一般这种情况下我们会增加一个中间实体，在Power Designer中，提供了一个专门的符号来对应，叫做“Association”。请考虑以下的情形：

企业中拥有帐号的雇员在系统中具有不同的操作权限，这通过用户角色来进行管理，权限已经分配给了多个不同的角色，一个用户帐号至少属于一个角色，并且可能会同时属于多个角色，一个角色可以包含0个或多个用户帐号。根据以上描述，我们添加一个实体“Role”，它与实体“User”之间是n..n 的关系，为了表达这种关系，我们增加一个“Association”并分别使用“Association Link”与其他两个实体建立关系，表示如下：

使用一个普通的实体，合理定义关系，并选择“Dependent”选项，是可以替代“Association”的，但使用 “Association”更方便、直观，使模型更容易理解，并可以减少因不谨慎而可能导致的错误。

本文链接

JavaScript闭包和模块模式[译]

2012-05-11T00:46:00Z

翻译原文
在JavaScript中一个最广泛使用的设计模式是模块的模式。模块模式使用了JavaScript中的一个很棒的特性-闭包- 用来给你方法中的隐私一些控制这样的第三方应用程序不能访问私有数据或覆盖它。在这篇文章中，我会教你什么是闭包，它是如何工作的，以及如何利用它在你的JavaScript代码中实现模块模式。

什么是闭包？

闭包是JavaScript语言的一种构造。在JavaScript内所有变量都能在全局范围内访问，除非变量在函数内用var关键字声明过。

variable1 = 1; //全局范围
var variable2 = 2; // 不在一个函数内: 全局范围
       
function funcName() {
  variable3 = 3; // 没用var关键字声明: 全局范围
  var variable4 = 4; //仅本地访问
}


view raw gistfile1.js This Gist brought to you by GitHub. 

在一个函数内，你也可以获得全局范围和每个你所在的函数上级范围的访问权限。换句话说，函数内声明变量只能在函数包围范围内访问。

var globalvar = 1; //全局范围

function outer() {
  var outervar = 2; // outer()范围内

  function inner() {
    var innervar = 3; // inner()范围内
    console.log(globalvar); // => 1
    console.log(outervar); // => 2
    console.log(innervar); // => 3
  }

  console.log(globalvar); // => 1
  console.log(outervar); // => 2
  console.log(innervar); // => Reference Error引用错误;
}

console.log(globalvar); // => 1
console.log(outervar); // => Reference Error引用错误
console.log(innervar); // => Reference Error引用错误

view raw gistfile1.js This Gist brought to you by GitHub. 

每一个真正的JavaScript程序员应该知道这一点，除非他不思进取。知道这一点，你可以得出这样的结论，用一种办法来保持你所有代码在全局命名空间外，是正确的。这特别有用，当你不想给任何人在未经许可的情况下有重写你任何代码的机会。你可以通过使用一个匿名函数（不给它命名，没有被赋予一个变量）立即执行自身。这是众所周知的自调用匿名函数（SIAF），虽然它可能是更准确地称为立即调用的函数表达 (IIFE–读做“iffy”) -作者Ben Alman。

(function() {
    // 这函数立即执行，内部所有变量都是私有的
}());

view raw gistfile1.js This Gist brought to you by GitHub. 

紧接着右大括号，是左右括号于是函数将立即执行。围绕整个函数表达式的括号不是运行的代码必需的，但一般用作给其他开发人员的信号，这是一个IIFE，而不是一个标准函数。有些人喜欢在前面加上一个惊叹号（!）或分号（;)，而不是用括号包起来。

用闭包的模块模式

知道了闭包是什么，我们就可以使用模块模式创建对象。通过返回一个对象或变量并赋给一个函数外变量，这样我们可以暴露任何希望暴露给外界的，我们可以有公开和私有的方法。

var Module = (function() {
    // 下面函数是私有的，但可以被公开函数访问
    function privateFunc() { … };
   
    // 返回一个对象赋予Module
    return {
        publicFunc: function() {
            privateFunc(); // publicFunc可以直接访问privateFunc
        }
    };
}());

view raw gistfile1.js This Gist brought to you by GitHub. 

这就是模块模式的本质。您还可以使用参数传入或缩写常用资源的名称：

var Module = (function($, w, undefined) {
    // …
    // return {…};
}(jQuery, window));

view raw gistfile1.js This Gist brought to you by GitHub. 

我传入jQuery和window，被分别缩写为$和w。注意我没有传任何东西作为第三个参数。这样参数undefined将是undefined，所以它完美地工作。有些人这样处理undefined是因为无论如何，它是可编辑的。所以，如果你判断某某是否是undefined，但undefined可能已经改变，你的比较将不起作用。这种技术保证它将按预期工作。

透露模块模式revealing module pattern

透露模块模式是另一种方式来写模块模式，需要更多点代码，但有时更容易理解和阅读。不同于在IIFE中定义所有私有变量并在返回对象中定义公开方法，你把所有方法都写在IIFE中，只是“透露”哪些是你想公开在return语句内的。

var Module = (function() {
    // 现在所有函数直接互访
    var privateFunc = function() {
        publicFunc1();
    };
   
    var publicFunc1 = function() {
        publicFunc2();
    };
   
    var publicFunc2 = function() {
        privateFunc();
    };
   
    // 返回对象赋予Module
    return {
        publicFunc1: publicFunc1,
        publicFunc2: publicFunc2
    };
}());

view raw gistfile1.js This Gist brought to you by GitHub. 

对比正常的模块模式，透露模块模式有几个优点：

所有函数的声明和实现都在同一个地方，从而制造较少的混乱。
私有函数现在可以访问公开函数，如果他们需要。
当一个公开函数需要调用另一个公开函数时，他们调用publicFunc2()，而不是用this.publicFunc2()，从而节省了几个字符。

透露模块模式的唯一真正的缺点，正如我所说，是你必须写更多的代码，因为你必须先写好函数然后再把它的名字写在return语句内，尽管它最终可能会因为你可以忽略this.部分而节省你的代码。

扩展模块模式

我想谈的最后一件事是使用模块模式扩展已经存在的模块。这很常用，当为jQuery之类的库做插件，如下。

var jQuery = (function($) {
    $.pluginFunc = function() {
        …
    }
   
    return $;    
}(jQuery));

view raw gistfile1.js This Gist brought to you by GitHub. 

此代码是相当灵活的，因为你甚至不需要var jQuery=或接近尾部的return语句。没有它们jQuery仍将可以用这个新方法扩展。实际上返回和赋值整个jQuery对象，可能在性能上有损失，但是，如果你想在扩展jQuery的同时，分配jQuery到一个新的变量名，你只需改变第一行的jQuery为任何你想要的。

结论

朋友们，今天就到这里。这些都是常见的技术和功能，即使你不使用这篇文章的知识，保留在你的脑海，以防万一用到（很可能会发生）。。。最后，不要忘记分享和在下面评论。感谢和编码快乐！

本文链接

jQuery获取Select选择的Text和 Value(转)

2012-05-09T02:15:00Z

jQuery获取Select选择的Text和Value:
语法解释：
1. $("#select_id").change(function(){//code...});   //为Select添加事件，当选择其中一项时触发
2. var checkText=$("#select_id").find("option:selected").text(); //获取Select选择的Text
3. var checkValue=$("#select_id").val(); //获取Select选择的Value
4. var checkIndex=$("#select_id ").get(0).selectedIndex; //获取Select选择的索引值
5. var maxIndex=$("#select_id option:last").attr("index"); //获取Select最大的索引值
jQuery设置Select选择的 Text和Value:
语法解释：
1. $("#select_id ").get(0).selectedIndex=1; //设置Select索引值为1的项选中
2. $("#select_id ").val(4);   // 设置Select的Value值为4的项选中
3. $("#select_id option[text='jQuery']").attr("selected", true);   //设置Select的Text值为jQuery的项选中

jQuery添加/删除Select的Option项：
语法解释：
1. $("#select_id").append("<option value='Value'>Text</option>"); //为Select追加一个Option(下拉项)
2. $("#select_id").prepend("<option value='0'>请选择</option>"); //为Select插入一个Option(第一个位置)
3. $("#select_id option:last").remove(); //删除Select中索引值最大Option(最后一个)
4. $("#select_id option[index='0']").remove(); //删除Select中索引值为0的Option(第一个)
5. $("#select_id option[value='3']").remove(); //删除Select中Value='3'的Option
5. $("#select_id option[text='4']").remove(); //删除Select中Text='4'的Option

http://www.cnblogs.com/SAL2928/archive/2008/10/28/1321285.html

jquery radio取值，checkbox取值，select取值，radio选中，checkbox选中，select选中，及其相关
获取一组radio被选中项的值
var item = $('input[name=items][checked]').val();
获取select被选中项的文本
var item = $("select[name=items] option[selected]").text();
select下拉框的第二个元素为当前选中值
$('#select_id')[0].selectedIndex = 1;
radio单选组的第二个元素为当前选中值
$('input[name=items]').get(1).checked = true;
获取值：
文本框，文本区域：$("#txt").attr("value")；
多选框 checkbox：$("#checkbox_id").attr("value")；
单选组radio：   $("input[type=radio][checked]").val();
下拉框select： $('#sel').val();
控制表单元素：
文本框，文本区域：$("#txt").attr("value",'');//清空内容
$("#txt").attr("value",'11');//填充内容
多选框checkbox： $("#chk1").attr("checked",'');//不打勾
$("#chk2").attr("checked",true);//打勾
if($("#chk1").attr('checked')==undefined) //判断是否已经打勾
单选组 radio：    $("input[type=radio]").attr("checked",'2');//设置value=2的项目为当前选中项
下拉框 select：   $("#sel").attr("value",'-sel3');//设置value=-sel3的项目为当前选中项
$("<option value='1'>1111</option><option value='2'>2222</option>").appendTo("#sel")//添加下拉框的option
$("#sel").empty()；//清空下拉框

----------------------------------------------------------------------------------------------------

//遍历option和添加、移除option
function changeShipMethod(shipping){
var len = $("select[name=ISHIPTYPE] option").length
if(shipping.value != "CA"){
$("select[name=ISHIPTYPE] option").each(function(){
if($(this).val() == 111){
$(this).remove();
}
});
}else{
$("<option value='111'>UPS Ground</option>").appendTo($("select[name=ISHIPTYPE]"));
}
}

//取得下拉選單的選取值

$(#testSelect option:selected').text();
或$("#testSelect").find('option:selected').text();
或$("#testSelect").val();
//////////////////////////////////////////////////////////////////
记性不好的可以收藏下：
1,下拉框:

var cc1 = $(".formc select[name='country'] option[selected]").text(); //得到下拉菜单的选中项的文本(注意中间有空格)
var cc2 = $('.formc select[name="country"]').val(); //得到下拉菜单的选中项的值
var cc3 = $('.formc select[name="country"]').attr("id"); //得到下拉菜单的选中项的ID属性值
$("#select").empty();//清空下拉框 //$("#select").html('');
$("<option value='1'>1111</option>").appendTo("#select")//添加下拉框的option

稍微解释一下:
1.select[name='country'] option[selected] 表示具有name 属性，
并且该属性值为'country' 的select元素里面的具有selected 属性的option 元素；

2,单选框:
$("input[@type=radio][@checked]").val(); //得到单选框的选中项的值(注意中间没有空格)
$("input[@type=radio][@value=2]").attr("checked",'checked'); //设置单选框value=2的为选中状态.(注意中间没有空格)

3,复选框:
$("input[@type=checkbox][@checked]").val(); //得到复选框的选中的第一项的值
$("input[@type=checkbox][@checked]").each(function() { //由于复选框一般选中的是多个,所以可以循环输出
alert($(this).val());
});

$("#chk1").attr("checked",'');//不打勾
$("#chk2").attr("checked",true);// 打勾
if($("#chk1").attr('checked')==undefined){} //判断是否已经打勾

当然jquery的选择器是强大的. 还有很多方法.

});
});
</script>

<a href="#">aaass</a>

<select id="selectTest" name="selectTest">
<option value="1">11</option>
<option value="2">22</option>
<option value="3">33</option>
<option value="4">44</option>
<option value="5">55</option>
<option value="6">66</option>
</select>
jquery radio取值，checkbox取值，select取值，radio选中，checkbox选中，select选中，及其相关获取一组radio被选中项的值
var item = $('input[@name=items][@checked]').val();
获取select被选中项的文本
var item = $("select[@name=items] option[@selected]").text();
select 下拉框的第二个元素为当前选中值
$('#select_id')[0].selectedIndex = 1;
radio单选组的第二个元素为当前选中值
$('input[@name=items]').get(1).checked = true;
获取值：
文本框，文本区域：$("#txt").attr("value")；
多选框 checkbox：$("#checkbox_id").attr("value")；
单选组radio： $("input[@type=radio][@checked]").val();
下拉框select： $('#sel').val();
控制表单元素：
文本框，文本区域：$("#txt").attr("value",'');//清空内容
$("#txt").attr("value",'11');// 填充内容
多选框checkbox： $("#chk1").attr("checked",'');//不打勾
$("#chk2").attr("checked",true);// 打勾
if($("#chk1").attr('checked')==undefined) //判断是否已经打勾
单选组radio： $("input[@type=radio]").attr("checked",'2');//设置value=2的项目为当前选中项
下拉框 select： $("#sel").attr("value",'-sel3');//设置value=-sel3的项目为当前选中项
$("<optionvalue='1'& gt;1111</option><optionvalue='2'>2222</option& gt;").appendTo("#sel")//添加下拉框的option
$("#sel").empty()；// 清空下拉框

获取一组radio被选中项的值
var item = $('input[@name=items][@checked]').val();
获取select被选中项的文本
var item = $("select[@name=items] option[@selected]").text();
select下拉框的第二个元素为当前选中值
$('#select_id')[0].selectedIndex = 1;
radio单选组的第二个元素为当前选中值
$('input[@name=items]').get(1).checked = true;
获取值：
文本框，文本区域：$("#txt").attr("value")；
多选框 checkbox：$("#checkbox_id").attr("value")；
单选组radio： $("input[@type=radio][@checked]").val();
下拉框select： $('#sel').val();
控制表单元素：
文本框，文本区域：$("#txt").attr("value",'');//清空内容
$("#txt").attr("value",'11');// 填充内容
多选框checkbox： $("#chk1").attr("checked",'');//不打勾
$("#chk2").attr("checked",true);// 打勾
if($("#chk1").attr('checked')==undefined) //判断是否已经打勾
单选组radio： $("input[@type=radio]").attr("checked",'2');//设置value=2的项目为当前选中项
下拉框 select： $("#sel").attr("value",'-sel3');//设置value=-sel3的项目为当前选中项
$("<option value='1'>1111</option><option value='2'>2222</option>").appendTo("#sel")//添加下拉框的option
$("#sel").empty()；// 清空下拉框

理念：网站优化工具之家致力于面向搜索引擎网站建设，SEO优化标准制定及免费搜索优化工具研发，是宁波首个面向搜索引擎网站服务团队网站:seo.al0574.com

本文链接

jquery validate使用总结

2012-04-11T02:03:00Z

$(this).rules("add", { required: true, messages: { required: "选择节点时必填!"} });

本文链接

快速上手Expression Tree(一)：做一做装配脑袋的Expression Tree 习题

2012-04-11T00:33:00Z

装配脑袋的习题在这里：Expression Tree上手指南（一）

不了解Expression Tree的同学可以去看下，很好，很强大。

1: -a2: a + b * 2 我把这些问题都弄成了方法，分别是Question1,Question2,….QuestionX

第一题：-a

因为实在是太短了，我不明白是什么意思，姑且认为是做取反操作吧，也就是假如输入是5，那么输出是-5.如果让你写lambda表达式，估计没几个人写不出来吧:(a)=>{return –a;}当然你可以简短点:(a)=>{-a} OK，看一看lambda表达式:(a)=>{return –a;},可以知道有一个参数a，输出是-a。参数是ParameterExpression. 所以Question1里面基本代码是：private static void Question1()
{
ParameterExpression expPara = Expression.Parameter(typeof(int), "a");
} 先声明一个参数a。类型是int.接着应该对参数求反。那么我们应该使用求反表达式了。在Msdn 里面的ExpressionType 里面可以查到当然在Expression里面你也可以找到下面的方法：public static UnaryExpression Negate(Expression expression); 于是代码可以修改为： private static void Question1()
{
ParameterExpression expPara = Expression.Parameter(typeof(int), "a");
UnaryExpression expNegate = Expression.Negate(expPara);
}

OK,剩下的就是生成lambda表达式了,

使用Expression.Lambda方法就可以生成了。lambda表达式最关键的是参数和body。

参数是(a).所以传递的是expPara.

body就是lambda表达式的主体，你可以认为是{}之间的代码,在这里传递的是expNegate.

为什么要生成lambda表达式??

因为可以编译lambda表达式生成委托。

private static void Question1()
{
int a = 5;

ParameterExpression expPara = Expression.Parameter(typeof(int), "a");
UnaryExpression expNegate = Expression.Negate(expPara);
LambdaExpression expLmd = Expression.Lambda(expNegate, expPara);
}
有了lambdaExpression后，就可以编译LambdaExpression了。private static void Question1()
{
int a = 5;

ParameterExpression expPara = Expression.Parameter(typeof(int), "a");
UnaryExpression expNegate = Expression.Negate(expPara);
LambdaExpression expLmd = Expression.Lambda(expNegate, expPara);

Console.WriteLine(expLmd.Compile().DynamicInvoke(a));
}

运行结果如下： DynamicInvoke的方法签名如下： //动态调用（后期绑定）由当前委托所表示的方法。
[SecuritySafeCritical]
public object DynamicInvoke(params object[] args); DynamicInvoke是后期绑定，所以性能比较差。 因为我们知道编译后的expLmd.的参数类型是int,结果是int.所以我们可以将委托转换为Func<int,int>的强类型的委托。 private static void Question1()
{
int a = 5;

ParameterExpression expPara = Expression.Parameter(typeof(int), "a");
UnaryExpression expNegate = Expression.Negate(expPara);
LambdaExpression expLmd = Expression.Lambda(expNegate, expPara);

Console.WriteLine(expLmd.Compile().DynamicInvoke(a));

Func<int, int> funcQuestion1 = expLmd.Compile() as Func<int, int>;
Console.WriteLine(funcQuestion1(a));
}

第二题：a + b * 2

第一步，如果你写lambda表达式，你应该怎么写??

(int a,int b)=>{return a+ b *2;}

好了，会写lambda表达式，基本上你也应该会写Expression了。

参数:int a,int b;

body:return a+b*2;

private static void Question2()
{
ParameterExpression expA = Expression.Parameter(typeof(int), "a");
ParameterExpression expB = Expression.Parameter(typeof(int), "b");
}

声明两个变量a,b类型是int.

接着要写body了。

body是a+b*2.

在这里2是常量。首先想到的是查看ExpressionType,看看有没有什么表达式代表的是常量，当然你可以找到ConstantExpression

于是代码变成了：

private static void Question2()
{
ParameterExpression expA = Expression.Parameter(typeof(int), "a");
ParameterExpression expB = Expression.Parameter(typeof(int), "b");
ConstantExpression exp2 = Expression.Constant(2);
}

接着用()来分隔下a+b*2.

()的意思是先执行什么，后执行什么。

结果如下 a + (b *2)

先执行b*2,然后将b*2的结果和a相加。

Expression expBody = Expression.Add(expA,
Expression.MakeBinary(ExpressionType.Multiply, expB, exp2)); Expression.MakeBinary(ExpressionType.Multiply, expB, exp2))将expB和exp2进行相乘操作。然后和expA做相加操作。生成的就是expBody了。因为我们知道参数是(int,int), 结果是int所以委托的类型是Func<int,int,int> 完整的代码如下：private static void Question2()
{
ParameterExpression expA = Expression.Parameter(typeof(int), "a");
ParameterExpression expB = Expression.Parameter(typeof(int), "b");
ConstantExpression exp2 = Expression.Constant(2);

Expression expBody = Expression.Add(expA, Expression.MakeBinary(
ExpressionType.Multiply, expB, exp2));

Expression<Func<int, int, int>> lmd = Expression.Lambda<Func<int, int, int>>
(expBody, expA, expB);

Console.WriteLine(lmd.Compile()(3, 2));
}

本文链接

Linq的Distinct太不给力了

2012-04-11T00:28:00Z

假设我们有一个类：Product

public class Product
{
public string Id { get; set; }
public string Name { get; set; }
}

Main函数如下：

static void Main()
{
List<Product> products = new List<Product>()
{
new Product(){ Id="1", Name="n1"},
new Product(){ Id="1", Name="n2"},
new Product(){ Id="2", Name="n1"},
new Product(){ Id="2", Name="n2"},
};

var distinctProduct = products.Distinct();

Console.ReadLine();
}

可以看到distinctProduct 的结果是：

因为Distinct 默认比较的是Product对象的引用，所以返回4条数据。

那么如果我们希望返回Id唯一的product，那么该如何做呢？

Distinct方法还有另一个重载：

//通过使用指定的 System.Collections.Generic.IEqualityComparer<T> 对值进行比较
//返回序列中的非重复元素。
public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer);

该重载接收一个IEqualityComparer的参数。

假设要按Id来筛选，那么应该新建类ProductIdComparer 内容如下：

public class ProductIdComparer : IEqualityComparer<Product>
{
public bool Equals(Product x, Product y)
{
if (x == null)
return y == null;
return x.Id == y.Id;
}

public int GetHashCode(Product obj)
{
if (obj == null)
return 0;
return obj.Id.GetHashCode();
}
}

使用的时候，只需要

var distinctProduct = products.Distinct(new ProductIdComparer());

结果如下：

现在假设我们要按照 Name来筛选重复呢？

很明显，需要再添加一个类ProductNameComparer.

那能不能使用泛型类呢？？

新建类PropertyComparer<T> 继承IEqualityComparer<T> 内容如下：

public class PropertyComparer<T> : IEqualityComparer<T>
{
private PropertyInfo _PropertyInfo;

/// <summary>
/// 通过propertyName 获取PropertyInfo对象 /// </summary>
/// <param name="propertyName"></param>
public PropertyComparer(string propertyName)
{
_PropertyInfo = typeof(T).GetProperty(propertyName,
BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Public);
if (_PropertyInfo == null)
{
throw new ArgumentException(string.Format("{0} is not a property of type {1}.",
propertyName, typeof(T)));
}
}

#region IEqualityComparer<T> Members

public bool Equals(T x, T y)
{
object xValue = _PropertyInfo.GetValue(x, null);
object yValue = _PropertyInfo.GetValue(y, null);

if (xValue == null)
return yValue == null;

return xValue.Equals(yValue);
}

public int GetHashCode(T obj)
{
object propertyValue = _PropertyInfo.GetValue(obj, null);

if (propertyValue == null)
return 0;
else
return propertyValue.GetHashCode();
}

#endregion
}

主要是重写的Equals 和GetHashCode 使用了属性的值比较。

使用的时候，只需要：

//var distinctProduct = products.Distinct(new PropertyComparer<Product>("Id"));
var distinctProduct = products.Distinct(new PropertyComparer<Product>("Name"));

结果如下：

为什么微软不提供PropertyEquality<T> 这个类呢？

按照上面的逻辑，这个类应该没有很复杂啊，细心的同学可以发现PropertyEquality 大量的使用了反射。每次获取属性的值的时候，都在调用
_PropertyInfo.GetValue(x, null);

可想而知，如果要筛选的记录非常多的话，那么性能无疑会受到影响。

为了提升性能，可以使用表达式树将反射调用改为委托调用，

具体代码如下：

public class FastPropertyComparer<T> : IEqualityComparer<T>
{
private Func<T, Object> getPropertyValueFunc = null;

/// <summary>
/// 通过propertyName 获取PropertyInfo对象
/// </summary>
/// <param name="propertyName"></param>
public FastPropertyComparer(string propertyName)
{
PropertyInfo _PropertyInfo = typeof(T).GetProperty(propertyName,
BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Public);
if (_PropertyInfo == null)
{
throw new ArgumentException(string.Format("{0} is not a property of type {1}.",
propertyName, typeof(T)));
}

ParameterExpression expPara = Expression.Parameter(typeof(T), "obj");
MemberExpression me = Expression.Property(expPara, _PropertyInfo);
getPropertyValueFunc = Expression.Lambda<Func<T, object>>(me, expPara).Compile();
}

#region IEqualityComparer<T> Members

public bool Equals(T x, T y)
{
object xValue = getPropertyValueFunc(x);
object yValue = getPropertyValueFunc(y);

if (xValue == null)
return yValue == null;

return xValue.Equals(yValue);
}

public int GetHashCode(T obj)
{
object propertyValue = getPropertyValueFunc(obj);

if (propertyValue == null)
return 0;
else
return propertyValue.GetHashCode();
}

#endregion
}

可以看到现在获取值只需要getPropertyValueFunc(obj) 就可以了。

使用的时候：

var distinctProduct = products.Distinct(new FastPropertyComparer<Product>("Id")).ToList();

作者：LoveJenny

出处：http://www.cnblogs.com/LoveJenny/

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

本文链接

Fluent NHibernate之旅

2012-04-10T00:42:00Z

ORM大家都非常熟悉了吧，我相信也有很多朋友正在用自己或者一些公开的框架，而最常用而且强大的，非Hibernate了（Net中为NHibernate）,网上的文档非常多，不过在博客园中，介绍NHibernate的非常少，李哥的NHibernate系列（NHibernate之旅）不失为一个经典，对于新手的我们，需要完全掌握还需要很长一段路，对于新手来说，最初的配置是非常头大的一件事情，好在老赵推荐一个开源的框架Fluent NHibernate，有了它，我们可以完全脱离配置文件，不过博客园中介绍Fluent NHibernate的文章非常少，而且官方文档也还没有完全，所以对于我来说也就一点一点摸索起来，这也激起了我写这个笔记的欲望，废话不说了，下面就介绍Fluent NHibernate，大家也一起来体验一下Fluent Nhibernate的快感吧。

本篇内容：

1、初识Fluent NHibernate（简称Fluent）

2、使用NHibernate和Fluent创建ISessionFactory

3、传统方式和Fluent的对比。

4、灵活的Fluent

一、初识Fluent NHibernate（简称Fluent）

Fluent NHibernate offers an alternative to NHibernate's standard XML mapping files. Rather than writing XML documents (.hbm.xml files), Fluent NHibernate lets you write mappings in strongly typed C# code. This allows for easy refactoring, improved readability and more concise code.

这是官方的说明，大体的话也就是用编程的方式进行配置，让你能更好的理解，不需要编写复杂的映射文件，它能完全替换NHibernate的映射文件，让你在映射的时候能使用C#的强类型方式。

在开始之前，我们先下载它的Dll，当然你也可以下载它的源代码进行修改和学习。

下载地址：http://fluentnhibernate.org/

二、使用NHibernate和Fluent创建ISessionFactory

准备工作：

1、下载Fluent类库，其中已经包含了NHibernate最新版本。
2、下载NHibernate类库，虽然Fluent已经有了最新版本，但我们还需要Proxy的Dll，这里我们使用NHibernate.ByteCode.Castle这个程序集。
3、建立一个空数据库（我们使用MSSql2005），数据库名为：MyNHibernate，这个数据库为信任连接。

在NHibernate中，ISession是操作数据的核心，我们需要通过SessionFactory来建造ISession来进行数据的交互。SessionFactory中反映了数据库映射关系，我们来看下配置：

<hibernate-configuration xmlns="urn:nhibernate-configuration-2.2">
    <session-factory>
      <property name="dialect">NHibernate.Dialect.MsSql2005Dialect</property>
      <property name="connection.connection_string">
        Server=(local);initial catalog=MyNHibernate;Integrated Security=SSPI
      </property>
      <property name="connection.isolation">ReadCommitted</property>
      <property name="proxyfactory.factory_class">
        NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle
      </property>
    </session-factory>
  </hibernate-configuration>

大体的意思我相信大家都懂，数据库类型和数据库的配置，还有一些NHibernate所需的配置，这里的proxyfactory.factory_class是2.1新加入的，至于用处还不是很了解，大家可以看下李大哥的“NHibernate2.1新特性之Tuplizers”。下面我们在代码中创建一个SessionFactory，NHibernate建议我们在一个应用程序中使用一个数据库一个SessionFactory，这里我们用单数据库，代码如下：

 1        public static ISessionFactory GetCurrentFactory()
 2        {
 3            if (sessionFactory == null)
 4            {
 5                sessionFactory = CreateSessionFactory();
 6            }
 7
 8            return sessionFactory;
 9        }
10
11        private static ISessionFactory CreateSessionFactory()
12        {
13            return new Configuration().Configure().BuildSessionFactory();
14        }
15
16        private static ISessionFactory sessionFactory
17        {
18            get;
19            set;
20        }

传统的方式其实已经非常灵活和简单了，但配置文件真的有点头大，那么多的属性，还有很多特性（Attribute），接下来我们来看下Fluent

折叠代码

使用Fluent我们不需要再进行配置，我们可以完全抛开xml文档，前面说过Fluent是对Mapping的一个代码化，Mapping的一切功能，我们都能通过Fluent进行配置。

因为Fluent是基于NHibernate的，它只实现了NHibernate的Mapping功能，其他功能还不能代替，所以我们的项目中要同时引入NHibernate和FluentNHibernate两个类库。代码如下：

 1        public static ISessionFactory GetCurrentFactory()
 2        {
 3            if (sessionFactory == null)
 4            {
 5                sessionFactory = CreateSessionFactory();
 6            }
 7
 8            return sessionFactory;
 9        }
10
11        private static ISessionFactory CreateSessionFactory()
12        {
13            return Fluently.Configure()
14                .Database(
15                    FluentNHibernate.Cfg.Db.MsSqlConfiguration.MsSql2005
16                        .ConnectionString(s => s.Server(".")
17                                .Database("MyNHibernate")
18                                .TrustedConnection())
19                ).BuildSessionFactory();
20        }
21              private static ISessionFactory sessionFactory
22        {
23            get;
24            set;
25        }

这样就可以了，我们完全抛开了配置，简单的一些代码，已经完成了SessionFactory的配置工作，或许你还有一些配置，在后面的文章中会继续为您讲解。

折叠代码

两种方式的创建写好了，因为是测试，所以写的比较乱，下面我们写一个测试代码，只需要测试一个方法即可。代码如下：

1[TestMethod]
2public void NHibernateFactory()
3{
4 var factory = TradSessionFactory.GetCurrentFactory();
5}
6[TestMethod]
7public void FluentFactory()
8{
9 var factory = FluentSessionFactory.GetCurrentFactory();
10}
11

运行一下，结果如下：

如果数据库配置是正确的话，你会看到如上的结果。

三、传统方式和Fluent的对比

上面的演示相信大家都能看明白，两者之间的对比也比较明显的显露出来，传统的方式我们只需要编写正确的配置文件，相对比较灵活，一些修改的话都可以在配置文件中进行更新，比如Mappings，而上面的代码，Fluent虽然使用代码的方式进行了配置，省去了配置文件，但灵活性却没有传统方式那么好，修改一些配置的时候，我们得扩充我们的CreateSessionFactory的方法，不过Fluent更符合人类的思考行为，而且有VS这么强大IDE，在编写代码的同时，能够享受强大的智能感知。

两者之间都各有长短，或许你还没有体会到Fluent的强大，在日后的Mappings时，你会慢慢了解为什么他会叫Fluent。传统方式对于一些经常使用的程序员来说非常简便，加上代码生成工具，使用起来也会游刃有余，但对于新手来说，Fluent绝对是一个好帮手。

四、灵活的Fluent

那我们Fluent就没有办法灵活了吗？当然不，Fluent的开发者不仅帮你保留了原有的方式，还可以混合你的配置文件，最有意思的时，你还可以使用它来学习NHibernate，甚至可以使用它来开发你自己的自动代码生成工具，因为我也刚学，先介绍一些简单的，至于其他功能，希望大家也能跟我一起学习，体验Fluent带来的快感。

使用NHibernate的配置
也就是你可以按照原先的方式进行配置，而读取呢使用Fluent来读取，然后创建SessionFactory，或许你感觉这不是多余了嘛，那是因为还没有讲到Mapping，这里我们先介绍一下，如果用Fluent结合传统的配置文件，来创建SessionFactory（后面的代码会简略，只修改上面其中的创建方法）。
private static ISessionFactory CreateSessionFactory()
{
return Fluently.Configure(new NHibernate.Cfg.Configuration().Configure()).BuildSessionFactory();
}
折叠代码
哈哈，简单吧，我们使用了原先的配置文件，然后用Fluent进行创建，而且我们可以为配置文件中没有的配置进行扩展。
折叠代码

原本打算把Fluent学习的方法说一下，后来一看，必须要先说Fluent的Mapping才能说到这个，所以暂时先不说了，等到下一章映射的部分再一起来说。

折叠代码

文章写得很烂，也当是笔记吧，NHibernate也是刚刚学，惭愧惭愧，学的不是很彻底，今后也会结合NHibernate的学习一起来说。

折叠代码

-----------------------------------------------------
网名：James.Ying（玄天尊）

MSN：x_inday@msn.com

经验：5年电子商务网站开发

目标：电子商务平民化。

本文链接

Ninject 2.x细说---2.绑定和作用域

2012-04-05T05:08:00Z

Ninject中提供多种接口和实现类的绑定的方式供我们选择，同时还可以设置相关的绑定项以及对象的作用域等。具体如下：（其中使用到的类和代码重用上一节的“Ninject 2.x细说---1.基本使用”中的定义）

1. 绑定：

Ninject中提供好几种绑定接口实现的方法，具体如下：

Ø To：绑定到接口的具体实现。

Ø ToConstant：绑定到某个常量值。

Ø ToMethod：绑定到方法。

Ø ToProvider：绑定到某个自定义的对象创建提供程序。

Ø ToSelf：自绑定。

代码如下：

1) 自绑定

Ninject可以使用ToSelf（）方法，将自己绑定自己，这里必须是一个具体的类。

Bind<MessageCfg>().ToSelf();

2) 绑定到方法：

Bind<IMessage>().ToMethod(context => new MessageDB());

3) 绑定到具体的类型

Bind<IMessage>().ToConstant(new MessageDB());

4) 绑定到指定的服务提供程序

以及Bind<IMessage>().ToProvider(实现IProvider接口的服务提供程序);

2. 指定相关绑定信息：

Ninject中，可以在绑定的时候指定一些附加信息，以便更加明确构造函数或者是给某些属性赋值或者在绑定时回调方法。如下面的代码中：Bind<IMessage>().To<MessageDB>().WithConstructorArgument("msg", 1);

我们在绑定的同时指定了构造函数的参数以及值。

此外，还可以设置的指定信息分别有：

Ø WithConstructorArgument：指定构造函数中相关的参数，还有回调方法的重载。

Ø WithMetadata：指定相关元数据信息。

Ø WithParameter：指定相关的自定义参数。这个方法也实现构造函数参数值指定，与WithConstructorArgument类似，如：Bind<IMessage>().To<MessageDB>().WithConstructorArgument("msg", 1);同样可以写成：Bind<IMessage>().To<MessageDB>().WithParameter(new ConstructorArgument("msg", 1));

Ø WithPropertyValue：指定相关的属性值，还有回调方法的重载。

3. 条件绑定：

Ninject中还可以指定相关的绑定的条件，只有条件满足的情况的下，才将相关的接口实现绑定到相关的接口上。如：

Bind<IMessage>().To<MessageDB>().WhenInjectedInto<MessageCfg>();

上面的代码，由于MessageCfg依赖与IMessage接口，所以其意思是在MessageCfg类中依赖的IMessage接口与MessageDB类绑定。

类似的还有When()如：

Bind<IMessage>().To<MessageDB>().When(cxt => cxt.Service.Name.StartsWith("Msg"));

其他的条件还有WhenClassHas、WhenParentNamed、WhenTargetHas等条件绑定。

4. 设置注入项

在Ninject中可以通过NinjectSettings类来指定注入项。如：

////设置注入项

var settings = new NinjectSettings() { AllowNullInjection = true };

using (var kernal = new StandardKernel(settings, new MessageModule()))

{

var msgcfg = kernal.Get<MessageCfg>();

}

其中，可以设置的项有：

ActivationCacheDisabled、AllowNullInjection、CachePruningInterval、ExtensionSearchPattern、InjectAttribute、InjectNonPublic等等。大概对应的就是设置缓存是否启用、是否允许空注入、缓存周期、扩展查找位置、必须被注入的属性、是否必须注入非公开成员等等。（BTW：Ninject中摘要说明少了Get，还发现好几个地方都是这样呢）。

5. Inject特性

在Inject中，我们构造函数、属性和字段上加 [Inject]特性指示，以便指定注入的属性、方法和字段等。[Inject]特性定义具体如下：

[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = true)]

public class InjectAttribute : Attribute

{

public InjectAttribute();

}

例如使用[Inject]指定构造函数，如果某个类存在多个构造函数，那么我们就可以在某个构造函数上使用[Inject]来指定从此处注入，具体代码如下：

public class MessageDB : IMessage

{

public MessageDB() { }

public MessageDB(object msg)

{

Console.WriteLine("使用了object 参数构造：{0}", msg);

}

[Inject]

public MessageDB(int msg)

{

Console.WriteLine("使用了int 参数构造：{0}", msg);

}

public string GetMsgNumber()

{

return "从数据中读取消息号!";

}

相应的MessageModule进行修改，具体如下：

public class MessageModule : NinjectModule

{

public override void Load()

{

//绑定接口并指定接口的实现。

Bind<IMessage>().To<MessageDB>().WithConstructorArgument("msg", 1);

}

具体使用如下：

using (var kernal = new StandardKernel(new MessageModule()))

{

//属性注入

var msgcfg = new MessageCfg() { Msg = kernal.Get<IMessage>() };

Console.WriteLine(msgcfg.GetMsgNumber());

Console.Read();

}

其中MessageCfg类的定义见前一节介绍的内容。通过上面的代码，我们可以看到，MessageDB分别由int和object类型的构造函数，如果没有在构造函数上指定[Inject]，经过测试发现它默认就是选择第一个构造函数，如果参数类型不匹配就直接抛出异常。

6. 对象作用域：

Transient	.InTransientScope()	每次调用创建新实例。
Singleton	.InSingletonScope()	单例，仅创建一个实例。
Thread	.InThreadScope()	每一个线程创建一个实例。
Request	.InRequestScope()	每当Web请求发起时创建一个实例，结束请求时释放实例
InScope	InScope(Func)	对象尽量保持到回调委托返回

上表来自“靠近太阳”的博文，后增加了InScope 。如使用InThreadScope（）具体例子如下：

public class MessageModule : NinjectModule

{

public override void Load()

{

//绑定接口并指定接口的实现。

Bind<IMessage>().To<MessageDB>().InThreadScope().WithParameter(new ConstructorArgument("msg", 1));

}

使用代码如下：

using (var kernal = new StandardKernel(new MessageModule()))

{

//属性注入

var th1 = new Thread(new ThreadStart(() =>

{

var msgcfg = new MessageCfg() { Msg = kernal.Get<IMessage>() };

Console.WriteLine(msgcfg.GetMsgNumber());

}));

var th2 = new Thread(new ThreadStart(() =>

{

var msgcfg = new MessageCfg() { Msg = kernal.Get<IMessage>() };

Console.WriteLine(msgcfg.GetMsgNumber());

}));

var th3 = new Thread(new ThreadStart(() =>

{

var msgcfg = new MessageCfg() { Msg = kernal.Get<IMessage>() };

Console.WriteLine(msgcfg.GetMsgNumber());

}));

th1.Start();

th2.Start();

th3.Start();

Console.Read();

}

在上面的代码中，我们指定了对象在InThreadScope，在使用的代码中分别创建了3个线程来进行模拟，最终每个线程都是创建了一个对象。

本文版权归作者所有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

本文链接