博客园_Dreampuf

驳HTML+CSS+JS就是MVC组合

2011-03-01T10:39:00Z

今天看到某位童鞋的笔记,提出了一个HTML + CSS + JS就是一个MVC 的观点,大意就是由HTML提供数据模型,CSS负责视图显示,JS来总管逻辑控制,列举了将一部分HTML写在JS中到用时还是需要copy CSS十分不便捷,还附带一句"前端不像后台那样能够一门语言吃天下",笔者不敢苟同,拿出一些看法供君判断一二.

第一:
   后端没有一语言定天下.相比前端的多浏览器.后端还是非常多的领域语言必须掌握,多个平台的区别(不是浏览器),语言上T-SQL访问数据库,shell管理服务器,而多个业务平台交互更是交融反复(笔者常使用的Python调用C模块只是一个小例子,为什么XML曾经被寄以众望. Web Service不正是为了解决这种跨平台的工具么)
第二:
   HTML绝不仅仅只是Model.还有多的视图成分在里面.HTML在很长的一段时间里都被人诟病,因为包含的内容太多,CSS,JS,图片甚至Flash,Java app…不能不说混杂.即便如今html5也改变不了他的视图身份,这里要注意:浏览器是解析HTML来生成页面的,而不是CSS,HTML由于包含太多,所以不能仅仅作为模型存在.
   前端也不一定非要往MVC里硬套.而且MVC本身存在很多问题,诸如结构不灵活,衔接不紧密等等.所以又会有MVP,MVVP等多个拓展模式.需要注意的一点,MVC提供给我们最基础的是一种分层思想,而不是固定不变的视图模型和控制器.
   比HTML+CSS+JS更MVC的应该是XML+XSL+XPATH,这套组合才是完全的MVC.CSDN就是使用的这套.
第三:
   将部分功能独立出来时,犹豫HTML本身包含太多,所以还是会碰到又要copy CSS, JS之类的.

我曾经也碰到过,那时我的解决方法是全部动态加载,使用JS.益处是完全作为了一个独立的模块,引入js就可以了,弊处就是所有修改都在JS总以字符串的形式修改,没有IDE的辅助略显麻烦,但是他们(HTML,CSS,JS)谁又不是能任意编辑的字符呢?

本文链接

django 阅读笔记 - Cache

2011-02-20T07:13:00Z

作者:	dreampuf
日期:	2011-02-18 23:22:50

1 简介
2 Cache
- 2.1 BaseCache
- 2.2 DataBaseCache
- 2.3 DummyCache
- 2.4 FileBaseCache
- 2.5 LocamemCache
- 2.6 MemcachedCache

1 简介

记录了个人在需要时阅读django源码时的一些阅读笔记.所有笔记基于 django v1.0.4.

2 Cache

2.1 BaseCache

django中缓存是一个独立的组件,它定义了一个父类,文件在 django/core/cache/backend/base.py 这个模块包含了一个父类 BaseCache ,指定了一些基础的操作.

__init__ :初始化指定了缓存项的过期时间,但是根据具体实现的不同会有不同的解释. (比如在数据库实现中就是删除数据项)
add :添加缓存,参数分别为键, 值, 过期时间 (默认是300秒).这个方法由子类实现.
get :获取缓存,参数为键 , 默认值 (默认为None).
set :改变缓存,参数同 add 函数.
delete :删除缓存,参数为键.
get_many :获取多个缓存, 参数为 键列表.
has_key :是否存在键, 参数为键.
__contains__ :判断是否存在的函数, 参数为键.结果与 has_key 一致.

2.2 DataBaseCache

基于数据库的缓存.模块文件在 django/core/cache/backend/db.py 这个文件包含了一个继承BaseCache的数据库缓存实现. 他还指定了数据库最多存多少缓存项.
其中值得注意的几点是:

使用pickle序列化对象.所以存储任何对象都是可以的,最后都会被转化为数据库支持的字符串.
过期时间是以秒为单位.
每次 set 都会处理序列化,哪怕本身存储的就是字符串.这显然不太合算.
构造缓存管理对象的时候可以指定一个 cull_frequency 参数，作为超过最大项时删除的参考,默认是 3,也就是说每当超过容量限制时,删除1/3的缓存数据项.奇怪的是,这里是根据 cache_key 的大小删除,而不是根据过期时间,这样就可能导致 时效非常久的缓存被提早就给删除 了.
每次获取时进行过期处理,也就是说可能有一些项永远都会存在数据库中.(过期后,自身cache_key非常大,极少有被删除的可能)

2.3 DummyCache

测试使用的缓存.模块文件在 django/core/cache/backend/dummy.py.这个缓存功能相当有限,仅仅只能被用于测试.而且本身无任何逻辑,只是返回一些默认值.

2.4 FileBaseCache

基于文件的缓存.模块文件在 django/core/cache/backend/filebase.py.这个文件系统缓存,实现了基于每个缓存对象一个文件的对应.只是在处理多文件管理时,使用了一些必要的方法.

构造时传递的第一个为路径地址.
add 方法如果添加已存在的键时不会成功,这和我们寻常的逻辑有点不符,如果还需要调用 add 那么肯定是想指定值,所以如果添加一些已有键,势必会添加一次判断.
每次 set 是都会进行一次目录遍历,搜索所有文件,看是否超过总数.
文件名的生成是对 cache_key 进行一次md5,然后取加密后的字符两个前两位作为一个二级目录存放(比如: ab/cd/*****),这样是为了目录下的文件过多时索引文件非常慢而导致效率很低的问题.但是结合构造函数时接受的最大缓存项来看,默认的 300 根本无法构成对文件索引拖慢的威胁.而 FileBaseCache默认就使用二级目录预估的至少可以存储 1000*1000 项缓存数据(假设缓存文件平均分布).是否是因该有所优化的在构造时加上一个判断,只有在一定数量级之后才启用二级目录,或者增加一个一级目录管理,再或者默认不设目录.

2.5 LocamemCache

基于内存的缓存,模块文件在 django/core/cache/backend/locamem.py.实现了简单的内存缓存系统.
实现了带锁的内存缓存系统,不过有些瑕疵,好像是为了保证整体统一,不过这种统一难免让人诟病.

构造时内部声明了两个字典,一个存放序列化之后的缓存值,一个存放设置好了的过期时间,并且额外声明了一个异步锁.不过据我所知 Python 的多线程简直就是在自慰, GIL 使然,你根本无法放开手脚,虽然值得解释器环境更加安全稳定,但是这种 伪多线程 很难让人提起兴趣.
在添加缓存时,获取缓存时,依然不辞幸苦给缓存值进行了序列化.作为的 dict 可能唯一的感受就是嫉妒羡慕恨.
在超出缓存最大值之后, LocamemCache 将会删除所有与 _cull_frequency 取模为0的值.仅仅是为了使用生成器表达式?!如果 _cull_frequency 为0时,则清空缓存库.但是当 _cull_frequency 为1时,同样会有清空缓存库的效果.

2.6 MemcachedCache

基于memcached的缓存系统,模块文件在 django/core/cache/backend/memcached.py.简单的对cmemcache或者memcache的封装.
这下django终于机灵了,没有在这里序列化了,因为这些动作会在memcache库中操作.

所有传入的 unicode字符 被转换为 utf-8,从缓存中获取的字符串则被转换为 unicode字符.
如果在 set 或者 add 方法中指定过期时间为 0 不过期有可能是无效的,因为 MemcachedCache 在处理默认过期时间时采用了一个 逻辑或 处理,所以导致如果指定为 0 被逻辑操作为 传递默认值.
他有一个额外的关闭连接方法(close),默认是不会自己调用的,需要在每次使用之后手动调用.

本文链接

脚本不脚本

2011-01-14T04:12:00Z

最近在看Python,可惜前有古人,后面也想必会有一堆来者,难免不和以前喜爱的JavaScript,C#比较一番.于是遂有此篇.各位看官,您只管一眼扫去,切莫往心里去,我不能误这个子弟.

"Lambda"

这里说的Lambda统指一切能够作为"参数传递的'函数'".这里函数还打了一对单引号,因为C#对应的是Delegate原因.

JavaScript: 无法让人释怀的First Class type. 弱类型, First Class对象,正如引用里的链接回答的:"能够从函数中返回,能够传递给函数,能够在运行时构造".而JavaScript相较Python的就是拥有多行执行,相对来说容量比较"大", 缺点也不是没有, 引用对象的绑定依据环境而变化,不过这也是脚本环境的通病哈,这时就需要构造一个闭包环境来帮助我们帮定相应的引用对象. 当然还有一个是关键字冗余,写多了难免觉得有些多余.

var divs = $("div");
for(var i = divs.length; i > 0; i--) {
    divs[i].click(function(){
        alert(divs[i]); //also alert(this)
    }
}

Python: 相对来说只能执行一行代码,自动返回,不需要return关键字.

C#: C# 1.0给出的方案是delegate ,让delegate作为函数的包装,在方法中传递. 随后C# 2.0的匿名函数就已经很相似了, C# 3.0给出了满意的答案,一个"=>"进一步简化了delegate关键字冗余,而且随之而来的匿名类型,Linq将生产力推向一个高峰.

Functional Programming

注意,这里所指"函数编程"不是在讨如如何在这三门语言里进行"函数化"代码的编写,而是记录一些三门语言对于函数式编程提供的一些类库,辅助函数等软环境.老赵的引文编程语言的发展趋势及未来方向（3）：函数式编程大家可以前去看看. 函数式编程相对于命令式编程,命令式处理只要包含几个分支判断,循环处理,重在如何解决问题. 而函数式则不同,重在解决什么问题.

JavaScript: 提供了强大的元编程能力, 无论是first class的function,还是函数对象的toString方法,都为函数式编程提供了基础,而函数式编程则又带来了诸多优点.二者日相彰益.不过一些基础设施明显不足,没有提供一个良好的可枚举对象方案,对集合对象的操作倍感乏力.

Array.prototype.map = function(func) {
    for(var i = this.length; i > 0; i--) {
        func(this[i]);
    }
}

Python: 完美的函数式编程,无论是map, zip 等等各种内置函数,还是各类可枚举类型, 元编程等等都是更胜一酬. 不过代码方面强制缩进作为程序是否正确的标准, 代码好看了,程序却显得有些古板, 不个性(恩恩,个性)

import sys, operator

a = range(5)
map(lambda x: sys.stdout.write(x), a)
reduce(operator.add, a)

C#: 不提1.0,2.0. C# 3.0 有点老树新开, 加入F# 后,C#的函数化跟着也上升好几个档次, 相较于前两者的弱类型脚本语言,强类型的C#肯向脚本化靠拢,而且提供了一个不错的脚本化环境. LINQ 为C# 对集合的操作提供了强大的增益(相对于1.0, 2.0).

模式

我们都知道设计模式为我们要解决的问题提供了成熟的解决方案,模式已经或多或少的成为了我们开发的必需品.

JavaScript: JavaScript的原型链不就是职责链的完美实现么.

Python: yield 实现了枚举器,各个可枚举对象同样都是如此,装饰器, 模块实现了单例, 继承方式又有点像原型链(__metaclass__属性).设计模式可谓在Python中发挥的淋漓尽致.

C#: Event 实现了监听者模式, IEnumerable 枚举对象...

在语言的层次上是否需要这么多的"模式"作为标准还没有定论,不过可以明确的是越来越多内置的"模式"为我们的开发极大的带来了便捷,这也是各位能够感同身受的.

好了,各位看官,我将三门语言从三个语言的角度谈了一点自己的想法,这三个角度不全面,相反,还有些片面,不过,这里是我个人给出的一个答案,而且还不是标准的.您肯定还有一些不吐不快的,能不能拿出来一块分享呢?

注:这里只是比较语言的区别,并没有优劣,他们各有千秋,python和C#不会跑到客户端去代替JS,C#和python互相也没什么好代替的.所以,在这里声明一下.

本文链接

JavaScript服务端编程现状

2010-10-18T03:33:00Z

除了枯燥的看看题解,做做题外,偶尔还做做实例,放松放松心情.前段时间也摆弄过Google Engine App(下简称GEA),以前依次在上面部署过Python,Java的应用,不过还真没怎么做真正的开发,一来环境不熟悉,二来功底不够.忽闻AppengineJS发布马上部署了一个,欣喜若狂的打算做个JavaScript(下简称JS)应用,不过静下心来,发现很多问题.

为什么不做JavaScript服务端开发

没有合适的JavaScript Runtime(JSR ?)
现在JS之所以能够流行,很大程度上取决于浏览器的普及.浏览网页的时候需要计算一道简单的四则混合运算,你会怎么做?心算?打开计算器然后点几个按钮?我的方法是在浏览器地址栏输入"javascrit:alert(1+2+4*5);".很方便不是么.
但是服务端的情况就不容乐观,除了少数几个解析器能够勉强运行单薄的JS语法,似乎很难让他在服务端大展拳脚.V8?嗯,确实很快,不过还只是个跑在客户端的小伙子.Node.js?嗯,的确提出了很多特性,不过就拿这些特性想征服服务端的开发还是不容乐观.RingoJS?JVM的庞大,让JS无法灵巧的伸展.IronJS?无案例,无图,无真相.
没有成熟的类库
   你愿意在一片荒芜的土地上开荒,还是在肥沃的农田挥锄?
   JS在客户端确实意气风发,jQuery,Prototype,YUI,Ext,Dojo等等.无数的框架,为我们的网页动态化提出了解决方案之道.在这百家争鸣的日子里,众多特性,理念,被提出来,链式操作,函数式编程....一片繁华.
   反观JS在服务端的表现,集合操作停留在增删改,没有filter,没有order.字符串只能拼接,没有格式化.文件读写就一个CommonJS标准.数据交互的确得益于JSON的流行,很方便,但是数据存储似乎又回到了ASP/VBScript时代.
标准
就像客户端浏览器对JS的支持参差不齐,服务端对于CommonJS标准也是有待加强.所幸服务端JS没有跨"浏览器"之忧.
效率
开发效率顶呱呱的JS在服务端由于缺少类库的支持,使得服务端开发相比现存的几个平台(JVM,.NetFX),慢了不止几个档次.客户端就备受诟病的执行效率放到服务端仍旧是一个不可忽视的问题.

为什么要看好JavaScript服务端开发

灵巧
没人否认JS本身强大的灵活性,强大的自解析,原型链和弱类型衍生出的种样繁多的开发方式.实在是让人爱不释手.
普及
JSON确实有XML不可比拟的潜质,体积瘦小,方便传输.众多语言中都有支持.客户端无需插件就能原生解析.还有什么比这更棒的么?
活跃的社区
一个篱笆三个桩,一个好汉三个帮.活跃的JS社区不会甘心JS止步与客户端,必然会向服务端虎视眈眈.

AppengineJS使用一段时间后有感而发.

原文地址: http://www.macgoo.com/myblog/archives/166/

本文链接

两个按钮,提高阅读效率

2010-08-28T19:33:00Z

大多数人都是如何使用网络?您在邮件,QQ,Twitter,Facebook等等程序里在新的标签里打开他们带来的连接.

然后,等到某个闲暇的时间,阅读这些打开的标签,对不对?更甚,某些文章有8页长,让您不得不提前打开几个页面来加载他.然后也许在您的浏览器崩溃或者系统重启的时候才想起来,你为什么要打开他.

这是不理智的,我拒绝使用这种方式浏览网站,下面是我的做法.

考虑下面的新的流程,看过之后,您将会决定是现在阅读他,还是以后再阅读.

首先,决定阅读先后

当您发现您要阅读的东西很长时,即便您确定您需要阅读他,但您就是没有时间了,不要打开一个标签.将他保存到Instapaper中去,在我所有的电脑上的所有浏览器里都有一个Instapaper书签,这很重要.

如果没有他,您将会退回到原始的使用浏览器标签保存将要阅读的文章连接的不好习惯.用10分钟去适应它.即使在GoogleReader中,您也可以使用它.此后的任何时间里,只要您需要,您就可以从Instapaper阅读列表里找到他,即刻打开开始阅读.

例子:

比如,我看到Phil Haack的某条消息,他能说会道,消息很有趣,我决定阅读他,但是我现在很忙.

我在书签栏里单击"Read Later",接下来会出现提示.

此后的几个小时里,我忙完了,有空闲时间了,并且我已经收集了一些有趣的阅读连接,我很期待阅读这些有意思的东东,于是我打开Instapaper,看看这个:

这里就是我保存的阅读连接,第一次的时候都还是新的,它知道我阅读了些什么,以及什么时候保存的,什么时候阅读的.

这里有一个值得注意的地方,当我打开其中的连接时,Instapapers为我设置了一个可读性过滤器,他删除了页面的一些不必要的部分,还在顶部增加了一个小工具栏,可以设置字体,大小,宽度和行距等等.这里的一切都是为了我的阅读,这使得我阅读更加舒适了.

当然,我也可以从Iphone中阅读,当然,其他设备也行,都是同样的一个阅读列表.

然后,开始阅读 - 可读性

有时候我会有想阅读某个页面的想法,但是页面复杂得就像迷宫一样,让我无法流畅阅读.

好在,我的工具栏里还有一个叫做"Readability"的书签.

就在这里

就像顾城所说"黑夜给了我黑色的眼睛,我却用它来寻找光明".就像这原来黑乎乎的插满广告的页面,被清洗成了一张简单明了的白底黑字页面,给我黑色,我却用来换成白色.但是这样子看上去,不是更舒服吗?

我这里有一些关于这两个标签的介绍, Instapaper for Reading Later 和 Readability for Reading Now ,不仅仅使得我花更少的时间获取更多信息,而且也是我远离了那可怕的43个标签.

转译自:http://www.hanselman.com/blog/TwoMustHaveToolsForAMoreReadableWeb.aspx 其中柔和了个人感觉.

本文链接

eWindow项目总结

2010-08-10T15:25:00Z

这本该是半年以前该做的事了.

这个项目前前后后折腾了近半年.在项目开始的时候,我在弄一个比赛,在那比赛的时候挺2的,没能夺魁.回来后项目也进行了近一个月.可丝毫没有进展的样子.还只是模模糊糊的画出了数据库设计.

项目分为三组,开始定好每组五人,结果因为童鞋们兴趣挺浓,就每组多了一人.整整十八个人,花了半年时间,就折腾出这么个东西,也只想到欲哭无泪这个词儿来形容了. 项目一开始我也是满心欢喜的参加,由于参加比赛的原因,不能一开始带领大家,于是组长的位置放给了另外一名童鞋.比赛结束之后,因为我个人的一些主张,以及从事风格和他大相径庭,最后是不欢而散,他退出了.他也是一个学习成绩不错的孩子,只可惜还停留在填鸭式的教学上去学习编程.每天完成老师布置的任务,几道哄小孩的题上面,然后看电影,玩游戏荒废光阴.这是题外话了.总之各组之内也出现了人员的调整,这一个小调整就为后面项目的进行造成了不小的阻力.

项目的进度,十月份开始项目,我十一月过半比完赛参加,中间断断续续的,因为都是鼓捣.Net的,而需求方要求使用J2EE,然后是一些框架的堆砌,Struts2+Hibernate3,这里没有用到Spring,需求方也没提,可能是出于降低项目难度的原因吧,因为依赖倒置之类的抽象理念对于为什么还要使用类都没琢磨透的童鞋们老说是有那么一点儿不可及.十一月十二月做需求,放寒假的时候还额外留了童鞋们半个多月,半个月前项目都没出来,半个月后都已经定型了,可以说主要的进度都是在这半个月里面出来的.之后来年三月四月修补BUG,最后交稿.

   项目中的问题:
   1.环境问题,说实话,我现在在Eclipse(MyEclipse)下写代码还是有那么些力不从心,各式各样的插件,遍布到处的报错,让人纠结的代码提示(是的,我是被VS惯坏了的孩子),奇怪的调试方式.种种种种的不适.首先是要去找各式各样的插件,而且这些插件由于是开源社区在维护,质量参差不齐,而且由于是在Windows环境下,表现得很是蛋疼.比如说Eclipse下的SVN插件,我已经忘记他的名字了,但是永远都忘不了新接触他的那几天,也让我见识了Xunix下的百家齐放,这个插件可能需要依赖那个插件,而那个插件可能也需要依赖那个.如此往复.版本控制在那时是块心病,就怕哪次更新代码之后错误不断,又要重新来过.不过在几次失败的提交之后导致项目重建,大家都学乖了,要先更新,再提交.这也是一个沟通问题,这点稍后再讲.

   2.态度问题.在项目结束的时候,还有童鞋对HTTP上的交互搞得云里雾里,还对于Session望而生畏.这些在某些培训机构几乎是只教其形而根本不教其意的东西,在他们来说会其形都有困难.打个小差,我在组中也过足了当老师的瘾,因为可以将自己当了十五年学生的经验反馈在我的教学上,好不过瘾,以前看不惯老师的某些手段,在我这里就得意充分更正.对于Session这些我通常是从HTTP无状态的这个设计着手,然后切开,继续深入,最后到为什么需要Session这个东西,在浏览器差异中也从当年的浏览器大战着手,讲的我自己都炮沫横飞,不过却过足了老师的瘾,要是老师们都能有我这样饱汉深情的讲下去何愁朽木不可雕呢?不过后面想想也是,一个老师通常要带两个甚至三个班,教育产业化,将一个东西讲重复一遍两边有可能三遍,而且一年一个循环,谁能受得了,也只有那些园丁们了.这个差有点远了,我们言归正传.在项目中,有很多自以为是的问题,这也许就是程序员们的根病吧.但是倘若没有了这股干劲,又怎样才能从无中生有,作出一个几万行的软件呢?在项目进行时,用了一些管理手段,比如一天一结,然后又是展望,当然计划无限好(其实还有很多其他模仿着大牛们的例子,但都难以奏效,往往是东施效颦,落得个吃饱了没事干的评价),只是领导有些小.这些规定对于童鞋们很难有实施的机会,往往他说好了今天完成的任务,其中有些自身无法估计问题大小的原因,还有确实编码能力不够的原因(我已经把模版代码写好了,这下您也懂了,他们是如何"编码"了的吧),可是一周之后可能问题依然没进展,最流行的词儿是"基本上没问题了","快可以了","只差几个小模块(小函数)就可以了".唉,我觉得这都能让爱吹的南郭先生笑掉大牙了.

3.项目起因问题,因为这是一个教学案例项目,这个项目的根本目的不是在于项目是否能成,而且项目本身也只是用于申报国家们的一些"计划",项目只是让童鞋们学习的,我这里就有些急功近利了,老是觉得自己不该为这样的项目编码那么多,说到底是个心里问题,不过念到自己又通过这个项目掌握了这么多,也不好说些什么,只能是说鱼与熊掌不可兼得吧,可我总觉得如果我把半年时间花在其他的地方上面可能就不是如今这样的了,话说回来谁又没有个"要是当年"呢.项目没有一个好的老师指导,整个进度也就凭我们几个说话没份量的童鞋约束.总而言之,言而总之.这就是一出没谱的戏儿,拿来给戏子们作秀的试验品.

4.贪大喜新.这是我们这组的问题,在前端页面上先独自用上了ExtJS.虽然使用的时候坎坎坷坷,但的出来的效果却是大受好评,而且引得另一组前来学习,不过因为框架学习难度的原因,导致基本上就我们组两个人会用,其他童鞋只能干看着,话说项目开始的时候还是ExtJS3.0,到结束的时候发现更新到了3.1了,直接换框架发现不行,不能兼容,尝试新东西总是要付出代价的.使用ExtJS作为后端表现后,唯独第三组(我们是一组,二组后来也换这个框架了,因为界面问题,始终让人头疼)不愿意更改原来的代码,这里又有一个沟通问题,待会再说.所以导致界面风格迥异,在我们这组的时候可能是标准的ExtJS组件,一旦跳转到三组的页面时,可能就是朴素的HTML了.

5.沟通问题.这也是最根本的问题,如果说依靠我们几个组能写代码的人,加上近半年的时间,而且项目也不是很大,如果沟通良好的话,绝对不是问题.一组擅长前台脚本,二组擅长文档,三组擅长后端编码.这不是配好了的三个桩么.可惜事与愿违.在前面定数据库的时候,我们都能为一个字段的存在与否争个面红耳赤,在后来为了一个接口的问题还差点儿罢了工,只能说年轻气盛,没地方发泄啊.互相也是彼此看不起彼此,觉得自己的观点和主见才是正确的.我记得最好笑的是,三组的童鞋把一些验证,以及数据之间关系的绑定都写在了一个Action里,我就指出这有悖分层,表现的逻辑都没分开,实体数据如果不是Hibernate帮忙分离下场可能是JDBC直接写到了Action中.三组的童鞋却一口咬定"这是面向领域编程,和面向对象编程不同".我当时不懂什么叫"面向领域",我就说"我不懂什么叫领域,但总不该把这些基本的操作写到页面上去吧."他却一口咬定.我只能作罢.要是如今碰到,肯定骂他个狗血淋头,"领域你妹啊,那只是一个开发模式,你妹的都把这些八杆子打不着一起的对象写在一起,以后改死你丫的.做三十年代码工人,而且次次项目都重头来过没沉淀.".唉,年轻气盛.

故事的最后,项目流产了,需求方发现同时操作的项目太多,无暇兼顾,所以就没了下文,我手抖着把项目用QQ邮箱发过去的时候,确实是勾了"回信短信通知"的.可能是没通知到吧.哎哟喔.....

最后是有图有真相.

首页

用户订单管理

登录界面

本文链接

EntityFramework v1 .Net3.5 Sp1 动态查询过滤检索所遇到的问题

2010-07-23T05:07:00Z

最近在封装EntityFramework的时候碰到许多问题,下面就做一个简短的笔记.

泛型推断

例如Save<T>(T o)这样的方法是没有问题的,但是如果参数再包裹一层泛型就不行了,Save<T>(IEnumerable<T> o),所以只能在方法体类判断是否实现了IEnumerable<T>接口,然后分情况处理.关于更多C#3.0中的泛型推断.大体上就是说C#编译器只能推断出明确的一种类型,而不能同时包含多种,比如上面的Save<T>(IEnumerable<T> o)则编译器无法得知参数的具体类型,就需要指定类型.

拓展方法的访问级别

基本上就是一个外部的类,除非在同一程序集里并设定被拓展对象为internal访问级别才能访问,否则protected都访问不到.

封装EntityFremawork操作

这里主要讲讲查询,一般来说Find方法的签名如下

public override List<T> Find<T>(int start, int len = 10, IWhereItem<T> whereitem = null, IOrderItem<T> orders = null, bool isDetach = true)

起始元素,页长度,过滤语句,排序语句,最后一个是EntityFramework独有,是否与上下文对象解绑.
在构造ObjectQuery时就需要获得EF的映射关系,用System.Data.Metadata.Edm读取映射信息就可以了,这里我就直接将代码贴出来了.接受一个EntityContainer就可以不断的读取信息了,本身继承一个见到那的缓存类,实际上就是对字典的一个简单封装.

    public class EdmInfo
    {
        public EntitySetBase EntitySetBase { get; set; }
        public string TableName { get; set; }
        public string TypeName { get; set; }
        public string KeyName { get; set; }
    }
    public class EdmInfoManager : SimpleCache<Type, EdmInfo>
    {
        public EntityContainer RootContainer { get; private set; }
        public EdmInfoManager(EntityContainer ec)
        {
            RootContainer = ec;
        }
        public new EdmInfo this[Type T]
        {
            get
            {
                if(!ContainsKey(T))
                {
                    EdmInfo edm = new EdmInfo();
                    edm.EntitySetBase = typeToEntitySetBase(T);
                    edm.TableName = edm.EntitySetBase.Name;
                    edm.TypeName = T.Name;
                    edm.KeyName = entitySetBaseToKeyName(edm.EntitySetBase);
                    base[T] = edm;
                    return edm;
                }
                return base[T];
            }
            set
            {
                base[T] = value;
            }
        }
        private EntitySetBase typeToEntitySetBase(Type t)
        {
            return RootContainer.BaseEntitySets
                       .Where(bes => bes.ElementType.Name == t.Name)
                       .FirstOrDefault();
        }
        private string entitySetBaseToKeyName(EntitySetBase es)
        {
            return es.ElementType.KeyMembers[0].Name;
        }
    }

     然后就是排序项,由于项目有一些lambda表达式风格的排序,以及普通属性字符串似的排序,所以又做了一个简单封装,IOrderItem<T>结构下有两个实现StringOrderItem与ExpressionOrderItem.主要是StringOrderItem,因为最后都将排序信息保存为字符串了,所以只能以字符串形式排序,这就为后面造成了一些人为的障碍.
     过滤项就是封装了一下Expression<Func<T, bool>>,不过提供从字符串构造的方法.最后都是Lambda表达式的形式存储.
     最后检索的时候就碰到问题了,ObjectQuery.Where(Expression<Func<T, bool>> exp)是一个拓展方法,返回的不是ObjectQuery,导致了后面无法使用OrderBy(String orderstring).只能使用OrderBy的拓展方法Lambda表达式形式.卡壳了很久,找了一些资料.其中不乏微软的EF拓展库.有个拓展方法能够强制转换为ObjectQuery在链式操作中,但是在我这里一旦强转后面的操作都报错,大概是只支持EFv4吧.

能否将IWhereItem里的Lambda表达式转为ESQL语句呢?.试着重写一个ExpressionVisitor可惜没功夫没到家,表达式的资料到是找到了不少.就是没写出来.

表达式的各种构造 : http://rednaxelafx.javaeye.com/blog/247270

LinqToSQL : 一种Linq到TSQL语句的转换,地址忘记了,代码在此

在stackoverflow的提问 : http://stackoverflow.com/questions/3305224/problems-with-entity-framework-queries

就想把Order转为Lambda表达式形式,但是如何泛型如何设置呢?Expression<Func<T, object>>在面对Expression<Func<T, int>>时会自动有个转换过程,详见Lambda传参自动包装.所以无法直接使用Expression<Func<T, object>>类型传递,在动态构造Linq过滤,排序时发现了一个解决方法,使用IOrderedQueryable包装过滤项,继续搜索,终于找到了使用泛型反射出类型,然后动态构造Lambda表达式(且指定类型)的解决方法了.

private static IOrderedEnumerable<T> SortEngine<T>(this IEnumerable<T> source, string columnName, bool isAscending, bool started)
{
    var item = Expression.Parameter(typeof(T), "item");
    var propertyValue = Expression.PropertyOrField(item, columnName);
    var propertyLambda = Expression.Lambda(propertyValue, item);
    // item => item.{columnName}

    var sourceExpression = Expression.Parameter(typeof(IEnumerable<T>), "source");

    string methodName;
    Expression inputExpression;
    if (started)
    {
        methodName = isAscending ? "ThenBy" : "ThenByDescending";
        inputExpression = Expression.Convert(sourceExpression, typeof(IOrderedEnumerable<T>));
        // ThenBy requires input to be IOrderedEnumerable<T>
    }
    else
    {
        methodName = isAscending ? "OrderBy" : "OrderByDescending";
        inputExpression = sourceExpression;
    }

    var sortTypeParameters = new Type[] { typeof(T), propertyValue.Type };
    var sortExpression = Expression.Call(typeof(Enumerable), methodName, sortTypeParameters, inputExpression, propertyLambda);
    var sortLambda = Expression.Lambda<Func<IEnumerable<T>, IOrderedEnumerable<T>>>(sortExpression, sourceExpression);
    // source => Enumerable.OrderBy<T, TKey>(source, item => item.{columnName})

    return sortLambda.Compile()(source);
}

public static IOrderedEnumerable<T> OrderBy<T>(this IEnumerable<T> source, string columnName)
{
    return SortEngine(source, columnName, true, false);
}

public static IOrderedEnumerable<T> OrderByDescending<T>(this IEnumerable<T> source, string columnName)
{
    return SortEngine(source, columnName, false, false);
}

public static IOrderedEnumerable<T> ThenBy<T>(this IOrderedEnumerable<T> source, string columnName)
{
    return SortEngine(source, columnName, true, true);
}

public static IOrderedEnumerable<T> ThenByDescending<T>(this IOrderedEnumerable<T> source, string columnName)
{
    return SortEngine(source, columnName, false, true);
}

最后Find方法全貌

        public override List<T> Find<T>(int start, int len = 10, IWhereItem<T> whereitem = null, IOrderItem<T> orders = null, bool isDetach = true)
        {
            var context = getInstence();
            var edminfo = EdmMgr[typeof (T)];
            ObjectQuery<T> query = context.CreateQuery<T>("[" + edminfo.TableName + "]");
            query = MemerVisitor.IncludeMembers.Aggregate(query, (current, str) => current.Include(str));
            orders = orders ?? OrderItemFactry.Get<T>(edminfo.KeyName, true);
            List<T> result;

            result = whereitem == null || whereitem.Body == null
                         ? start == -1
                               ? query.Skip(orders.OrderString, "0").ToList()
                               : query.Skip(orders.OrderString, start.ToString()).Take(len).ToList()
                         : start == -1
                               ? query.Skip(orders.OrderString, "0").Where(whereitem.Body).ToList()
                               : query.Skip(orders.OrderString, "0").Where(whereitem.Body).OrderBy(orders.Property).Skip(start).Take(len).ToList();

            if (isDetach && MemerVisitor.IncludeMembers.Count == 0)
                result.ForEach(x =>
                                   {
                                       try
                                       {
                                           context.Detach(x);
                                       }
                                       catch (InvalidOperationException)
                                       {
                                       }
                                   });
            MemerVisitor.IncludeMembers.Clear();
            return result;
        }

本文链接

在 Asp.net MVC 2 中解决页面提交数据并发问题

2010-07-15T15:41:00Z

通过本篇,你能了解到 Asp.net MVC 模型绑定处理过程,一种解决并发颗粒度到一条数据的方法.

* 如何解决互联网中某条数据的并发问题
    在一个页面提交数据库前把从数据库取出的数据和提交时数据库中的数据比较,不同则给出提示.
    在和其他童鞋的讨论中,都明确的指出了采用HashCode的方案,HashCode作为区分对象不同的一种方案,确实可行,但也有反对的声音.采用HashCode难免会涉及到对于实体对象的HashCode生成的问题,而实体对象的Hash又是根据自身属性生成,而属性又包含了其他关系,这种连带作用十分可观,也想过采用对于所有值属性采用Hash生成,对于关系对象着获取ID后再生成,但表数量也不少,如果考虑反射则每次提交都要遍历所有属性,性能客观,这还仅仅只是一次修改呢,折腾再三有了这样的方法.
    在每张表中加入一个新的DateTime字段,每次修改赋最新值.
    对,就是这么简单,每次读取时获得DateTime对象,返回到客户端页面,提交时再和数据库中对象比较.DateTime对象精确到毫秒,这种程度已经足够应付需求中所定义的并发.

通过Ticks构造的DateTime对象

*如何在Asp.net MVC中使用DateTime对象作为验证数据是否已过期依据

Asp.net MVC 的模型肩负着承载数据的责任.同时又很容易配置,使用.下面这张图介绍了Asp.net MVC如何处理实体对象模型的(截自Pro Asp.net MVC 2 Framework.

模型作为.net对象传递给视图后经过渲染后,呈现在HTML中.这就是回应客户端响应的流程.

同样的,作为客户端,以单纯的字符串是无法直接在.net中使用的,又需要进行模型绑定.才能转换为.net对象,继而使用他.

知道了整个模型的整个流程后,我们有了几个对策,思考再三决定传递DateTime对象的Ticks作为依据,因为直接输出DateTime最多也就精确到秒,不能和数据库中的原始数据DateTime匹配.所以获得其Ticks,作为字符串传输,然后返回的时候再解析.有了解决思路后就好做了.

这是我们的模型,注意其中的HashTime可空属性. 注意他标上了一个UIHint Attribute,能够绑定指定的用户控件,继而单独的渲染该属性.

1     public partial class ModelSimpleChangeUser : IHashTime
2     {
3         [HiddenInput]
4         [DisplayName("用户编号")]
5         [Required]
6         public int UserId { get; set; }
7
8         [Required(ErrorMessage="名称必须不为空")]
9         [DisplayName("用户名")]
10         [DataType(System.ComponentModel.DataAnnotations.DataType.Text)]
11         public string UserName { get; set; }
12         [Required(ErrorMessage="Email必须存在")]
13         [DisplayName("电子邮件")]
14         [DataType(System.ComponentModel.DataAnnotations.DataType.EmailAddress)]
15         public string Email { get; set; }
16
17         [HiddenInput(DisplayValue = false)]
18         [UIHint("HiddenDateTime")]
19         [Required(ErrorMessage="HashTime必须存在")]
20         public DateTime? HashTime { get; set; }
21
22
23
24         public ModelSimpleChangeUser() { }
25         public ModelSimpleChangeUser(ES.DAL.User u)
26         {
27             this.UserId = u.UserId;
28             this.Email = u.Email;
29             this.HashTime = u.HashTime;
30             this.UserName = u.UserName;
31         }
32
33         public ES.DAL.User ChangeTo(ES.DAL.User user)
34         {
35             if(UserId == user.UserId && user.HashTime.HasValue)
36             {
37                 user.UserName = UserName;
38                 user.Email = Email;
39             }
40             return user;
41         }
42     }

整个编辑视图也就一行起作用的代码.之所以能够这样是因为Asp.net MVC 2强大的模型特性标记功能,他能够在模型中声明如何显示,这就使得视图和模型完全分离,在视图里我都没有内联ViewPage的泛型类.使得页面可以编写完全独立的效果,而不必纠缠于和模型属性配对的问题中.

<%= Html.EditorForModel() %>

在HiddenDateTime控件实现了一个简单的从当前实体模型对象读取Ticks的功能,由于是可空DateTime,所以处理了为null情况(标记字段在测试的时候有些是Null,所以这里给处理了一下,如果在真实的环境中这是不存在的,因为在建立和修改时都已经自动赋值了)

1 <%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl<DateTime?>" %>
2
3 <%
4 Dictionary<string, object> others = new Dictionary<string, object>();
5 //others.Add("Oth", "ccc");
6 %>
7 <%= Html.Hidden("", Model.HasValue ? Model.Value.Ticks : -1, others)%>

效果如下:

然后是绑定从客户端发来的数据问题.在这个点上费了很久,后来还是在书上找到了解决办法.
首先要知道Asp.net MVC是从那些地方以怎样的顺序获取了数据,下面是获取的顺序.

1. Request.Form
2. RouteData.Values
3. Request.QueryString
4. Request.Files
5. null

前台输出的是DateTime的Ticks而不是默认的DateTime输出,所以还需要自己解析下.这里有一段ValueProviderFactroy的代码是截自书中的,在Global.asax的Appcation_Start事件注册后,就能截获所有参数的传递了.

1         protected void Application_Start()
2         {
3             AreaRegistration.RegisterAllAreas();
4
5             RegisterRoutes(RouteTable.Routes);
6
7             ValueProviderFactories.Factories.Insert(0, new ES.WEB.Models.HiddentTimeValueProviderFactory());
8         }

下面是那个解析工厂

    public class HiddentTimeValueProviderFactory : ValueProviderFactory
    {
        public override IValueProvider GetValueProvider(ControllerContext ctx)
        {
            return new HiddentTimeValueProvider(ctx.HttpContext.Request);
        }

        private class HiddentTimeValueProvider : IValueProvider
        {
            private HttpRequestBase request;
            public HiddentTimeValueProvider(HttpRequestBase Request)
            {
                request = Request;
            }

            public bool ContainsPrefix(string prefix)
            {
                return "HashTime".Equals(prefix, StringComparison.OrdinalIgnoreCase);
            }

            public ValueProviderResult GetValue(string key)
            {
                var result = ContainsPrefix(key)
                  ? new ValueProviderResult(new DateTime(long.Parse(request["HashTime"])), null, CultureInfo.CurrentCulture)
                  : null;
                return result;
            }
        }
    }

自此我们的代码已经完全可以跑起来了,在控制器里对传过来的数据直接分析,看Ticks是否相等就能判断有并发情况了.当然在返回错误的视图中我们也做了一些改善用户体验的处理.

下面是我们的控制器:

1         public ActionResult Edit(Models.ModelSimpleChangeUser users)
2         {
3             return DoSafe(() =>
4                 {
5                     var u = UserManager.FindById(users.UserId);
6                     if (u.HashTime != null)
7                         if(users.HashTime != null &&
8                            users.HashTime.Value.Ticks == u.HashTime.Value.Ticks)
9                         {
10                             u.UserName = users.UserName;
11                             u.Email = users.Email;
12                             UserManager.Update(u);
13                             return RedirectToAction("Index") as ActionResult;
14                         }
15                     ViewData["lastAction"] = "Edit";
16                     ViewData["lastController"] = "User";
17                     return View(RetiredPage, users);
18                 });
19         }

注意15,16行,他将当前处理的Controller和Action的名称都保存了起来,以备在视图中使用,同样将用户输入的数据返回了出去.

下面是视图页面:

1 <asp:Content ID="RetiredMain" ContentPlaceHolderID="MainContent" runat="server">
2
3     <h2>对不起,您访问的页面已过期!</h2>
4     <p>
5         您所操作的原始数据可能被更改,请您返回获取最新数据.
6     </p>
7     <%= Html.ActionLink("返回",
8                         ViewData[BaseController.LastAction].ToString(),
9                         ViewData[BaseController.LastController].ToString(),
10                         Model, new { id = "PostBackLink"}) %>
11     <script type="text/javascript">
12         setTimeout(function () {
13             var g = document.getElementById("PostBackLink");
14             try { g.click(); } catch (ex) { }
15         }, 2000);
16     </script>
17 </asp:Content>

用HtmlHelper生成了一个超链接,使用了我们之前保存的控制器数据,从而得知是在哪里引发了错误,并且还保存了用户输入的数据模型,最后给这个超链接赋值了一个id属性,供我们在客户端脚本上使用.

在客户端脚本里我们触发了一个延迟脚本,两秒后触发返回超链接的click事件,由于在FireFox下没有该对象,所以只是简单的容错了一下,还有更多FireFox下的超链接的脚本触发请移步JavaScript模拟用户单击事件.

整个过程还是相当简单的,不过条条大路通罗马,不一定都要坐技术含量高的飞机嘛.
前些天分享了一个封装了EntityFramework的操作的类,这里又拓展了他,将HashTime自动写入,这里就没考虑泛型,因为数据的读写实在太频繁了,就将所有实体继承一个IHashTime接口,接口只有一个HashTime属性,然后封装了一个方法,在每次数据创建或者改写的时候调用.从而整个并发问题迎刃而解.

1 private void setHashTime(object o)
2         {
3             (o as IHashTime).HashTime = DateTime.Now;
4         }

本文链接

一个基于EntityFramework的DAO (反射出架构信息并应用在CRUD中)

2010-07-08T15:03:00Z

满是坎坷的完成了这个DAO,间或断了几次,对MSDN欲求不满,还好Google在.

在VS中生成了映射文件,以及实体类后,简单配置一下就可以使用了,请各位指点迷津,这样写法是否妥当,千万别把这个类拿去搞生产,否则后果自负,作者不承担任何后果.

我们知道,一般的项目都是分了几层,而其中少不了对于数据持久化的管理,也就是数据访问层,在被Hibernate的配置淹没后,被DbEntry.net(国产推荐!)的总总不适后又投向了M$自己的EntityFramework,但是也不能直接拿来用,万一以后又要转向其他数据源,那改动就真的是欲哭无泪了.所以免不了对其封装一番.好在C#是一门相当灵活的语言,通过反射,我们可以进行对程序自己的解析.下面我就将我对EF简单封装后的一个DAO以及一些体会和大家分享,经验不足难免有误人子弟的嫌疑,欢迎各位指正.

如何获得实体类的映射信息
在EF映射信息生成后编译,然后在使用项目中引用,反射得到映射资源,一般是个目录下,怎样得知映射文件名?在EF连接字符串中可以获得.在metadata节点可获得.
metadata=res://*/School.csdl|res://*/School.ssdl|res://*/School.msl;
如何读取映射信息
    通过XML操作可以获得,不过在这里我碰到了个问题,就是有名称空间的节点以及属性该如何访问,试了几次,以为Xpath没写对,结果参照XPathVisualizer(一个开源项目,用于验证Xpath)显示结果是正确的,后来在其源码中找到了读取有名称空间的节点以及属性的方法,大致思路就是获得所有名称空间并在检索xpath时提供这些名称空间.
1         private XmlNamespaceManager getAllNamespace(XmlDocument doc)
2         {
3             XmlNamespaceManager xnm = new XmlNamespaceManager(doc.NameTable);
4             XPathNavigator nav = doc.CreateNavigator();
5             XPathNodeIterator list = nav.Select("//namespace::*[name() != 'xml'][not(http://www.cnblogs.com/namespace::*=.)]");
6             Dictionary<string, string> xmlNamespaces = new Dictionary<string, string>();
7             int c = 1;
8             while (list.MoveNext())
9             {
10                 XPathNavigator nsNode = list.Current;
11                 if (nsNode.NodeType == XPathNodeType.Namespace)
12                 {
13                     string ns = nsNode.Value;
14                     if (!xmlNamespaces.Values.Contains(ns))
15                     {
16                         // get the prefix - it's either empty or not
17                         string origPrefix = nsNode.LocalName;
18
19                         // make sure the prefix is unique
20                         int dupes = 0;
21                         string actualPrefix = origPrefix;
22                         while (actualPrefix == "" || xmlNamespaces.Keys.Contains(actualPrefix))
23                         {
24                             actualPrefix = (origPrefix == "")
25                                 ? String.Format("ns{0}", c++)
26                                 : String.Format("{0}-{1}", origPrefix, dupes++);
27                         }
28                         xnm.AddNamespace(actualPrefix, ns);
29                         xmlNamespaces.Add(actualPrefix, ns);
30                     }
31
32                 }
33             }
34             return xnm;
35         }
"it"别名
在EF构造SQL语句的时候,使用的是"it"作为默认别名,所以在进行SQL操作的时候记得要加上"it."作为前缀.
读取出数据后记得移除读取对象与ObjectContext的联系
仅仅只是toList返回对象后还要为每个对象Detach,解除绑定才能进行一些后续操作,否则无法再次访问数据库(当然,除非是在同一个ObjectContext下)
修改
修改的时候如果不是同一ObjectContext读取的,那么还需要使用该上下文来读取出对象,否者会报错.详细的讨论:http://social.msdn.microsoft.com/Forums/en-SG/adodotnetentityframework/thread/501d7b99-0cb9-44b6-b2cd-16275a151b31

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5
  6 using System.Configuration;
  7 using System.Data.Objects;
  8 using System.Data.EntityClient;
  9 using System.Xml;
10 using System.Xml.XPath;
11 namespace ES.DAL
12 {
13     public class DataService<T>
14         where T : System.Data.Objects.DataClasses.EntityObject
15     {
16         private static Type contextType;
17         private static XmlDocument doc;
18         private static string entityContainer;
19
20         private string tableName;
21         private string keyName;
22         private Dictionary<string, Type> propertype;
23
24         static DataService()
25         {
26             contextType = Type.GetType(ConfigurationManager.ConnectionStrings[DataService.EFObjectContext].ConnectionString);
27
28             EntityConnectionStringBuilder scsb = new EntityConnectionStringBuilder(ConfigurationManager.ConnectionStrings[DataService.ConnectionString].ConnectionString);
29             string str = scsb.Metadata.Split('|').Single(x => x.EndsWith(".csdl"));
30             var ls = contextType.Assembly.GetManifestResourceStream(str.Substring(str.LastIndexOf('/') + 1));
31             using (System.IO.StreamReader reader = new System.IO.StreamReader(ls))
32             {
33                 string csdlData = reader.ReadToEnd();
34                 doc = new XmlDocument();
35                 doc.LoadXml(csdlData);
36             }
37         }
38
39         private ObjectContext getInstence()
40         {
41             return (ObjectContext)Activator.CreateInstance(contextType);
42         }
43
44         private XmlNamespaceManager getAllNamespace(XmlDocument doc)
45         {
46             XmlNamespaceManager xnm = new XmlNamespaceManager(doc.NameTable);
47             XPathNavigator nav = doc.CreateNavigator();
48             XPathNodeIterator list = nav.Select("//namespace::*[name() != 'xml'][not(http://www.cnblogs.com/namespace::*=.)]");
49             Dictionary<string, string> xmlNamespaces = new Dictionary<string, string>();
50             int c = 1;
51             while (list.MoveNext())
52             {
53                 XPathNavigator nsNode = list.Current;
54                 if (nsNode.NodeType == XPathNodeType.Namespace)
55                 {
56                     string ns = nsNode.Value;
57                     if (!xmlNamespaces.Values.Contains(ns))
58                     {
59                         // get the prefix - it's either empty or not
60                         string origPrefix = nsNode.LocalName;
61
62                         // make sure the prefix is unique
63                         int dupes = 0;
64                         string actualPrefix = origPrefix;
65                         while (actualPrefix == "" || xmlNamespaces.Keys.Contains(actualPrefix))
66                         {
67                             actualPrefix = (origPrefix == "")
68                                 ? String.Format("ns{0}", c++)
69                                 : String.Format("{0}-{1}", origPrefix, dupes++);
70                         }
71                         xnm.AddNamespace(actualPrefix, ns);
72                         xmlNamespaces.Add(actualPrefix, ns);
73                     }
74
75                 }
76             }
77             return xnm;
78         }
79         public DataService()
80         {
81             tableName = typeof(T).Name;
82             XmlNamespaceManager xnm = getAllNamespace(doc);
83             entityContainer = doc.SelectSingleNode(".//ns1:EntityContainer", xnm).Attributes["Name"].Value;
84             var cur = doc.SelectSingleNode("//ns1:EntityType[@Name=\"" + tableName + "\"]", xnm);
85             XmlNodeList pros = cur.SelectNodes(".//ns1:Property", xnm);
86             propertype = new Dictionary<string, Type>();
87             for (int i = 0; i < pros.Count; i++)
88             {
89                 XmlNode node = pros[i];
90
91                 //System.Collections.IEnumerator itor = node.Attributes.GetEnumerator();
92                 //while (itor.MoveNext())
93                 //{
94                 //    XmlAttribute a = (XmlAttribute)itor.Current;
95
96                 //}
97
98                 if (node.Attributes["StoreGeneratedPattern", xnm.LookupNamespace("annotation")] != null)
99                     keyName = node.Attributes["Name"].Value;
100                 propertype.Add(node.Attributes["Name"].Value, Type.GetType(node.Attributes["Type"].Value));
101             }
102         }
103         /// <summary>
104         /// 执行Linq表达式返回List
105         /// </summary>
106         /// <param name="linq">接受一个QbjectQuery,返回IEnumerable的表达式</param>
107         /// <returns>List</returns>
108         public List<T> Linq(Func<ObjectQuery<T>, IEnumerable<T>> linq)
109         {
110             using(var context = getInstence())
111             {
112                 return linq(context.CreateQuery<T>("[" + tableName + "]")).ToList<T>();
113             }
114         }
115         public List<T1> Linq<T1>(Func<ObjectQuery<T>, IEnumerable<T1>> linq)
116         {
117             using (var context = getInstence())
118             {
119                 return linq(context.CreateQuery<T>("[" + tableName + "]")).ToList<T1>();
120             }
121         }
122
123         public T FindById(object keyValue)
124         {
125             var key = new System.Data.EntityKey(entityContainer + "." + tableName, keyName, keyValue);
126             using (var context = getInstence())
127             {
128                 T result = (T)context.GetObjectByKey(key);
129                 context.Detach(result);
130                 return result;
131             }
132         }
133
134         public List<T> Find()
135         {
136             return Find(0, -1, x => true, keyName, false);
137         }
138         public List<T> Find(Func<T, bool> wherecase)
139         {
140             return Find(0, -1, wherecase, keyName, false);
141         }
142         public List<T> Find(Func<T, bool> wherecase, bool isdescending)
143         {
144             return Find(0, -1, wherecase, keyName, isdescending);
145         }
146         public List<T> Find(int start, int len)
147         {
148             return Find(start, len, null, keyName, false);
149         }
150         public List<T> Find(int start, int len, Func<T, bool> wherecase)
151         {
152             return Find(start, len, wherecase, keyName, false);
153         }
154         public List<T> Find(int start, int len, Func<T, bool> wherecase, string orderKey)
155         {
156             return Find(start, len, wherecase, orderKey, false);
157         }
158         public List<T> Find(int start, int len, Func<T, bool> wherecase, string orderKey, bool isdescending)
159         {
160             using (var context = getInstence())
161             {
162                 ObjectQuery<T> query = context.CreateQuery<T>("[" + tableName + "]").OrderBy(orderKey);
163                 orderKey = orderKey.StartsWith("it.") ? orderKey : "it." + orderKey;
164                 IEnumerable<T> result;
165                 if (wherecase != null)
166                     result = query.Where(wherecase);
167                 else
168                     result = query.AsEnumerable();
169                 result = result.Skip(start);
170                 result = len == -1 ?
171                         isdescending ?
172                             result.Reverse()
173                             :
174                             result
175                         :
176                         isdescending ?
177                             result.Take(len).Reverse()
178                             :
179                             result.Take(len);
180                 List<T> list = result.ToList();
181                 list.ForEach(x => context.Detach(x));
182                 return list;
183             }
184         }
185
186         public void Save(T o)
187         {
188             using (var context = getInstence())
189             {
190                 context.AddObject(tableName, o);
191                 context.SaveChanges();
192             }
193         }
194         public void Save(IEnumerable<T> listo)
195         {
196             using (var context = getInstence())
197             {
198                 foreach (T i in listo)
199                 {
200                     context.AddObject(tableName, i);
201                 }
202                 context.SaveChanges();
203             }
204         }
205         public void Update(T o)
206         {
207             using (var context = getInstence())
208             {
209                 //fix
210                 //http://social.msdn.microsoft.com/Forums/en-SG/adodotnetentityframework/thread/501d7b99-0cb9-44b6-b2cd-16275a151b31
211                 object original = context.GetObjectByKey(o.EntityKey);
212                 context.ApplyPropertyChanges(tableName, o);
213                 context.SaveChanges();
214             }
215         }
216         public void Update(IEnumerable<T> listo)
217         {
218             using (var context = getInstence())
219             {
220                 foreach (T o in listo)
221                 {
222                     object original = context.GetObjectByKey(o.EntityKey);
223                     context.ApplyPropertyChanges(tableName, o);
224                 }
225                 context.SaveChanges();
226             }
227         }
228         public void Delete(T o)
229         {
230             using (var context = getInstence())
231             {
232                 object original = context.GetObjectByKey(o.EntityKey);
233                 context.DeleteObject(o);
234                 context.SaveChanges();
235             }
236         }
237         public void Delete(IEnumerable<T> listo)
238         {
239             using (var context = getInstence())
240             {
241                 foreach (T o in listo)
242                 {
243                     object original = context.GetObjectByKey(o.EntityKey);
244                     context.DeleteObject(o);
245                 }
246                 context.SaveChanges();
247             }
248         }
249
250     }
251
252     public class DataService
253     {
254         /// <summary>
255         /// 设置从配置文件中读取的ObjectContext节点\n默认为"EFObjectContext"
256         /// </summary>
257         public static string EFObjectContext = "EFObjectContext";
258         /// <summary>
259         /// 设置从配置文件中读取的EF链接节点\n默认为"ConnectionString"
260         /// </summary>
261         public static string ConnectionString = "ConnectionString";
262     }
263
264 }
265

本文链接

!+"\v1" & !+[1,] & !"1"[0] 比比谁更快

2010-02-01T20:02:00Z

下面所做的可能有点鸡蛋里跳骨头的味道,但却也十分有趣,希望各位能够在看了之后能够有所收获.总所周知,浏览器兼容问题一直困扰着开发者们,勤劳的开发者们也想到了各式各样的小技巧来区分各个派系的浏览器.通过各种各样的小技巧来区分IE浏览器