博客园_wudi

转：http://www.cnblogs.com/chuncn/archive/2009/09/07/1561564.html

使用HtmlAgilityPack批量抓取网页数据

2011-01-07T09:31:00Z

登录的处理。因为有些网页数据需要登陆后才能提取。这里要使用ieHTTPHeaders来提取登录时的提交信息。

抓取网页

HtmlAgilityPack.HtmlDocument htmlDoc;

            if (!string.IsNullOrEmpty(登录URL))
            {
                htmlDoc = htmlWeb.Load(登录URL, 提交的用户验证信息, 获取数据的网页URL);
            }
            else
            {
                htmlDoc = htmlWeb.Load(获取数据的网页URL);
            }

ArrayList list = new ArrayList();
            list.add("//table/tr[1]/td");
            list.add("//table/tr[2]/td");
            //获取循环的节点的xpath，比如：//table/tr
            HtmlNodeCollection repeatNodes = htmlDoc.DocumentNode.SelectNodes("//table/tr");

            //循环节点
            foreach (HtmlNode node in repeatNodes)
            {
                //循环获取数据
                foreach (string dataPath in list)
                {

                    HtmlNode dataNode = node.SelectSingleNode(list);
                    if (dataNode != null)
                    {
                        string text = dataNode.InnerText;
                    }

                }
            }

如果出现乱码，调整编码集为gb2312或者是utf-8

htmlWeb.DefaultEncoding = System.Text.Encoding.GetEncoding(strEncode);

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

using System;

using System.Collections.Generic;

using System.Text;

using Microsoft.VisualStudio.TestTools.WebTesting;

using HtmlAgilityPack;

public class WebTest1Coded : WebTest

{

public override IEnumerator<WebTestRequest> GetRequestEnumerator()

{

WebTestRequest request1 = new WebTestRequest("http://www.microsoft.com/");

request1.ValidateResponse += new EventHandler<ValidationEventArgs>(request1_ValidateResponse);

yield return request1;

}

void request1_ValidateResponse(object sender, ValidationEventArgs e)

{

//load the response body string as an HtmlAgilityPack.HtmlDocument

HtmlAgilityPack.HtmlDocument doc = new HtmlAgilityPack.HtmlDocument();

doc.LoadHtml(e.Response.BodyString);

//locate the "Nav" element

HtmlNode navNode = doc.GetElementbyId("Nav");

//pick the first <li> element

HtmlNode firstNavItemNode = navNode.SelectSingleNode(".//li");

//validate the first list item in the Nav element says "Windows"

e.IsValid = firstNavItemNode.InnerText == "Windows";

}

}

Jquery each

2010-11-04T10:10:00Z

json="[{"Id":6065,"TenantID":100001,"FromUserId":"100002","ToUserId":100000001,"Subject":"标题",

"Content":"内容","SendMode":1,"SendTime":"2010-11-04 16:55","MessageType":3,

"FK_MessageCategory_ID":0,"ActionLink":"个人报告地址","Status":0}]";

 json=eval(json);

$.each(json,function(){

alert(this.Id);

});

堆？栈？(转）

2010-11-01T10:36:00Z

堆栈
在计算机领域，堆栈是一个不容忽视的概念，但是很多人甚至是计算机专业的人也没有明确堆栈其实是两种数据结构。

要点：

堆：顺序随意

栈：先进后出

堆和栈的区别

一、预备知识—程序的内存分配

一个由c/C++编译的程序占用的内存分为以下几个部分

1、栈区（stack）— 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区（heap） — 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放

4、文字常量区 —常量字符串就是放在这里的。程序结束后由系统释放

5、程序代码区—存放函数体的二进制代码。

二、例子程序

这是一个前辈写的，非常详细

//main.cpp

int a = 0; 全局初始化区

char *p1; 全局未初始化区

main()

{

int b; 栈

char s[] = "abc"; 栈

char *p2; 栈

char *p3 = "123456"; 123456\0在常量区，p3在栈上。

static int c =0；全局（静态）初始化区

p1 = (char *)malloc(10);

p2 = (char *)malloc(20);

分配得来得10和20字节的区域就在堆区。

strcpy(p1, "123456"); 123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。

}

二、堆和栈的理论知识

2.1申请方式

stack:

由系统自动分配。例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间

heap:

需要程序员自己申请，并指明大小，在c中malloc函数

如p1 = (char *)malloc(10);

在C++中用new运算符

如p2 = (char *)malloc(10);

但是注意p1、p2本身是在栈中的。

2.2

申请后系统的响应

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，

会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。
2.3申请大小的限制

栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

2.4申请效率的比较：

栈由系统自动分配，速度较快。但程序员是无法控制的。

堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.

另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活

2.5堆和栈中的存储内容

栈：在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。

当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

2.6存取效率的比较

char s1[] = "aaaaaaaaaaaaaaa";

char *s2 = "bbbbbbbbbbbbbbbbb";

aaaaaaaaaaa是在运行时刻赋值的；

而bbbbbbbbbbb是在编译时就确定的；

但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。

比如：

#include

void main()

{

char a = 1;

char c[] = "1234567890";

char *p ="1234567890";

a = c[1];

a = p[1];

return;

}

对应的汇编代码

10: a = c[1];

00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]

0040106A 88 4D FC mov byte ptr [ebp-4],cl

11: a = p[1];

0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]

00401070 8A 42 01 mov al,byte ptr [edx+1]

00401073 88 45 FC mov byte ptr [ebp-4],al

第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。
2.7小结：

堆和栈的区别可以用如下的比喻来看出：

使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。

使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

堆和栈的区别主要分：

操作系统方面的堆和栈，如上面说的那些，不多说了。

还有就是数据结构方面的堆和栈，这些都是不同的概念。这里的堆实际上指的就是（满足堆性质的）优先队列的一种数据结构，第1个元素有最高的优先权；栈实际上就是满足先进后出的性质的数学或数据结构。

虽然堆栈，堆栈的说法是连起来叫，但是他们还是有很大区别的，连着叫只是由于历史的原因。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zlp8383178/archive/2007/06/19/1657897.aspx

数据库并发控制！！！

2010-10-29T13:49:00Z

实验环境：

w Visual Studio .NET 2005

w SQL Server 2005

w 其它说明：

w SQL Server 2000 + VS.NET 2003 也可以

w 需要对代码做细微调整

w 源代码及数据库见附件

设某银行存款帐户数据如下表：

w 现在要求编写一程序，完成两项功能：存款与取款。每次操作完成后向明细表中插入一行记录并更新帐户余额

并发控制案例

解决办法：

w ① 读取最后一行记录的帐户余额数据

w ② 根据存、取款金额计算出新的帐户余额

w ③ 将新的记录插入表中

§ 真的这么简单？

w 在不考虑并发问题的情况下是可行的

w 如果考虑并发，问题就多了

问题所在：并发问题！

§ 解决办法：加锁！

w 在读最后一条记录时先加上锁。

§ 怎么加锁？加什么锁？

w 读之前加共享锁？

w 读之前加排它锁？

如何读取帐户余额？

         SELECT TOP 1 帐户余额

                   FROM 帐户明细

                  ORDER BY 序号 DESC

存在的问题：
在并发场景下你怎么确定它一定是最后一行？
随着数据量增大越来越没效率（因为需要排序）

为什么引入冗余数据？

w 确保帐户余额在唯一的地方进行存储

w 避免了读取帐户余额时访问大量数据并排序

§ 新问题：

w 我们无法直接对数据库进行锁操作

w 必须通过合理的事务隔离级别完成并发控制

§ ReadUnCommitted

§ ReadCommitted

§ RepeatableRead

§ Serializable

看来我们必须对各事务隔离级别逐一分析
① ReadUnCommitted

w 显然不行

w 在这个事务隔离级别下连脏数据都可能读到，何况“脏”帐户余额数据。

w ② ReadCommitted

w 也不行

w 该隔离级别与二级封锁协议相对应。读数据前加共享锁，读完就释放。前面分析过，此处不再赘述。

③ RepeatableRead

w 这个隔离级别比较迷惑人，需要仔细分析：

w RepeatableRead对应第三级封锁协议：读前加共享锁，事务完成才释放。

w 例：

w 假设事务1执行存钱操作，首先对帐户余额加S锁，然后修改数据。此时事务2要想改帐户余额，它必须先加X锁（自然加不上），所以无法完成操作。

w 这似乎避免了并发问题的发生，在一个事务执行时将另一个事务的修改请求暂时阻塞，直到事务完成。

w 但真的能满足应用程序的需要吗？

w 可见RepeatableRead事务隔离级别容易造成死锁。

w 一旦出现死锁，DMBS不得不牺牲一个进程。

w 牺牲进程换来的是不会出现并发异常。

§ ④ Serializable

w 该事务隔离级别在执行时可以避免幻影读。

w 但对于本案例执行效果与RepeatableRead一样。

似乎走到了绝路

w 连最高隔离级别都会在高度并发时因为死锁造成很大一部分事务执行失败

§ 原因分析

w 死锁的原因是因为读前加S锁，而写前要将S锁提升为X锁，由于S锁允许共享，导致X锁提升失败，产生死锁。

§ 解决办法

w 如果在读时就加上X锁，就可避免上述问题

w 从封锁协议角度这似乎不可能，但确完全可行！

解决办法：

w 其实SQL Server允许在一条命令中同时完成读、写操作，这就为我们提供了入手点。

w 在更新帐户余额的同时读取帐户余额，就等同于在读数据前加X锁。命令如下：

UPDATE Account

SET @newBalance = Balance = Balance + 100

WHERE AccountID = 1

w 上面的命令对帐户余额增加100元（蓝色部分）

w 同时读取更新后的帐户余额到变量@newBalance中

w 由于读取操作融入写操作中，实现了读时加X锁，避免因锁的提升造成死锁。

完成存取款的操作可由下面的伪代码实现

@amount = 存取款的金额
BEGIN TRANSACTION
Try
{

UPDATE Account
SET @newBalance = Balance = Balance + @amount
WHERE AccountID = 1

INSERT INTO AccountDetail (AccountID, Amount, Balance)
VALUES (1, @amount, @newBalance)

COMMIT

}
Catch
{
ROLLBACK
}

改造结果：

w 通过上述改造，事务中只有写操作而没有了读操作

w 因此甚至将事务隔离级别设置为ReadUnCommitted都能确保成功执行

w 写前加X锁，避免了因提升S锁造成死锁的可能

§ 实验结果：

w 所有并行执行的事务全部成功

w 帐户余额全部正确

w 程序执行时间同串行执行各事务相同

- 解决办法：
w 使用存储过程

§ 修改后的更新过程：

w 1、将存、取款用到的数据通过网络发给存储过程。

w 2、数据加锁、修改、解锁。

w 3、将结果通过网络回传。

将网络延迟放到了事务之外，提高了事务效率。

还有可优化的余地

w 网络带宽受到限制时，数据在网络上传输的时间往往比对数据进行读写操作的时间要长。

w 一个典型的更新过程：

w 1、读前加锁

w 2、帐户数据从网上传过来

w 3、修改、插入新记录

w 4、将改后的数据通过网络传回去

w 5、数据库提交更新并解锁。

如果网速很慢，资源锁定时间就很长。

实验结果

w 由于在同一台机器上执行数据库与应用程序，实验结果表明存储过程的执行效率不如直接在应用程序中通过命令调用高。

w 如果能在一个带宽受到限制的网络上将数据库与应用程序分离，然后测试，相信会有令人满意的结果。（有待具体实验证实）

Velocity脚本简明教程

2010-10-28T03:11:00Z

Velocity脚本简明教程转（http://home.beisencorp.com/space.php?uid=232&do=blog&id=984）

　　很多人下载了EasyJWeb的开源应用示例，但是对动态页面模板文件中的标签使用不是很熟悉，这里简单介绍一下。EasyJWeb特定把视图限定为Velocity，因为我们觉得在Velocity在表现上从可维护性、简洁性乃灵活性上，比JSP及其它视力技术表现强得多。虽然我们可以非常简单把EasyJWeb扩展成支持多种视力技术，但当前我们不打算这样做！
　　使用EasyJWeb的目的，是在于把页面－程序完成分开，就也就是一个项目中，程序员使用专业Java开发工具（如Eclipse、JBuilder等)来编写、调试、测试程序，页面制作人员使用专业的网页制作工具（如Macromedia Dreamweaver）来设计制作网页，而两者之间的协调通过一个规范的接口协议来解决。需要在页面里面加如一些标签，来生成动态内容，这一工作可以交由网页制作人员来完成。因为使用Velocity作为视图，由于他的语法、功能及使用方法都比较简单，因此一般情况下，一天以内就能让页面制作人员熟练掌握其用法。
　　Velocity是一个基于java的模板引擎（template engine），它允许任何人仅仅简单的使用模板语言（template language）来引用由java代码定义的对象。作为一个比较完善的模板引擎，Velocity的功能是比较强大的，但强大的同时也增加了应用复杂性。

一、基本语法

1、"#"用来标识Velocity的脚本语句，包括#set、#if 、#else、#end、#foreach、#end、#iinclude、#parse、#macro等；
如:
#if($info.imgs)
<img src="$info.imgs" border=0>
#else
<img src="noPhoto.jpg">
#end

2、"$"用来标识一个对象(或理解为变量)；如
如：$i、$msg、$TagUtil.options(...)等。

3、"{}"用来明确标识Velocity变量；
比如在页面中，页面中有一个$someonename，此时，Velocity将把someonename作为变量名，若我们程序是想在someone这个变量的后面紧接着显示name字符，则上面的标签应该改成${someone}name。

4、"!"用来强制把不存在的变量显示为空白。
如当页面中包含$msg，如果msg对象有值，将显示msg的值，如果不存在msg对象同，则在页面中将显示$msg字符。这是我们不希望的，为了把不存在的变量或变量值为null的对象显示为空白，则只需要在变量名前加一个“!”号即可。
如：$!msg

二、在EasyJWeb中的最佳实践

　　理论上你可以在EasyjWeb模板使用所有Velocity的脚本及功能，但我们不推荐你在界面模板中使用过多过复杂的脚本表达方式，在万不得已的情况下，不要在界面模板中加入任何复杂的逻辑，更不要在界面模板中加入变量声明、逻辑运算符等等。
在EasyJWeb中，我们提供了五条基本的模板脚本语句，基本上就能满足所有应用模板的要求。这四条模板语句很简单，可以直接由界面设计人员来添加。在当前很多EasyJWeb的应用实践中，我们看到，所有界面模板中归纳起来只有下面四种简单模板脚本语句即可实现：
　　 1、$!obj 　直接返回对象结果。
　　如：在html标签中显示java对象msg的值。<p>$!msg</p>
　在html标签中显示经过HtmlUtil对象处理过后的msg对象的值　　<p>$!HtmlUtil.doSomething($!msg)</p>

2、#if($!obj) #else #end 判断语句
　　如：在EasyJWeb各种开源应用中，我们经常看到的用于弹出提示信息msg的例子。
　　 #if($msg)
　　 <script>
　　 alert('$!msg');
　　 </script>
　　 #end
上面的脚本表示当对象msg对象存在时，输出<script>等后面的内容。

　3、#foreach( $info in $list) $info.someList #end　　循环读取集合list中的对象，并作相应的处理。
　　如：EasyJF开源论坛系统中论(0.3)坛首页显示热门主题的html界面模板脚本：
　　#foreach( $info in $hotList1)
<a href="/bbsdoc.ejf?easyJWebCommand=show&&cid=$!info.cid" target="_blank">$!info.title</a><br>
　　　 #end
　　上面的脚本表示循环遍历hotList1集合中的对象，并输出对象的相关内容。
　　
　　 4、#macro(macroName)#end 脚本函数(宏)调用，不推荐在界面模板中大量使用。
　　如：在使用EasyJWeb Tools快速生成的添删改查示例中，可以点击列表的标题栏进行升降排序显示，这是我们在EasyJWeb应用中经常看到的一个排序状态显示的模板内容。
　　函数(宏)定义，一般放在最前面
　　 #macro(orderPic $type)
　　 #if ($orderField.equals($type))
　　 <img src="http://images.cnblogs.com/ico/${orderType}.gif">
　　 #end
　　 #end
具体的调用如：<font color="#FFFFFF">头衔#orderPic("title")</font>

5、包含文件#inclue("模板文件名")或#parse("模板文件名")
　　主要用于处理具有相同内容的页面，比如每个网站的顶部或尾部内容。
　　使用方法，可以参考EasyJF开源Blog及EasyJF开源论坛中的应用！
　　如：#parse("/blog/top.html")或#include("/blog/top.html")
　　parse与include的区别在于，若包含的文件中有Velocity脚本标签，将会进一步解析，而include将原样显示。

三、关于#set的使用

　　在万不得已的时候，不要在页面视图自己声明Velocity脚本变量，也就是尽量少使用#set。有时候我们需要在页面中显示序号，而程序对象中又没有包含这个序号属性同，可以自己定义。如在一个循环体系中，如下所示：
　　#set ($i=0)
　　#foreach($info in $list)
　　序号:$i
　　#set($i=$i+1)
　　#end
　

四、Velocity脚本语法摘要

1、声明:#set ($var=XXX)
　　左边可以是以下的内容
　　Variable reference
　　String literal
　　Property reference
　　Method reference
　　Number literal #set ($i=1)
　　ArrayList #set ($arr=["yt1","t2"])
　　算术运算符

2、注释:
　　单行## XXX
　　多行#* xxx
　　xxxx
　　xxxxxxxxxxxx*#

　　References 引用的类型
3、变量 Variables
　　以 "$" 开头，第一个字符必须为字母。character followed by a VTL Identifier. (a .. z or A .. Z).
　　变量可以包含的字符有以下内容：
　　alphabetic (a .. z, A .. Z)
　　numeric (0 .. 9)
　　hyphen ("-")
　　underscore ("_")

4、Properties
　　$Identifier.Identifier
　　$user.name
　　hashtable user中的的name值.类似：user.get("name")

5、Methods
　　object user.getName() = $user.getName()

6、Formal Reference Notation
　　用{}把变量名跟字符串分开

　　如
　　#set ($user="csy"}
　　${user}name
　　返回csyname

　　$username
　　$!username
　　$与$!的区别
　　当找不到username的时候，$username返回字符串"$username"，而$!username返回空字符串""

7、双引号与引号
　　#set ($var="helo")
　　test"$var" 返回testhello
　　test'$var' 返回test'$var'
　　可以通过设置 stringliterals.interpolate=false改变默认处理方式

8、条件语句
　　#if( $foo )
　　 <strong>Velocity!</strong>
　　#end
　　#if($foo)
　　#elseif()
　　#else
　　#end
　　当$foo为null或为Boolean对象的false值执行.

9、逻辑运算符:== && || !

10、循环语句#foreach($var in $arrays ) // 集合包含下面三种Vector, a Hashtable or an Array
#end
　　#foreach( $product in $allProducts )
　　 <li>$product</li>
　　#end

　　#foreach( $key in $allProducts.keySet() )
　　 <li>Key: $key -> Value: $allProducts.get($key)</li>
　　#end

　　#foreach( $customer in $customerList )
　　 <tr><td>$velocityCount</td><td>$customer.Name</td></tr>
　　#end

11、velocityCount变量在配置文件中定义
　　# Default name of the loop counter
　　# variable reference.
　　directive.foreach.counter.name = velocityCount
　　# Default starting value of the loop
　　# counter variable reference.
　　directive.foreach.counter.initial.value = 1

12、包含文件
　　#include( "one.gif","two.txt","three.htm" )

13、Parse导入脚本
　　#parse("me.vm" )

14、#stop 停止执行并返回

15、定义宏Velocimacros ,相当于函数支持包含功能
　　#macro( d )
　　 <tr><td></td></tr>
　　#end
　　调用
　　#d()

16、带参数的宏
　　#macro( tablerows $color $somelist )
　　#foreach( $something in $somelist )
　　 <tr><td bgcolor=$color>$something</td></tr>
　　#end
　　#end

17、Range Operator
　　#foreach( $foo in [1..5] )

附：《浅析MVC框架中View层的优雅设计及实例》

　　　　　作者：EasyJF开源团队大峡
在基于B/S的应用程序开发中，从基本的技术分工上来说就是两大块，一是软件显示界面，另一个是程序逻辑。在N年前的脚本语言时代，无论是asp、php还是jsp，我们基本是都是把这两者柔和在一起的。尽管我们想方设法做好很多函数或者包含文件来努力达到软件的复用，但仍然无法满足多变的用户需求,这主要是因为以前的纯脚本编码方式无法很好支持及应用面向对象(OO)领域中的强大功能。

在常见的B/S软件项目中，界面的设计包括html界面、Wap界面及其它由文本字符协议为基本表示的界面等。以我们接触最多的html页面为例子，在做这些界面的时候往往需要美工先使用photoshop或fireworks等图形界面设计工具进行全局设计，然后再使用进行Dreamweaver等html页面制作工具进行加工制作。而强大的程序逻辑及后台处理都是由服务器端程序完成，这些程序具有较高的稳定性，其开发工具如JBuilder、Eclipse等对View层的界面无法很好的支持(当然那些用记事本写界面的应用除外)，这就使得很多MVC框架的设计都无法两全齐美。

作位一个比较友好的MVC的框架，在简化服务器应用开发的同时，还需要在View这一层设计上不要过多的影响到界面人员的工作，最基本的要求就是不要过多的加入一些设计软件不支持的标签等元素(如Struts的很多标签在Dreamweaver中都不支持)。这里我们以EasyJWeb为例，探讨在View层如何实现比较合理的设计。

EasyJWeb作为一个快速Java Web MVC框架，其设计目标不尽是要简化软件开发人员的代码书写工作，更是要能方便界面设计人员的工作。

当然，要使界面能跟后台程序逻辑能融合，显示界面及程序逻辑之间需要一定的对话协议在所难免。EasyJWeb作为一个MVC框架，同样也存在着这样的对话协议，这就是EasyJWeb中的界面模板标识语言。

在当前发布的版本中，EasyJWeb界面模板标识语言使用的是Apache开源的Velocity模板引擎(template engine)，当然以后会根据际需要加入更多的模板引擎以供框架应用者选择。

Velocity是一个基于java的模板引擎（template engine），它允许任何人仅仅简单的使用模板语言（template language）来引用由java代码定义的对象。作为一个比较完善的模板引擎，Velocity的功能是比较强大的，但强大的同时也增加了应用复杂性。

理论上你可以在EasyjWeb模板使用所有Velocity的脚本及功能，但我们不推荐你在界面模板中使用过多过复杂的脚本表达方式，在万不得已的情况下，不要在界面模板中加入任何复杂的逻辑，更不要在界面模板中加入变量声明、逻辑运算符等等。

在EasyJWeb中，我们提供了四条基本的模板脚本语句，基本上就能满足所有应用模板的要求。这四条模板语句很简单，可以直接由界面设计人员来添加。在当前很多EasyJWeb的应用实践中，我们看到，所有界面模板中归纳起来只有下面四种简单模板脚本语句即可实现：

1、$!obj 　直接返回对象结果。
　　
　　如：在html标签中显示java对象msg的值。<p>$!msg</p>
　　　　在html标签中显示经过HtmlUtil对象处理过后的msg对象的值.<p>$!HtmlUtil.doSomething($!msg)</p>

2、#if($!obj) #else #end 判断语句

如：在EasyJWeb各种开源应用中，我们经常看到的用于弹出提示信息msg的例子。
　　 #if($msg)
　　 <script>
　　 alert('$!msg');
　　 </script>
　　 #end
上面的脚本表示当对象msg对象存在时，输出<script>等后面的内容。

3、#foreach( $info in $list) $info.something #end　　循环读取集合list中的对象，并作相应的处理。
　　
　　如：EasyJF开源论坛系统中论坛首页显示热门主题的html界面模板脚本

#foreach( $info in $hotList1)
<a href="/bbsdoc.ejf?easyJWebCommand=show&&cid=$!info.cid" target="_blank">$!info.title</a><br>
　　　 #end
　　上面的脚本表示循环遍历hotList1集合中的对象，并输出对象的相关内容。
　　
　　 4、#macro(macroName)#end 脚本函数(宏)调用，不推荐在界面模板中大量使用。

如：在EasyJF简易订销管等系统中经常看到的一个排序状态显示的模板内容。
　　函数(宏)定义，一般放在最前面
　　 #macro(orderPic $type)
　　 #if ($orderField.equals($type))
　　 <img src="http://images.cnblogs.com/ico/${orderType}.gif">
　　 #end
　　 #end

具体的调用如：<font color="#FFFFFF">头衔#orderPic("title")</font>
本文链接

Visual Studio的调试技巧

2010-10-09T09:13:00Z

Visual Studio的调试技巧

【原文地址】Debugging Tips with Visual Studio 2010

【原文发表日期】 2010/8/19 10:48 AM

这是我写的关于VS2010和.Net4发布的博客系列的第26篇。

今天的博文包含了一些有用的能用于VS的调试技巧。我的朋友Scott Cate（他写了很多很好的关于VS使用技巧和窍门的博客）最近向我强调了这些很好的技巧，大部分使用VS的开发人员好像不知道这些技巧（即使他们大部分都在产品开发组呆过一阵子）。如果你还没有使用过这些技巧，希望这篇博文能帮你发现它们。它们学起来很容易，能帮你节省很多时间。

运行到光标（Ctrl+ F10）

我经常看见人们是这样来调试应用程序的：他们在应用程序需要调试的代码前设置一个断点，然后反复的敲F10/F11来逐步通过代码，直到到达他们真正想要研究的确切位置。有些时候他们需要仔细观察所跨过的每行代码，这样使用F10/F11 就很合理。但是更普遍的是，他们只想快点进入他们真正关心的那行代码——这是使用F10/F11 就不是最好的选择了。

相反，你可能想利用调试器支持的特性“运行到光标”。只需简单地把你的光标放在代码中你想程序运行到的那一行，然后同时敲Ctrl+F10。这样程序就会运行到光标所在的那一行，然后执行中止，由调试器控制——这样就节约了你反复敲击F10/F11到达那里的时间。即使你想运行到的那行代码不在当前调试的方法或类里，而是在一个独立的方法或类里，这也同样奏效。

条件断点

我们经常在可用性学习中见到另一个普遍的技巧：开发人员设置断点，运行程序，试着输入一些数据，当到达一个断点时，手工检查某种条件是不是成立，如果成立才决定进一步研究。如果条件不符合他们想要的，按F5继续执行程序，尝试另外一些输入，再手工重复同样的过程。

VS的条件断点功能提供了一个更加容易的方法来处理以上情况。条件断点允许你只在某种明确指定的条件成立时才中止执行，由调试器控制。这帮你免于手动检查/恢复你的程序，使得整个调试过程免去许多手工活，也不那么冗长乏味。

设置一个条件断点

设置一个条件断点十分简单，在代码里按F9为某一行设置一个断点：

然后右击断点——编辑器左边的红色圆圈，在右键菜单中，选择“条件…” ：

将弹出以下对话框，允许你指明某种条件，只有当这种条件成立时，断点才能达到。例如：我们可以通过写下面的表达式来指明，只有当paginatedDinners列表元素的个数小于10时，才中止程序，由调试器控制。

现在，当我重新运行程序来研究一下，调试器只在这个查找返回值小于10时，才中止程序执行。如果返回值不小于10 ，将不会触发断点。

命中次数功能

有时你只想在条件第N次成立时中止执行。例如：仅当第5次出现查找返回值小于10时，才中止执行。你这样启用这个功能：右击断点，选择“命中次数…”菜单命令。

将弹出以下对话框，允许你指明程序中断的条件：条件被第N次满足时，或者条件被满足的次数是N的倍数时，或者条件被满足的次数大于等于N次时。

机器/线程/进程筛选器

你可以右击断点，选择“筛选器…”菜单命令，来指明断点只在某台特定的机器，或某个特定的进程或线程中才能被触发。

跟踪点——当击中断点时自定义行为

很多人不知道的一个调试功能是使用跟踪点。跟踪点是一个断点，当它被击中时，某种自定义的宏会被触发执行。当你想研究你的应用程序而又不想中止执行程序时，这个功能特别有用。

我将用一个简单的控制台程序来演示如何使用跟踪点。下面是斐波那契数列的递归实现：

在上面的应用程序中，针对特定的输入，我们使用Console.WriteLine()来输出最后的斐波那契数列。假如我们想在调试过程中研究斐波那契的递归过程——而不停止调试的执行？跟踪点能帮我们很轻松地做到这一点。

设置跟踪点

你可以这样启用跟踪点：按F9在代码上设置一个断点，右击断点，在右键菜单中选择“命中条件…”菜单命令：

将弹出以下对话框——允许你指定当断点触发时，进行何种操作：

如上所示，我们指定每次当断点的条件成立时，打印跟踪信息。注意我们指定了想要输出的局部变量“X” 的值作为输出信息的一部分。局部变量能通过{变量名}的语法被引用。也有内嵌的命令（像$CALLER，$CALLSTACK， $FUNCTION等等）可以用来输出跟踪信息中常见的值。

上面对话框的底部，我们也选中了“继续执行”单选框——表示我们不希望调试器暂停程序。相反，程序会继续执行——只是我们自定义的跟踪信息会在每次断点条件满足时输出，就这点不同。

现在当我们运行程序时，我们会发现自定义的跟踪信息会自动出现在VS的输出窗口中——使我们能看到程序的递归过程。

你也可以选择为你的程序设置一个自定义跟踪监听器——这样跟踪点的输出信息就会被重定向到它里面，而不是VS的输出窗口里。

跟踪点——运行自定义的宏

上周我在伦敦做了一次演讲，听众中有个人问了这样一个问题：有没有可能当击中一个跟踪点时，自动输出所有的局部变量。

这个功能不是内置在VS中的，但是可以通过在VS中写一个自定义的宏来启用它，然后设置一个跟踪点，当它被击中时，调用这个宏。为了实现这个目的，打开VS中的宏窗口（工具->宏->宏菜单命令）。然后在项目管理器“MyMacros”结点下面，选择模板或者新建一个模板（如：添加一个名为“UsefulThings”的模板），再将下面的VB宏代码贴到模板里，并保存它：

Sub DumpLocals()

Dim outputWindow As EnvDTE.OutputWindow

outputWindow = DTE.Windows.Item(EnvDTE.Constants.vsWindowKindOutput).Object

Dim currentStackFrame As EnvDTE.StackFrame

currentStackFrame = DTE.Debugger.CurrentStackFrame

outputWindow.ActivePane.OutputString("*Dumping Local Variables*" + vbCrLf)

For Each exp As EnvDTE.Expression In currentStackFrame.Locals

outputWindow.ActivePane.OutputString(exp.Name + " = " + exp.Value.ToString() + vbCrLf)

End Sub

上面的宏代码依次检测当前堆栈，获取所有的局部变量，并将其显示在输出窗口。

使用DumpLocals自定义宏

在下面这个简单的应用程序中，我们可以利用自定义的“DumpLocals”宏：

在上面的Add方法的return语句上，按F9设置一个断点。右击断点，选择“命中条件…”菜单命令：

将弹出以下对话框，上例中，我们选中了“打印信息”的单选框，再手工指定希望输出的变量，而这里，我们选中“运行宏”的单选框，使它指向我们创建的自定义宏UsefulThings.DumpLocals：

我们仍然选中“继续执行”单选框，这样能保证当跟踪点被击中时，程序依然能够继续执行。

运行程序

现在当我们按F5运行程序，当调用Add方法时，我们将看见以下输出出现在VS输出窗口中。注意当跟踪点被击中时，宏是如何自动列出各个变量名及其值的。

总结

VS调试器功能非常丰富。我强烈建议大家抽出一些时间来学习它的所有功能。以上的技巧和诀窍只是很多大家没有真正意识到的功能中的一小部分。

我之前写过其他一些关于VS2010调试器改进的博客（包括数据标签固定，断点导入导出，保留最后值变量，等等）。我将发表更多关于VS2010的智能跟踪和转储文件调试支持的博文。这些技术提供了很多非常酷的新功能，会让程序(包括产品中的程序)的调试变得非常简单和强大。

也请务必看看Scott Cate很棒的VS2010技巧和诀窍系列，你可以学习如何更好的利用VS。他有一些非常棒的免费视频和博客。

也要看看Jim Griesmer很棒的VS调试技巧和诀窍系列。他有许多很好的可以利用的技巧和诀窍。

希望这能对您有所帮助。

Scott

《C#与.NET3.5高级程序设计(第4版)》笔记10

2010-10-09T08:32:00Z

第十章集合与泛型

.NET 平台最基础的容器是 System.Array类型。但是许多时候需要更灵活的数据结构，为了理解构建灵活和安全类型的容器，本章首先介绍了System.Collections命名空间。

然而，在 .NET2.0 发布之后，C# 编程语言就增强了支持CTS的新特性泛型。大多数泛型都在System.Collections.Generic命名空间中。泛型容器和它的非泛型版本相比有很多优势。最后，研究了如何构建自己的泛型成员、类、结构和接口。

10.1 System.Collections的类型

之前用到最多的容器就是System.Array了，但是有很多限制，最大问题就是不能动态调整大小，因此就需要更灵活的容器，这就需要用System.Collections空间中的类型来实现。

首先，在这个命名空间中，有许多的接口，如Icomparer、IEnumerable、IEnumerator等，实现对容器的各种操作的定义（添加、删除、遍历等），然而，前面一章说过了，接口本身不是很有用，而是在各种类型中实现之后，方可显示他们的作用，而 System.Collections 中的类就实现了这些接口。实际上，这个空间中的各种类就是一个容器，用于承载其他类型，容器本身的意义不大，而主要的意义是对其中的内容进行操作（删除、插入、排序等）。

经常用到的类包括：

ArrayList：动态大小的数组。

可以随心所欲的调整内容的大小，利用AddRange批量填充数组，利用Insert插入到指定位置，ToaArray方法可以返回一个Object 类型的数组。

Hashtable：哈希表，是数值键标识的对象集合。

Queue：先进先出队列。

具有 Dequeue、Enqueue和Peek主要方法，完成出队、进队和查看队头元素。

Stack：后进先出队列（栈）。

具有Pop、Push、Peek 主要方法，完成出栈、进栈和查看栈顶元素。

SortedList：和字典相似，但是可以通过顺序位置进行访问。

由于这些都是一些应用类，因此没必要详细介绍，多看看 MSDN 就熟悉了，只要知道用途，在使用过程中自然都理解了。

另外，还有一些不常用的类，比如 bitarray 等，还有一些抽象基类，以供构造强类型的容器。

此外，System.Collections下还存在一个Specialized 命名空间，它定义了一组更特定的类型。不再赘述， MSDN 即可。

实际上，System.Collections和System.Collections.Specialized目前已经算是遗留类型了，这些类型不应该用于在.NET2.0 或更高版本中开发的新项目中。原因不是这些类型很危险，而是性能问题而缺少类型安全。新项目应该忽略这两个命名空间中的类型，而是用System.Collections.Generic 命名空间中相关类型。

10.2 遗留类型的问题

这里不直接进入泛型概念，而是先说说遗留类型存在的问题。

(1) 装箱、拆箱的问题

装箱就是通过把变量保存在System.object中（一定是保存在System.object才是装箱哦，非System.object 不是装箱），将值类型显式转换为相应的引用类型（显然引用类型之间的转换不属于此类问题）。如果装箱一个值，则 CLR 会分配新对象到堆上并且将值类型的值复制到那个实例中，因此，返回给我们得就是新分配对象的引用。

如：

short s=25;

object objshort=s;//object objshort=(object)s;也是可以的

疑问：系统是在哪里记住一个装箱操作的原来类型的？

疑问：装箱后，原来的栈中的数据怎么处理呢？立刻释放还是？

相反的操作叫拆箱。拆箱就是把保存在对象引用中的值类型转换回栈上的相应值类型。注意，拆箱首先会验证收到的值类型是不是等价于装箱的类型，如果是就将值复制回本地栈变量上。

short anothershrot=(short)objshort;

显然，拆箱必须是强制的，手动的。

int anotherint=(int)objshort;

注：这句也是强制转换，但是若由于转换类型不兼容，因此运行时是要抛出异常的。其实装箱和拆箱很有用，这使得我们把所有东西都当成 object 类型，而 CLR 回负责内存相关额细节。

例如对于 ArryaList 类，其中有一些方法：

`1`	`public` `virtual` `int` `add(object` `value)`

2 {

`3`	`//............`

4 }

`5`	`public` `virtual` `object` `this(int` `index)`

6 {

`7`	`{get;set;}`

8 }

那么使用时：

`1`	`ArrayList mylist=new` `ArrayList();`

`2`	`mylist.add(10);`

`3`	`//显然这里先把10进行了装箱为一个object，然后传入add的，这个装箱过程是自动的`

`4`	`mylist.Add(new` `datatable());//显然，这个不是装箱操作，而是子类转父类的操作哦。`

`5`	`int` `i=(int)mylist[0];//要用类型索引器查看mylist的值，因为是返回的object类型，这是就要强制转换为原来的值类型。`

疑问：拆箱后，将值复制回原来的变量位置？还是重新分配栈空间？

拆箱和装箱造成的主要问题在于：

1 ）必须在托管堆上分配一个新的对象;

2 ）基于栈数据的值必须被转移到那个内存位置;

3 ）在拆箱时，保存在基于堆的对象中的值必须转移回栈;

4 ）堆上无用的对象最后会被回收。

这就是性能方面的问题。另外，装箱和拆箱在类型安全方面，也有缺失。要使用语法进行拆箱，需要使用强制转换运算符，但是转换是成功还是失败要到运行时才能知道，如果尝试转换为错误的数据类型，就会抛出异常。这时，就需要将一组值类型保存在不需要装箱的容器中，这就是泛型可以解决的问题之一。

(2) 类型安全和强类型集合问题

在某些情况下，我们需要非常灵活的容器来保存所有东西。但是大多数时候希望是类型安全的容器，只可以操作某个类型的数据点。在引入.NET2.0泛型之前，程序员通过手动构建强类型集合来实现类型安全。

比如自定义了一个类person，要构建人员的一个容器（集合），可以在另外一个类，personcollection类中定义ArrayList成员（用于保存 person 类型，但是这个ArrayList是可以保存任意类型的），并且配置所有成员操作强类型的person对象而不是object类型。这样就不用担心类型安全了，因为C#编译器会检查任何尝试插入不兼容类型的请求（而不是在运行时）。虽然自定义的集合可以确保类型安全，但是必须每一个希望包含的类型创建一个自定义集合。但这不仅重复劳动，而且难以维护。泛型集合就允许我们推迟到创建时才制定包含的类型。

另外，尽管 .NET 类库中到处有强类型集合，但是这些自定义容器并没有解决装箱问题。即使只处理某种数据类型，还是要分配某个类型的对象来保存数据等。这时还是需要泛型类型，总结起来，泛型的优势：

1 ）泛型提供更好的性能，因为他们不会导致装箱或拆箱损失;

2 ）泛型更类型安全，因为他们只包含我们指定的类型;

3 ）泛型大幅减少了构建自定义集合类型的需要，因为基类库提供了几个预置的容器。

10.3 System.Collections.Generic

这个命名空间中布满了泛型类型。和非泛型命名空间一样，这里包含了大量的类和接口容器（接口就不再赘述了），这些容器能容纳各种类型。

按照约定，泛型类型使用普通名字指定他们的占位符（当然一个泛型可以有无数个占位符），使用字母和字符串都可以，但是还是有通常的规则，T表示类型，Tkey表示键，Tvalue表示值。

许多泛型集合类（System.Collections.Generic中）都在System.Collections对应着一个非泛型副本。比如List<T> 对应ArrayList。

在实例化泛型类型时，必须带有new关键字和需要的构造函数参数。此外，需要指定在泛型类型定义中类型参数的替代类型。例如：

List<int> myint=new List<int>();

这样，这个 myint 将在其 List 中将定义时所有的占位符都替换为int。这样，我们就只能往myint中操作int类型了，而相应的内部也无需进行装箱和拆箱操作，因为里面的定义的参数类型均是只针对int的，而不是通用的object类型。

10.4 泛型的其他应用

虽大部分开发人员都使用基类库中已有的泛型类型，但是，我们当然可以构建自己的泛型成员和自定义的泛型类型。

（1）泛型方法

我们可以在普通的类和泛型类型中定义泛型方法：

例如：

`1`	`static` `void` `Swap<T>(ref` `T a ,` `ref` `T b)`

2 {

`3`	`Console.Write(“The type of T` `is` `{0}”,typeof(T));`

4 T temp;

5 temp=a;

6 a=b;

7 b=temp;

8 }

`1`	`注意，泛型方法在方法名称后、参数列表前定义类型参数的（占位符）。前面说过，只要你需要，下面都是合法的：`

static test<T,K>(ref T a , ref K b){}
static test<hahaha>(ref hahaha a){}

在调用这个方法时（实例方法和静态方法），当且仅当泛型方法需要参数，而且参数也要有基于类型参数的类型时（且包括所有类型参数时），可以选择省略类型参数，因为编译器会基于参数推断类型参数。如：

`1`	`int` `b1 = 1;`

`2`	`int` `b2 = 2;`

`3`	`Swap(ref` `b1,ref` `b2);//合法，因为可以通过b1和b2来判断T为int型了`

`4`	`Swap<int>(ref` `b1,ref` `b2);` `//合法`

但是若定义的泛型方法如下：

void Swap<T>(int a){}//带参数，但是没有类型参数

void Swap<T>(){}//不带参数

static void Swap<T,P>(ref T a, ref int b)//参数中没有完全包括所有类型参数

则调用时必须带上<T> 。

最后，实际上，定义的泛型方法的返回类型甚至也可以为T：

`1`	`static` `T test<T>()`

2 {

`3`	`Console.WriteLine(typeof(T));`

`4`	`T TEMP =` `default(T);`

`5`	`return` `TEMP;`

6 }

当然，似乎单独定义这样的方法意义不大。但是语法上是可以的。
最后，对于泛型方法的命名，它是否与现有成员方法冲突，是通过名称和类型参数的，而对于和成员变量，只通过名字来判断，例如，下面这两个显然不能同时定义的：

`01`	`static` `void` `test1<w>()`

02 {}

`03`	`static` `void` `test1<t>()`

04 {}

`05`	`//而下面两个则是可以共存不冲突的：`

`06`	`static` `void` `test1<w>()`

07 {}

`08`	`static` `void` `test1<t,w>()`

09 {}

`10`	`//而下面两个依然冲突：`

`11`	`public` `int` `test1;`

`12`	`static` `void` `test1<T>()`

13 {}

（2） 泛型结构和类

泛型结构和泛型类的定义方法是类似的。在他们内部，可以定义泛型方法（上面已经讲到）、泛型构造函数、泛型属性等各种泛型成员，当然也可以有普通成员。

`01`	`Public` `struct` `point<T>`

02 {

`03`	`Private T xpos;//泛型成员变量`

`04`	`Public point(T xval)//泛型构造函数`

05 {}

`06`	`Public T x//泛型属性`

07 {

`08`	`get{return` `xpos;}`

09 }

`10`	`Public` `void` `resetpoint()`

11 {

`12`	`Xpos=default(T);//利用default关键字获取占位符T的默认值`

13 }

14 }

从上面可以看出，类型参数可以出现在字段数据定义、构造函数参数、属性定义中，只要是任何涉及到类型的，都可以用类型参数，只要有必要。注意上面使用了default关键字来获取占位符的默认值。其实，这个关键字也可以用于非泛型的时候，比如：

int a=default(int); // 虽然没这个必要，但是语法正确。

（3）自定义泛型集合

实际上，由于基类库提供了大量的允许我们创建类型安全且高效的容器，一般情况下不需要再构建自定义的集合类型。它的大部分好处就是可以添加有独特名字的方法，而不是使用通用的方法名称而已。

但是，自定义的泛型方法也是比较麻烦的，要实现这个集合的目的，还需要实现泛型的接口，比如一个自定义泛型集合，要foreach来遍历它，则应该实现IEnumerable<T>, 而由于此接口是继承了IEnumerable 接口，因此，实际上需要在自定义泛型集合中实现两个接口。另外，一般设计的自定义泛型集合都是专门为某种类型比如car类型或者兼容类型设计的，如果我们期待着的T应该是car类型，那么在编写方法时就有可能访问了car类型的一个成员，显然编译器是无法通过的，因为在用户使用过程中，可能传入非car类型（这是可能的）。当一个类型参数未被关联时，称该泛型类型是未绑定，依据设计，未绑定的类型参数被假定为仅仅是object成员，所以不可能有其他类的特有成员和成员变量。

`1`	`Class cartest<T>//原本期待只能传入car类型`

2 {

`3`	`Public T Testcar;`

`4`	`static` `void` `test()`

5 {

`6`	`car temp=(car)Testcar;` `//可惜期待只是一厢情愿，编译器不知道，所以这里编译错误！`

7 }

在这里不再介绍自定义泛型集合的具体实现了。

（4）使用where关键字给泛型类型(或泛型方法)加约束条件

正如上面所说，开发人员编写自定义泛型集合，一般是为了对类型参数强制约束以构建更类型安全的容器中，通过where关键字，可以控制类型参数的各种特性（从而也就避免了上述的传入非期待的类型）。此时，若传入的类型参数不符合约束条件，将得到编译错误，而不是在运行期间，发生可能的异常抛出。

where 可以规定五个泛型约束：

where T：struct ，必须是值类型（并因为所有值类型都是结构体，所以就是约束必须是值类型）

where T：class ，非值类型，也就是引用类型

where T：new() ，必须有一个默认的构造函数，注意在多个约束组合时，这个放在最后面。注意，只有约束了这个条件，类中才能 new 一个T类型，否则会提示“变量类型“T”没有new() 约束，因此无法创建该类型的实例”。

where T：nameofbaseclass，必须是派生自指定的类（这个类或者子类）

where T：nameofinterface，必须实现指定的接口

where约束列表应该置于泛型类型的基类和列表之后。同时，where 可以约束包含多个类型参数的泛型类型参数。实际上，不仅仅泛型类型可以使用 where，泛型方法也可以使用它来约束：

例子：

Public class myclass<T,K>:

Mybase,ISomeInterface, where T:car,IEnumerable1, IEnumerable2 ,new() where K:struct

{}

意思就是myclass是一个泛型类，它继承了Mybase类，实现了ISomeInterface1、IEnumerable2接口，T必须是car类或其派生类，而且是必须有默认构造函数。而K必须是一个值类型。

疑问：如何约束只能是int类型呢？

注意，既然是加了约束条件，那么类型参数就可以认为是具有约束条件的类型了，在使用时，就可以认为他就是xx类型，从而访问xx的特有成员和变量，而不是仅仅的object类型了。

`01`	`class` `car`

02 {

`03`	`public` `car()`

04 { }

`05`	`public` `void` `test()`

06 {}

07 }

`08`	`class` `cartest<T> where T:car,new()//只能传入car类型`

09 {

`10`	`public` `static` `T tes=new` `T();`

`11`	`static` `void` `gettest()`

12 {

`13`	`car temp = (car)tes;//由于已经告诉编译器T只能是car类型，所以这里编译通过！`

`14`	`temp.test();//由于temp是car类型的实例，所以可以访问实例方法、属性、变量等特有信息。`

15 }

可惜的一点是，虽然我们告诉编译器我们传来的T是什么类型的，它其实并不能完全的理解。

1 ）比如，即使我们指定T是car类型，而car确实有默认构造函数，如果不约束必须new，则还是无法实例化的。

`01`	`class` `car`

02 {

`03`	`public` `car ()`

04 { }

05 }

`06`	`class` `cartest<T> where T:car`

07 {

`08`	`public` `static` `T tes=new` `T();`

`09`	`/是无法通过编译的，提示“错误变量类型“T”没有 new() 约束，因此无法创建该类型的实例” /`

10 }

2 ）另外，即使我们知道car有带有参数构造函数，还是不能在用T实例化时候使用有参构造函数进行初始化。

`01`	`class` `car`

02 {

`03`	`public` `car()`

04 { }

`05`	`public` `car(int` `a )`

06 { }

07 }

`08`	`class` `cartest<T> where T:car,new()`

09 {

`10`	`public` `static` `T tes=new` `T(4);`

`11`	`//是无法通过编译的，提示“错误 "T”:创建变量类型的实例时无法提供参数”`

12 }

3 ）还有，虽然约束了T为某种类型（这里为car），但是无法直接用T来访问car的静态变量信息，例如：

`01`	`class` `car`

02 {

`03`	`public` `car ()`

04 {}

`05`	`public` `static` `void` `test2()//静态方法哦`

06 {}

07 }

`08`	`class` `cartest<T> where T:car`

09 {

`10`	`public` `void` `gettest ()`

11 {

`12`	`T.test2();/试图调用car的test2静态方法，但是编译错误“错误 “T”是一个“类型形参”，这在给定的上下文中无效”/`

13 }

14 }

疑问：那么如何调用 T 的静态方法？

4 ）最后一点，创建泛型方法时，如果应用类型参数上的任何C#运算符（加、减、乘、除、 == 等），将会收到编译器错误。编译器不允许向类型参数应用运算符。因为编译器不能保证一个未知的T重载了这些运算符而可以使用它们进行运算操作。

`1`	`Class basemath<T>`

2 {

`3`	`void` `T add(T arg1,T arg2)`

4 {

`5`	`Return arg1+arg2;`

`6`	`//提示“错误运算符“+”无法应用于“T”和“T”类型的操作数”`

7 }

8 }

（5）创建泛型基类

泛型类是可以作为基类的，可以定义许多虚方法和抽象方法。但是，泛型类的派生类型必须遵守一些规则：
1）如果一个非泛型类扩展了一个泛型类，派生类必须为基类指定一个类型参数。

`1`	`Public` `class` `parclass<T>`

2 {}

`1`	`//不能是T了，而是要指定一个具体类型，而且要符合基类的约束条件哦（where关键字限制的）`

`2`	`Public` `class` `childclass:parclass<string>{}`

2）如果泛型基类定义了泛型虚方法或抽象方法，派生类必须使用上面使用的指定类型参数重写泛型方法（意思当然是可能要重写一个虚方法或者必须重写一个抽象方法喽）：

`1`	`Public` `class` `parclass<T>`

2 {

`3`	`public` `virtual` `void` `print(T data){}`

4 }

`5`	`Public` `class` `childclass:parclass<string>`

6 {

`7`	`public` `override` `void` `print(string` `data){}//不能是T喽`

8 }

3）如果派生类也是泛型，则它能够（可选的）重用类型占位符。不过要注意派生类型必须遵照基类中的任何约束，也就是泛型类如果派生另一个泛型类，只能是如下两种方式之一：
第一种，子类扩展父类，但是依然使用父类的类型参数，此时，子类的约束必须包括父类约束的前提下，再进行别的约束。

`1`	`public` `class` `parclass<T> where T: DataTable`

2 {

3 }

`4`	`//多加了一个new约束`

`5`	`public` `class` `childclass<T> : parclass<T> where T : DataTable,` `new()`

6 {

7 }

第二种，如果子类想实现父类，则必须指定一个类型参数给父类，自己还可以有新的类型参数。

`1`	`public` `class` `parclass<T>`

2 {

3 }

`4`	`public` `class` `childclass<TT>:parclass<string>//书中没有说这种形式`

5 {

6 }

因此，以下两种都是不对的：

`01`	`public` `class` `parclass<T>`

02 {}

`03`	`public` `class` `childclass<T>:parclass<T>//书中没有说这种形式`

04 {}

05

06

`07`	`public` `class` `parclass<T> where T:struct`

08 {}

`09`	`public` `class` `childclass<T> : parclass<T> where T : DataTable`

10 {}

`11`	`总结一下，一个泛型基类，其他类（泛型或非泛型）要不就是实现它，在定义时就给出基类的类型参数，要不就被泛型类继续传递下去，不具体指定基类类型参数，但是这时候子泛型类必须有和基类相同的类型参数和具有基类约束规则的超集。<BR>正常情况下，构建泛型类层次结构的机会微乎其微，但是，只要遵守规则，机会也是有的。`

（6）创建泛型接口

当然可以自由定义自己的泛型接口，带不带约束均可，只要满足接口定义和泛型类定义的约束规则，就没问题。
对于这种泛型接口被实现时，必须指定给接口确定的类型参数了，和泛型基类被实现是一样的。另外，对于泛型接口的传递，应该符合上面泛型类传递泛型基类的规则（书中没有论述，但规则是一致的）。

作者：lerit

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

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

sql分页问题，老话题！！

2010-09-13T07:21:00Z

老话题了，主要是看下测试数据，不同数量级的效率是不一样的，具体差别很大滴！！,看许多人都说是row number效率最低，但是本人测试结果有点出入。10万级别的基本没啥差距，百万级别的差距不是太明显，但是not in变慢，千万级别的差距就很明显了，not in明显跟不上了。总体比较而言，还是max(id)效率最高，但是不通用。row number比较通用。

PS:上亿的就别玩了，还是分表吧！！

方法1：
适用于 SQL Server 2000/2005

SELECT TOP 页大小 *
FROM table1
WHERE id NOT IN
          (
          SELECT TOP 页大小*(页数-1) id FROM table1 ORDER BY id
          )
ORDER BY id

方法2：
适用于 SQL Server 2000/2005

SELECT TOP 页大小 *
FROM table1
WHERE id >
          (
          SELECT ISNULL(MAX(id),0)
          FROM
                (
                SELECT TOP 页大小*(页数-1) id FROM table1 ORDER BY id
                ) A
          )
ORDER BY id

方法3：
适用于 SQL Server 2005

SELECT TOP 页大小 *
FROM
        (
        SELECT ROW_NUMBER() OVER (ORDER BY id) AS RowNumber,* FROM table1
        ) A
WHERE RowNumber > 页大小*(页数-1)

每页20条记录，取第10000条以后的

表结构：id(int) name(varchar) insertTime(datetime)

测试数据：10万级别的数据

三种方式几乎没有区别。

2百万级别

第一种方法：

第二种方法：

第三种方法：

3千万级别

第一种：

第二种：

第三种：

sql查询连续三天之内都有记录的人员！！

2010-09-02T09:23:00Z

select name from
testB a where
exists
(
   select * from testB b
   where b.InsertTime = DATEADD(D,1,a.InsertTime) and a.name=b.name
)
and
exists
(
   select * from testB b
   where b.InsertTime = DATEADD(D,2,a.InsertTime) and a.name=b.name
)
group by name