博客园_心有多远就能走多远～～

UML 依赖关联聚合组合

2011-12-05T15:57:00Z

继承

指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系；在Java中此类关系通过关键字extends明确标识，在设计时一般没有争议性；

实现

指的是一个class类实现interface接口（可以是多个）的功能；实现是类与接口之间最常见的关系；在Java中此类关系通过关键字 implements明确标识，在设计时一般没有争议性；

依赖

可以简单的理解，就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、、临时性的、非常弱的，但是B类的变化会影响到A；比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖；表现在代码层面，为类B作为参数被类A在某个method方法中使用；

关联

他体现的是两个类、或者类与接口之间语义级别的一种强依赖关系，比如我和我的朋友；这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的、关联可以是单向、双向的；表现在代码层面，为被关联类B以类属性的形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量；

聚合

聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

组合

组合也是关联关系的一种特例，他体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合；他同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束；比如你和你的大脑；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

对于继承、实现这两种关系没多少疑问，他们体现的是一种类与类、或者类与接口间的纵向关系；其他的四者关系则体现的是类与类、或者类与接口间的引用、横向关系，是比较难区分的，有很多事物间的关系要想准备定位是很难的，前面也提到，这几种关系都是语义级别的，所以从代码层面并不能完全区分各种关系；但总的来说，后几种关系所表现的强弱程度依次为：组合>聚合>关联>依赖 ；

本文链接

亲属称谓

2011-12-04T11:05:00Z

古代将凡血缘相近的同姓本族和异性外族都称作亲属。

祖：(王父、祖父)父之父。祖母、王母、父之母。(曾祖父、母)祖之父、母。(高祖父、母)曾祖之父、母。(上五世即从本位起，上及父、祖、曾祖、高祖)。

曾孙：孙之子。

玄孙：曾孙之子。

来孙：玄孙之子。(下五世指从本位起，下主立孙)

世父：(伯父)父之兄。

叔父：父之弟。

世母(伯母)：世父之妻。

叔母(婶)：叔父之妻。

姑(姑母)：父之姊妹。

姑父：姑之夫。

从祖祖父(伯祖父、叔祖父)：父之伯叔。

从祖祖母(伯祖母、叔祖母)：父之伯母、叔母。

从祖父(堂伯、堂叔)：父之从兄弟。

从祖母(堂伯母、堂叔母)：从祖父之妻。

族曾祖父(族曾王父)：祖父的伯叔。

族曾王母：祖父的伯叔之妻子。

族祖父(族祖王父)：族曾祖父之子。

族父：族祖父之子。

族兄弟：族父之子。

嫂：兄之妻。

弟妇：弟之妇。

从子(侄)：兄弟之子。

从女(侄女)：兄弟之女。

从孙：兄弟之孙。

甥(外甥)：姊妹之子。

私姊：妹之夫。

女婿(子婿、婿)：女之夫。

中表(姑表)：父之姊妹之子女。

外祖父(外王父)：母之父。

外祖母(外王母)：母之母。

外曾王父：外祖父之父。

外曾王母：外祖父之母。

舅(舅父)：母之兄弟。

舅母(妗子)：舅之妻。

从母(姨母、姨)：母之姊妹。

姨父：姨母之夫。

中表(姨表)：姨之子女。

从母兄弟、从母姊妹(姑表兄弟姊妹、姨表兄弟姊妹)：母之兄弟姊妹的子女。

外舅(岳父、岳丈、丈人、泰山、岳翁)：妻之父。

外姑(岳母、丈母、泰水)：妻之母。

姨(姨子)：妻之姊妹。

妻侄：妻之兄弟之子。

舅(嫜、公)：夫之父。

姑（婆)：夫之母。

姑嫜、舅姑：即夫之父母(俗称公婆)。

伯叔(大伯、大叔子)：夫之兄弟。

小姑子：夫之妹。

娣妇：夫之弟妇。

姒姆：夫之嫂。

娣姒、妯娌：古之弟妇与嫂的简称。

娅、连襟(襟兄、襟弟)、两乔两婿互称。

编辑本段1、祖辈

祖辈的亲属，按古代关于宗亲的范围，是从高祖开始。高祖以上的直系祖先则称为远祖、先祖、先人、鼻祖（鼻，始的意思）。

（1）祖：在古代，广义是指所有父辈以上的男性先辈，狭义则是指祖父。

（2）祖父：又称为“王父”、“大父”、“祖君”。在古代，“公”、“太公”、“翁”也可用来称呼祖父；如今对祖父最常见的称呼是“爷爷”。

（3）祖母：又可以称为“大母”、“王母”、 “重慈”。又因古人有妻有妾，所以祖母又有 “季祖母”、“庶祖母”、“妾祖母”之分。祖母之称古今通用。

（4）婆：是古代对成年妇女的很普遍的称呼，也可以用来称祖母。

（5）奶奶：是今天对祖母的普遍称呼，古代的使用较晚。作为称谓，“奶”最早是作为乳母之称，以后又用以称母亲，又作为对以婚妇女的较广义的称呼。

（6）堂祖父、从祖父、伯公、伯祖、伯翁、叔公、叔祖、叔翁等：这些是对祖父的兄弟的称谓。

（7）堂祖母、从祖母、伯婆、伯祖母、叔婆、叔祖母等：这些是对祖父兄弟妻子的称谓。

编辑本段2、曾祖辈

（1）曾祖：即祖父之父。古代还有“太翁”、“曾翁”、“曾大父”、“大王父”、“王大父”、“太公”、“曾太公”等称呼，比较特殊的是称“曾门”。

（2）曾祖母：指曾祖之妻，还可以称为“太婆”、“曾祖王母”、“太奶”，其中较常见的为“太婆”。

编辑本段3、高祖辈

（1）高祖：即曾祖之父，古今多称为高祖父，也有称为“高祖王父”、“高门”。但需注意的是，古代对高祖之上的历代远祖也可称为高祖。

（2）高祖母：指高祖之妻，或称“高王祖母”。

编辑本段4、父母

（1）父母：父母是亲属中最重要的亲属，除“父母”、“双亲”、“二老”、“爹娘”等古今通用的合称外还有“高堂”、“严君”、“尊亲”、“严亲”、“两亲”、“亲闱”等以及文人笔下的“所生”、“椿萱”等对父母的代称。

（2）父、父亲：是对父亲古今习见的称呼，还可以称父亲为“公”、“翁”、“尊”、“大人”、“严君”、“爷”、“爹”、“爸”、“老子”等。

（3）尊：古代常见的敬称用语，称自己的父亲可称“家尊”，称对方的父亲则称“令尊”。

（4）爷：古代对成年男子较广义的称呼，宋代开始用作对祖父之称，魏晋南北朝就用作对父亲之称，或写作“耶”。

（5）母：是对母亲最常见的称呼。而在古代对母亲的称谓中，大都和“母”相似，又用作对成年妇女或老年妇女的泛称。其中较重要的有：“婆”、“娘”、“娘娘”、“姥”、“大人”、“妈”、“慈”、“家家”和“姊姊”等。

（6）继母:如果自己的母亲去世、离异或被父辈逐出，则称续娶之妻为继母、继亲、后母、假母、续母。

（7）出母:如果自己的母亲离家之后还能相见，则称为出母。

（8）生母：在古代一夫多妻制的家庭中，称自己的生身母亲为“生母”或 “本生母”。

（9）庶母：在古代一夫多妻制的家庭中，如果自己的生母是正妻，则称父亲之妾为“庶母”、“少母”、“诸母”、“妾母”。

（10）家家和姊姊:是中古时期对母亲的两种特殊称呼。

（11）姨: 在古代一夫多妻制的家庭中，无论自己的生母是妻或妾，对父亲的妾都可以称为“姨”、“姨姨”、“阿姨”。

( 12 )义父：指是在自己的父亲之外再拜认某人为父，这个“义”字有外加、假、代、自愿等意。

( 13 )义母：指是在自己的母亲之外再拜认某人为母。

编辑本段5、与父亲相关的亲属?

（1）诸父、诸母：是对父亲的兄弟及其妻室的统称。

（2）世父：对父亲的兄弟的称谓，现在更多的场合是称“伯父”、“叔父”

或简称“伯”、“叔”。古人偶尔将几个叔父按伯、仲、叔、季的排行次序，分别称为“伯父”、“仲父”、“叔父”、“季父”。

（3）伯母、叔母：是对父亲的兄弟的妻室的称呼。

（4）从父：对父亲的叔伯兄弟可统称“从父”，又可分别称为“从伯”、“从叔”。

（5）姑：对父亲的姊妹可称为“姑”（沿用至今），又可以称为“诸姑”、“姑姊”、“姑妹”，对已婚者一般都称为“姑母”、“姑妈”，与今不同的是偶尔也称“姑娘”。

（6）姑父：对姑母的丈夫，既可称为“姑父”、“姑丈”，又可以称为“姑婿”、“姑夫”。

（7）表兄弟：对姑母的子的称谓。

（8）表姊妹：对姑母的女的称谓。

编辑本段6、与母亲相关的亲属

（1）外祖父：对母亲的父亲，称其为“外祖父”（与今同），又可称为“外翁”、“外大人”、“家公”、“老爷”等。

（2）外祖母：对母亲的母亲，称为“外祖母”、“外婆”（与今同），又称为“姥姥”、“老老”等。

（3）舅：对母亲的兄弟，古今均称“舅”，在不同场合，可加上一些修饰或补充性文字，如：“舅氏”、“舅父”、“嫡舅”、“元舅”、“堂舅”等。

（4）舅母：对舅父之妻的称谓。

（5）姨母：对母亲姊妹的称呼，先秦时称为“从母”，秦汉以来则称为“姨母”，或称为“姨娘”、“姨婆”、“姨妈”等。

（6）姨父：对姨母之夫称为“姨夫”或“姨父”。姨母之子女也称“表兄弟”、“表姊妹”。

（无论是舅父之女、姨母之女，还是姑母之女，都可以以“表兄弟”、“表姊妹”相称，古人统称为“诸表”。）

编辑本段7、考妣

“考”和“妣”在先秦时是对父母的异称，无论生死均可用。秦汉以来，父母死后仍可称为考妣，但生前不再称考妣，考妣只用来对死去的父母之称。而且，考**不仅用来称死去的父母，死去的祖辈乃至更早的直系先辈均可用考妣相称（在先秦时则是对先祖的泛称）。

编辑本段8、夫妻

（1）夫：或作“丈夫”，本是对成年男子的美称，但又用作夫妻之夫。“夫”

加上其它附加成分的表示丈夫意的相关称谓很多，如：“夫子”、“夫君”、“夫主”、“夫婿”等。除此，还可以用“良人” 、“郎”、“丈人”、“君”、“老公”、“官人”、“汉子”等称呼丈夫。

（2）妻、妻子：是由古至今对妻的最主要的称呼。在妻之前加上各种附加成分，还有“贤妻”、“良妻”、“仁妻”、“令妻”、“娇妻”等。除此，还可用“妇”、“室”、“君”、“夫人”、“娘子”、“浑家”、“内”、“老婆”、“婆娘”、“太太”等来称呼。

编辑本段9、与丈夫相关亲属

（1）公：也称公公，对丈夫之父，古称为“舅”，也称为“公”、“公公 ”。这些称呼正是今天称丈夫之父为“公”、“公公”、“老人公”的前身。

（2）婆：也称婆婆，对丈夫之母，古称为“姑”以及由“姑”派生出的“君姑”、“严姑”、“慈姑”、“阿姑”等。后又称“婆”、“婆婆”。

（3）舅姑、姑舅：是早期对丈夫父母的合称。近者称“公婆”。此外还有一个常见的称呼是“姑章”，或作“姑嫜”。

（4）伯叔：对丈夫的兄弟的称谓，与近代所称的“大伯”、“小叔”是一致的。

（5）小姑：对丈夫妹妹的称谓。

编辑本段10、与妻子相关亲属

（1）岳丈：是对于妻子之父的称呼，古代还有“泰山”、“冰翁” 外舅” “外父”、“妻父”等代称。

（2）岳母：对妻子之母的称谓，或称为“丈母”。

（3）姑、外姑：早期用来对妻子之母的称呼。

（4）舅舅：对妻子兄弟的称呼，或称为“舅”、“舅爷”、“舅子”等，还称为“内兄”、“内弟”、“妻兄”、“妻弟”等。

（5）姨：对妻子的姊妹的称呼，或称“大姨”、“小姨”，也称为“妻妹”、“内妹”。

编辑本段11、兄弟及与其相关亲属

（1）兄：又称为“昆”。今天则可用“哥”来称呼兄长。有兄弟数人的情况下，称呼中必须表示出排行，或以数字为排行，或用伯、仲、叔、季这些排行常用语等。（“哥”，古代是用得十分广泛的称呼，可以称父、称兄、称弟、称子。）

（2）嫂：对兄的妻子的称谓，或称“嫂嫂”。

（3）弟：是对与兄相对者的称呼。

（4）弟媳：对弟的妻子的称谓，或称“弟妹”。

（5）侄：对兄弟的子女最常见的称呼，也可直接称之为“兄子”、“兄女”，或称为“从子”、“从女”、“犹子”、“犹女”。

编辑本段12、姊妹及与其相关亲属

（1）女兄、女弟：古代对姊妹的称谓，或直接称姊妹为兄弟。“姊”又称“姐”，与姊相对者称为“妹”。

（2）姊夫、妹夫：对姊妹的丈夫的称呼，也可称为“姊婿”、“妹婿”。

（3）甥：对姊妹之子最普遍的称呼，还称为“外甥”、“甥女”、“外甥女”。

编辑本段13、子女及与其相关亲属

（1）子：在古代是一个使用范围较广的称呼，秦汉以后主要用作儿子之称。

自己之子可称为“犬子”、“孽子”、“不孝子”等，别人之子又可称为“令子”、“良子”、“不凡子”、“贤子”等。除此，还可用“男”、“子息”、“贱息”、“儿子”、“儿郎”、“儿男”等来称呼子。若有几个儿子则有“长子”、“次男”、“幼子”等称呼。

（2）女：对女儿的主要称呼。对别人的女儿往往称为“爱”或“嫒”，也称为“令嫒”、“闺嫒”。

（3）义子、义女：指不是自己生育的，而是收养的子女，又称“养子”、“养女”、“假子”。同时还有一个常见的代称“螟蛉”。

（4）媳妇：对儿子之妻的称呼。最初只称为“妇”，后因儿子又称为“息”，所以子之妻又称为“息妇”，或写作“媳妇”。

（5）婿：对女儿丈夫的称呼，或称为“女婿”、“子婿”、“郎婿”、“快婿”等。除此，女儿之夫还可以被称为“女夫”、“半子”、“东床”“令坦”。

女婿到了岳丈家，除了岳父、岳母可以称“贤婿”之类，岳家一般人都尊称其为“姑爷”、“姑老爷”。

（6）孙：对儿子的子女的称呼，或称“孙息”、“孙枝”。“孙”又分为“孙儿”、“孙女”，“孙女”又称为“女孙”。

（7）外孙：对女儿的子女的称呼。女姓还可称为“外孙女”。

编辑本段另附：

一、家族长辈称谓

（前为称谓————后为自称）下同

曾祖父、母——曾孙、孙女

太公翁（丈夫的曾祖父）——曾孙媳

太奶亲（丈夫的曾祖母）——曾孙媳

曾伯父、母（父亲的祖父的哥哥、嫂嫂）——曾侄孙、曾侄孙女

太伯翁、太姆婆（丈夫的曾伯父、母）——曾侄孙媳

曾叔祖父、母（父亲的祖父的弟弟、弟媳）——曾侄孙、曾侄孙媳

太叔翁、太婶婆（丈夫的曾叔祖父、母）——曾侄孙媳

祖父、祖母（父亲的父母）——孙、孙女

祖翁、婆（丈夫的祖父、祖母）——孙媳妇

伯祖父、母（父亲的伯父、母）——侄孙、侄孙女

伯祖翁、婆（丈夫的伯祖父、母）——曾孙媳

叔祖父、母（父亲的叔父、母）——侄孙、侄孙女

叔祖翁（丈夫的叔祖父）——侄孙媳

婶婆（丈夫的叔祖母）——侄孙媳

翁亲、姑亲（丈夫的父亲、母亲）——儿媳

伯父、母（父亲的哥哥、嫂嫂）——侄儿、侄女

伯翁、母（丈夫的伯父、母）——侄媳

叔父、母（父亲的弟弟、弟媳）——侄、侄女

堂伯、叔（同族与父同辈者）——堂侄、堂侄女

宗伯、叔（同姓与父同辈者）——宗侄、宗侄女

叔翁、婶亲（丈夫的叔父、叔母）——侄媳

二、亲戚长辈称谓

曾祖姑丈（曾祖父的姐妹父）——内曾侄孙、内曾侄孙女

曾祖姑母（曾祖父的姐妹）——曾侄孙、曾侄孙女

祖姑丈（祖父的姐妹父）——内侄孙、内侄孙女

祖姑母（祖父的姐妹）——侄孙、侄孙女

舅祖父（祖母的兄弟）——外甥孙、外甥孙女

舅祖母（祖母的兄弟的妻子）——外甥孙、外甥孙女

祖姨夫（祖母的姐妹父）——姨甥孙、姨甥孙女

祖姨母（祖母的姐妹）——姨外甥、姨外甥女

姑丈（父亲的姐妹父）——内侄、内侄女

姑母（父亲的姐妹）——侄、侄女

表伯、姆（父亲的表兄、嫂）——表侄、表侄女

太外祖父、母（母亲的祖父、母）——外曾孙、外曾孙女

外祖父、母（母亲的父母）——外孙、外孙女

外伯祖、外姆婆（母亲的伯父、母）——外侄孙、外侄孙女

外叔祖、外婶婆（母亲的叔父、叔母）——外侄孙、外侄孙女

舅父（母亲的兄弟）——外甥、外甥女

舅母（母亲的兄嫂、弟媳）——外甥、外甥女

姨丈（母亲的姐妹父）——姨甥、姨甥女

姨母（母亲的姐妹）——襟侄、襟侄女

太岳父、母（妻的祖父、母）——孙婿、孙女婿

太伯岳、母（妻的伯祖父、母）——侄孙婿、侄孙女婿

太叔岳、母（妻的叔祖父、母）——侄孙婿、侄孙女婿

岳父、母（妻的父母）——女婿

伯岳、母（妻的伯父、母）——侄女婿

叔岳、母（妻的叔父、母）——侄女婿

姻伯丈、姆（妻的从伯父、母）——姻家侄婿

姻叔丈、姻婶（妻的从叔父、母）——姻家侄婿

姻伯、姆（妻的堂伯父、母）——姻家侄

姻叔、姻婶（妻的堂叔父、母）——姻家侄

三：家族平辈称谓

胞哥（本人的哥哥）——弟、妹

兄嫂（哥哥的爱人）——夫弟、夫妹

弟妇（胞弟的爱人）——夫兄、夫姐

胞姐、妹（本人的姐、妹）——弟、妹、兄、姐

夫兄（丈夫的哥哥）——弟妇

兄嫂（丈夫的嫂嫂）——弟妇

夫弟（丈夫的弟弟）——嫂

弟妇（丈夫的弟媳）——嫂

爱妻（本人的妻子）——夫

良人、夫君（本人的丈夫）——拙荆、妻

夫姐（丈夫的胞姐）——弟媳

夫妹（丈夫的胞妹）——兄嫂

从兄、姐（伯、叔的女儿）——从弟、妹

从弟、妹（伯、叔的女儿）——从兄、姐

夫从兄（丈夫的从兄）——从弟妇

从兄嫂（丈夫的从嫂）——从弟妇

从弟（丈夫的从弟）——从兄嫂

从弟妇（丈夫的从弟媳）——从兄嫂

堂兄（丈夫的堂兄）——堂弟妇

堂嫂（丈夫的堂嫂）——堂弟妇

堂弟（丈夫的堂弟）——堂兄嫂

堂小弟（丈夫的堂弟媳）——堂兄嫂

堂兄、堂姐、堂弟、堂妹（同族平辈者）——堂弟、堂妹、堂兄、堂姐

宗兄、宗姐、宗弟、宗妹（同姓平辈者）——宗弟、宗妹、宗兄、宗姐

姐丈（本人的胞姐夫）——内弟、内弟妇

妹丈（本人的胞妹夫）——内兄、内兄嫂

表兄、表姐（姑、姨、妗的子、女）——表弟、表妹

表弟、表妹（姑、姨、妗的子、女）——表兄、表姐

表姐丈（姑母的女婿）——表内弟、表妹

内兄、嫂（妻子的哥、嫂）——内兄、嫂

内弟、媳（妻子的弟、媳）——姐夫

襟兄（妻的姐、妹夫）——襟弟

姻兄、弟（妻的从兄、弟）——姻兄、弟

姻家兄、弟（妻的堂兄、弟）——姻家兄、弟

四：亲戚互称

老太姻翁、姆（亲家的祖父、母）——姻再侄、姻再侄妇

太姻翁（亲家的父亲）——姻侄、姻侄妇

太姻姆（亲家的母亲）——姻侄、姻侄妇

姻伯翁、叔翁（亲家的伯、叔父）——姻家侄、姻家侄室

姻伯姆、叔母（亲家的伯、叔母）——夫姻家侄

姻翁（亲家）——姻弟

姻姆（亲家姆）——姻室

姻兄（亲家的兄弟）——姻家弟

姻仁兄（亲家姆的兄弟）——姻家室

姻家兄（亲家的从、堂兄弟）——姻家弟

姻侄（亲家的堂、侄儿）——姻家伯、姻愚叔

姻伯祖（兄弟妻的祖父）——姻家再侄

本文链接

以字节流上传文件

2011-11-20T04:06:00Z

public string SaveFile(byte[] binData, string filePath, string fileName, int type, string fileType)
{

           ///定义并实例化一个内存流，以存放提交上来的字节数组。
           MemoryStream m = new MemoryStream(binData);
           FileStream fileStream = null;
           try
           {
               string savePath = System.Configuration.ConfigurationSettings.AppSettings["DcFilePath"];

//不是绝对路径
if (savePath.IndexOf(":\\") < 0) savePath = Server.MapPath(savePath);

//没有反斜杠
if (!savePath.EndsWith("\\")) savePath += "\\";

//目录
savePath += filePath;

//没有文件夹，创建文件夹

               if (!Directory.Exists(savePath))
               {
                   Directory.CreateDirectory(savePath);
               }

               if (type == 0)
               {
                   fileName = "\\" + DateTime.Now.Day.ToString() + DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString() + DateTime.Now.Millisecond.ToString();
               }
               if (!File.Exists(savePath + fileName + fileType))
               {
                   fileName = "\\" + DateTime.Now.Day.ToString() + DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString() + DateTime.Now.Millisecond.ToString();
               }
               fileName = fileName + fileType;
               //写文件
               fileStream = new FileStream(savePath + fileName, FileMode.Create);
               m.WriteTo(fileStream);
               StreamWriter sw=new StreamWriter(savePath+".txt");
               sw.WriteLine(binData.Length.ToString());
               sw.Close();
                return "filePath.Replace("\\", "/") + fileName.Replace("\\", "/");
           }
           catch
           {
               return "上传文件出错|1";
           }
           finally
           {
               m.Close();
               fileStream.Close();
           }

}

有时候下面的函数会报错,也不知道什么原因. 还是用上传控件自带的转换.

#region 将文件转化成2进制流 ConvertFileStreamToByteBuffer
/// </summary>
/// <param name="filename"></param>
/// <returns></returns>
public byte[] getBinaryFile(string filename)
{
      if (File.Exists(filename))
      {
          FileStream s = null;
          try
          {
              //打开现有文件以进行读取。
              s = File.OpenRead(filename);
              return this.ConvertStreamToByteBuffer(s);
          }
          catch
          {
              return new byte[0];
          }
          finally
          {
              s.Close();
          }
      }
      else
      {
          return new byte[0];
      }
}
#endregion

#region 将流文件转化成2进制字节数组Convert FileStream Into Byte
/// </summary>
/// <param name="theStream"></param>
/// <returns></returns>
public byte[] ConvertStreamToByteBuffer(System.IO.Stream theStream)
{
int b1;
MemoryStream tempStream = new System.IO.MemoryStream();

      try
      {
          while ((b1 = theStream.ReadByte()) != -1)
          {
              tempStream.WriteByte(((byte)b1));
          }
          return tempStream.ToArray();
      }
      catch
      {
          return new byte[0];
      }
      finally
      {
          tempStream.Close();
      }
}
#endregion

本文链接

C#命名规范(微软官方版)

2011-09-18T13:41:00Z

使用以下三命名法来标示字符

Pascal case

标识符和每个后续的串连词的第一个字母都是大写；三个或更多字符的情况下可以使用Pascal命名法。

For example:BackColor

Camel case（骆驼式命名法）

标识符的第一个字母是小写字母和第一个字母后面连接的每个单词的首字母都大写。

For example:backColor

Upper case（大写命名）

标识符中的所有字母都大写。本公约只使用标识符构成的2个或更少的字母。

For example:

System.IO

System.Web.UI

你也可能利用标识符保持兼容现有的象征，托管方案，所有字符大写通常用于枚举和常数的值。一般来说，这些符号应该是不可见的外部组件使用他们的。

下表总结了大写规则，并提供不同类型的标识符的例子。

Identifier	Case	Example
Class	Pascal	AppDomain
Enum type	Pascal	ErrorLevel
Enum values	Pascal	FatalError
Event	Pascal	ValueChange
Exception class	Pascal	WebException Note Always ends with the suffix Exception.
Read-only Static field	Pascal	RedValue
Interface	Pascal	IDisposable Note Always begins with the prefix I.
Method	Pascal	ToString
Namespace	Pascal	System.Drawing
Parameter	Camel	typeName
Property	Pascal	BackColor
Protected instance field	Camel	redValue Note Rarely used. A property is preferable to using a protected instance field.
Public instance field	Pascal	RedValue Note Rarely used. A property is preferable to using a public instance field.

本文链接

MongoDB学习笔记(六) MongoDB索引用法和效率分析（转）

2011-05-05T11:29:00Z

MongoDB中的索引其实类似于关系型数据库，都是为了提高查询和排序的效率的，并且实现原理也基本一致。由于集合中的键(字段)可以是普通数据类型，也可以是子文档。MongoDB可以在各种类型的键上创建索引。下面分别讲解各种类型的索引的创建，查询，以及索引的维护等。

一、创建索引

1. 默认索引

MongoDB有个默认的“_id”的键，他相当于“主键”的角色。集合创建后系统会自动创建一个索引在“_id”键上，它是默认索引，索引名叫“_id_”，是无法被删除的。我们可以通过以下方式查看：

`1`	`var _idIndex = mongoCollection.Metadata.Indexes.Single(x => x.Key ==` `"_id_");`

`2`	`Console.WriteLine(_idIndex);`

2. 单列索引

在单个键上创建的索引就是单列索引，例如我们要在“UserInfo”集合上给“UserName”键创建一个单列索引，语法如下：（1表示正序，-1逆序）

`1`	`mongoCollection.Metadata.CreateIndex(new` `Document { {` `"UserName", 1 } },` `false);`

接着，我们用同样方法查找名为“_UserName_”的索引

`1`	`var _UserName_Index = mongoCollection.Metadata.Indexes.Single(x => x.Key ==` `"_UserName_");`

`2`	`Console.WriteLine(_UserName_Index);`

3.组合索引

另外，我们还可以同时对多个键创建组合索引。如下代码创建了按照“UserId”正序，“UserName”逆序的组合索引:

`1`	`mongoCollection.Metadata.CreateIndex(new` `Document { {` `"UserId", 1 }, {` `"UserName", -1 } },` `false);`

4.子文档索引

我们可以对文档类型的键创建各种索引，例如单列索引，如下创建用户详细信息“Detail”的单列索引：

`1`	`mongoCollection.Metadata.CreateIndex(new` `Document { {` `"Detail", 1 } },` `false);`

对子文档的键创建组合索引：例如在“Detail.Address”和“Detail.Age”上创建组合索引：

`1`	`mongoCollection.Metadata.CreateIndex(new` `Document { {` `"Detail.Address", 1 }, {` `"Detail.Age", -1 } },` `false);`

5.唯一索引

唯一索引限制了对当前键添加值时，不能添加重复的信息。值得注意的是，当文档不存在指定键时，会被认为键值是“null”，所以“null”也会被认为是重复的，所以一般被作为唯一索引的键，最好都要有键值对。

对“UserId”创建唯一索引(这时候最后一个参数为“true”)：

`1`	`mongoCollection.Metadata.CreateIndex(new` `Document { {` `"UserId", 1 } },` `true);`

二、维护索引

1. 查询索引

通过索引名查询的方式已有介绍。但有时候，我们可能忘记了索引名，怎么查询呢？

下面提供一个遍历全部索引的方法，打印全部索引信息：

`1`	`foreach` `(var index` `in` `mongoCollection.Metadata.Indexes)`

2 {

`3`	`Console.WriteLine(index.Value);`

4 }

输出结果示例：

`1`	`{` `"name":` `"_id_",` `"ns":` `"myDatabase.UserInfo",` `"key": {` `"_id": 1 } }`

`2`	`{` `"name":` `"_UserId_unique_",` `"ns":` `"myDatabase.UserInfo",` `"key": {` `"UserId": 1 },` `"unique":` `true,` `"_id":` `"4d8f406ab8a4730b78000005"` `}`

`3`	`{` `"name":` `"_UserName_",` `"ns":` `"myDatabase.UserInfo",` `"key": {` `"UserName": 1 },` `"unique":` `false,` `"_id":` `"4d8f406ab8a4730b78000006"` `}`

`4`	`{` `"name":` `"_Detail.Address_Detail.Age_",` `"ns":` `"myDatabase.UserInfo",` `"key": {` `"Detail.Address": 1,` `"Detail.Age": -1 },` `"unique":` `false,` `"_id":` `"4d8f406ab8a4730b78000007"` `}`

`5`	`{` `"name":` `"_UserId_UserName_",` `"ns":` `"myDatabase.UserInfo",` `"key": {` `"UserId": 1,` `"UserName": -1 },` `"unique":` `false,` `"_id":` `"4d8f406ab8a4730b78000008"` `}`

`6`	`{` `"name":` `"_Detail_",` `"ns":` `"myDatabase.UserInfo",` `"key": {` `"Detail": 1 },` `"unique":` `false,` `"_id":` `"4d8f406ab8a4730b78000009"` `}`

可见，集合的索引也是通过一个集合来维护的。name表示索引名，ns表示索引属于哪个库哪个集合，key表示索引在哪个键上，正序还是逆序，unique表示是否为唯一索引，等等...

2. 删除索引

新手常陷入的误区是，认为集合被删除，索引就不存在了。关系型数据库中，表被删除了，索引也不会存在。在MongoDB中不存在删除集合的说法，就算集合数据清空，索引都是还在的，要移除索引还需要手工删除。

例如，删除名为“_UserName_”的索引：

`1`	`mongoCollection.Metadata.DropIndex("_UserName_");`

下面提供删除除默认索引外其他全部索引的方法:

`01`	`public` `void` `DropAllIndex()`

02 {

`03`	`var listIndexes = mongoCollection.Metadata.Indexes.ToList();`

`04`	`for` `(int` `i = 0; i < listIndexes.Count; i++)`

05 {

`06`	`if` `(listIndexes[i].Key !=` `"_id_")`

07 {

`08`	`mongoCollection.Metadata.DropIndex(listIndexes[i].Key);`

09 }

10 }

11 }

三、索引的效率

MongoDB的索引到底能不能提高查询效率呢？我们在这里通过一个例子来测试。比较同样的数据在无索引和有索引的情况下的查询速度。

首先，我们通过这样一个方法插入10W条数据:

`01`	`public` `void` `InsertBigData()`

02 {

`03`	`var random =` `new` `Random();`

`04`	`for` `(int` `i = 1; i < 100000; i++)`

05 {

`06`	`Document doc =` `new` `Document();`

07

`08`	`doc["ID"] = i;`

`09`	`doc["Data"] =` `"data"` `+ random.Next(100000);`

10

`11`	`mongoCollection.Save(doc);`

12 }

13

`14`	`Console.WriteLine("当前有"` `+ mongoCollection.FindAll().Documents.Count() +` `"条数据");`

15 }

然后，实现一个方法用来创建索引:

`1`	`public` `void` `CreateIndexForData()`

2 {

`3`	`mongoCollection.Metadata.CreateIndex(new` `Document { {` `"Data", 1 } },` `false);`

4 }

　还有排序的方法：

`1`	`public` `void` `SortForData()`

2 {

`3`	`mongoCollection.FindAll().Sort(new` `Document { {` `"Data", 1 } });`

4 }

　运行测试代码如下:

`01`	`static` `void` `Main(string[] args)`

02 {

`03`	`IndexBLL indexBll =` `new` `IndexBLL();`

`04`	`indexBll.DropAllIndex();`

`05`	`indexBll.DeleteAll();`

`06`	`indexBll.InsertBigData();`

07

`08`	`Stopwatch watch1 =` `new` `Stopwatch();`

`09`	`watch1.Start();`

`10`	`for` `(int` `i = 0; i < 1; i++) indexBll.SortForData();`

`11`	`Console.WriteLine("无索引排序执行时间："` `+ watch1.Elapsed);`

12

`13`	`indexBll.CreateIndexForData();`

14

`15`	`Stopwatch watch2 =` `new` `Stopwatch();`

`16`	`watch2.Start();`

`17`	`for` `(int` `i = 0; i < 1; i++) indexBll.SortForData();`

`18`	`Console.WriteLine("有索引排序执行时间："` `+ watch2.Elapsed);`

19

20 }

最后执行程序查看结果：

多次测试表明在有索引的情况下，查询效率要高于无索引的效率。

原文出处：

http://www.cnblogs.com/lipan/archive/2011/03/28/1997202.html

本文链接

MongoDB学习笔记(五) MongoDB文件存取操作（转）

2011-05-05T11:27:00Z

由于MongoDB的文档结构为BJSON格式（BJSON全称：Binary JSON），而BJSON格式本身就支持保存二进制格式的数据，因此可以把文件的二进制格式的数据直接保存到MongoDB的文档结构中。但是由于一个 BJSON的最大长度不能超过4M，所以限制了单个文档中能存入的最大文件不能超过4M。为了提供对大容量文件存取的支持，samus驱动提供了 “GridFS”方式来支持，“GridFS”方式文件操作需要引入新的程序集“MongoDB.GridFS.dll”。下面我们分别用两种方式来实现。

一、在文档对象中存取文件

当文件大小较小的时候，直接存入文档对象实现起来更简洁。比如大量图片文件的存取等，一般图片文件都不会超过4M。我们先实现一个上传图片存入数据库，再取出来写回页面的例子：

1. 把图片存到BJSON中

`01`	`/// <summary>`

`02`	`/// 把图片存到BJSON中`

`03`	`/// </summary>`

`04`	`public` `void` `SaveImgBJSON(byte[] byteImg)`

05 {

`06`	`Document doc =` `new` `Document();`

`07`	`doc["ID"] = 1;`

`08`	`doc["Img"] = byteImg;`

`09`	`mongoCollection.Save(doc);`

10 }

2. 获取BJSON方式存储的图片字节数据

`1`	`/// <summary>`

`2`	`/// 获取BJSON方式存储的图片字节数据`

`3`	`/// </summary>`

`4`	`public` `byte[] GetImgBJSON()`

5 {

`6`	`Document doc= mongoCollection.FindOne(new` `Document { {` `"ID", 1 } });`

`7`	`return` `doc["Img"]` `as` `Binary;`

8 }

上面两段代码是在对MongoDB相关操作进行BLL封装类中添加的两个方法，封装方式查看上节内容。下面看看在webform中如何调用：

在界面拖出一个FileUpload控件和一个Button控件，页面cs类加如下方法：

`1`	`protected` `void` `Button1_Click(object` `sender, EventArgs e)`

2 {

`3`	`ImgBLL imgBll =` `new` `ImgBLL();`

`4`	`imgBll.DeleteAll();`

`5`	`imgBll.SaveImgBJSON(FileUpload1.FileBytes);`

`6`	`Response.BinaryWrite(imgBll.GetImgBJSON());`

7 }

二、用GridFS方式存取文件

在实现GridFS方式前我先讲讲它的原理，为什么可以存大文件。驱动首先会在当前数据库创建两个集合："fs.files" 和"fs.chunks"集合，前者记录了文件名，文件创建时间，文件类型等基本信息；后者分块存储了文件的二进制数据（并支持加密这些二进制数据）。分块的意思是把文件按照指定大小分割，然后存入多个文档中。"fs.files"怎么知道它对应的文件二进制数据在哪些块呢？那是因为在"fs.chunks"中有个"files_id"键，它对应"fs.files"的"_id"。"fs.chunks"还有一个键(int 型)"n"，它表明这些块的先后顺序。这两个集合名中的"fs"也是可以通过参数自定义的。

如果你只是想知道怎么用，可以忽略上面这段话，下面将用法：

1. GridFS方式的文件新建，读取，删除

`01`	`private` `string` `GridFsSave(byte[] byteFile)`

02 {

`03`	`string` `filename = Guid.NewGuid().ToString();`

04

`05`	`//这里GridFile构造函数有个重载，bucket参数就是用来替换那个创建集合名中默认的"fs"的。`

`06`	`GridFile gridFile =` `new` `GridFile(mongoDatabase);`

`07`	`using` `(GridFileStream gridFileStream = gridFile.Create(filename))`

08 {

`09`	`gridFileStream.Write(byteFile, 0, byteFile.Length);`

10 }

`11`	`return` `filename;`

12 }

13

`14`	`private` `byte[] GridFsRead(string` `filename)`

15 {

`16`	`GridFile gridFile =` `new` `GridFile(mongoDatabase);`

`17`	`GridFileStream gridFileStream = gridFile.OpenRead(filename);`

`18`	`byte[] bytes =` `new` `byte[gridFileStream.Length];`

`19`	`gridFileStream.Read(bytes, 0, bytes.Length);`

`20`	`return` `bytes;`

21 }

22

`23`	`private` `void` `GridFsDelete(string` `filename)`

24 {

`25`	`GridFile gridFile =` `new` `GridFile(mongoDatabase);`

`26`	`gridFile.Delete(new` `Document("filename", filename));`

27 }

2. 再次封装GridFS操作，新文档只存储文件名称，相当于只是一个键，新文档还可以有除“文件名”之外其他的键。

`01`	`/// <summary>`

`02`	`/// 把图片存到GridFS中`

`03`	`/// </summary>`

`04`	`public` `void` `SaveImgGridFS(byte[] byteImg)`

05 {

`06`	`string` `filename = GridFsSave(byteImg);`

07

`08`	`Document doc =` `new` `Document();`

`09`	`doc["ID"] = 1;`

`10`	`doc["filename"] = filename;`

`11`	`mongoCollection.Save(doc);`

12 }

13

`14`	`/// <summary>`

`15`	`/// 获取GridFS方式存储的图片`

`16`	`/// </summary>`

`17`	`public` `byte[] GetImgGridFS()`

18 {

`19`	`Document doc = mongoCollection.FindOne(new` `Document { {` `"ID", 1 } });`

`20`	`string` `filename = doc["filename"].ToString();`

`21`	`return` `GridFsRead(filename);`

22 }

三、小结

文件存取应该不是很难，值得注意的地方是：用第一种方式从文档中读出二进制数据时，一定要将类型转换为“Binary”类型；还有系统自带的键“_id”，它也不是string类型，是“Oid”类型的。

原文出处：

http://www.cnblogs.com/lipan/archive/2011/03/21/1989409.html

本文链接

MongoDB学习笔记(四) 用MongoDB的文档结构描述数据关系（转）

2011-05-05T10:58:00Z

MongoDB的集合（collection）可以看做关系型数据库的表，文档对象（document）可以看做关系型数据库的一条记录。但两者并不完全对等。表的结构是固定的，MongoDB集合并没有这个约束；另外，存入集合的文档对象甚至可以嵌入子文档，或者“子集合”。他们最终都可以用类似于BJSON的格式描述。我们今天就来分析MongoDB这一特性带来的独特数据管理方式。我们还是以samus驱动为例来分析，samus驱动支持两种方式访问数据库，基本方式和linq方式，基本方式在上篇以介绍过，linq方式我不想单独讲解应用实例，这篇我会用两种方式来对比介绍。

一、包含子文档的集合操作

有这么一个应用场景，某网站提供会员登录的功能，用户需要注册账号才能享受会员服务，但是注册者可能会因为用户资料表单输入项过大而放弃填写，因此用户信息分为主要资料和详细资料两项，初次注册只需要填写主要资料就行了。我们打算把详细信息设计为子文档存储。

1) linq方式实现

1. 新建数据描述类，描述用户信息

`01`	`/// <summary>`

`02`	`/// 用户主要资料`

`03`	`/// </summary>`

`04`	`public` `class` `UserInfo`

05 {

`06`	`public` `string` `UserId {` `get;` `set; }`

`07`	`public` `string` `UserName {` `get;` `set; }`

`08`	`public` `string` `PassWord {` `get;` `set; }`

`09`	`public` `Detail Detail {` `get;` `set; }`

10 }

11

`12`	`/// <summary>`

`13`	`/// 用户详细资料`

`14`	`/// </summary>`

`15`	`public` `class` `Detail`

16 {

`17`	`public` `string` `Address {` `get;` `set; }`

`18`	`public` `int` `Age {` `get;` `set; }`

`19`	`public` `string` `Email {` `get;` `set; }`

20 }

2. 我们要新建一个用户业务操作类“UserBLL”。这个时候要让驱动知道UserInfo类描述了“用户资料”的字段信息，在GetMongo()方法实现了配置步骤，UserBLL完整代码如下：

`01`	`public` `class` `UserBLL`

02 {

`03`	`public` `string` `connectionString =` `"mongodb://localhost";`

`04`	`public` `string` `databaseName =` `"myDatabase";`

05

`06`	`private` `Mongo mongo;`

`07`	`private` `MongoDatabase mongoDatabase;`

08

`09`	`//注意这里泛型类型为“UserInfo”`

`10`	`private` `MongoCollection<UserInfo> mongoCollection;`

11

`12`	`public` `UserBLL()`

13 {

`14`	`mongo = GetMongo();`

`15`	`mongoDatabase = mongo.GetDatabase(databaseName)` `as` `MongoDatabase;`

`16`	`mongoCollection = mongoDatabase.GetCollection<UserInfo>()` `as` `MongoCollection<UserInfo>;`

`17`	`mongo.Connect();`

18 }

`19`	`~UserBLL()`

20 {

`21`	`mongo.Disconnect();`

22 }

23

`24`	`/// <summary>`

`25`	`/// 配置Mongo,将类UserInfo映射到集合`

`26`	`/// </summary>`

`27`	`private` `Mongo GetMongo()`

28 {

`29`	`var config =` `new` `MongoConfigurationBuilder();`

`30`	`config.Mapping(mapping =>`

31 {

`32`	`mapping.DefaultProfile(profile =>`

33 {

`34`	`profile.SubClassesAre(t => t.IsSubclassOf(typeof(UserInfo)));`

35 });

`36`	`mapping.Map<UserInfo>();`

37 });

`38`	`config.ConnectionString(connectionString);`

`39`	`return` `new` `Mongo(config.BuildConfiguration());`

40 }

41 }

3. 接着，在“UserBLL”类中定义一个方法“InsertSomeData()”来插入一些数据：

show source

4. 定义一个查找数据的方法“Select”，它将查找用户详细信息中，地址在湖北的全部用户：

`1`	`/// <summary>`

`2`	`/// 查询详细资料地址为湖北的用户信息`

`3`	`/// </summary>`

`4`	`public` `List<UserInfo> Select()`

5 {

`6`	`return` `mongoCollection.Linq().Where(x => x.Detail.Address ==` `"湖北").ToList();`

7 }

5. 还定义一个删除数据的方法，将删除集合全部数据：

`1`	`/// <summary>`

`2`	`/// 删除全部用户信息`

`3`	`/// </summary>`

`4`	`public` `void` `DeleteAll()`

5 {

`6`	`mongoCollection.Remove(x =>` `true);`

7 }

6. 在Main方法中添加如下代码：

`01`	`static` `void` `Main(string[] args)`

02 {

03

`04`	`UserBLL userBll =` `new` `UserBLL();`

`05`	`userBll.InsertSomeData();`

`06`	`var users = userBll.Select();`

`07`	`foreach` `(var user` `in` `users)`

08 {

`09`	`Console.WriteLine(user.UserName +` `"是湖北人");`

10 };

`11`	`userBll.DeleteAll();`

12 }

7. 最后执行程序，打印如下信息：

李四是湖北人

赵六是湖北人

1) 普通实现

普通方式实现不想多讲，直接贴代码，看看与linq方式有什么区别：

show source

最后，我们通过这段代码输出全部用户资料信息的BJSON格式：

`01`	`/// <summary>`

`02`	`/// 打印数据BJSON`

`03`	`/// </summary>`

`04`	`public` `void` `PrintBJSON()`

05 {

`06`	`string` `BJSON =` `string.Empty;`

`07`	`foreach` `(var documet` `in` `mongoCollection.FindAll().Documents)`

08 {

09

`10`	`BJSON += documet.ToString();`

11

12 }

`13`	`Console.WriteLine(BJSON);`

14 }

结果如下：

`1`	`{` `"UserId":` `"1001",` `"UserName":` `"张三",` `"PassWord":` `"123456",` `"_id":` `"4d80ec1ab8a4731338000001"` `}`

`2`	`{` `"UserId":` `"1002",` `"UserName":` `"李四",` `"PassWord":` `"123456",` `"Detail": {` `"Address":` `"湖北",` `"Age": 20,` `"Email":` `"lisi@163.com"` `},` `"_id":` `"4d80ec1ab8a4731338000002"` `}`

`3`	`{` `"UserId":` `"1003",` `"UserName":` `"王五",` `"PassWord":` `"123456",` `"Detail": {` `"Address":` `"广东",` `"Age": 20,` `"Email":` `"wangwu@163.com"` `},` `"_id":` `"4d80ec1ab8a4731338000003"` `}`

`4`	`{` `"UserId":` `"1004",` `"UserName":` `"赵六",` `"PassWord":` `"123456",` `"Detail": {` `"Address":` `"湖北"` `},` `"_id":` `"4d80ec1ab8a4731338000004"` `}`

二、包含“子集合”的集合操作

同样举个例子：有一个学校人事管理系统要统计班级和学生的信息，现在定义了一个“班级集合”，这个集合里面的学生字段是一个“学生集合”，包含了本班全部学生。

1) linq方式实现

基础配置我就不多说了，数据类定义如下：

`01`	`/// <summary>`

`02`	`/// 班级信息`

`03`	`/// </summary>`

`04`	`public` `class` `ClassInfo`

05 {

`06`	`public` `string` `ClassName {` `get;` `set; }`

`07`	`public` `List<Student> Students {` `get;` `set; }`

08 }

09

`10`	`/// <summary>`

`11`	`/// 学生信息`

`12`	`/// </summary>`

`13`	`public` `class` `Student`

14 {

`15`	`public` `string` `Name {` `get;` `set; }`

`16`	`public` `int` `Age {` `get;` `set; }`

17 }

查询叫“张三”的学生在哪个班级，以及他的详细信息：

(这里其实是ToList后在内存中查的,linq方式直接查询好像驱动不支持。)

`1`	`public` `List<ClassInfo> Select()`

2 {

`3`	`return` `mongoCollection.Linq().ToList().Where(x => x.Students.Exists(s => s.Name ==` `"张三")).ToList();`

4 }

1) 普通实现

查询叫“张三”的学生在哪个班级，以及他的详细信息：

`1`	`public` `List<Document> Select()`

2 {

`3`	`var mongocollection = mongoDatabase.GetCollection("ClassInfo");`

`4`	`return` `mongocollection.Find(new` `Document { {` `"Students.Name",` `"张三"` `} }).Documents.ToList();`

5 }

打印数据的BJSON：

`1`	`{` `"_id":` `"4d814bae5c5f000000005f63",` `"ClassName":` `"1001",` `"Students": [ {` `"Name":` `"张三",` `"Age": 10 }, {` `"Name":` `"李四",` `"Age": 0 } ] }`

`2`	`{` `"_id":` `"4d814bae5c5f000000005f64",` `"ClassName":` `"1002",` `"Students": [ ] }`

`3`	`{` `"_id":` `"4d814bae5c5f000000005f65",` `"ClassName":` `"1003",` `"Students": [ {` `"Name":` `"王五",` `"Age": 11 }, {` `"Name":` `"赵六",` `"Age": 9 } ] }`

三、小结

通过本节例子我们发现，MongoDB有它独特的文档结构可以描述数据对象之间的一些关系特征。它虽然没有关系型数据库多表符合查询那样强大的表间查询方式，但也可以通过文档结构描述更灵活的关系特性，可以这么说，关系型数据库能做的，MongoDB基本上也可以做到。甚至有些关系数据库不容易做到的，MongoDB也可以轻松做到，比如，描述数据类的继承关系等。

原文出处：

http://www.cnblogs.com/lipan/archive/2011/03/17/1986616.html

本文链接

MongoDB学习笔记(三) 在MVC模式下通过Jqgrid表格操作MongoDB数据（转）

2011-05-05T10:51:00Z

在上一篇MongoDB学习笔记中笔者带领我们学习了如何通过samus驱动实现基本数据操作，本篇中笔者带领我们学习在MVC模式下通过Jqgrid表格操作MongoDB数据。

看到下图，是通过Jqgrid实现表格数据的基本增删查改的操作。表格数据增删改是一般企业应用系统开发的常见功能，不过不同的是这个表格数据来源是非关系型的数据库MongoDB。nosql虽然概念新颖，但是MongoDB基本应用实现起来还是比较轻松的，甚至代码比基本的ADO.net访问关系数据源还要简洁。由于其本身的“非关系”的数据存储方式，使得对象关系映射这个环节对于MongoDB来讲显得毫无意义，因此我们也不会对 MongoDB引入所谓的“ORM”框架。

下面我们将逐步讲解怎么在MVC模式下将MongoDB数据读取，并展示在前台Jqgrid表格上。这个“简易系统”的基本设计思想是这样的：我们在视图层展示表格，Jqgrid相关Js逻辑全部放在一个Js文件中，控制层实现了“增删查改”四个业务，MongoDB的基本数据访问放在了模型层实现。下面我们一步步实现。

一、实现视图层Jqgrid表格逻辑

首先，我们新建一个MVC空白项目，添加好jQuery、jQueryUI、Jqgrid的前端框架代码：

然后在Views的Home文件夹下新建视图“Index.aspx”，在视图的body标签中添加如下HTML代码：

<div>
<table id="table1">
</table>
<div id="div1">
</div>
</div>

接着新建Scripts\Home文件夹，在该目录新建“Index.js”文件，并再视图中引用，代码如下：

jQuery(document).ready(function () {
//jqGrid初始化
jQuery("#table1").jqGrid({
url: '/Home/UserList',
datatype: 'json',
mtype: 'POST',
colNames: ['登录名', '姓名', '年龄', '手机号', '邮箱地址', '操作'],
colModel: [
{ name: 'UserId', index: 'UserId', width: 180, editable: true },
{ name: 'UserName', index: 'UserName', width: 200, editable: true },
{ name: 'Age', index: 'Age', width: 150, editable: true },
{ name: 'Tel', index: 'Tel', width: 150, editable: true },
{ name: 'Email', index: 'Email', width: 150, editable: true },
{ name: 'Edit', index: 'Edit', width: 150, editable: false, align: 'center' }
],
pager: '#div1',
postData: {},
rowNum: 5,
rowList: [5, 10, 20],
sortable: true,
caption: '用户信息管理',
hidegrid: false,
rownumbers: true,
viewrecords: true
}).navGrid('#div1', { edit: false, add: false, del: false })
.navButtonAdd('#div1', {
caption: "编辑",
buttonicon: "ui-icon-add",
onClickButton: function () {
var id = $("#table1").getGridParam("selrow");
if (id == null) {
alert("请选择行！");
return;
}
if (id == "newId") return;
$("#table1").editRow(id);
$("#table1").find("#" + id + "_UserId").attr("readonly","readOnly");
$("#table1").setCell(id, "Edit", "<input id='Button1' type='button' value='提交' onclick='Update(\"" + id + "\")' /><input id='Button2' type='button' value='取消' onclick='Cancel(\"" + id + "\")' />");
}
}).navButtonAdd('#div1', {
caption: "删除",
buttonicon: "ui-icon-del",
onClickButton: function () {
var id = $("#table1").getGridParam("selrow");
if (id == null) {
alert("请选择行！");
return;
}
Delete(id);
}
}).navButtonAdd('#div1', {
caption: "新增",
buttonicon: "ui-icon-add",
onClickButton: function () {
$("#table1").addRowData("newId", -1);
$("#table1").editRow("newId");
$("#table1").setCell("newId", "Edit", "<input id='Button1' type='button' value='提交' onclick='Add()' /><input id='Button2' type='button' value='取消' onclick='Cancel(\"newId\")' />");
}
});
});
//取消编辑状态
function Cancel(id) {
if (id == "newId") $("#table1").delRowData("newId");
else $("#table1").restoreRow(id);
}
//向后台ajax请求新增数据
function Add() {
var UserId = $("#table1").find("#newId" + "_UserId").val();
var UserName = $("#table1").find("#newId" + "_UserName").val();
var Age = $("#table1").find("#newId" + "_Age").val();
var Tel = $("#table1").find("#newId" + "_Tel").val();
var Email = $("#table1").find("#newId" + "_Email").val();
$.ajax({
type: "POST",
url: "/Home/Add",
data: "UserId=" + UserId + "&UserName=" + UserName + "&Age=" + Age + "&Tel=" + Tel + "&Email=" + Email,
success: function (msg) {
alert("新增数据: " + msg);
$("#table1").trigger("reloadGrid");
}
});
}
//向后台ajax请求更新数据
function Update(id) {
var UserId = $("#table1").find("#" + id + "_UserId").val();
var UserName = $("#table1").find("#" + id + "_UserName").val();
var Age = $("#table1").find("#" + id + "_Age").val();
var Tel = $("#table1").find("#" + id + "_Tel").val();
var Email = $("#table1").find("#" + id + "_Email").val();
$.ajax({
type: "POST",
url: "/Home/Update",
data: "UserId=" + UserId + "&UserName=" + UserName + "&Age=" + Age + "&Tel=" + Tel + "&Email=" + Email,
success: function (msg) {
alert("修改数据: " + msg);
$("#table1").trigger("reloadGrid");
}
});
}
//向后台ajax请求删除数据
function Delete(id) {
var UserId = $("#table1").getCell(id, "UserId");
$.ajax({
type: "POST",
url: "/Home/Delete",
data: "UserId=" + UserId,
success: function (msg) {
alert("删除数据: " + msg);
$("#table1").trigger("reloadGrid");
}
});
}

二、实现控制层业务

在Controllers目录下新建控制器“HomeController.cs”，Index.js中产生了四个ajax请求，对应控制层也有四个业务方法。HomeController代码如下：

public class HomeController : Controller
{
UserModel userModel = new UserModel();
public ActionResult Index()
{
return View();
}
/// <summary>
/// 获取全部用户列表，通过json将数据提供给jqGrid
/// </summary>
public JsonResult UserList(string sord, string sidx, string rows, string page)
{
var list = userModel.FindAll();
int i = 0;
var query = from u in list
select new
{
id = i++,
cell = new string[]{
u["UserId"].ToString(),
u["UserName"].ToString(),
u["Age"].ToString(),
u["Tel"].ToString(),
u["Email"].ToString(),
"-"
}
};
var data = new
{
total = query.Count() / Convert.ToInt32(rows) + 1,
page = Convert.ToInt32(page),
records = query.Count(),
rows = query.Skip(Convert.ToInt32(rows) * (Convert.ToInt32(page) - 1)).Take(Convert.ToInt32(rows))
};
return Json(data, JsonRequestBehavior.AllowGet);
}
/// <summary>
/// 响应Js的“Add”ajax请求，执行添加用户操作
/// </summary>
public ContentResult Add(string UserId, string UserName, int Age, string Tel, string Email)
{
Document doc = new Document();
doc["UserId"] = UserId;
doc["UserName"] = UserName;
doc["Age"] = Age;
doc["Tel"] = Tel;
doc["Email"] = Email;
try
{
userModel.Add(doc);
return Content("添加成功");
}
catch
{
return Content("添加失败");
}
}
/// <summary>
/// 响应Js的“Delete”ajax请求，执行删除用户操作
/// </summary>
public ContentResult Delete(string UserId)
{
try
{
userModel.Delete(UserId);
return Content("删除成功");
}
catch
{
return Content("删除失败");
}
}
/// <summary>
/// 响应Js的“Update”ajax请求，执行更新用户操作
/// </summary>
public ContentResult Update(string UserId, string UserName, int Age, string Tel, string Email)
{
Document doc = new Document();
doc["UserId"] = UserId;
doc["UserName"] = UserName;
doc["Age"] = Age;
doc["Tel"] = Tel;
doc["Email"] = Email;
try
{
userModel.Update(doc);
return Content("修改成功");
}
catch
{
return Content("修改失败");
}
}
}

三、实现模型层数据访问

最后，我们在Models新建一个Home文件夹，添加模型“UserModel.cs”，实现MongoDB数据库访问代码如下：

public class UserModel
{
//链接字符串(此处三个字段值根据需要可为读配置文件)
public string connectionString = "mongodb://localhost";
//数据库名
public string databaseName = "myDatabase";
//集合名
public string collectionName = "userCollection";
private Mongo mongo;
private MongoDatabase mongoDatabase;
private MongoCollection<Document> mongoCollection;
public UserModel()
{
mongo = new Mongo(connectionString);
mongoDatabase = mongo.GetDatabase(databaseName) as MongoDatabase;
mongoCollection = mongoDatabase.GetCollection<Document>(collectionName) as MongoCollection<Document>;
mongo.Connect();
}
~UserModel()
{
mongo.Disconnect();
}
/// <summary>
/// 增加一条用户记录
/// </summary>
/// <param name="doc"></param>
public void Add(Document doc)
{
mongoCollection.Insert(doc);
}
/// <summary>
/// 删除一条用户记录
/// </summary>
public void Delete(string UserId)
{
mongoCollection.Remove(new Document { { "UserId", UserId } });
}
/// <summary>
/// 更新一条用户记录
/// </summary>
/// <param name="doc"></param>
public void Update(Document doc)
{
mongoCollection.FindAndModify(doc, new Document { { "UserId", doc["UserId"].ToString() } });
}
/// <summary>
/// 查找所有用户记录
/// </summary>
/// <returns></returns>
public IEnumerable<Document> FindAll()
{
return mongoCollection.FindAll().Documents;
}
}

四、小结
代码下载：http://files.cnblogs.com/lipan/MongoDB_003.rar

自此为止一个简单MongoDB表格数据操作的功能就实现完毕了，相信读者在看完这篇文章后，差不多都可以轻松实现MongoDB项目的开发应用了。聪明的你一定会比本文做的功能更完善，更好。下篇计划讲解linq的方式访问数据集合。

原文出处：http://www.cnblogs.com/lipan/archive/2011/03/11/1980227.html

本文链接

MongoDB学习笔记(二) 通过samus驱动实现基本数据操作（转）

2011-05-05T10:47:00Z

上一期笔者为我们做了MongoDB的介绍并且介绍了MongoDB的安装方法，这一期我们将继续跟随笔者学习通过samus驱动实现基本数据操作。

传统的关系数据库一般由数据库（database）、表（table）、记录（record）三个层次概念组成，MongoDB是由（database）、集合（collection）、文档对象（document）三个层次组成。MongoDB对于关系型数据库里的表，但是集合中没有列、行和关系概念，这体现了模式自由的特点。

一、关于MongoDB的驱动

MongoDB支持多种语言的驱动，在此我们只介绍C#的驱动。仅C#驱动都有很多种，每种驱动的形式大致相同，但是细节各有千秋，因此代码不能通用。比较常用的是官方驱动和samus驱动。samus驱动除了支持一般形式的操作之外，还支持linq方式操纵数据。各人比较喜欢这种方式。

官方驱动下载地址：https://github.com/mongodb/mongo-csharp-driver/downloads

samus驱动下载地址：https://github.com/samus/mongodb-csharp

本篇将从samus驱动入手讲解数据库访问，国际惯例，存取“Hello World!”。

二、通过samus驱动实现HelloWorld存取

在进行下述操作之前，请先确定MongoDB服务已经开启，不知道怎么开启服务，请看上篇。下载驱动，新建控制台项目，并添加对MongoDB.dll的引用，如果你下载的是驱动源码，编译一遍引用生成的DLL即可。

基本代码如下：

//链接字符串
string connectionString = "mongodb://localhost";
//数据库名
string databaseName = "myDatabase";
//集合名
string collectionName = "myCollection";
//定义Mongo服务
Mongo mongo = new Mongo(connectionString);
//获取databaseName对应的数据库，不存在则自动创建
MongoDatabase mongoDatabase = mongo.GetDatabase(databaseName) as MongoDatabase;
//获取collectionName对应的集合，不存在则自动创建
MongoCollection<Document> mongoCollection = mongoDatabase.GetCollection<Document>(collectionName) as MongoCollection<Document>;
//链接数据库
mongo.Connect();
try
{
//定义一个文档对象，存入两个键值对
Document doc = new Document();
doc["ID"] = 1;
doc["Msg"] = "Hello World!";
//将这个文档对象插入集合
mongoCollection.Insert(doc);
//在集合中查找键值对为ID=1的文档对象
Document docFind = mongoCollection.FindOne(new Document { { "ID", 1 } });
//输出查找到的文档对象中键“Msg”对应的值，并输出
Console.WriteLine(Convert.ToString(docFind["Msg"]));
}
finally
{
//关闭链接
mongo.Disconnect();
}

运行程序，成功打印helloword。同时，我们打开数据文件夹，发现多了两个文件“myDatabase.ns”和“myDatabase.0”。

三、小结

代码下载：http://files.cnblogs.com/lipan/MongoDB_001.rar

本篇简洁的讲解了基本存取操作，下篇将结合MVC框架通过MongoDB实现model层单个集合的基本增删查改操作

原文出处：http://www.cnblogs.com/lipan/archive/2011/03/08/1977691.html

本文链接

MongoDB学习笔记（一）MongoDB介绍及安装(转)

2011-05-05T10:40:00Z

这是MongoDB的系列学习笔记的第一篇，主要介绍什么是非关系型数据库MongoDB，如何下载，去哪儿下载，又该怎么正确的安装等一系列问题。

一、前言

最近开始学习非关系型数据库MongoDB，却在博客园上找不到比较系统的教程，很多资料都要去查阅英文网站，效率比较低下。本人不才，借着自学的机会把心得体会都记录下来，方便感兴趣的童鞋分享讨论。部分资源出自其他博客，旨将零散知识点集中到一起，如果有侵犯您的权利，请联系li- pan2@163.com。大部分内容均系原创，欢迎大家转载分享，但转载的同时别忘了注明作者和原文链接哦。

二、MongoDB简介

MongoDB是一个高性能，开源，无模式的文档型数据库，是当前NoSql数据库中比较热门的一种。它在许多场景下可用于替代传统的关系型数据库或键/值存储方式。Mongo使用C++开发。Mongo的官方网站地址是：http://www.mongodb.org/，读者可以在此获得更详细的信息。

小插曲：什么是NoSql？

NoSql，全称是 Not Only Sql,指的是非关系型的数据库。下一代数据库主要解决几个要点：非关系型的、分布式的、开源的、水平可扩展的。原始的目的是为了大规模web应用，这场运动开始于2009年初，通常特性应用如：模式自由、支持简易复制、简单的API、最终的一致性（非ACID）、大容量数据等。NoSQL被我们用得最多的当数key-value存储，当然还有其他的文档型的、列存储、图型数据库、xml数据库等。

特点:

高性能、易部署、易使用，存储数据非常方便。主要功能特性有：
面向集合存储，易存储对象类型的数据。
模式自由。
支持动态查询。
支持完全索引，包含内部对象。
支持查询。
支持复制和故障恢复。
使用高效的二进制数据存储，包括大型对象（如视频等）。
自动处理碎片，以支持云计算层次的扩展性
支持Python，PHP，Ruby，Java，C，C#，Javascript，Perl及C++语言的驱动程序，社区中也提供了对Erlang及.NET等平台的驱动程序。
文件存储格式为BSON（一种JSON的扩展）。
可通过网络访问。

功能:

面向集合的存储：适合存储对象及JSON形式的数据。
动态查询：Mongo支持丰富的查询表达式。查询指令使用JSON形式的标记，可轻易查询文档中内嵌的对象及数组。
完整的索引支持：包括文档内嵌对象及数组。Mongo的查询优化器会分析查询表达式，并生成一个高效的查询计划。
查询监视：Mongo包含一个监视工具用于分析数据库操作的性能。
复制及自动故障转移：Mongo数据库支持服务器之间的数据复制，支持主-从模式及服务器之间的相互复制。复制的主要目标是提供冗余及自动故障转移。
高效的传统存储方式：支持二进制数据及大型对象（如照片或图片）
自动分片以支持云级别的伸缩性：自动分片功能支持水平的数据库集群，可动态添加额外的机器。

适用场合:

网站数据：Mongo非常适合实时的插入，更新与查询，并具备网站实时数据存储所需的复制及高度伸缩性。
缓存：由于性能很高，Mongo也适合作为信息基础设施的缓存层。在系统重启之后，由Mongo搭建的持久化缓存层可以避免下层的数据源过载。
大尺寸，低价值的数据：使用传统的关系型数据库存储一些数据时可能会比较昂贵，在此之前，很多时候程序员往往会选择传统的文件进行存储。
高伸缩性的场景：Mongo非常适合由数十或数百台服务器组成的数据库。Mongo的路线图中已经包含对MapReduce引擎的内置支持。
用于对象及JSON数据的存储：Mongo的BSON数据格式非常适合文档化格式的存储及查询。

三、下载安装和配置

安装Mongo数据库：

在发布本文的时间官方提供的最新版本是：1.6.5 ，如果不做特殊声明，本教程所用的版本将会是这个版本。

第一步：下载安装包：如果是win系统，注意是64位还是32位版本的，请选择正确的版本。
第二步：新建目录“D:\MongoDB”，解压下载到的安装包，找到bin目录下面全部.exe文件，拷贝到刚创建的目录下。
第三步：在“D:\MongoDB”目录下新建“data”文件夹，它将会作为数据存放的根文件夹。

注：官方下载地址：http://www.mongodb.org/downloads

配置Mongo服务端：

打开CMD窗口，按照如下方式输入命令：
> d:
> cd D:\MongoDB
> mongod --dbpath D:\MongoDB\data

配置成功后会看到如下画面：

在浏览器输入：http://localhost:27017/，可以看到如下提示：
You are trying to access MongoDB on the native driver port. For http diagnostic access, add 1000 to the port number

如此，MongoDB数据库服务已经成功启动了。

为方便启动数据库，也可以安装windows服务
1.创建logs/mongodb.log文件
2.D:\MongoDB>mongod --logpath d:/MongoDB/logs/mongodb.log --logappend --dbpath d:\MongoDB\data --directoryperdb --install

说明：
指定日志文件及输出方式（追加）：--logpath d:/MongoDB/logs/mongodb.log --logappend
指定数据文件目录：--dbpath d:\MongoDB\data
指定每个DB新建一个目录：--directoryperdb

安装参数：--install，相对应的是：--remove

启动服务：net start MongoDB
停止服务:net stop MongoDB

四、后记

现在我们已经初步实现了MongoDB的安装和服务的启动工作。后面我们还有很多的工作，要使MongoDB能在我们的C#代码中被操作，还需要驱动，经常有朋友在网上copy代码后发现编译不通过，那估计是驱动不一致的问题了，下篇文章会详细讲解，未完待续。。

原文出处：http://www.cnblogs.com/lipan/archive/2011/03/08/1966463.html

本文链接

博客园_心有多远 就能走多远～～

UML 依赖 关联 聚合 组合

亲属称谓

以字节流上传文件

C#命名规范(微软官方版)

MongoDB学习笔记(六) MongoDB索引用法和效率分析（转）

MongoDB学习笔记(五) MongoDB文件存取操作（转）

MongoDB学习笔记(四) 用MongoDB的文档结构描述数据关系（转）

MongoDB学习笔记(三) 在MVC模式下通过Jqgrid表格操作MongoDB数据（转）

MongoDB学习笔记(二) 通过samus驱动实现基本数据操作（转）

MongoDB学习笔记（一）MongoDB介绍及安装(转)

博客园_心有多远就能走多远～～

UML 依赖关联聚合组合