博客园_Kane

时间排序，去重复SQL语句

2011-07-27T08:30:00Z

select * from(select distinct barcode,out_date, company_name,company_no,in_date,employee_name,addresser_name,send_address,addresser_phone
from (SELECT a.barcode,b.company_name,a.company_no,a.in_date,d.employee_name,a.addresser_name,a.send_address,a.addresser_phone,c.out_date FROM post_info a
Left join express_company_info b on a.company_no = b.express_company_no
left join post_out_info c on c.barcode=a.barcode
left join employee_info d on d.employee_job_no=c.employee_no
WHERE a.post_state in ('10','11','12') and a.postal_no = 'BJBSD00001' ) as tb
WHERE out_date in(select max(out_date) from (SELECT a.barcode,b.company_name,a.company_no,a.in_date,d.employee_name,a.addresser_name,a.send_address,a.addresser_phone,c.out_date FROM post_info a
Left join express_company_info b on a.company_no = b.express_company_no
left join post_out_info c on c.barcode=a.barcode
left join employee_info d on d.employee_job_no=c.employee_no
WHERE a.post_state in ('10','11','12') and a.postal_no = 'BJBSD00001' ) as tb group by barcode)
) a order by out_date

本文链接

再次写给我们这些浮躁的程序员

2011-05-20T07:44:00Z

再次写给我们这些浮躁的程序员

2010年初写过一篇博客（我们是一群和平年代充满浮躁与抱怨的程序员），一年过去了，社会好像更浮躁，也有网友问我这方面的问题，于是有了下面这篇文章，再次写给我们这些刚入行浮躁的程序员，如何成长，以下是列出了一些成长的心得，我们不必每条都去实践，但是优秀的程序员成长过程中总会实践里面的几条。

多做项目，多思考
不要害怕做事，刚毕业的同学最缺的就是工作经验，乱七八糟的项目能让你很快就了解了一个公司的业务与使用的技术，并且可以多接触同事与客户。

当你毕业后刚进一家公司时，如果主管没有把你安排到项目组工作，那真的很杯具，因为他认为你还不能胜任工作或者你的加入会让项目组更糟。

还有人说，我刚进公司，公司就把我当成了苦工，工资又低，项目组加入好几个，也做了很多事情，每天都要加班。我估计有很多人感觉是这种状态，为什么会是这样，因为全国人民（不只是程序员）里有90%可能都和你一样的感觉，这说明你现在状况是很普遍的，也说明你现在的能力并没有很多出众的地方。也许是逆境才能让人成长，如果有一天你让你的团队从这些苦力工作中解脱出来或者能给你的团队前进的动力，那你就升华了，你就比他们出众。你没有能力去改变现状，所以只能接受，而不要认为是自己生不逢时，或者说公司环境太差。创业也一样，不要认为公司没发展的主要原因是环境太差，那你不要去当老板算了，投资环境都非常好还能轮到你吗。

还有很多同学感觉自己付出了很多，回报太少，这个问题很难平衡，首先一点，公司在聘你进来后不会因为你没有成绩就先给你回报，公司也不可能会在你有了成绩后就立即给你回报，但是长时间付出没有回报，那这个公司就不值得你付出。我不赞成频繁换公司，这么做至少可以说明你是一个只求回报不求付出的人。

至于薪资的问题，这个很难去评估，因为每个企业的收益相差太远。但是刚毕业的同学工作需要关注薪资+成长环境，当薪资可以满足普通生活需求后，成长环境更为重要，就好比，给你一月5000元，或者6000元，真的不那么重要，因为这些收入在你以后的人生中基本没有影响。当然，如果你现在在大城市几年里每个月只拿着1000元，那还是需要选择一下收入更好的公司，因为这么低的收入会严重影响你的工作学习计划，也说明你的公司不重视员工，没有能力给员工好生活的公司，将来的发展也是有限的。

特别说明一点，互联网公司与传统信息化企业不一样，互联网一直是风险比较高的行业，也许你选择了一个看好的企业，也佩服老板的眼光，可能你现在需要的是与公司同甘共苦。不要指望在刚创业的团队里拿到非常好的待遇，因为你现在就是在投资，也许几年后公司成功了，你就是功臣，不怎么出色的你也可以当上总监或副总裁。

自己开发框架与工具来提高工作效率
当你参与了很多项目，当你发现自己经常做一些COPY,PASTE的操作时，你可以考虑花时间去提取问题的共性，做一些自动化工具去摆平问题，或者是写一些基础框架来屏蔽这些无聊并且累赘的代码。

自己开发框架与工具，可以让你快速的从一个初级程序员转变成更高级的程序员或分析师或架构师，因为这个过程中给你提供了为其他程序员服务的机会，你有动力去了解其它程序员的工作需求，你可以把你的框架或工具写得很好，接口简单灵活并且性能好，分析师和架构师就经常要干这种让人力成本降低的事。但要记住一点，不要以为自己开发框架与工具就认为很NB了，因为这种工作并不会体现多少技术含量，而只是提高个人抽象问题的能力，这个活很多程序员都能干，但是很少人去干好。

参与开源项目
参与开源项目可以让你领略到不同程序员的沟通方法，开发习惯，技术思维，可以认识更多的朋友，如果你足够强，也可能一举成名哦。可以让你更深入了解这个开源东西，所以最好是感兴趣或者是与工作有关的，不要说什么流行就参与什么。开源项目可以自己贡献一个新的项目，或者参与一个感兴趣的项目。

不要指望开源项目会给你带来直接的金钱，如果你想拿着开源项目封装一下去发财，那我真不知道如何做，可以去问问什么什么芯，什么什么国产操作系统的人，他们更有经验。

英语
在这个全球信息时代，英语真的是一个很重要的工具，我真的很羡慕那些学校里英语就很好的同学，好的英语能力可以更快速的了解到更多知识。当前，新的技术与知识大部份语言都是英语或翻译成英语，如果能把英语学好，可以让你人生少奋斗10年。

写技术博客
写技术博客是一种可以快速提高的方法，但是一个人能坚持每周写技术博客，那是需要付出很多代价，写博客并不是要我们写出高质量的文章才发表，我们可以分享自己的一些小经验，也可以分享自己的体会。一样东西在你大脑里，并不表示你已经掌握了，如果你能说给别人听，或者用文字表达出来，那首先你要将这些知识点整理清楚才好表达。我经常认为自己已经对某个问题了解了，但是在整理技术博客时发现自己的知识盲点，然后再去查找知识来补充自己的盲点，直到最后搞清楚了才算告一段落。

有些人不喜欢分享或者害怕分享，但是在这个世界，只要不是公司机密或商业秘密，拿出来分享可以让你得到更多同行的反馈，网络上的人会给你相对真实的反馈，因为大部份人与你没有利益关系。

新人不要害怕自己分享的知识是否有技术含量，只要你认为有价值，都可以拿出来，这不仅可以给别人提供知识，也可以自己整理思路，还可以得到网友的反馈。如果你的知识没有价值，分享出来也没有关系，如果你的文章技术含量低，怕被人鄙视，那是你这个人不敢承认现实，因为同事与朋友可能不会说你的文章很菜，就算被鄙视了又如何，有时被人鄙视也是一种前进的动力。有人说如果几年后我进步了很多，但还让人看到我这些初学时弱智的文档，误人子弟，不好意思，Ok，那个时候有可以完全把文档删除，其实我更喜欢放在那里品味自己成长的过程，把有误导的地方更正。

我知道有一个技术博客作者，数据库专家杨廷琨(http://yangtingkun.itpub.net/)，他几年来，每天坚持写一篇技术博客，现在已经有2千多篇，我的ORACLE数据库水平比他差很多，但是我也偶尔看到一些他新写的文档我几年前就会了，但这些并不妨碍我对这位博客作者的敬佩，因为他的博客让我学到了很多知识。

加入感兴趣的技术论坛
每个公司使用的技术与产品及环境都不太一样，也许你在公司里感觉什么东西都是别人做好了，我只是个流水线工人，我们的系统由于有严格的规范也不太出问题，自己的实践提高机会太少，那建议你加入感兴趣的技术论坛。

技术论坛上你可以看到很多人各种各样的问题与分享讨论，你也可以试着去帮别人解决问题。技术论坛可以让你进一步成长，但不要告诉我你只是会沙发、顶或接分的那种。

国内CSDN、ITPUB、CHINAUNIX、JAVAEYE、MSDN、51TESTING都是人气很旺，里面也不缺技术大牛与无敌大菜鸟。

常看参考手册
很多程序员，遇到问题喜欢直接去请教别人，或是Google找结果，通过别人或Google也许问题可以解决，但是只能形成知识点，不能形成知识体系。

要全面掌握一个东西最快的方法是看产品的官方参考手册，参考手册一般是代表正规的用法或者是推荐的用法，对于小产品最好是先将参考手册全部看一遍。如果是比较大的产品如（ORACLE、JAVA、.NET）那可以选择看经常使用到的部分。只有当你在看完参考手册还不懂的时候再去Google或与别人探讨，这样的方式会让你的知识更体系化。

深入分析问题原因
程序员一定要具备对技术问题刨根问底的想法，很多程序员能解决问题，但是不想去了解问题的根源。我们经常遇到问题，而且很多问题重启程序或者重启机器就好了，有多少程序员会去挖掘重启就解决问题的原因。我是从事数据库的，也经常看到很多人遇到数据库有问题，重装一下搞定，而没有深入分析问题产生的原因。也许在生产环境我们没有时间去分析，但是在开发环境、测试环境你是不是也经常重启解决问题。如果能在开发环境与测试环境遇到问题，这是技术人员成长的最好机会，我们在自己的领域一定不能放过这种成长的机会，因为大部份专家都是在这种历练中出来的。

不要害怕复杂
很多程序员习惯了利用各种框架及工具解决问题，自己只是写一些简单逻辑，当有一天遇到一个问题，没有对应的框架或工具时就放弃需求。我们不要害怕困难，如果你每天的代码都没有挑战，那何来提高，我们应该在适当的时候给自己一些压力，这样可以让自己提高得更快一些。比如你的系统需要一个轻量级的工作流引擎、编译器、解析器、界面设计器、屏幕控制器，或者一个http服务器之类的东东，但是现有的东西都感觉不太满意，你可以自己去搞一个试试，不要害怕不成功，不要害怕自己做不好。这些东西看起来有点复杂，但是当你深入去做时，你会发现里面有很多有意思的东西，你需要去逐步改进你的小系统，直到它能很好的运行为止，这是个很好的成长过程，可以让你对程序有更深的理解，也可打开思路。

学习计算机基础，深入技术原理
有时候我们经常迷惘，感觉技术水平没有提高，感觉技术能力总是浮在表面，特别是当你发现自己算法分析、性能分析、故障诊断能力有限时，也许这是你再次需要学习计算机基础的时候，因为基础不牢，所以你的问题诊断准确率不高。每个程序员应该都学过计算机基础（计算机体系、操作系统、网络、数据库原理、算法等等），这些知识对很多人来说是很枯燥。在当前高级编程语言时代，你的计算机基础不好也能编码，而且效率也不低，但是当你要想成为技术牛人，计算机基础就是一道坎，因为不扎实的计算机基础知识会让你在忽悠与被忽悠中成长。

关心产品市场与商业动态
程序员是否需要关心产品市场与商业动态，我认为是有必要的，除非你真是技术天才，能闭关十年后横扫江湖。计算机技术发展太快，每年都有新的流行产品与技术，大公司也经常改变战略或易主。如果你想引领技术潮流，想创业，那一定要关心产品市场与商业动态。

不要去轻视任何一种职位、语言、工具
在IT岗位里，没有高低之分，不要去轻视任何一种岗位，有些程序员认为自己的成果最有价值，美工、测试只是边缘岗位，项目经理就只会瞎指挥，不干活，销售人员与售前人员接到定单后屁事都没有，整个项目基本上就是我一个人的成果。这种心态是最要不得的。其实你的领导并不会这么想，很多事情是你不知道的，如客户关系就可能不是你一个人搞定的。还有最重要的一点，如果这个项目没有你参加怎么样？项目可能换成另外一个人做，也许他也能做得也不错，这就说明你的价值或重要性并不像你想象的那么重要。举个例子：

就好比你买一台联想电脑4000块，卖给一个没看过电脑的火星人20000块，这台电脑是最后的成果，但是否表示联想这台电脑是最重要的，可能你买一台戴尔的电脑还赚的钱更多，也可能你只要给对方一台杂牌电脑就可以拿到20000块。在这个例子里更重要的也许是客户关系与抓住商机，而买什么样的电脑影响不大（你在项目里的地位可能就是这台电脑的作用，没有你肯定不完整，但是很容易找到你的替代品，所以你的价值并不是最重要的）。

计算机编程语言是初学者最喜欢对比的话题，有的大师也经常对比各种语言的优缺点。我并不反对的评论那种语言的优劣，但我们不能去鄙视某种语言的及其使用者，因为流行的语言都有它生存的环境，可能是我们对技术的见识太窄，也可能是我们对人类的思维习惯了解的不全面，不要总是拿自己的习惯去评价。有很多系统管理员喜欢用命令行，喜欢用shell,perl等脚本语言，这些东西在我看来简直是低效且易读性差的东西，但是当你经常在没有图形界面下工作时，脚本语言可能真是更高效的选择。

最后写上一句浮躁的根源：

不要把祖国当母亲，应该把祖国当自己的孩子。

本不想讲这句话的，但是现实就是如此，浮躁的人群总是对社会充满了意见。我认为所有的这些浮躁都有一个共同点，就是认为自己无法改变这个社会，改变这个社会是国家的事，是其他人的事。

小时候老师总是讲祖国是母亲，我们是花朵，但是实际上我们也不是什么花朵，我们就是郑智化歌里的那根“小小的草，风吹雨打后依然不倒”。现实的社会总是充满着种种不平衡，但是浮躁并不能解决问题。有时总在想祖国并不像我的母亲，她更像是我的孩子，她还很小，经历过很多坎坷，我们经常感觉自家的孩子比不上别人的孩子的某个方面，于是对孩子多加责骂，也可能会让她花一个暑假的时间去补习。小孩子有一些成绩后也会骄傲，有时还会欺骗，我们不能容忍的是她的恶意谎言，但是她还没有到无药可救的程度，她依然还在成长。我们经常拿孩子与别人的孩子对比，而且总是发现别人孩子更好的一面，但是你是否希望与别人交换孩子呢，除了感情外你是否了解别人孩子的全部，我们需要更多的面对现实，应该在孩子成长的时候及时指出她的缺点，她不可能什么都是优秀的，所以我们应该尽自己的能力让她更好一些。你不太可能改变母亲，但是你的行动会影响孩子，你抛弃孩子，你真正的孩子将来可能也会抛弃你，所以说祖国可能并不像母亲，更像孩子，如果你把祖国当孩子，也许是另一种人生价值。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/yzsind/archive/2011/01/29/6168854.aspx

本文链接

谈谈对于企业级系统架构的理解

2011-05-13T03:15:00Z

原帖地址：http://www.cnblogs.com/liping13599168/archive/2011/05/11/2043127.html

在我们刚开始学习架构的时候，首先会想到分层的概念，分层架构比较经典的是三层架构，那么，什么是三层架构呢？它包括表现层，业务层，数据访问层；而对于一个新手来说，从抽象意义上的三层架构，逻辑上就划分为三个层。

这个是最基本的三层架构模式。

表现层充当系统的界面呈现以及UI逻辑的角色，也就是说，UI（用户界面）属于表现层；

举一个对于asp.net WebForm来说，人们喜欢把对于UI的控制逻辑（服务器控件的读取、设置、事件等等）写在页面的后置隐藏代码中，并且依赖业务逻辑层。当然，服务器控件支持数据绑定的功能，可以通过数据源进行绑定控件。这样就可以节省在后置隐藏中的代码。

因此，我们就可以把表现层分为UI用户界面以及UI逻辑：

UI用户界面的职责只是作为数据输入和输出后的展示工作。

UI逻辑的职责是负责业务逻辑层以及UI用户界面之间的数据交互，并且尽可能地让UI逻辑不依赖于UI技术。

其中UI用户界面的实现方式有很多，包括ASP.NET，WinForm，WPF，Silverlight，移动Web，智能设备等等。

将表现层中UI页面和UI逻辑分离的策略中，当前使用最多的两种模式是MVC模式和MVP模式。

MVC模式，即模型-视图-控制器模式，通过视图触发并执行某个操作，调用控制器，通过控制器去操作业务层，最终返回模型，在视图中进行展示。这里的模型可以是一个领域模型（DM），也可以是一个数据迁移对象（DTO）。

MVP模式，即模型-视图-展示器模式，和MVC模式有点像，不同的是MVP中视图和模型是被完全分离出来的，视图中定义一个接口，而展示器通过调用该接口的方法以控制视图。因此，视图和模型是松散的，展示器也充当了一个控制器的角色，同时它也不依赖于UI技术。

另外再介绍一种模式PM（Preentation Model），它可以说是MVP的变体，在PM中，视图不定义接口，这里的模型只是表示视图状态的类，视图中的元素被直接绑定到模型属性上。例如在WPF中，WPF就先天的具有数据双向绑定机制以及事件通知属性机制。

所以它特别适用于WPF，Sliverlight等等。

在开始业务层之前,不得不说一个前提,在一个小型项目中,直接让表现层调用业务层,足以解决所有问题。但是，当项目大到使用多种表现形式，如使用了各种UI技术，ASP.NET，WPF，移动设备等等，就要考虑在你的表现层和业务层之间增加一个层，以至于让表现层和业务层解耦，因为业务层作为一个业务中间件的平台，最好不要暴露于表现层中，这个层就是传说中的服务层。架构图又演化为：

服务层实际上并不执行任何具体的工作，其功能在于组织各个业务对象,服务层将业务层所有的细节对表现层都隐藏起来,服务器将组织业务逻辑层中的组件,并且通过数据迁移对象(DTO)与表现层交互,因此就产生一个DTO模型。

为了实现服务的可重用性，需要使用服务接口，表现层通过规定的接口访问功能。服务的实现继承服务接口，而服务的实现专注于业务层的调用。

对于服务层，常用的方法包括Web服务、.NET Remoting、Rest以及WCF技术。

本人比较建议使用WCF作为服务，因为可以方便地通过配置达到远程调用服务的目的。

服务层消除了两个表现层和业务层之间的耦合，服务层可以实现一个远程接口，达到多UI技术甚至多平台上的通信。

当然增加服务层也有缺点，假如使用WCF服务，会增加系统的调用开销，进而影响性能。

业务层中包含系统所需要业务过程上的实现，并与下层的数据访问层交互。

我们通常也叫做业务层叫做业务逻辑层，但我认为业务逻辑层是属于业务层的一方面，业务逻辑更专注于业务上逻辑算法的实现。因为业务层还可以包括其他的方面。

业务层必须包括对业务实体尽心建模的对象模型，表达了客户的所有策略和需求的业务规则，因此就产生了领域模型。

（PS：如果这里你不使用领域模型，那么需要采用业务规则层进行业务功能上的业务规则的验证和控制）

领域模型包括对实体的属性定义，方法定义以及实体与实体之间的关系。从这个角度上看，UML建模至关重要，通过对UML动态图和静态图的描述，可以映射到领域模型中。

从服务层刚才讲到了DTO模型，这里需要一个机制将DTO转化为领域模型，所以产生了DTO映射层（DTOMapper）。

另外业务层还包括核心中间件技术，包括第三方组件，以及工作流引擎等等。

业务层需要考虑到一些与数据访问层交互的设计模式，模式中包括事物脚本模式、表模块模式、活动记录模式、领域模型模式。

事物脚本模式是通过方法来执行业务流程，它是一个过程式模型，事物脚本的每个方法都有一个特定的事物脚本，它侧重于业务上一系列流程上的顺序操作，它实现起来很简单，但是它有个致命的缺点就是它会造成很多重复的代码。

表模块模式比起事物脚本模式，具有一定的结构，它的思想也很简单，每个数据表都定义一个业务组件（实体类，实体操作类），在.NET中更多的使用DataSet作为表模型的数据交互。但是它也有一个缺点就是它是从数据库驱动它不适合于大量的数据表以及数据表之间的复杂关系。

活动记录模式中的对象中，可以包含数据和方法。它接近于数据表的结构，它的对象中执行方法中可以包含CRUD操作，验证算法，以及其他的计算功能。一般来说，领域模型不是太复杂，活动记录模式是个好选择。当然他也存在问题，同样地，它对于复杂的业务上，维护的成本也很高，并且如果需求变更导致数据库修改，就需要调整记录对象模型中的相关代码。

经典应用：LINQ-TO-SQL以及Castle ActiveRecord。

领域模型模式是从领域驱动设计中衍生来的，它是以业务为核心的设计模式。它对于复杂的业务逻辑，相当适用。前三种方式使用的是以数据驱动方式，数据驱动方式特点简单，但是当系统到了一定的规模后，就会到难以维护的程度。

数据访问层的目的很明确,主要作为提供数据持久化的功能，包括数据的读取和写入，另外还必须包括事务处理，并发控制等等。

操作数据库的方法可以有两种方式,ORM方式，ADO.NET方式。

ORM可以采用一些第三方的ORM框架来实现，ADO.NET采用ASP.NET自带的数据库操作来实现。

不同的数据库具有不同的持久化实现，因此这里添加一个存储仓库接口层，来适应不同的数据库实现，这里你可以使用IOC依赖注入方式进行数据库选型，可以利用Unity、Spring.NET、Castle的IOC容器等等。

最后各个层中都可以依赖于公共基础设施层。

公共基础设施层可以包括Common通用模块，Logging日志模块，Exception异常模块，Configuration配置模块，DI依赖注入模块，单元测试模块以及第三方组件（例如NHibernate、Sprint.NET、Castle、Quartz计划任务等等）

最终图：

总结：项目类型、项目规模以及业务上的需求，都影响着系统架构的设计，系统架构并不是一层不变的，没有最好的架构，只有更好的架构，并且从项目中多思考系统的扩展性。文中对于架构的分析，只是从通常的角度上去考虑，在项目中，您还需要根据实际情况去做调整。

谢谢大家阅读！

本文链接

EXT GridPanel 获取当前页面显示的数据（变通法）

2011-03-09T07:52:00Z

这两天新到个公司。。需要用到EXT 非要用EXT啊 0_0 ..

用到其中一个控件 GridPanel 我需要取其中的页面上的数据然后保存到数据库中.. 翻了两天资料

发现大神们用的都是JS 啊 JS 本人可不会JS 一直做winform来着完全不会

无奈只好翻官方的示例结合 GridPanel其中Selection Models--> Row Selection

和update-->Autodate 两个示例

附地址：http://examples.ext.net/

取其中可用部分

获取选中行的数据

获取总行数

这两段代码组合成一下后台代码

        string json = e.ExtraParams["Values"];

        RowSelectionModel rs = this.grp_rulelot.SelectionModel.Primary as RowSelectionModel;
        for (int i = 0; i < Convert.ToInt32(json); i++)
        {
            rs.SelectedRows.Add(new SelectedRow(i));
        }
        rs.UpdateSelection();
        //锁定选中状态
        RowSelectionModel1.Lock();

和

        string json = e.ExtraParams["Valuess"];
        #region 序列化选中的数据
        Dictionary<string, string>[] companies = JSON.Deserialize<Dictionary<string, string>[]>(json);

        StringBuilder sb = new StringBuilder();
        sb.Append("<table  cellspacing='15'>");
        bool addHeader = true;

        foreach (Dictionary<string, string> row in companies)
        {
            if (addHeader)
            {
                sb.Append("<tr>");
                foreach (KeyValuePair<string, string> keyValuePair in row)
                {
                    sb.Append("<td style='white-space:nowrap;font-weight:bold;'>");

                    sb.Append(keyValuePair.Key);

                    sb.Append("</td>");
                }
                sb.Append("</tr>");

                addHeader = false;
            }

            sb.Append("<tr>");
            foreach (KeyValuePair<string, string> keyValuePair in row)
            {
                sb.Append("<td style='white-space:nowrap;'>");

                sb.Append(keyValuePair.Value);

                sb.Append("</td>");
            }
            sb.Append("</tr>");
        }
        sb.Append("</table>");
        lab.Html = sb.ToString();
        #endregion

来完成数据获取。

完成后效果图如下

我的方法比较笨，，仅供参考。希望对大家有用

如果有大神能指点1，2就更好了

QQ：363116554

本文链接

如何更改存储过程所有者 dbo

2010-08-10T03:22:00Z

查询分析器执行

use dbname

if exists (select * from dbo.sysobjects where id = object_id(N'[dbo].[changename]') and OBJECTPROPERTY(id, N'IsProcedure') = 1)
drop procedure [dbo].[changename]
GO

SET QUOTED_IDENTIFIER OFF
GO
SET ANSI_NULLS OFF
GO

Create PROCEDURE dbo.changename
@OldOwner as NVARCHAR(128),--参数原所有者
@NewOwner as NVARCHAR(128)--参数新所有者
AS

DECLARE @Name as NVARCHAR(128)
DECLARE @Owner as NVARCHAR(128)
DECLARE @OwnerName as NVARCHAR(128)

DECLARE curObject CURSOR FOR
select 'Name' = name,
'Owner' = user_name(uid)
from sysobjects
where user_name(uid)=@OldOwner
order by name

OPEN curObject
FETCH NEXT FROM curObject INTO @Name, @Owner
WHILE(@@FETCH_STATUS=0)
BEGIN
if @Owner=@OldOwner
begin
set @OwnerName = @OldOwner + '.' + rtrim(@Name)
exec sp_changeobjectowner @OwnerName, @NewOwner
end

FETCH NEXT FROM curObject INTO @Name, @Owner
END

close curObject
deallocate curObject
GO
SET QUOTED_IDENTIFIER OFF
GO
SET ANSI_NULLS ON
GO

exec Changename 'cwa1034','dbo' --将cwa1034所有者更改为dbo

本文链接

C# dataGridView用法

2010-05-31T02:06:00Z

C# dataGridView用法

2009-05-04 09:02

SqlConnection conn = new SqlConnection("Server=(local);DataBase=test;User=sa;Pwd=sa");
            SqlDataAdapter da = new SqlDataAdapter("select * from test", conn);
            DataSet ds = new DataSet();
            da.Fill(ds);
            dataGridView1.DataSource = ds.Tables[0];

①　DataGridView 取得或者修改当前单元格的内容：

当前单元格指的是 DataGridView 焦点所在的单元格，它可以通过 DataGridView 对象的 CurrentCell 属性取得。如果当前单元格不存在的时候，返回Nothing(C#是null)

// 取得当前单元格内容
Console.WriteLine(DataGridView1.CurrentCell.Value);
// 取得当前单元格的列 Index
Console.WriteLine(DataGridView1.CurrentCell.ColumnIndex);
// 取得当前单元格的行 Index
Console.WriteLine(DataGridView1.CurrentCell.RowIndex);
另外，使用 DataGridView.CurrentCellAddress 属性（而不是直接访问单元格）来确定单元格所在的行：DataGridView.CurrentCellAddress.Y 和列： DataGridView.CurrentCellAddress.X 。这对于避免取消共享行的共享非常有用。
当前的单元格可以通过设定 DataGridView 对象的 CurrentCell 来改变。可以通过 CurrentCell 来设定
DataGridView 的激活单元格。将 CurrentCell 设为 Nothing(null) 可以取消激活的单元格。

// 设定 (0, 0) 为当前单元格
DataGridView1.CurrentCell = DataGridView1[0, 0];

在整行选中模式开启时，你也可以通过 CurrentCell 来设定选定行。

/// <summary>
/// 向下遍历
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button4_Click(object sender, EventArgs e)
...{
int row = this.dataGridView1.CurrentRow.Index + 1;
if (row > this.dataGridView1.RowCount - 1)
row = 0;
this.dataGridView1.CurrentCell = this.dataGridView1[0, row];
}

/// <summary>
/// 向上遍历
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button5_Click(object sender, EventArgs e)
...{
int row = this.dataGridView1.CurrentRow.Index - 1;
if (row < 0)
row = this.dataGridView1.RowCount - 1;
this.dataGridView1.CurrentCell = this.dataGridView1[0, row];
}

* 注意: this.dataGridView 的索引器的参数是: columnIndex, rowIndex 或是 columnName, rowIndex
这与习惯不同。

②　DataGridView 设定单元格只读：

1）使用 ReadOnly 属性
如果希望，DataGridView 内所有单元格都不可编辑，那么只要：

[C#]
// 设置 DataGridView1 为只读
DataGridView1.ReadOnly = true;
此时，用户的新增行操作和删除行操作也被屏蔽了。
如果希望，DataGridView 内某个单元格不可编辑，那么只要：

[C#]
// 设置 DataGridView1 的第2列整列单元格为只读
DataGridView1.Columns[1].ReadOnly = true;

// 设置 DataGridView1 的第3行整行单元格为只读
DataGridView1.Rows[2].ReadOnly = true;

// 设置 DataGridView1 的[0，0]单元格为只读
DataGridView1[0, 0].ReadOnly = true;

2）使用 EditMode 属性
DataGridView.EditMode 属性被设置为 DataGridViewEditMode.EditProgrammatically 时，用户就不能手动编辑单元格的内容了。但是可以通过程序，调用 DataGridView.BeginEdit 方法，使单元格进入编辑模式进行编辑。

[C#]
DataGridView1.EditMode = DataGridViewEditMode.EditProgrammatically;

3）根据条件设定单元格的不可编辑状态
当一个一个的通过单元格坐标设定单元格 ReadOnly 属性的方法太麻烦的时候，你可以通过 CellBeginEdit 事件来取消单元格的编辑。

[C#]
// CellBeginEdit 事件处理方法
private void DataGridView1_CellBeginEdit(object sender,
DataGridViewCellCancelEventArgs e)
{
DataGridView dgv = (DataGridView)sender;
//是否可以进行编辑的条件检查
if (dgv.Columns[e.ColumnIndex].Name == "Column1" &&
!(bool)dgv["Column2", e.RowIndex].Value)
{
// 取消编辑
e.Cancel = true;
}
}

③　DataGridView 不显示最下面的新行：

通常 DataGridView 的最下面一行是用户新追加的行（行头显示 * ）。如果不想让用户新追加行即不想显示该新行，可以将 DataGridView 对象的 AllowUserToAddRows 属性设置为 False。

[C#]
// 设置用户不能手动给 DataGridView1 添加新行
DataGridView1.AllowUserToAddRows = false;
但是，可以通过程序： DataGridViewRowCollection.Add 为 DataGridView 追加新行。
补足：如果 DataGridView 的 DataSource 绑定的是 DataView, 还可以通过设置 DataView.AllowAdd
属性为 False 来达到同样的效果。

④　DataGridView 判断新增行：

DataGridView的AllowUserToAddRows属性为True时也就是允许用户追加新行的场合下，DataGridView的最后一行就是新追加的行(*行)。使用 DataGridViewRow.IsNewRow 属性可以判断哪一行是新追加的行。另外，通过DataGridView.NewRowIndex 可以获取新行的行序列号。在没有新行的时候，NewRowIndex = -1。

⑤　DataGridView 行的用户删除操作的自定义：

1）无条件的限制行删除操作。
默认时，DataGridView 是允许用户进行行的删除操作的。如果设置 DataGridView对象的AllowUserToDeleteRows属性为 False 时，用户的行删除操作就被禁止了。

[C#]
// 禁止DataGridView1的行删除操作。
DataGridView1.AllowUserToDeleteRows = false;
但是，通过 DataGridViewRowCollection.Remove 还是可以进行行的删除。
补足：如果 DataGridView 绑定的是 DataView 的话，通过 DataView.AllowDelete 也可以控制行的删除。
2）行删除时的条件判断处理。
用户在删除行的时候，将会引发 DataGridView.UserDeletingRow 事件。在这个事件里，可以判断条件并取消删除操作。

[C#]
// DataGridView1 的 UserDeletingRow 事件
private void DataGridView1_UserDeletingRow(
object sender, DataGridViewRowCancelEventArgs e)
{
// 删除前的用户确认。
if (MessageBox.Show("确认要删除该行数据吗？", "删除确认",
MessageBoxButtons.OKCancel,
MessageBoxIcon.Question) != DialogResult.OK)
{
// 如果不是 OK，则取消。
e.Cancel = true;
}
}

⑥　DataGridView 行、列的隐藏和删除：

1）行、列的隐藏

[C#]
// DataGridView1的第一列隐藏
DataGridView1.Columns[0].Visible = false;
// DataGridView1的第一行隐藏
DataGridView1.Rows[0].Visible = false;
2）行头、列头的隐藏

[C#]
// 列头隐藏
DataGridView1.ColumnHeadersVisible = false;
// 行头隐藏
DataGridView1.RowHeadersVisible = false;
3）行和列的删除

[C#]
' 删除名为"Column1"的列
DataGridView1.Columns.Remove("Column1");
' 删除第一列
DataGridView1.Columns.RemoveAt(0);
' 删除第一行
DataGridView1.Rows.RemoveAt(0);
4）删除选中行

[C#]
foreach (DataGridViewRow r in DataGridView1.SelectedRows)
{
if (!r.IsNewRow)
{
DataGridView1.Rows.Remove(r);
}
}

⑦ DataGridView 禁止列或者行的Resize：

1）禁止所有的列或者行的Resize

[C#]
// 禁止用户改变DataGridView1的所有列的列宽
DataGridView1.AllowUserToResizeColumns = false;

//禁止用户改变DataGridView1の所有行的行高
DataGridView1.AllowUserToResizeRows = false;
但是可以通过 DataGridViewColumn.Width 或者 DataGridViewRow.Height 属性设定列宽和行高。
2）禁止指定行或者列的Resize

[C#]
// 禁止用户改变DataGridView1的第一列的列宽
DataGridView1.Columns[0].Resizable = DataGridViewTriState.False;

// 禁止用户改变DataGridView1的第一列的行宽
DataGridView1.Rows[0].Resizable = DataGridViewTriState.False;
&S658; 关于 NoSet

当 Resizable 属性设为 DataGridViewTriState.NotSet 时，实际上会默认以 DataGridView 的 AllowUserToResizeColumns 和 AllowUserToResizeRows 的属性值进行设定。比如： DataGridView.AllowUserToResizeColumns = False 且 Resizable 是 NoSet 设定时，Resizable = False 。

判断 Resizable 是否是继承设定了 DataGridView 的 AllowUserToResizeColumns 和 AllowUserToResizeRows 的属性值，可以根据 State 属性判断。如果 State 属性含有 ResizableSet，那么说明没有继承设定。

3）列宽和行高的最小值的设定

[C#]
// 第一列的最小列宽设定为 100
DataGridView1.Columns[0].MinimumWidth = 100;

// 第一行的最小行高设定为 50
DataGridView1.Rows[0].MinimumHeight = 50;

4) 禁止用户改变行头的宽度以及列头的高度

[C#]
// 禁止用户改变列头的高度
DataGridView1.ColumnHeadersHeightSizeMode =
DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

// 禁止用户改变行头的宽度
DataGridView1.RowHeadersWidthSizeMode =
DataGridViewRowHeadersWidthSizeMode.EnableResizing;

⑧ DataGridView 列宽和行高自动调整的设定：
1) 设定行高和列宽自动调整

[C#]
// 设定包括Header和所有单元格的列宽自动调整
DataGridView1.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells;

// 设定包括Header和所有单元格的行高自动调整
DataGridView1.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.AllCells;
AutoSizeColumnsMode 属性的设定值枚举请参照 msdn 的 DataGridViewAutoSizeRowsMode 说明。
2）指定列或行自动调整

[C#]
// 第一列自动调整
DataGridView1.Columns[0].AutoSizeMode =
DataGridViewAutoSizeColumnMode.DisplayedCells;
AutoSizeMode 设定为 NotSet 时，默认继承的是 DataGridView.AutoSizeColumnsMode 属性。
3) 设定列头的高度和行头的宽度自动调整

[C#]
// 设定列头的宽度可以自由调整
DataGridView1.ColumnHeadersHeightSizeMode =
DataGridViewColumnHeadersHeightSizeMode.AutoSize;

// 设定行头的宽度可以自由调整
DataGridView1.RowHeadersWidthSizeMode =
DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders;
4）随时自动调整
a，临时的，让列宽自动调整，这和指定AutoSizeColumnsMode属性一样。

[C#]
// 让 DataGridView1 的所有列宽自动调整一下。
DataGridView1.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCells);

// 让 DataGridView1 的第一列的列宽自动调整一下。
DataGridView1.AutoResizeColumn(0, DataGridViewAutoSizeColumnMode.AllCells);
上面调用的 AutoResizeColumns 和 AutoResizeColumn 当指定的是DataGridViewAutoSizeColumnMode.AllCells 的时候，参数可以省略。即：
DataGridView1.AutoResizeColumn(0) 和 DataGridView1.AutoResizeColumns()
b，临时的，让行高自动调整

[C#]
// 让 DataGridView1 的所有行高自动调整一下。
DataGridView1.AutoResizeRows(DataGridViewAutoSizeRowsMode.AllCells);

//让 DataGridView1 的第一行的行高自动调整一下。
DataGridView1.AutoResizeRow(0, DataGridViewAutoSizeRowMode.AllCells);
上面调用的 AutoResizeRows 和 AutoResizeRow 当指定的是DataGridViewAutoSizeRowMode.AllCells 的时候，参数可以省略。即：DataGridView1.AutoResizeRow (0) 和 DataGridView1.AutoResizeRows()
c，临时的，让行头和列头自动调整
关于性能：
通过 AutoSizeColumnsMode 或者 AutoSizeRowsMode 属性所指定的单元格进行自动调整时，如果调整次数过于多那么将可能导致性能下降，尤其是在行和列数比较多的情况下。在这时用 DisplayedCells 代替 AllCells 能减少非所见的单元格的调整，从而提高性能。

[C#]
// 列头高度自动调整
DataGridView1.AutoResizeColumnHeadersHeight();

// 行头宽度自动调整
DataGridView1.AutoResizeRowHeadersWidth(
DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders);

⑨ DataGridView 冻结列或行

1）列冻结
DataGridViewColumn.Frozen 属性为 True 时，该列左侧的所有列被固定，横向滚动时固定列不随滚动条滚动而左右移动。这对于重要列固定显示很有用。 [C#]
// DataGridView1的左侧2列固定
DataGridView1.Columns[1].Frozen = true;
但是，DataGridView.AllowUserToOrderColumns = True 时，固定列不能移动到非固定列，反之亦然。

2）行冻结
DataGridViewRow.Frozen 属性为 True 时，该行上面的所有行被固定，纵向滚动时固定行不随滚动条滚动而上下移动。
[C#]
// DataGridView1 的上3行固定
DataGridView1.Rows[2].Frozen = true;
⑩ DataGridView 列顺序的调整

设定 DataGridView 的 AllowUserToOrderColumns 为 True 的时候，用户可以自由调整列的顺序。
当用户改变列的顺序的时候，其本身的 Index 不会改变，但是 DisplayIndex 改变了。你也可以通过程序改变 DisplayIndex 来改变列的顺序。列顺序发生改变时会引发 ColumnDisplayIndexChanged 事件：

[C#]
// DataGridView1的ColumnDisplayIndexChanged事件处理方法
private void DataGridView1_ColumnDisplayIndexChanged(object sender,
DataGridViewColumnEventArgs e)
{
Console.WriteLine("{0} 的位置改变到 {1} ",
e.Column.Name, e.Column.DisplayIndex);
}

DataGridView 行头列头的单元格

[C#]
// 改变DataGridView1的第一列列头内容
DataGridView1.Columns[0].HeaderCell.Value = "第一列";

// 改变DataGridView1的第一行行头内容
DataGridView1.Rows[0].HeaderCell.Value = "第一行";

// 改变DataGridView1的左上头部单元内容
DataGridView1.TopLeftHeaderCell.Value = "左上";
另外你也可以通过 HeaderText 来改变他们的内容。

[C#]
// 改变DataGridView1的第一列列头内容
DataGridView1.Columns[0].HeaderText = "第一列";

DataGridView 剪切板的操作

DataGridView.ClipboardCopyMode 属性被设定为 DataGridViewClipboardCopyMode.Disable 以外的情况时，「Ctrl + C」按下的时候，被选择的单元格的内容会拷贝到系统剪切板内。格式有： Text， UnicodeText，Html， CommaSeparatedValue。可以直接粘贴到 Excel 内。
ClipboardCopyMode 还可以设定 Header部分是否拷贝： EnableAlwaysIncludeHeaderText 拷贝Header部分、EnableWithoutHeaderText 则不拷贝。默认是 EnableWithAutoHeaderText ， Header 如果选择了的话，就拷贝。
1）编程方式实现剪切板的拷贝
Clipboard.SetDataObject(DataGridView1.GetClipboardContent())
2) DataGridView 的数据粘贴
实现剪切板的拷贝比较容易，但是实现 DataGridView 的直接粘贴就比较难了。「Ctrl + V」按下进行粘贴时，DataGridView 没有提供方法，只能自己实现。
以下，是粘贴时简单的事例代码，将拷贝数据粘贴到以选择单元格开始的区域内。

[C#]
//当前单元格是否选择的判断
if (DataGridView1.CurrentCell == null)
return;
int insertRowIndex = DataGridView1.CurrentCell.RowIndex;

// 获取剪切板的内容，并按行分割
string pasteText = Clipboard.GetText();
if (string.IsNullOrEmpty(pasteText))
return;
pasteText = pasteText.Replace(" ", " ");
pasteText = pasteText.Replace(' ', ' ');
pasteText.TrimEnd(new char[] { ' ' });
string[] lines = pasteText.Split(' ');

bool isHeader = true;
foreach (string line in lines)
{
// 是否是列头
if (isHeader)
{
isHeader = false;
continue;
}

// 按 Tab 分割数据
string[] vals = line.Split(' ');
// 判断列数是否统一
if (vals.Length - 1 != DataGridView1.ColumnCount)
throw new ApplicationException("粘贴的列数不正确。");
DataGridViewRow row = DataGridView1.Rows[insertRowIndex];
// 行头设定
row.HeaderCell.Value = vals[0];
// 单元格内容设定
for (int i = 0; i < row.Cells.Count; i++)
{
row.Cells[i].Value = vals[i + 1];
}

// DataGridView的行索引+1
insertRowIndex++;
}

DataGridView 单元格的ToolTip的设置

DataGridView.ShowCellToolTips = True 的情况下，单元格的 ToolTip 可以表示出来。对于单元格窄小，无法完全显示的单元格， ToolTip 可以显示必要的信息。
1）设定单元格的ToolTip内容

[C#]
// 设定单元格的ToolTip内容
DataGridView1[0, 0].ToolTipText = "该单元格的内容不能修改";

// 设定列头的单元格的ToolTip内容
DataGridView1.Columns[0].ToolTipText = "该列只能输入数字";

// 设定行头的单元格的ToolTip内容
DataGridView1.Rows[0].HeaderCell.ToolTipText = "该行单元格内容不能修改";

2） CellToolTipTextNeeded 事件
在批量的单元格的 ToolTip 设定的时候，一个一个指定那么设定的效率比较低，这时候可以利用 CellToolTipTextNeeded 事件。当单元格的 ToolTipText 变化的时候也会引发该事件。但是，当DataGridView的DataSource被指定且VirualMode=True的时候，该事件不会被引发。

[C#]
// CellToolTipTextNeeded事件处理方法
private void DataGridView1_CellToolTipTextNeeded(object sender,
DataGridViewCellToolTipTextNeededEventArgs e)
{
e.ToolTipText = e.ColumnIndex.ToString() + ", " + e.RowIndex.ToString();
}
DataGridView 的右键菜单（ContextMenuStrip）
DataGridView, DataGridViewColumn, DataGridViewRow, DataGridViewCell 有 ContextMenuStrip 属性。可以通过设定 ContextMenuStrip 对象来控制 DataGridView 的右键菜单的显示。 DataGridViewColumn 的 ContextMenuStrip 属性设定了除了列头以外的单元格的右键菜单。 DataGridViewRow 的 ContextMenuStrip 属性设定了除了行头以外的单元格的右键菜单。DataGridViewCell 的 ContextMenuStrip 属性设定了指定单元格的右键菜单。 [C#]
// DataGridView 的 ContextMenuStrip 设定
DataGridView1.ContextMenuStrip = this.ContextMenuStrip1;
// 列的 ContextMenuStrip 设定
DataGridView1.Columns[0].ContextMenuStrip = this.ContextMenuStrip2;
// 列头的 ContextMenuStrip 设定
DataGridView1.Columns[0].HeaderCell.ContextMenuStrip = this.ContextMenuStrip2;
// 行的 ContextMenuStrip 设定
DataGridView1.Rows[0].ContextMenuStrip = this.ContextMenuStrip3;
// 单元格的 ContextMenuStrip 设定
DataGridView1[0, 0].ContextMenuStrip = this.ContextMenuStrip4;
对于单元格上的右键菜单的设定，优先顺序是：　Cell > Row > Column > DataGridView
CellContextMenuStripNeeded、RowContextMenuStripNeeded　事件
利用　CellContextMenuStripNeeded　事件可以设定单元格的右键菜单，尤其但需要右键菜单根据单元格值的变化而变化的时候。比起使用循环遍历，使用该事件来设定右键菜单的效率更高。但是，在DataGridView使用了DataSource绑定而且是VirtualMode的时候，该事件将不被引发。
[C#]
//　CellContextMenuStripNeeded事件处理方法
private void DataGridView1_CellContextMenuStripNeeded(object sender,
DataGridViewCellContextMenuStripNeededEventArgs e)
{
DataGridView dgv = (DataGridView)sender;
if (e.RowIndex < 0)
{
//　列头的ContextMenuStrip设定
e.ContextMenuStrip = this.ContextMenuStrip1;
}
else if (e.ColumnIndex < 0)
{
//　行头的ContextMenuStrip设定
e.ContextMenuStrip = this.ContextMenuStrip2;
}
else if (dgv[e.ColumnIndex, e.RowIndex].Value is int)
{
//　如果单元格值是整数时
e.ContextMenuStrip = this.ContextMenuStrip3;
}
}
同样，可以通过　RowContextMenuStripNeeded　事件来设定行的右键菜单。

[C#]
//　RowContextMenuStripNeeded事件处理方法
private void DataGridView1_RowContextMenuStripNeeded(object sender,
DataGridViewRowContextMenuStripNeededEventArgs e)
{
DataGridView dgv = (DataGridView)sender;
//　当"Column1"列是Bool型且为True时、设定其的ContextMenuStrip
object boolVal = dgv["Column1", e.RowIndex].Value;
Console.WriteLine(boolVal);
if (boolVal is bool && (bool)boolVal)
{
e.ContextMenuStrip = this.ContextMenuStrip1;
}
}

CellContextMenuStripNeeded　事件处理方法的参数中、「e.ColumnIndex=-1」表示行头、「e.RowIndex=-1」表示列头。RowContextMenuStripNeeded则不存在「e.RowIndex=-1」的情况。
DataGridView 的单元格的边框、网格线样式的设定
1) DataGridView 的边框线样式的设定
DataGridView 的边框线的样式是通过 DataGridView.BorderStyle 属性来设定的。 BorderStyle 属性设定值是一个
BorderStyle 枚举： FixedSingle（单线，默认）、Fixed3D、None。
2) 单元格的边框线样式的设定
单元格的边框线的样式是通过 DataGridView.CellBorderStyle 属性来设定的。 CellBorderStyle 属性设定值是
DataGridViewCellBorderStyle 枚举。（详细参见 MSDN）
另外，通过 DataGridView.ColumnHeadersBorderStyle 和 RowHeadersBorderStyle 属性可以修改 DataGridView 的头部的单元格边框线样式。属性设定值是 DataGridViewHeaderBorderStyle 枚举。（详细参见 MSDN）
3）单元格的边框颜色的设定
单元格的边框线的颜色可以通过 DataGridView.GridColor 属性来设定的。默认是 ControlDarkDark 。但是只有在 CellBorderStyle 被设定为 Single、SingleHorizontal、SingleVertical 的条件下才能改变其边框线的颜色。同样，ColumnHeadersBorderStyle 以及 RowHeadersBorderStyle 只有在被设定为 Single 时，才能改变颜色。
4）单元格的上下左右的边框线式样的单独设定
CellBorderStyle只能设定单元格全部边框线的式样。要单独改变单元格某一边边框式样的话，需要用到DataGridView.AdvancedCellBorderStyle属性。如示例：
同样，设定行头单元格的属性是： AdvancedRowHeadersBorderStyle，设定列头单元格属性是：AdvancedColumnHeadersBorderStyle。
&e327; DataGridView 单元格表示值的自定义
通过CellFormatting事件，可以自定义单元格的表示值。（比如：值为Error的时候，单元格被设定为红色）
下面的示例：将“Colmn1”列的值改为大写。
[C#]
//CellFormatting 事件处理方法
private void DataGridView1_CellFormatting(object sender,
DataGridViewCellFormattingEventArgs e)
{
DataGridView dgv = (DataGridView)sender;

// 如果单元格是“Column1”列的单元格
if (dgv.Columns[e.ColumnIndex].Name == "Column1" && e.Value is string)
{
// 将单元格值改为大写
string str = e.Value.ToString();
e.Value = str.ToUpper();
// 应用该Format，Format完毕。
e.FormattingApplied = true;
}
}CellFormatting事件的DataGridViewCellFormattingEventArgs对象的Value属性一开始保存着未被格式化的值。当Value属性被设定表示用的文本之后，把FormattingApplied属性做为True，告知DataGridView文本已经格式化完毕。如果不这样做的话，DataGridView会根据已经设定的Format，NullValue，DataSourceNullValue，FormatProvider属性会将Value属性会被重新格式化一遍。
&e328; DataGridView 用户输入时，单元格输入值的设定
通过 DataGridView.CellParsing 事件可以设定用户输入的值。下面的示例：当输入英文文本内容的时候，立即被改变为大写。
[C#]
//CellParsing 事件处理方法
private void DataGridView1_CellParsing(object sender,
DataGridViewCellParsingEventArgs e)
{
DataGridView dgv = (DataGridView)sender;

//单元格列为“Column1”时
if (dgv.Columns[e.ColumnIndex].Name == "Column1" &&
e.DesiredType == typeof(string))
{
//将单元格值设为大写
e.Value = e.Value.ToString().ToUpper();
//解析完毕
e.ParsingApplied = true;
}
}
DataGridView 新加行的默认值的设定
需要指定新加行的默认值的时候，可以在DataGridView.DefaultValuesNeeded事件里处理。在该事件中处理除了可以设定默认值以外，还可以指定某些特定的单元格的ReadOnly属性等。
[C#]
// DefaultValuesNeeded 事件处理方法
private void DataGridView1_DefaultValuesNeeded(object sender,
DataGridViewRowEventArgs e)
{
// 设定单元格的默认值
e.Row.Cells["Column1"].Value = 0;
e.Row.Cells["Column2"].Value = "-";

本文链接

C#下用P2P技术实现点对点聊天

2010-05-19T05:04:00Z

NET将关于多线程的功能定义在System.Threading名字空间中。因此，要使用多线程，必须先声明引用此名字空间（using System.Threading;）。
即使你没有编写多线程应用程序的经验，也可能听说过“启动线程”“杀死线程”这些词，其实除了这两个外，涉及多线程方面的还有诸如“暂停线程”“优先级”“挂起线程”“恢复线程”等等。下面将一个一个的解释。
a.启动线程
顾名思义，“启动线程”就是新建并启动一个线程的意思，如下代码可实现：
Thread thread1 = new Thread(new ThreadStart( Count));
其中的 Count 是将要被新线程执行的函数。
b.杀死线程
“杀死线程”就是将一线程斩草除根，为了不白费力气，在杀死一个线程前最好先判断它是否还活着（通过 IsAlive 属性），然后就可以调用 Abort 方法来杀死此线程。
c.暂停线程
它的意思就是让一个正在运行的线程休眠一段时间。如 thread.Sleep(1000); 就是让线程休眠1秒钟。
d.优先级
这个用不着解释了。Thread类中有一个ThreadPriority属性，它用来设置优先级，但不能保证操作系统会接受该优先级。一个线程的优先级可分为5种：Normal, AboveNormal, BelowNormal, Highest, Lowest。具体实现例子如下:
thread.Priority = ThreadPriority.Highest;
e.挂起线程
Thread类的Suspend方法用来挂起线程，知道调用Resume，此线程才可以继续执行。如果线程已经挂起，那就不会起作用。
if (thread.ThreadState = ThreadState.Running)
{
thread.Suspend();
}
f.恢复线程
用来恢复已经挂起的线程，以让它继续执行，如果线程没挂起，也不会起作用。
if (thread.ThreadState = ThreadState.Suspended)
{
thread.Resume();
}
下面将列出一个例子，以说明简单的线程处理功能。此例子来自于帮助文档。
using System;
using System.Threading;

// Simple threading scenario: Start a static method running
// on a second thread.
public class ThreadExample {
// The ThreadProc method is called when the thread starts.
// It loops ten times, writing to the console and yielding
// the rest of its time slice each time, and then ends.
public static void ThreadProc() {
for (int i = 0; i < 10; i++) {
Console.WriteLine("ThreadProc: {0}", i);
// Yield the rest of the time slice.
Thread.Sleep(0);
}
}

public static void Main() {
Console.WriteLine("Main thread: Start a second thread.");
// The constructor for the Thread class requires a ThreadStart
// delegate that represents the method to be executed on the
// thread. C# simplifies the creation of this delegate.
Thread t = new Thread(new ThreadStart(ThreadProc));
// Start ThreadProc. On a uniprocessor, the thread does not get
// any processor time until the main thread yields. Uncomment
// the Thread.Sleep that follows t.Start() to see the difference.
t.Start();
//Thread.Sleep(0);

for (int i = 0; i < 4; i++) {
Console.WriteLine("Main thread: Do some work.");
Thread.Sleep(0);
}

Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.");
t.Join();
Console.WriteLine("Main thread: ThreadProc.Join has returned. Press Enter to end program.");
Console.ReadLine();
}
}

此代码产生的输出类似如下内容：

Main thread: Start a second thread.
Main thread: Do some work.
ThreadProc: 0
Main thread: Do some work.
ThreadProc: 1
Main thread: Do some work.
ThreadProc: 2
Main thread: Do some work.
ThreadProc: 3
Main thread: Call Join(), to wait until ThreadProc ends.
ThreadProc: 4
ThreadProc: 5
ThreadProc: 6
ThreadProc: 7
ThreadProc: 8
ThreadProc: 9
Main thread: ThreadProc.Join has returned. Press Enter to end program.

转自http://benben.javaeye.com/blog/279240

本文链接

C# Delegate(委托)与多线程

2010-05-19T05:02:00Z

C# Delegate(委托)与多线程

   很多时候写windows程序都需要结合多线程，在.net中用如下得代码来创建并启动一个新的线程。
    public void ThreadProc();
    Thread thread = new Thread(new ThreadStart(ThreadProc));
    thread.IsBackground = true;
    thread.Start();
    但是很多时候，在新的线程中，我们需要与UI进行交互，在.net中不允许我们直接这样做。可以参考MSDN中的描述：
    “Windows 窗体”使用单线程单元 (STA) 模型，因为“Windows 窗体”基于本机 Win32 窗口，而 Win32 窗口从本质上而言是单元线程。STA 模型意味着可以在任何线程上创建窗口，但窗口一旦创建后就不能切换线程，并且对它的所有函数调用都必须在其创建线程上发生。除了 Windows 窗体之外，.NET Framework 中的类使用自由线程模型。
    STA 模型要求需从控件的非创建线程调用的控件上的任何方法必须被封送到（在其上执行）该控件的创建线程。基类 Control 为此目的提供了若干方法（Invoke、BeginInvoke 和 EndInvoke）。Invoke 生成同步方法调用；BeginInvoke 生成异步方法调用。
    Windows 窗体中的控件被绑定到特定的线程，不具备线程安全性。因此，如果从另一个线程调用控件的方法，那么必须使用控件的一个 Invoke 方法来将调用封送到适当的线程。
    正如所看到的，我们必须调用Invoke方法，而BeginInvoke可以认为是Invoke的异步版本。调用方法如下：
    public delegate void OutDelegate(string text);
    public void OutText(string text)
    {
         txt.AppendText(text);
         txt.AppendText( "\t\n" );
    }
    OutDelegate outdelegate = new OutDelegate( OutText );
    this.BeginInvoke(outdelegate, new object[]{text});

    如果我们需要在另外一个线程里面对UI进行操作，我们需要一个类似OutText的函数，还需要一个该函数的委托delegate，当然，这里展示的是自定义的，.net中还有很多其他类型的委托，可以直接使用，不需要而外声明。例如：MethodInvoker和EventHandler，这两种类型委托的函数外观是固定的，MethodInvoker是void Function()类型的委托，而EventHandler是void Function(object, EventArgs)类型的委托，第一个不支持参数，第二中的参数类型和数量都是固定的，这两种委托可以很方便的调用，但是缺乏灵活性。请注意 BeginInvoke前面的对象是this，也就是主线程。现在再介绍Control.InvokeRequired，Control是所有控件的基类，对于这个属性MSDN的描述是：
    获取一个值，该值指示调用方在对控件进行方法调用时是否必须调用 Invoke 方法，因为调用方位于创建控件所在的线程以外的线程中。
该属性可用于确定是否必须调用 Invoke 方法，当不知道什么线程拥有控件时这很有用。
    也就是说通过判断InvokeRequired可以知道是否需要用委托来调用当前控件的一些方法，如此可以把OutText函数修改一下：
    public delegate void OutDelegate(string text);
    public void OutText(string text)
    {
         if( txt.InvokeRequired )
         {
             OutDelegate outdelegate = new OutDelegate( OutText );
             this.BeginInvoke(outdelegate, new object[]{text});
             return;
         }
         txt.AppendText(text);
         txt.AppendText( "\t\n" );
    }
    注意，这里的函数没有返回，如果有返回，需要调用Invoke或者EndInvoke来获得返回的结果，不要因为包装而丢失了返回值。如果调用没有完成，Invoke和EndInvoke都将会引起阻塞。
    现在如果我有一个线程函数如下：
    public void ThreadProc()
    {
         for(int i = 0; i < 5; i++)
         {
             OutText( i.ToString() );
             Thread.Sleep(1000);
         }
    }
    如果循环的次数很大，或者漏了Thread.Sleep(1000);，那么你的UI肯定会停止响应，想知道原因吗？看看BeginInvoke前面的对象，没错，就是this，也就是主线程，当你的主线程不停的调用OutText的时候，UI当然会停止响应。
    与以前VC中创建一个新的线程需要调用AfxBeginThread函数，该函数中第一个参数就是线程函数的地址，而第二个参数是一个类型为 LPVOID的指针类型，这个参数将传递给线程函数。现在我们没有办法再使用这种方法来传递参数了。我们需要将传递给线程的参数和线程函数包装成一个单独的类，然后在这个类的构造函数中初始化该线程所需的参数，然后再将该实例的线程函数传递给Thread类的构造函数。代码大致如下：
    public class ProcClass
    {
         private string procParameter = "";
         public ProcClass(string parameter)
         {
             procParameter = parameter;
         }
         public void ThreadProc()
         {
         }
    }
    ProcClass threadProc = new ProcClass("use thread class");
    Thread thread = new Thread( new ThreadStart( threadProc.ThreadProc ) );
    thread.IsBackground = true;
    thread.Start();
    就是这样，需要建立一个中间类来传递线程所需的参数。
    那么如果我的线程又需要参数，又需要和UI进行交互的时候该怎么办呢？可以修改一下代码：
    public class ProcClass
    {
         private string procParameter = "";
         private Form1.OutDelegate delg = null;
         public ProcClass(string parameter, Form1.OutDelegate delg)
         {
             procParameter = parameter;
             this.delg = delg;
         }
         public void ThreadProc()
         {
             delg.BeginInvoke("use ProcClass.ThreadProc()", null, null);
         }
    }
    ProcClass threadProc = new ProcClass("use thread class", new OutDelegate(OutText));
    Thread thread = new Thread( new ThreadStart( threadProc.ThreadProc ) );
    thread.IsBackground = true;
    thread.Start();
    //-----------------------以下为自己写的异步委托的例子------------------------
     namespace PhsControlDelegate
     {
          public partial class Form2 : Form
          {
               PhsControl.phsControl phsObj = new PhsControl.phsControl();
               public delegate void OperationDelegate(string strMessage);

               public Form2()
               {
                    phsObj.OnJieShouDuanXin +=new PhsControl.JieShouDXHandler(phsObj_OnJieShouDuanXin);
               }

               public void SetText(string strMessage)
               {
                    txtReceive.AppendText(strMessage);
               }

               protected void phsObj_OnJieShouDuanXin(Object sender, PhsControl.jsSmsArgs e)
               {
                    OperationDelegate optionDelgate = new OperationDelegate(SetText);

                    this.BeginInvoke(optionDelgate, new object[] { e.dhHaoMa + " " + e.dxNeiRong + "\t\n" });
               }
          }
     }

转自 http://kenter1643.javaeye.com/blog/415701

本文链接

SQL 连接 JOIN 例解。左连接，右连接，全连接，等

2010-05-05T08:09:00Z

SQL 连接 JOIN 例解。（左连接，右连接，全连接，内连接，交叉连接，自连接）

假设有如下表：

一个为投票主表，一个为投票者信息表～记录投票人IP及对应投票类型，左右连接实际说是我们联合查询的结果以哪个表为准～
1：如右接连 right join 或 right outer join：

我们以右边voter表为准，则左表(voteMaster)中的记录只有当其ID在右边(voter)中存在时才会显示出来，如上图，左边中ID为3.4.5.6因为这些ID右表中没有相应记录，所以没有显示！
2：因此我们自然能理解左连接 left join 或者 left outer join

可见，现在右边中ID在中存在时才会显示，当右边中没有相应数据时则用NULL代替！
3：全连接 full join 或者 full outer join,为二个表中的数据都出来，这里演示效果与上一样！
4：内连接 inner join 或者 join;它为返回字段ID同时存在于表voteMaster 和 voter中的记录

5：交叉连接（完全连接）cross join 不带 where 条件的
没有 WHERE 子句的交叉联接将产生联接所涉及的表的笛卡尔积。第一个表的行数乘以第二个表的行数等于笛卡尔积结果集的大小。（table1和table2交叉连接产生6*3=18条记录）

等价select vm.id,vm.voteTitle,vt.ip from voteMaster as vm,voter as vt

6:自连接。在这里我用我前段时间一个电力项目中的例子（改造过）
如下表：

这是一个部门表，里面存放了部门及其上级部门，但都放在同一张表中，我们假设现在需要用SQL查询出各部门及其上级部门！就如何做，
当然，不用自连接也一样，可以如下：

我们达到预期目的！在这个查询中使用了一个子查询完成对上级部门名的查询，如果使用自连接，那么结构上感觉会清晰很多。

是不是也同样完成了功能呢，这里除了使用自连接外，还使用了左连接，因为省电力没有上级部门，他是老大，如果使用内连接，就会把这条记录过滤掉，因为没有和他匹配的上级部门。
自连接用的比较多的就是对权形结构的查询！类似上表！

本文链接

Settings 设置(2010-04-26)

2010-04-26T07:46:00Z

//------------------------------------------------------------------------------
// <auto-generated>
//     此代码由工具生成。
//     运行库版本:2.0.50727.3603
//
//     对此文件的更改可能会导致不正确的行为，并且如果
//     重新生成代码，这些更改将会丢失。
// </auto-generated>
//------------------------------------------------------------------------------

namespace Mtxspfrom.Config {


    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "9.0.0.0")]
    internal sealed partial class SetUser : global::System.Configuration.ApplicationSettingsBase {

        private static SetUser defaultInstance = ((SetUser)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new SetUser())));

        public static SetUser Default {
            get {
                return defaultInstance;
            }
        }

        [global::System.Configuration.UserScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("False")]
        public bool Setting {
            get {
                return ((bool)(this["Setting"]));
            }
            set {
                this["Setting"] = value;
            }
        }

        [global::System.Configuration.UserScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("True")]
        public bool get {
            get {
                return ((bool)(this["get"]));
            }
            set {
                this["get"] = value;
            }
        }

        [global::System.Configuration.UserScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("测试1")]
        public string test1 {
            get {
                return ((string)(this["test1"]));
            }
            set {
                this["test1"] = value;
            }
        }

        [global::System.Configuration.UserScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("测试2")]
        public string test2 {
            get {
                return ((string)(this["test2"]));
            }
            set {
                this["test2"] = value;
            }
        }
    }
}

/////////////////////////////////////////////窗体区域////////////////////////////////////////////////////

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Mtxspfrom.Config;
using System.Configuration;

namespace Mtxspfrom.Show
{
    public partial class Set_Form : Form
    {
        private SetUser user = new SetUser();

internal SetUser SetUser
        {
            get
            {
                return user;
            }
            set
            {
                user = value;
            }
        }

public Set_Form()
        {
            InitializeComponent();
        }

public void UpdateOptionSetting()
        {
            if (checkBox1.Checked)
                user.Setting = true;
            else
                user.Setting = false;

if (checkBox2.Checked)
                user.get = true;
            else
                user.get = false;
            user.test1 = txt_one.Text.ToString();
            user.test2 = txt_two.Text.ToString();
        }

//窗体加载读取配置信息
        private void Set_Form_Load(object sender, EventArgs e)
        {
            button2.Text = user.test1;
            if (user.Setting)
                checkBox1.Checked = true;
            else
                checkBox1.Checked = false;

if (user.get)
                checkBox2.Checked = true;
            else
                checkBox2.Checked = false;
            txt_one.Text = user.test1;
            txt_two.Text = user.test2;
        }

private void btn_test_Click(object sender, EventArgs e)
        {
            UpdateOptionSetting();
            user.Save();
            //这里需要线程来执行窗体再加载和用户提示加载进度(类似保存中....20%)
            Set_Form_Load(sender, e);
        }

private void btn_tests_Click(object sender, EventArgs e)
        {
            this.Close();
        }
    }
}

本文链接