博客园_Kingthy's blog

我的KT库之----与VT的结合

2011-09-14T05:15:00Z

了解或者认识KT：

http://www.cnblogs.com/kingthy/archive/2011/08/08/2130973.html

在项目中如何使用KT？

KT是一个库，所以将KT的dll文件引用到您的项目上即可使用KT里的函数功能。

本节将介绍大家如何将KT与VT结合进行Web项目的开发。KT里的与VT相关的操作对象存放于在“KT.Framework.Web“下，当你已在你的项目里引用了KT库后，写下以下代码就可以使用了。

using KT.Framework.Web;

什么是VT？

VT是VTemplate模板引擎的简称，你可以从下面链接里了解此模板引擎的相关资料

http://www.cnblogs.com/kingthy/archive/2009/08/17/net-vtemplate.html

KT里的VTemplatePage对象

在Web Form页面开发，我们很多页面都是基于System.Web.UI.Page这个对象，这是因为Page对象帮我们实现了IHttpHandler接口，以便我们的“.aspx”页面能处理一个HTTP会话，并且对HTTP会话进行了“事件包装”，使我们能在开发中使用到Web Form里的各种事件驱动。如果我们在项目页面中直接使用VT进行处理数据，那么我们可以抛弃掉Page这个“笨重”的东西，因为我们不再需要那些WEB控件，也不再需要Page中那过于“复杂”的事件模型。我们只需要一个简单的“事件模型”即可，如下：

（当然，实际上是不可能就这么简单的)

VTemplatePage对象则是对上面流程的实现，它也是基于IHttpHandler接口的实现。

VTemplatePage对象的事件流程

上面中的各个事件方法，在VTemplatePage里都是以虚方法实现的，因此在开发时，我们可以根据需要重载上面里的任一个事件方法，以便在某个阶段做额外的处理，比如：在“OnInit“事件里我们做用户权限判断处理，如果当前用户没有访问权限我们就可以拒绝他继续访问页面。

VTemplatePage对象特别的对以下几个事件方法进行了实现处理，以便我们开发时能够更快速开发。

1、OnProcessAjaxHandler ： Ajax委托处理事件函数，用于处理Ajax方法。（在下面会详细对此介绍）

2、OnLoad ：页面装载事件函数，此方法衍生一个抽象方法: InitPageTemplate，使我们在开发时只关注此抽象方法的实现即可。并且此事件方法还增加了一个简单的缓存处理。（关于缓存见下面的LoadPageCache与SavePageCache方法解释）

3、OnRender : 呈现页面数据事件函数，用于呈现模板数据并Response回客户端。此事件方法增加了简单缓存的处理功能。（关于缓存见下面的LoadPageCache与SavePageCache方法解释）

在了解VTemplatePage对象前，让我们先了解另外一个对象。

站点配置对象WebSiteConfiguration

此配置对象用于设置站点项目的参数，比如设置站点项目路径信息、页面模板的参数信息、站点上传文件设置参数等数据。

此对象可以映射为某个XML配置文件进行管理。如下面的XML示例：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <!--设置站点的域名,如: "http://www.host.com/"。如果为空则默认-->
  <HostName></HostName>
  <!--设置站点所在的根目录,默认为: "/"-->
  <RootPath>/</RootPath>
  <!--设置站点的绝对路径地址,如: "c:\wwwroot\web\"， 如果为空则默认-->
  <AppPath></AppPath>
  <!--设置站点模板文件存放的目录,默认为: "template/default/"-->
  <TemplatePath>template/default/</TemplatePath>
  <!--设置站点模板文件的扩展名,如: ".html"-->
  <TemplateFileExt><![CDATA[.html]]></TemplateFileExt>
  <!--设置站点模板文件的编码,如: "gb2312"-->
  <TemplateFileCharset>utf-8</TemplateFileCharset>

</configuration>

如需更详细的可以查看KT项目doc目录下的website.default.config配置文件。

在使用时，直接调用From<T>方法获取配置对象。如下：

WebSiteConfiguration config = WebSiteConfiguration.From<WebSiteConfiguration>("website.config");

在实际项目开发时，可以根据需要对此对象进行扩展，以增加其它站点参数。

VTemplatePage的使用

A、VTemplatePage对象的属性

1、Context : 返回当前的System.Web.HttpContext对象

2、Request : 返回当前的System.Web.HttpRequest对象

3、Response : 返回当前的System.Web.HttpResponse对象

4、Server : 返回当前的System.Web.HttpServerUtility对象

5、Session : 返回当前的System.Web.HttpSessionState对象

6、Application : 返回当前的System.Web.HttpApplicationState对象

7、Document : 返回或设置当前的TemplateDocument对象

8、DocumentConfig ：返回当前的TemplateDocumentConfig对象，用于设置模板文档的相关解析配置。这是一个虚属性，开发中可根据需要重写此属性。

9、DocumentIsLoaded : 返回判断Document是否已装载，即模板文档是否已装载

10、IsPostBack : 返回当前页面是否是以POST方式访问

11、Configuration ：返回当前页面站点的WebSiteConfiguration对象，也就是站点的配置参数。此属性是一个抽象属性。

12、PageCacheExpireTime ：返回当前页面的缓存过期时效(单位:秒钟,默认为1小时,如果小于等于0则不缓存)，此属性是一个虚属性，需要页面需要缓存功能，必须重写此属性

13、PageCacheFileName ：返回当前页面的缓存文件绝对地址，此属性是一个虚属性，如果需要使用页面缓存则必须重写此属性并返回真实地址

B、VTemplatePage对象的方法

1、LoadTemplateFromFile ：从模板文件里装载模板，调用此方法后，将会对Document属性进行实例化。

2、LoadCurrentPageTemplate : 装载当前访问页面对应的模板。

当前访问页面对应的模板文件地址由Configuration里的配置参数计算得出，比如Configuration的配置参数为上面的XML示例里的配置。如果当前的访问页面地址为

/user/profile.ashx

那么此页面对应的模板文件即为

/template/default/user/profile.html

而如果Configuration里配置RootPath为“/apps/”，那么如果访问地址为

/apps/user/profile.ashx

那么此页面对应的模板文件即为

/apps/template/default/user/profile.html

3、LoadPageCache ：装载此页面的缓存。如果页面已重写了PageCacheExpireTime与PageCacheFileName两个属性，则此方法会判断PageCacheFileName文件是否存在，如果存在并且距上次更改时间还没有超出PageCacheExpireTime的设置时间间隔，则将会直接输出(Response)缓存文件里的数据。

4、SavePageCache : 保存当前的页面到缓存里。如果页面已重写了PageCacheExpireTime与PageCacheFileName两个属性，则此方法判断当前是否已装载了模板，如果是，则将模板数据解析到缓存文件里存储。

5、InitPageTemplate ：初始化当前的页面模板。此方法是一个抽象方法，在OnLoad事件发生时被调用。此方法类似于Web Form里的Page_Load方法。

C、VTemplate对象的简单开发示例

通过上面了解了VTemplatePage的属性与方法后，现在我们可以使用它来做页面开发了。下面跟我一步一步来做一个简单的开发示例

1、打开你的Visual Studio, 新建一个Web项目(Web Application或者Web Site项目都可以)，将KT库引入到您的项目里

2、在项目里新建一个“一般处理程序”页面，也就是“.ashx”页面。比如叫“firstpage.ashx”，确定后VS会帮我们生成一个".ashx”与".ashx.cs”文件。其中".ashx.cs”文件里面的内容如下：

/// <summary>
/// firstpage 的摘要说明
/// </summary>
public class firstpage : IHttpHandler
{

    public void ProcessRequest(HttpContext context)
    {
        context.Response.ContentType = "text/plain";
        context.Response.Write("Hello World");
    }

    public bool IsReusable
    {
        get
        {
            return false;
        }
    }
}

注：对于使用“一般处理程序.ashx”页面，是因为上面所说的，我们不需要Page里的太过于“复杂”的事件模型，我们只需要简单的事件模型即可。经常有群友在群里说“aspx比ashx好”、“为什么你用ashx，不用aspx呢？”、“VT能在aspx下用吗？”等等问题，当你看到我这里的讲解时，我相信你的心里已有答案了吧？aspx与ashx没有谁比谁好，aspx可以说是为webform而生的，因为aspx里的事件模型就是为webform而做的。

3、改写一下页面的.cs代码文件里的代码，比如将上面的代码改为如下

/// <summary>
/// firstpage 的摘要说明
/// </summary>
public class firstpage : VTemplatePage
{
    /// <summary>
    /// 初始化页面模板
    /// </summary>
    public override void InitPageTemplate()
    {
        this.LoadCurrentPageTemplate();
    }

    /// <summary>
    /// 站点的配置
    /// </summary>
    public override WebSiteConfiguration Configuration
    {
        get 
        {
            return WebSiteConfiguration.From<WebSiteConfiguration>("website.config");
        }
    }
}

我们的页面继承于VTemplatePage对象，由于VTemplatePage对象是一个抽象对象，所以我们还需要实现其的一个抽象方法与一个抽象属性。其中在InitPageTemplate方法里我们调用LoadCurrentPageTemplate方法，装载当前页面对应的模板文件，在Configuration属性里返回当前项目站点的配置。

4、在站点目录下建立配置文件存放目录"config"，在上面代码里，我们的站点配置是从"website.config”这个配置文件读取的，所以我们需要在配置文件目录建一个website.config文件并且配置好（我们可以直接拷贝VT项目里的"website.default.config”示例文件）

5、在站点目录下建模板目录"template/default/”（此目录路径由配置文件来决定），并在此目录一个模板文件"firstpage.html”（模板文件的扩展名也是由配置文件决定）。示例模板：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title> KT与VT的结合 --  第一个页面 </title>
<link type="text/css" rel="stylesheet" href="{$Page.TemplatePath}css/common.css" />
</head>
<body>
<h4>KT与VT的结合 --  第一个页面</h4>
<ol>
<li>Page = <span>{$Page}</span></li>
<li>Page.SitePath = <span>{$Page.SitePath}</span></li>
<li>Page.SiteUrl = <span>{$Page.SiteUrl}</span></li>
<li>Page.TemplatePath  = <span>{$Page.TemplatePath}</span></li>
<li>Page.Request.Url  = <span>{$Page.Request.Url}</span></li>
<li>当前服务器时间 = <span><vt:serverdata type="time" output="true" /></span></li>
</ol>
</body>
</html>

注：在调用LoadCurrentPageTemplate方法后，VTemplatePage对象会自动将以下4个变量赋值到模板文件里，也就是我们可以在模板文件里随时调用此4个变量对象。

A、Page变量 : 当前的页面对象，如上面的"firstpage”对象

B、Page.SitePath变量：当前的站点的根目录地址，此变量值由配置文件的RootPath参数决定。如“/”

C、Page.SiteUrl变量：当前的站点URL地址。如“http://www.hostname.com/”

D、Page.TemplatePath 变量：相对于当前站点根目录地址的模板路径地址，此变量值由配置文件的TemplatePath参数决定。如"/template/default/”

经过上面几步后，我们的项目可以编译运行了，结果如下面的运行示例截图

我们的模板与页面成功进行了“绑定”，后面要如何去做就是发挥你们的才智时间了

D、VTemplatePage对象里的简单缓存功能的启用

VTemplatePage对象的缓存功能是默认是简单采用对比缓存文件的更改时间来维护缓存的变化（如果需要更复杂的缓存处理，则可以重写LoadPageCache与SavePageCache方法），如果需要在页面上启用简单缓存功能，则重写PageCacheExpireTime与PageCacheFileName两个属性即可，如下面对firstpage.ashx页面的修改

/// <summary>
/// firstpage 的摘要说明
/// </summary>
public class firstpage : VTemplatePage
{
    /// <summary>
    /// 初始化页面模板
    /// </summary>
    public override void InitPageTemplate()
    {
        this.LoadCurrentPageTemplate();
    }

    /// <summary>
    /// 站点的配置
    /// </summary>
    public override WebSiteConfiguration Configuration
    {
        get 
        {
            return WebSiteConfiguration.From<WebSiteConfiguration>("website.config");
        }
    }

    /// <summary>
    /// 缓存1分钟后过期
    /// </summary>
    protected override int PageCacheExpireTime
    {
        get
        {
            return 60;
        }
    }
    /// <summary>
    /// 缓存文件
    /// </summary>
    protected override string PageCacheFileName
    {
        get
        {
            return this.Configuration.ToAbsoluteAppPath("cache/firstpage.html");
        }
    }
}

经过上面修改后，我们的"firstpage.ashx”页面在1分钟之内，不管刷新多少次，页面上显示的“服务器时间”都是不变，直到60秒后缓存失效。并且会在站点根目录下的cache目录生成一个firstpage.html缓存文件（注：对于POST方式访问页面则默认不会启用缓存功能）

E、VTemplatePage对象的Ajax方法委托处理

先让我们认识一下“AjaxHandlerMethodAttribute”特性类，此特性用于标记某个方法是否为Ajax方法委托方法。

共有以下几个属性定义：

1、Name : 定义用于处理的Ajax方法，如果未定义(null)则表示与实际的函数方法名称一样。此名称将与用户提交的"ajaxhandler"参数(QueryString或者Form)匹配

2、Description : 用于定义描述此Ajax方法的说明

3、ContentType : 用于定义输出数据的内容类型，如text/xml; text/plain; text/html; application/x-javascript等等。如果未定义则会自动根据ReturnType返回

4、AllowBrowserCache : 是否允许浏览器缓存方法的处理结果，默认不允许

5、IsTerminative : 是否在处理AJax方法委托后自动中止页面执行

6、ReturnType ：数据的访问类型，如JSON、Text等，默认是Auto（自动根据方法返回值处理：如果方法返回非null值则按Json数据处理，否则按空返回处理）

我们修改一下上面的"firstpage.ashx”页面的代码，增加两个Ajax委托方法：

/// <summary>
/// firstpage 的摘要说明
/// </summary>
public class firstpage : VTemplatePage
{
    /// <summary>
    /// 初始化页面模板
    /// </summary>
    public override void InitPageTemplate()
    {
        this.LoadCurrentPageTemplate();
    }

    /// <summary>
    /// 站点的配置
    /// </summary>
    public override WebSiteConfiguration Configuration
    {
        get 
        {
            return WebSiteConfiguration.From<WebSiteConfiguration>("website.config");
        }
    }


    /// <summary>
    /// 获取时间值
    /// </summary>
    /// <returns></returns>
    [AjaxHandlerMethod("timer")]
    public long GetTimer()
    {
        return DateTime.Now.Ticks;
    }

    /// <summary>
    /// 获取数据
    /// </summary>
    /// <returns></returns>
    [AjaxHandlerMethod("data")]
    public object GetData()
    {
        string r = Request.Form["r"];
        return new
        {
            id = DateTime.Now.Ticks,
            rnd = r
        };
    }
}

为了能达到演示效果，我们也将"firstpage.ashx”页面对应的"firstpage.html”模板文件做一下相应的修改，增加Ajax的脚本调用，如下：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title> KT与VT的结合 --  第一个页面 </title>
<link type="text/css" rel="stylesheet" href="{$Page.TemplatePath}css/common.css" />
</head>
<body>
<h4>KT与VT的结合 --  第一个页面</h4>
<ol>
<li>Page = <span>{$Page}</span></li>
<li>Page.SitePath = <span>{$Page.SitePath}</span></li>
<li>Page.SiteUrl = <span>{$Page.SiteUrl}</span></li>
<li>Page.TemplatePath  = <span>{$Page.TemplatePath}</span></li>
<li>Page.Request.Url  = <span>{$Page.Request.Url}</span></li>
<li>当前服务器时间 = <span><vt:serverdata type="time" output="true" /></span></li>
</ol>
<h4>Ajax操作区</h4>
<input type="button" value="获取Timer值" id="b1" /><input type="button" value="获取数据" id="b2" />
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>
<script type="text/javascript">
    $('#b1').click(function () {
        $.post('?', { ajaxhandler: 'timer' }, function (timer) {
            alert('timer=' + timer);
        }, 'json');
    });
    $('#b2').click(function () {
        $.post('?', { ajaxhandler: 'data', r : Math.random() }, function (d) {
            alert('data=' + d);
        }, 'text');
    });
</script>
</body>
</html>

最终编译后运行，页面效果如下

当我们点击上面两个按钮，将可分别获取对应的数据。

VTemplatePage对象处理Ajax方法委托的简单原理：在HTTP会话开始时，查看QueryString或Form参数里是否有ajaxhandler值，如果有则判断当前页面对象是否包有AjaxHandlerMethodAttribute特性且名称定义相同的公开方法，如果有则调用方法。

注意：根据我们最上面的VTemplatePage事件流程图可知，我们的Ajax方法优先于OnLoad(InitPageTemplate)方法的执行，也就是在我们的Ajax方法被执行时，我们的页面模板是还没有装载的，所以请勿在Ajax委托方法里处理模板，如需要操作请先“装载模板”。

说明：上面所说的示例项目代码，来源于KT.WebApp项目

http://kt.codeplex.com/SourceControl/changeset/view/9738#

本文链接

我的KT库之----数据库的操作(DbCommandBuilder/DbConditionBuilder)

2011-09-02T07:46:00Z

了解或者认识KT：

http://www.cnblogs.com/kingthy/archive/2011/08/08/2130973.html

在项目中如何使用KT？

KT是一个库，所以将KT的dll文件引用到您的项目上即可使用KT里的函数功能。

本节将介绍大家如何使用KT库操作数据库。KT里的数据库操作对象存放于在“KT.Framework.Database“下，当你已在你的项目里引用了KT库后，则写下以下代码就可以使用了。

using KT.Framework.Database;

在这节里，将会向大家介绍两个用于构造数据查询命令的对象。

数据库命令构造对象：DbCommandBuilder

不知道大家在平常做数据库操作时，是不是经常写INSERT或UPDATE两条SQL语句？如果是并且还在使用SQL语句拼接的话，那DbCommandBuilder就非常适合你的使用，它可以帮你构造生成INSERT或者UPDATE的参数化SQL语句。

DbCommandBuilder的实例方法是需要你传递一个“表名”与“DbHelper”对象，如下面示例代码：

using (DbHelper db = new DbHelper(connection))
{
    DbCommandBuilder command = new DbCommandBuilder("user", db);
}

表示将对"user”表进行构造INSERT或者UPDATE语句。

DbCommandBuilder的方法

1、AddField ：增加一个字段值。对于INSERT语句来说，这个字段将是会插入到表里；对于UPDATE语句来说，这个字段将是会被更新的。

command.AddField("name", DbType.String, 10, "张三");
                command.AddField("age", DbType.Int32, 20);

注: 此方法有多个重载版本，用于处理字段值的参数化。

2、AddCondition : 增加一个条件字段值。在构造UPDATE语句时才需要使用。

command.AddCondition("id", DbType.Int32, 1);

注: 此方法有多个重载版本，用于处理字段值的参数化。

3、GetParameter : 获取某个字段参数。只能获取在AddField或者AddCondition方法添加的字段参数。

4、ContainParameter : 判断是否存在某个字段参数，只能判断在AddField或者AddCondition方法添加的字段参数。

5、Insert : 执行INSERT语句命令

DbCommandBuilder command = new DbCommandBuilder("user", db);
command.AddField("name", DbType.String, 10, "张三");
command.AddField("age", DbType.Int32, 20);
var r = command.Insert();

执行此方法后，将会在user表里插入一行数据，等同于执行以下sql语句

INSERT INTO `user` (`name`,`age`) VALUES (@name,@age)

6、Update ：执行UPDATE语句命令

DbCommandBuilder command = new DbCommandBuilder("user", db);
command.AddField("name", DbType.String, 10, "张三");
command.AddField("age", DbType.Int32, 20);
command.AddCondition("id", DbType.Int32, 1);
var r = command.Update();

执行此方法后，将会更新user表里id=1的记录，等同于执行以下sql语句

UPDATE `user` SET `name`=@name,`age`=@age WHERE `id`=@id

7、ClearAll : 清空所有添加的字段值或者条件字段值

DbCommandBuilder的属性

1、DbHelper ：获取对应的DbHelper实例对象

2、TableName : 获取当前操作的表名

3、InsertCommandText : 获取当前字段构造的INSERT语句

DbCommandBuilder command = new DbCommandBuilder("user", db);
command.AddField("name", DbType.String, 10, "张三");
command.AddField("age", DbType.Int32, 20);
command.DbHelper.ExecuteNonQuery(command.InsertCommandText, command.Parameters);

上面的代码等同于直接执行command.Insert()方法。

4、UpdateCommandText : 获取当前字段构造的UPDATE语句

DbCommandBuilder command = new DbCommandBuilder("user", db);
command.AddField("name", DbType.String, 10, "张三");
command.AddField("age", DbType.Int32, 20);
command.AddCondition("id", DbType.Int32, 1);
command.DbHelper.ExecuteNonQuery(command.UpdateCommandText, command.Parameters);

上面的代码等同于直接执行command.Update()方法。

5、Parameters : 获取当前字段值的参数。其返回的是一个数组，包含当前所有字段的参数值。

数据查询条件构造对象：DbConditionBuilder

在平时查询数据时，经常都要写不同的查询条件，如果你还是在拼接SQL条件语句，那么DbConditionBuilder也是非常适合你的使用，它可以帮你构造条件语句，并可以参数化处理条件值。

DbConditionBuilder的方法

1、Add : 添加一个条件

DbConditionBuilder condition = new DbConditionBuilder();
                condition.Add("id>1"); //简单添加一个条件，其条件关系是“and”
                condition.Add("id>2", DbConditionRelation.OR); //简单添加一个条件，其条件关系是“or”
                var par = db.CreateDbParameter("name", DbType.String, 20, db.EscapeString("张三"));
                condition.Add("name=" + par.ParameterName, par);  //添加一个条件，并对条件值实行参数化处理，其条件关系是“and”

上面的条件语句为

id>1 OR id>2 AND name=@name

注意：对于没有进行参数化处理的值，为避免出现“注入”漏洞，请记得将字符串值转义处理！如上面的“db.EscapeString("张三")”

2、AddFormat : 添加一个条件，并可以进行格式化处理

DbConditionBuilder condition = new DbConditionBuilder();
                condition.AddFormat("id>{0}", 1);  //简单添加一个条件，其条件关系是“and”
                condition.AddFormat("name='{0}'", DbConditionRelation.OR, db.EscapeString("张三")); //简单添加一个条件，其条件关系是“or”

上面的条件语句为

id>1 OR name='张三'

注意：为避免出现“注入”漏洞，请记得将字符串值转义处理！如上面的“db.EscapeString("张三")”

3、BeginParentheses : 开始左括号的写入

4、EndParentheses : 结束括号的写入

DbConditionBuilder condition = new DbConditionBuilder();
                condition.BeginParentheses();
                condition.Add("id>1"); //简单添加一个条件，其条件关系是“and”
                condition.Add("id>2", DbConditionRelation.OR); //简单添加一个条件，其条件关系是“or”
                condition.EndParentheses();
                var par = db.CreateDbParameter("name", DbType.String, 20, db.EscapeString("张三"));
                condition.Add("name=" + par.ParameterName, par);  //添加一个条件，并对条件值实行参数化处理，其条件关系是“and”

上面的条件语句为

 (id>1 OR id>2) AND name=@name

5、Clear : 清空所有条件

6、ToString : 已重写，输出带"WHERE“部分的条件语句

DbConditionBuilder condition = new DbConditionBuilder();
condition.BeginParentheses();
condition.Add("id<1000"); 
condition.BeginParentheses();
condition.Add("age>20", DbConditionRelation.OR);
condition.Add("age<=30");
condition.EndParentheses();
condition.EndParentheses();
var par = db.CreateDbParameter("name", DbType.String, 20, string.Concat(db.EscapeString("张"), "%"));
condition.Add("name like " + par.ParameterName, par);
Console.WriteLine(condition.ToString());

上面代码将输出以下语句

WHERE (id<1000 OR (age>20 AND age<=30)) AND name like @name

DbConditionBuilder的属性

1、Condition ：获取当前的条件语句

DbConditionBuilder condition = new DbConditionBuilder();
condition.BeginParentheses();
condition.Add("id<1000"); 
condition.BeginParentheses();
condition.Add("age>20", DbConditionRelation.OR);
condition.Add("age<=30");
condition.EndParentheses();
condition.EndParentheses();
var par = db.CreateDbParameter("name", DbType.String, 20, string.Concat(db.EscapeString("张"), "%"));
condition.Add("name like " + par.ParameterName, par);
Console.WriteLine(condition.Condition);

上面代码将输出以下语句

(id<1000 OR (age>20 AND age<=30)) AND name like @name

2、HasCondition : 判断构造器里面是否有条件

3、Parameters : 获取当前条件中的条件参数值

本文链接

VTemplate模板引擎的使用—Function标签

2011-08-31T09:59:00Z

了解或者认识VTemplate：

VTemplate也被网友们简称VT，它是一个基于.net里的模板引擎。

http://www.cnblogs.com/kingthy/archive/2009/08/17/net-vtemplate.html

现在让我们了解一下VT里最常用的function标签。

Function标签

其定义格式:

<vt:function var="变量" method="方法名" type="类型或实例变量" args="参数" output="true/false" />

它的作用即是在VT里调用某个方法并将返回值赋给某个变量（定义了var的情况）。

假设我们现有这样的一个类定义

namespace Test
{
    public class Db
    {
        public DataTable GetData()
        {
            //这里是详细的代码
        }

        public DataTable GetDataByName(string name)
        {
            //这里详细的代码
        }

        public static DataTable GetDbData()
        {
            //这里是详细的代码
        }
    }
}

现在我们要调用其定义的方法。

静态方法的调用

在我们的程序代码里，如果要调用上面类的GetDbData静态方法，我们一般这样写（完整写法）

var data = Test.Db.GetDbData();

而将上面的语句转成VT的模板标签后，就需要写成这样的function标签

<vt:function var="data" method="GetDbData" type="Test.Db" />

也就是function标签里的type属性我们需要写Db类的完整定义路径。

实例方法的调用

在我们的程序代码里，如果要调用类实现的方法，我们一般这样写

var db = new Db();
var data = db.GetData();

而将上面代码转成VT的模板标签后，我们的function标签就是这样写

<vt:function var="data" method="GetData" type="$db" />

function标签里的type属性我们写为“$db”，这就表示，我们调用的方法是“db”这个变量的实例方法。

但这个变量是从哪里来呢？这个变量也是同程序代码里一样，也是需要你在VT里对其赋值，比如下面的示例代码：

TemplateDocument document = TemplateDocument.FromFileCache(@"c:\template\test.html", Encoding.UTF8);
            document.SetValue("db", new Db());

上面代码里我们调用了SetValue方法，将“db”这个变量赋值到了VT模板里，这样模板里就可以调用此变量的值或方法了。

带参数的方法调用

如上面Db类里的GetDataByName方法，在程序代码里我们一般这样写

var db = new Db();
            var data = db.GetDataByName("car");

而对于带参数的方法，在VT模板里，我们就可以使用function标签里的args属性，如下面

<vt:function var="data" method="GetDataByName" type="$db" args="car" />

而如果我们的参数不是一个常量值，而是一个变量值，我们也可以在args属性里调用，如下面

<vt:function var="data" method="GetDataByName" type="$db" args="$name" />

但name变量也是需要赋值才可以使用（如通过SetValue方法），并且类型要一致，如果不一致，VT引擎将会尝试转换类型，如果类型转换成功则执行方法，如果失败将不会执行方法！！(参数类型不匹配时，因为会尝试转换，所以这里的效率会非常低，请尽量避免）

如果我们的方法里有多个参数，我们可以通过定义多个args属性，但要注意它们的定义顺序是同方法的参数定义顺序一样的。如下面的示例

public DataTable GetDataBy(string name, int category)
{
    //这里详细的代码
}

VT里的function标签我们就可以写成这样

<vt:function var="data" method="GetDataBy" type="$db" args="car" args="1" />

参数的自定义

上面的例子里，如果我们的方法参数非常多，用args定义是可以做到，但是却非常的不直观，并且如果参数定义的顺序或类型一错，将会导致我们的方法无法正确执行！如果能换一种方式，比如下面这样的定义

<vt:function var="data" method="GetDataBy" type="$db" pName="car" pCategory="1" />

这样我们的模板代码看起来就非常的直观明了。

VT模板里允许在标签里添加自定义属性，所以我们上面的标签定义是符合格式的，但是我们为了能使自定义属性当作参数使用，我们就需要改写GetDataBy方法，如下

public DataTable GetDataBy()
{
    var document = TemplateDocument.CurrentRenderingDocument;
    var tag = document == null ? null : document.CurrentRenderingTag;
    if (tag == null) return null;

    var name = tag.Attributes.GetValue("pName");
    var category = tag.Attributes.GetValue("pCategory").As<int>(0);

    //这里是详细的代码

}

GetDataBy方法变成了无参数方法，并在方法里我们调用了“TemplateDocument.CurrentRenderingDocument”获取当前正在呈现解析数据的模板文档对象，再通过“document.CurrentRenderingTag”获取当前呈现解析数据的模板标签对象。如果我们的GetDataBy方法是通过上面的function标签调用执行的，则“document.CurrentRenderingTag”获取到的标签对象就是此function标签，所以我们可以获取此标签里的所有自定义属性值，从而得到pName与pCategory里定义的值。

注：各个模板标签都有自己的关键属性，这些是无法在自定义属性里获取的，比如"id“、“name“这些是不能用做自定义属性的。

用户自定义方法

如果我们有些方法是私有的，比如

private DataTable GetUserData(object[] o)
{

}

或者匿名方法

UserDefinedFunction GetUserData = (o) =>
{
    //这里是详细的处理代码
};

对于这两种情况，我们是无法直接通过function标签调用的，因为我们无法写type属性！因为type属性需要类名或者是类实例变量，并且是只能调用公开方法

而对于这两种情况，则我们需要先在模板里注册用户自定义函数，才能通过function标签调用。如下示例

TemplateDocument document = TemplateDocument.FromFileCache(@"c:\template\test.html", Encoding.UTF8);
document.RegisterGlobalFunction("GetUserData", GetUserData);

注册了自定义函数后，我们就可以写无type属性的function标签，如下

<vt:function var="data" method="GetUserData" />

VT在处理这种没有type属性的方法时，将会在“自定义函数”列表里查找同名的方法，如果找到则执行方法，否则不处理。

小提示

对于无参数的实例方法，可以直接在变量表达式里执行，所以在任意标签里可直接使用，不一定需要通过function标签执行，如下面示例

<vt:set var="data" value="$db.GetData()" />
<vt:foreach from="$db.GetData()" item="data">.......</vt:foreach>

本文链接

我的KT库之----数据库的操作(DbCommandExecutor)

2011-08-27T09:00:00Z

了解或者认识KT：

http://www.cnblogs.com/kingthy/archive/2011/08/08/2130973.html

在项目中如何使用KT？

KT是一个库，所以将KT的dll文件引用到您的项目上即可使用KT里的函数功能。

using KT.Framework.Database;

数据库命令执行对象: DbCommandExecutor

DbCommandExecutor里封装了常用的数据执行命令。通过DbConnection或DbHelper实例化一个实例，如下面

OleDbConnection connection = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=e:\\db.mdb");
DbCommandExecutor executor = new DbCommandExecutor(connection);

或者

DbHelper db = new DbHelper(connection);
DbCommandExecutor executor = new DbCommandExecutor(db);

但建议的是直接调用DbHelper里的Executor属性直接获取对应的DbCommandHelper实例，如下面范例

DbHelper db = new DbHelper(connection);
DbCommandExecutor executor = db.Executor;

DbCommandExecutor的方法

注：以下的演示代码使用的表结构如下，表名：user

id	int	标识字段
name	nvarchar(20)	姓名
age	int	年龄
phone	nvarchar(20)	电话

1、ExecuteIdentity ：执行命令，并且返回数据库的最后标识值。此方法一般用于执行INSERT命令

OleDbConnection connection = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=e:\\db.mdb");
using (DbHelper db = new DbHelper(connection))
{
    long id = db.Executor.ExecuteIdentity("insert into `user` (`name`,`age`,`phone`) values ('小明',20,'13833233322')");
    Console.WriteLine(id);
}

此方法如在OleDbConnection/OdbcConnection执行环境下，将调用“SELECT @@IDENTITY ”语句获取标识值；如果是在SqlConnection执行环境下，则调用“SELECT SCOPE_IDENTITY() ”获取标识值；而如果是MySql执行环境下，则调用“SELECT LAST_INSERT_ID() ”获取标识值。

2、ExistRow ：判断是否存在某行数据符合条件的数据

using (DbHelper db = new DbHelper(connection))
{
    bool exist = db.Executor.ExistRow("user", "id=2");
    Console.WriteLine(exist);
}

3、GetRow<T> : 获取某行数据，并将行数据映射为某个数据对象

using (DbHelper db = new DbHelper(connection))
{
    //通过Id值获取数据
    var user = db.Executor.GetRow<DbUser>("user", 1);
    //通过条件获取数据
    var user2 = db.Executor.GetRow<DbUser>("user", "id=3 and age=30");
}

4、GetRowList<T> : 获取某些行数据，并将行数据映射为某个数据对象

using (DbHelper db = new DbHelper(connection))
{
    //获取某个表里的所有数据
    var users = db.Executor.GetRowList<DbUser>("user");
    //通过条件获取数据
    users = db.Executor.GetRowList<DbUser>("user", "id>2");
    //通过条件获取数据，并按id降序排列返回
    users = db.Executor.GetRowList<DbUser>("user", "id>2", "id desc");
    //获取符合条件的前10条数据
    users = db.Executor.GetRowList<DbUser>(10, "user", "id>2");
}

5、DeleteRow : 删除某些数据行，并返回已删除的行数

using (DbHelper db = new DbHelper(connection))
{
    //删除id=1,id=2, id=3的数据行
    int r = db.Executor.DeleteRow("user", 1, 2, 3);
    //删除符合条件的数据行
    int r1 = db.Executor.DeleteRow("user", "id>2");
}

6、RemoveRow<T> : 删除某些数据行，并返回被删除的行数据

using (DbHelper db = new DbHelper(connection))
{
    //删除id=1,id=2, id=3的数据行并返回行数据
    var rows = db.Executor.RemoveRow<DbUser>("user", 1, 2, 3);
    //删除符合条件的数据行并返回行数据
    rows = db.Executor.RemoveRow<DbUser>("user", "id>2");
}

7、Insert ：将某个对象插入到某个数据表。对象需要插入的数据（属性）需要用DbFieldAttribute做属性标记

注：以下示例代码中的DbUser类结构请看下面的DbFieldAttribute说明

OleDbConnection connection = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=e:\\db.mdb");
var dbuser = new DbUser();
dbuser.Name = "小明";
dbuser.Age = 23;
dbuser.Phone = "13800138000";
using (DbHelper db = new DbHelper(connection))
{
    var f = db.Executor.Insert("user", dbuser);
    if (f)
    {
        //输出当前新记录的id值
        Console.WriteLine(dbuser.Id);
    }
}

8、Update : 将某个对象更新到某个数据表。对象需要更新的数据（属性）需要用DbFieldAttribute做属性标记

注：以下示例代码中的DbUser类结构请看下面的DbFieldAttribute说明

var dbuser = new DbUser();
dbuser.Id = 2;
dbuser.Name = "小明";
dbuser.Age = 23;
dbuser.Phone = "13800138000";
using (DbHelper db = new DbHelper(connection))
{
    var f = db.Executor.Update("user", dbuser);
    Console.WriteLine(f ? "更新成功" : "更新失败");
}

上面代码将会自动更新“id=2”的记录值。

数据字段属性标记：DbFieldAttribute

此属性标记是用于标记对象中的哪些属性在DbCommandExecutor的Insert或Update方法中是需要处理的。如下面的类结构定义

/// <summary>
/// 用户对象
/// </summary>
public class DbUser : DbObject
{
    public DbUser()
    {
        
    }
    /// <summary>
    /// 编号
    /// </summary>
    [DbField(DbType.Int32, Identity=true, PrimaryKey=true)]
    public int Id
    {
        get
        {
            return this.GetData<int>("Id", 0);
        }
        set
        {
            this["Id"] = value;
        }
    }

    /// <summary>
    /// 姓名
    /// </summary>
    [DbField(DbType.String, Size=20, Groups = 1)]
    public string Name
    {
        get
        {
            return this.GetData<string>("Name", null);
        }
        set
        {
            this["Name"] = value;
        }
    }
    /// <summary>
    /// 年龄
    /// </summary>
    [DbField(DbType.Int32, Groups = 1|2)]
    public int Age
    {
        get
        {
            return this.GetData<int>("Age", 0);
        }
        set
        {
            this["Age"] = value;
        }
    }
    /// <summary>
    /// 电话
    /// </summary>
    [DbField(DbType.String, Size = 20, Groups = 2)]
    public string Phone
    {
        get
        {
            return this.GetData<string>("Phone", null);
        }
        set
        {
            this["Phone"] = value;
        }
    }
}

标记了Id、Name、Age、Phone四个属性是需要处理的。

DbFieldAttribute的属性

1、Name : 定义对应于数据库的字段名称。如果为空或null则默认采用属性名称

/// <summary>
/// 姓名
/// </summary>
[DbField(DbType.String, Name = "UserName", Size = 20)]
public string Name
{
    get;
    set;
}

此属性定义了Name值，所以表示此属性是对应于数据库的“username”字段。

2、DbType : 数据字段类型

/// <summary>
/// 姓名
/// </summary>
[DbField(DbType.String, Size = 20)]
public string Name
{
    get;
    set;
}

对应的是DbType.String类型。如果采用空类型构造函数，则表示采用系统自动检测，如下

/// <summary>
/// 姓名
/// </summary>
[DbField(Size = 20)]
public string Name
{
    get;
    set;
}

因为未定义DbType，所以在运行Insert或Update方法，KT会自动根据属性类型“string”决定使用DbType.String类型。

3、PrimaryKey ：是否是主键字段。如果是则在UPDATE时将使用此属性值做为更新条件

4、Identity : 是否是自增标识字段，如果是则不参与INSERT与UPDATE，并且在INSERT后会自动获取

5、Size ：用于标记字段值的长度大小

6、Groups ：字段所在组，在插入或更新数据时可根据组更新或者插入部分字段值。

var dbuser = new DbUser();
dbuser.Id = 2;
dbuser.Name = "小明";
dbuser.Age = 23;
dbuser.Phone = "13800138000";
using (DbHelper db = new DbHelper(connection))
{
    var f = db.Executor.Update("user", dbuser, 1);
    Console.WriteLine(f ? "更新成功" : "更新失败");
}

上面代码则只更新属于组1的数据，也即是只更新“Name”与“Age”数据，“Phone“数据由于属于组2不会被更新！如果改为以下代码

var f = db.Executor.Update("user", dbuser, 2);

也即是只更新属于“组2”的数据，因为“Age”是被定义为混合组“Groups=1|2“，所以表示Age属于“组1”且也属于“组2”数据。所以上面代码里“Age“与“Phone“数据将会被更新。

如果将代码改为以下

var f = db.Executor.Update("user", dbuser, 1|2);

则表示同时更新“组1”与“组2”的数据，所以“Name“、“Age”、“Phone”都会被同时更新。

7、Insertable ：是否允许进行INSERT操作，默认允许

此属性可设置为以下三种值：

DbFieldOperable.Allowed : 允许操作

DbFieldOperable.OnlyGroup: 只允许同组的操作

DbFieldOperable.Unallowed: 不允许操作，也即是不会参与到INSERT操作中

/// <summary>
/// 姓名
/// </summary>
[DbField(Size = 20, Groups=1, Insertable = DbFieldOperable.OnlyGroup)]
public string Name
{
    get;
    set;
}

上面代码由于设置为只允许同组的操作，并且定义了属于“组1”数据，所以

db.Executor.Insert("user", dbuser);     //Name不参与INSERT
                db.Executor.Insert("user", dbuser, 1);  //因为设置了插入组1数据，所以Name将会参与INSERT

8、Updateable ：是否允许进行UPDATE操作，默认允许

此属性类似Insertable

DbFieldAttribute的两个特殊常量

1、EmptyGroup ：表示空组，常量：0

如在Insert与Update方法中，传递此值，则表示是所有定义为“DbFieldOperable.Allowed”的数据

//以下两个方法相同效果
db.Executor.Insert("user", dbuser);     
db.Executor.Insert("user", dbuser, DbFieldAttribute.EmptyGroup);

2、NoGroup : 表示不属于任何组，常量：-1

如在Insert与Update方法中，传递此值，则表示只处理所有未定义“Groups”的属性数据。

db.Executor.Insert("user", dbuser, DbFieldAttribute.NoGroup);

本文链接

我的KT库之----数据库的操作(DbHelper)

2011-08-26T11:06:00Z

了解或者认识KT：

http://www.cnblogs.com/kingthy/archive/2011/08/08/2130973.html

在项目中如何使用KT？

KT是一个库，所以将KT的dll文件引用到您的项目上即可使用KT里的函数功能。

using KT.Framework.Database;

数据库帮助对象: DbHelper

DbHelper类似于微软的SqlHelper，但又有不同的区别。

DbHelper是对DbConnection对象进行封装，并且是一个实例对象，在使用它时必须进行实例化，如下面示例

OleDbConnection connection = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=e:\\db.mdb");
DbHelper db = new DbHelper(connection);

在实例化DbHelper时传入了一个OleDbConnection对象，之后在DbHelper进行的操作大部分都是针对OleDbConnection对象进行的，并且在每执行一次命令都会自动恢复DbConnection对象的原状态（如：原状态是关闭的，则在执行命令时将会自动打开，执行完后将恢复关闭状态）。

DbHelper还有一个实例化重载函数，可设置是否保持DbConnection对象的打开状态，如下面的代码

DbHelper db = new DbHelper(connection, true);

使用此重载函数实例化后，DbConnection在被打开(Open)之后，将会一值保持打开状态，直到手动关闭(Close)为此

DbHelper的方法

1、ChangeDbConnection ：更换DbConnection

2、BeginTransaction : 启动事务，启动之后所有数据执行命令都将在同一个事务里执行。

3、CommitTransaction ：提交事务

4、RollbackTransaction : 回滚事务

5、Open与Close ：打开/关闭DbConnection

6、CreateDbCommand : 建立一个DbCommand对象

var command = db.CreateDbCommand("select * from [user]");

7、CreateDbCommandWrapped : 建立一个已对DbCommand包装了的DbCommandWrapped对象

var command = db.CreateDbCommandWrapped("select * from [user]");

8、CreateDbDataAdapter : 建立一个DbDataAdapter对象

9、CreateDbParameter : 建立一个DbParameter参数对象。注意：参数名不需要带前缀

var pName = db.CreateDbParameter("name", DbType.String, 30, "张三");

10、ExecuteScalar ：执行命令并返回第一行第一列的数据

var id = db.ExecuteScalar("select top 1 Id from [user]").As<int>();

11、ExecuteReader : 执行命令并返回DbReader数据流

using (var reader = db.ExecuteReader("select * from [user]"))
{
    while (reader.Read())
    {
        //读取数据
    }
}

12、ExecuteNonQuery : 执行命令并返回受影响的行数

var success = db.ExecuteNonQuery("update [user] set name='李四' where id=1") > 0;

13、ExecuteDataSet : 执行命令并返回DataSet对象

var dataset = db.ExecuteDataSet("select * from [user]");

14、ExecuteDbObject<T> : 执行命令并返回一个数据对象。

var user = db.ExecuteDbObject<DbUser>("select * from [user] where id=1");

15、ExecuteDbObjectList<T> : 执行命令并返回数据对象列表

var users = db.ExecuteDbObjectList<DbUser>("select * from [user]");

16、FillDataSet : 执行集合并填充DataSet数据表

17、GetDbParameterName : 获取一个带前缀的参数名称

var pName = db.GetDbParameterName("name");  //如果传入的是SqlConnection、OleDbConnection对象则返回“@name”

18、QuoteIdentifier : 对标识符(表名、列名)进行处理。也就是在表名或列名前后加上相应的引用符（如Sql server则是加入“[”与“]”，但在MySql里则是“`”）

string sql = string.Format("select {0},{1} from {2}",
        db.QuoteIdentifier("name"),
        db.QuoteIdentifier("age"),
        db.QuoteIdentifier("user"));

上面语句经过这样处理后，则可以兼容所有数据库，当DbHelper当前是对SqlConnection执行操作，则上面的sql等于

select [name],[age] from [user]

而如果是对OleDbConnection的Access环境下，则是这样的语句

select `name`,`age` from `user`

嗯？是不是和MySql数据库的语法一样？。

但需要注意的是，如果是在OleDbConnection或OdbcConnection执行环境，如果数据源还处于未打开(Open)的状态，则调用此方法后，DbHelper会自动打开数据源并保持打开状态。

19、EscapeString ：对字符串数据进行转义处理。比如Sql server数据库则需要字符串里的单引号进行转义。

string text = db.EscapeString("当前时间是'2011-08-01 20:33'");

对于SqlConnection或者OleDbConnection返回的都是

当前时间是''2011-08-01 20:33''

而如果是在MySql环境下则返回的是

当前时间是\'2011-08-01 20:33\'

DbHelper的属性

1、Connection ：返回当前执行的数据库连接对象(DbConnection)

2、DbTransaction : 返回或设置在执行命令时使用的事务，一般通过BeginTransaction方法启用事务，如果需要使用其它外部事务则可以设置此属性进行更改。

3、DbTransactionIsCreatedByDbConnection ：返回DbTransaction 是否是通过BeginTransaction方法建立的还是由外部手工设置的。

4、KeepConnection ：当前的DbHelper是否是处于保持打开状态模式的。

using (DbHelper db = new DbHelper(connection))
{
    db.ExecuteNonQuery("update [user] set age=22 where id=1");                //打开一次，执行完后又关闭
    var user = db.ExecuteDbObject<DbUser>("select * from [user] where id=1"); //打开一次，执行完后又关闭
}

上面代码里，执行两次命令共需要打开2次DbConnection。

using (DbHelper db = new DbHelper(connection, true))
{
    db.ExecuteNonQuery("update [user] set age=22 where id=1");                //打开一次，执行完后又不关闭
    var user = db.ExecuteDbObject<DbUser>("select * from [user] where id=1"); //直接执行
}

上面代码，则只需要打开1次DbConnection

5、Executor ：返回一个DbCommandExecutor对象(关于此对象见后文）。

注：DbHelper里的内部方法很多是虚方法，所以你可以根据你的需要对其重写以适用不同的数据库，比如KT里提供的MySqlDbHelper，就是继承于DbHelper并重写部分内部方法，以便适应MySql数据库环境。

数据命令的包装对象:DbCommandWrapped

对于DbCommand有一个小问题，在执行命令时，如果使用了参数，在执行完成后如果忘记了调用Clear方法清除，将会导致那些参数无法再次使用！！具体可查看我的这篇文章《认父亲的DbParameter!!》

所以我在KT对DbCommand加了一个包装对象，类似如下的代码：

/// <summary>
/// 对DbCommand进行包装
/// </summary>
public class DbCommandWrapped : IDisposable
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="command"></param>
    /// <param name="keepConnection"></param>
    public DbCommandWrapped(DbCommand command) 
    {
        this.Command = command;
    }

    public DbCommand Command;

    public void Dispose()
    {
        if (this.Command != null)
        {
            this.Command.Parameters.Clear();
            this.Command.Dispose();
        }
    }
}

有了这个包装对象，我们在执行命令时直接using一下就可以回收参数了，如下面代码

var pId = db.CreateDbParameter("@id", DbType.Int32, 1);
using (var command = db.CreateDbCommandWrapped("update [user] set age=22 where id=@id", pId))
{
    command.ExecuteNonQuery();
}
//pId可以再次使用
var user = db.ExecuteDbObject<DbUser>("select * from [user] where id=@id", pId);

本文链接

我的KT库之----数据对象

2011-08-24T15:00:00Z

了解或者认识KT：

http://www.cnblogs.com/kingthy/archive/2011/08/08/2130973.html

在项目中如何使用KT？

KT是一个库，所以将KT的dll文件引用到您的项目上即可使用KT里的函数功能。

本节将介绍大家认识KT库里的数据对象(DbObject)。KT里的数据对象是KT简易ORM框架里的一个对象角色，它存放于在“KT.Framework“下，当你已在你的项目里引用了KT库后，则写下以下代码就可以使用数据对象了。

using KT.Framework;

什么是数据对象

数据对象可用于简单处理数据的存储与交互，如将数据进行实体化处理。KT里的数据对象DbObject对象类似于一个“字典”对象，添加到数据对象里的数据都被放入内部的一个“槽”里进行维护，如以下的代码:

DbObject obj = new DbObject();
obj["name"] = "张三";
obj["age"] = 23;
Console.WriteLine("姓名:{0}", obj["name"]);
Console.WriteLine("年龄:{0}", obj["age"]);

//或者通过SetData/GetData<T>方法设置/获取数据
obj.SetData("name", "李四");
Console.WriteLine("姓名:{0}", obj.GetData<string>("name"));
Console.WriteLine("年龄:{0}", obj.GetData<int>("age"));
Console.Read();

扩展数据对象

虽可以直接将数据对象当作一个字典对象使用，但很多场合下我们却是需要将数据进行实体化处理，所以我们需要将数据对象进行扩展。如以下的代码示例：

/// <summary>
/// 用户对象
/// </summary>
public class DbUser : DbObject
{
    public User()
    {

    }
    /// <summary>
    /// 姓名
    /// </summary>
    public string Name
    {
        get
        {
            return this.GetData<string>("Name", null);
        }
        set
        {
            this["Name"] = value;
        }
    }
    /// <summary>
    /// 年龄
    /// </summary>
    public int Age
    {
        get
        {
            return this.GetData<int>("Age", 0);
        }
        set
        {
            this["Age"] = value;
        }
    }
}

这样扩展后，我们的数据对象User就是强类型的了，如下面的使用代码示例：

DbUser user = new DbUser();
user.Name = "张三";
user.Age = 12;

有时我们的类里需要使用到类内部的“字段”，则我们也可以将“字段”关联到数据对象里，如下面的扩展方法处理

/// <summary>
/// 用户对象
/// </summary>
public class DbUser : DbObject
{
    public DbUser()
    {
        this.AddInternalData("Id", () => this.Id, (o) => this.Id = o.As<int>());
    }
    /// <summary>
    /// 编号
    /// </summary>
    public int Id;

    /// <summary>
    /// 姓名
    /// </summary>
    public string Name
    {
        get
        {
            return this.GetData<string>("Name", null);
        }
        set
        {
            this["Name"] = value;
        }
    }
    /// <summary>
    /// 年龄
    /// </summary>
    public int Age
    {
        get
        {
            return this.GetData<int>("Age", 0);
        }
        set
        {
            this["Age"] = value;
        }
    }
}

我们通过“AddInternalData”方法，将Id字段加入到了数据对象里，这样我们就可以在数据对象里使用”Id”数据了，如下面代码

DbUser user = new DbUser();
            user["Id"] = 33;
            Console.WriteLine(user.Id);  //输出33
            user.Id = 22;
            Console.WriteLine(user.GetData<int>("Id"));  //输出22

还有一种情况，有时对一种数据，我们多有种不同的名称，比如“用户名”，有时使用为“name“，有时又为“username“，比如以下两句SQL语句

SELECT Name FROM [User]

SELECT B.BookName,U.UserId,U.Name AS UserName FROM [Book] B INNER JOIN [User] U ON U.Id=B.UserId

在第一句SQL语句里，因为只单纯查询用户表，所以可以使用“name”做用户的名称，但在第二句SQL语句里，为了区别用户的数据，又采用了"username”做为用户名数据，对于这种情况，我们也可以在数据对象里进行扩展，如以下示例代码

/// <summary>
/// 用户对象
/// </summary>
public class DbUser : DbObject
{
    public DbUser()
    {
        this.AddInternalData("Id", () => this.Id, (o) => this.Id = o.As<int>());
    }
    /// <summary>
    /// 编号
    /// </summary>
    public int Id;

    /// <summary>
    /// 姓名
    /// </summary>
    public string Name
    {
        get
        {
            return this.GetData<string>("Name", null);
        }
        set
        {
            this["Name"] = value;
        }
    }
    /// <summary>
    /// 年龄
    /// </summary>
    public int Age
    {
        get
        {
            return this.GetData<int>("Age", 0);
        }
        set
        {
            this["Age"] = value;
        }
    }

    protected override bool OnBeforeSetData(string name, object value)
    {
        if ("username".Equals(name, StringComparison.OrdinalIgnoreCase))
        {
            //调用内部的SetDataImp方法，可避免再一次触发OnBeforeSetData方法
            this.SetDataImp("name", value);

            /**
             * 注：以下两种方式都会再一次触发OnBeforeSetData方法，所以尽量不要使用
             * this.SetData("name", value);
             * this.Name = value.As<string>();
            **/
            return false;
        }
        return base.OnBeforeSetData(name, value);
    }
}

使用示例

DbUser user = new DbUser();
            user.Name = "张三";
            Console.WriteLine(user.Name);  //输出"张三"
            user["username"] = "李四";
            Console.WriteLine(user.Name);  //输出"李四"

数据对象的使用

在上面示例代码里，也许会有很多同学都会问“这样的数据对象，看不出它的好处在哪里，并且比直接写一个类结构还更复杂”，是的，直接这样使用数据对象，真的体现不出它的好处在哪里，但如果将数据对象与“数据库”挂上关系，那就可以体现数据对象的好处在哪里了。比如我们的数据库有这样的两个表

表1：User 用户表
Id int
Name nvarchar(20)
Age int
Phone nvarchar(20)
LocationId int


表2：Location 位置表
Id int
UserId int
City nvarchar(30)
Address nvarchar(200)
Zipcode nvarchar(6)

现在我们需要获取User表里的数据，比如有以下的SQL语句

SELECT * FROM [User]

根据上表可以知道，这样的查询语句，将获取到的数据共有5个(Id,Name,Age,Phone,LocationId)，但如果将这些数据映射到某个实体类去，并且实现数据的一一对应，那我们就需要定义这5个属性或字段，如下面的类

/// <summary>
/// 用户对象
/// </summary>
public class User 
{
    public User()
    {

    }
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public string Phone { get; set; }
    public int LocationId { get; set; }
}

但假如我们现在在获取用户数据时还需要同时获取用户的地址位置数据，如以下的SQL语句

SELECT U.Id,U.Name,L.City,L.Address,L.Zipcode FROM [User] U INNER JOIN [Location] L ON L.Id=U.Location.Id

这条查询语句我们共需要获取Id,Name,City,Address,Zipcode这5个数据，很明显，这里的数据与上面的User类结构是不相同的，也就是如果需要将这条SQL语句映射为类对象，我们又需要建多一个类结构对象。也就是每当我们SQL语句有变化时，我们就需要增加不同的类对象，这样对我们来说是非常麻烦且工作量是非常之大的。

如果我们使用数据对象来做数据映射，因为数据对象本来就是一个“字典”对象，所以不管我们的SQL语句如何变化，数据都是进入到数据对象里的“槽”里，再根据“扩展数据对象”反映到对象的“属性”或“字段”里。比如上面两句SQL语句我们都可以将其映射为“扩展数据对象”那段里定义的“DbUser”对象，对于未“扩展”的“Phone,LocationId,City,Address,Zipcode“等数据，我们则可以在需要时通过数据对象的“GetData<T>”方法获取，如下：

var phone = user.GetData<string>("Phone");
var locationId = user.GetData<int>("LocationId");

从上面的示例中，我们可以看到DbObject有点类似于DataTable，确切的说应该是像DataRow，只当一个相同的DbObject列表集时，才能说象DataTable。KT也提供了DbObject的扩展方法，通过扩展方法DataTable与List<DbObject>可以互相转换。如下示例：

DataTable table = new DataTable();
            table.Columns.Add("name", typeof(string));
            table.Columns.Add("age", typeof(int));
            table.Rows.Add("张三", 20);
            table.Rows.Add("李四", 30);
            var users = table.ToDbObjectList<DbUser>();
            Console.WriteLine(users.Count);    //输出：2
            Console.WriteLine(users[0].Name);  //输出：张三
            var userTable = users.ToDataTable();
            Console.WriteLine(userTable.Rows.Count);  //输出：2
            Console.WriteLine(userTable.Rows[0]["Name"]);//输出：张三

本文链接

【原创】腾讯微博的XSS攻击漏洞

2011-08-20T09:44:00Z

相信大家都知道新浪微博在6月28日发生的XSS攻击事件了吧？在那晚里，大量新浪微博用户自动发送微博信息和自动关注一名叫“hellosamy“的用户。

究竟XSS攻击为什么能有这么大的威力？现在很多网站都采用了Cookie记录访问者的登录状态，在进行某些功能操作时（比如：发微博），服务器判断用户的Cookie记录的登录状态，如果用户是登录状态的则允许操作。正常情况下这样的操作看起来是安全的，因为服务器假想那些操作都是用户自己主动提交的操作。但假如攻击者进行了恶意的渗透（页面脚本注入或会话截取），模拟了用户的操作，这样这些操作就是恶意的并且可能是带有“危险”性的！比如新浪微博里的自动发微博、自动关注等等。

XSS攻击分成两类

一类是来自内部的攻击，主要指的是利用网页自身的漏洞，将恶意脚本注入到网页，当用户访问此页面时，恶意脚本也会跟着执行，这样恶意脚本就能利用到用户的所有状态数据执行恶意操作，比如发微博、私信等（新浪微博的XSS攻击就是此类）。

另一类则是来自外部的攻击，主要指的自己构造XSS跨站漏洞网页或者寻找非目标机以外的有跨站漏洞的网页。如当我们要渗透一个站点，我们自己构造一个有跨站漏洞的网页，然后构造跨站语句，通过结合其它技术，如社会工程学等，欺骗目标服务器的管理员打开。

新浪微博的XSS攻击事件过去了，腾讯微博目前还没有发生此类事件，但这不表明腾讯微博是安全的：）

因为我这几天都在捣鼓腾讯微博的小应用开发，所以很经常去逛腾讯微博应用频道，想看看最近推荐的应用有哪些（其实是想看到自己的应用有没有被推荐出来，很可惜！没有，失望：(！），昨晚在闲逛腾讯微博的应用频道，突然好奇心突起，测试了一下，竟然被我发现一个XSS注入点！

腾讯微博的应用介绍地址基本都是这样的：

http://app.t.qq.com/app/intro/xxxxxxxxx

比如这个不知是什么虾米的“test9“应用的介绍地址是这样的：

http://app.t.qq.com/app/intro/24042/test9/http%253A%252F%252Fappst.qq.com%252Fcgi-bin%252Fwbapps%252Fwb_appstore_app.cgi%253Fappid%253D24042

看到后面的“http%253A%252F%252Fappst.qq.com%252Fcgi-bin%252Fwbapps%252Fwb_appstore_app.cgi%253Fappid%253D24042”这串东西没有？很明显是一个URL地址，这个URL地址在哪里用到呢？我们打开那应用的介绍地址，然后查看一下源码，会发现这个URL地址会在一个iframe里出现，如下图：

如果我们在那URL里加点东西会怎样？试试，改这样的地址:

http://app.t.qq.com/app/intro/24042/test9/http%253A%252F%252Fappst.qq.com%252Fcgi-bin%252Fwbapps%252Fwb_appstore_app.cgi%253Fappid%253D24042%22%20onload=%22alert('Hello');

也就是将那URL改为这样的URL数据（未编码）

http://appst.qq.com/cgi-bin/wbapps/wb_appstore_app.cgi?appid=24042" onload="alert('Hello');

访问上面的链接，浏览器向我Say hello（如下），很好！很好！

源码就成了这样的：

注意：在IE9下，上面的XSS注入无效，只对IE8及以下有效，IE9里将会这样提示：

并且上面的代码里会自动将onload给转换掉，如下图：

虽然IE9里不能构成XSS攻击，但是现在有多少人在用IE9呢？

好了，注入点有了，后面该做什么的就做什么吧，打酱油的打酱油，泡妞的泡妞吧。具体如何打酱油、泡妞，我就不再教你们了，嘿嘿，我没有你们这么坏：）

真的想看XSS攻击效果？请猛点这里！ (注：此演示需要在您已登录腾讯微博的情况下才能XSS攻击成功，如果成功，你将会自动关注我的微博http://t.qq.com/kingthy和发送一条微博信息）

备注说明：此漏洞在我发此日志前我已告诉腾讯官方，所以如果你看到我这篇文章后，发现上面的漏洞根本无法使用了，那就是腾讯已修复了此漏洞。如果还未修复，那只能说腾讯不重视或者还在打酱油ING……

声明：请勿利用此漏洞做任何非法的事！否则造成的任何后果都全由你个人承担！本人概不负责！！！！

文章转载请注明本人博客来源地址！

本文链接

我的KT库之-----缓存与配置

2011-08-16T03:37:00Z

了解或者认识KT：

http://www.cnblogs.com/kingthy/archive/2011/08/08/2130973.html

在项目中如何使用KT？

KT是一个库，所以将KT的dll文件引用到您的项目上即可使用KT里的函数功能。

本节将介绍大家认识KT库里的缓存与配置。它们都存放在“KT.Core“下，当你已在你的项目里引用了KT库后，则写下以下代码就可以使用到KT里的缓存与配置对象了。

using KT.Core;

缓存

KT的缓存只是简单的对.NET的缓存Cache进行了一个简单的包装，以便更方便的使用。

1、增加一个缓存项：

//增加一个长时效的缓存项
Cache.Add("key1", DateTime.Now);
//增加一个具有绝对过滤时间的缓存项
Cache.Add("key2", DateTime.Now, DateTime.Today.AddDays(1));
//增加一个与文件关联的缓存项，如果文件有更改则缓存失效
Cache.Add("key3", DateTime.Now, "c:\cache.txt");

2、删除缓存项

//删除对应键值的缓存项
Cache.Remove("key1");
//清空所有缓存
Cache.Clear();

3、获取某个缓存项

//获取对应键值的缓存项
object value = Cache.Get("key1");
//获取对应键值的缓存项，如果缓存没有数据，则调用委托获取数据并存入缓存后返回
DateTime time = Cache.GetOrAdd<DateTime>("key2", () =>
{
    return DateTime.Now;
});

配置

平时在项目开发中，参数配置都习惯在项目配置文件(app.config或web.config)的AppSettings节点中配置，比如以下示例：

<appSettings>
    <add key="api_key" value="key-2011" />
    <add key="api_secret" value="iu5r324323423422" />
  </appSettings>

程序代码里要使用参数时，直接调用即可，如下代码：

string api_key = ConfigurationManager.AppSettings["api_key"];
string api_secret = ConfigurationManager.AppSettings["api_secret"];

如果我们的参数非常的多，这将会导致我们的项目配置文件非常的大。并且如果在web项目中，我们的配置参数在运行过程中需要更改，则将会导致我们的web站点应用程序的重启！对于正常运行的项目来说，程序的重启是希望不要发生的，因为这将会导致session的丢失等相关问题。虽然我们可以在appSettings节点里使用file属性采用外部文件来配置避免这问题，但在某些场合下，file属性却是无能为力了。比如需要分多个配置文件存储不同的数据，file属性是无法做到的。

KT的配置

1、KT的配置文件

KT的配置文件，默认存储于程序根目录下的config目录，当然，你也可以自定义配置的存储路径，比如在app.config或web.config里的AppSettings节点里配置以下设置。

<appSettings>
    <!--方法1：设置绝对路径-->
    <add key="KT.SETTINGS.BASEPATH" value="c:\data\config\" />
    <!--方法2：设置相对路径-->
    <add key="KT.SETTINGS.BASEPATH" value="~/data/config/" />
  </appSettings>

如果未设置则默认是程序的根目录(Web应用程序则是站点根目录；Windows应用程序则是可执行文件所在的目录)下的config目录

KT的配置文件采用的是标准xml文件，如下示例：

<?xml version="1.0" encoding="utf-8" ?>
<settings>
  <add key="k1" value="1" />
  <k2>2</k2>
  <k.name>aliey</k.name>
  <k.age>20</k.age>
</settings>

上面配置中，共定义了4个参数。其中k1参数的定义同.net里的appSettings一样，通过<add>节点元素定义；其它的参数都是采用节点形式定义。

KT的配置文件有两个特殊的节点<add>与<include>节点。

1、<add>节点：如果定义此节点，并且带有“key”属性，则表示增加一个参数，参数值由“value”属性定义。如果定义此节点，但不带有任何属性，则看作普通的参数"add”对待。如下面示例：

<?xml version="1.0" encoding="utf-8" ?>
<settings>
  <add key="k1" value="1" />
  <add>action/add</add>
</settings>

共定义了“k1”与“add”两个参数。

2、<include>节点：如果定义此节点，并且带有“file”属性，则表示是引用相关的配置文件。否则如果不带有任何属性，则看作普通的参数“include”对待。如下面示例：

<?xml version="1.0" encoding="utf-8" ?>
<settings>
  <add key="k1" value="1" />
  <add>action/add</add>
  <include file="mysettings.xml" />
  <include file="c:\config\mysettings2.xml" />
  <include>action/include</include>
</settings>

共导入了“mysettings.xml”与“c:\config\mysettings2.xml”两个配置文件里的配置参数，并且还定义了一个“include”参数，其中file属性的值可以是相对路径或绝对路径，如果是相对路径则是“相对于当前配置文件所在的路径”。

所有参数的节点都可以重复定义，但参数最终的值将由最后一个定义节点决定(注：“<include file=””>”节点是例外)，即最后定义的将覆盖先前定义的值。如下示例：

<?xml version="1.0" encoding="utf-8" ?>
<settings>
  <add key="k1" value="1" />
  <k1>2</k1>
</settings>

最终，“k1"的值是“2”。

2、配置参数的获取

参数的获取是通过KT.Core.Settings实例类获取，此类共有几个静态方法和属性。

A、BasePath : 返回存储配置文件所在的基路径。此值可以通过上面所说的方法，在appSettings里修改。默认是程序根目录下的config目录.

B、Default : 返回默认存储配置文件的所有配置参数值。此默认配置参数存储于基路径下的"settings.config"文件。

C、From ：从配置文件获取配置参数。配置文件可以是相对路径或绝对路径，如果是相对路径则相对于BasePath。

D、Get<T>：从配置文件获取配置参数并映射为某个实体类。配置文件可以是相对路径或绝对路径，如果是相对路径则相对于BasePath。

假如以下配置存储在基路径下的settings.config文件

<?xml version="1.0" encoding="utf-8" ?>
<settings>
  <add key="k1" value="1" />
  <k2>2</k2>
  <k.name>aliey</k.name>
  <k.age>20</k.age>
</settings>

那我们可以这样获取参数“k1”、“k2”、“k.name”的值

Console.WriteLine(Settings.Default["k1"]);
Console.WriteLine(Settings.Default["k2"]);
Console.WriteLine(Settings.Default["k.name"]);
Console.WriteLine(Settings.Default["k.age"]);

如果我们配置文件不是默认的“settings.config”文件，那我们可以这样获取配置

var setttings = Settings.From("mysettings.xml");
Console.WriteLine(setttings["k1"]);
Console.WriteLine(setttings["k2"]);
Console.WriteLine(setttings["k.name"]);
Console.WriteLine(setttings["k.age"]);

如果我们的配置文件结构可以映射为某个类，比如上面的配置文件可以映射为以下类结构

public class KItem
{
    public string Name { get; set; }
    public int Age { get; set; }
}
public class AppSettings
{
    public int K1 { get; set; }
    public int K2 { get; set; }
    public KItem K { get; set; } 
}

那我们还可以直接通过Get<T>方法直接获取配置实体类，如下面的示例：

var app = Settings.Get<AppSettings>("mysettings.xml");
 Console.WriteLine("K1={0}", app.K1);
 Console.WriteLine("K2={0}", app.K2);
 Console.WriteLine("K.Name={0}", app.K.Name);
 Console.WriteLine("K.Age={0}", app.K.Age);

由于AppSettings里的属性“K”是一个“KItem”类型，所以KT将会自动将“<k.name>”和“<k.age>”这两个节点映射为“KItem”类型的值.

注：KT的配置都已启用缓存功能，所以不需要担心它的效率问题。

我们可以用KT的配置做什么？

A、各应用程序之间的配置可以互相独立存放。比如在WEB环境下，同一个站点下有多个不同的WEB应用程序，如论坛、博客、接口服务等等，那我们可以将它们的配置分别以不同的文件名存放于“基路径”下，如“forum.config”, “blog.config”,"service.config“，再调用From或Get<T>方法读取不同的文件名即可。

B、各应用程序之间的配置可以共享使用。比如上面例子所说的，如果“论坛”程序要调用“博客”里的参数，则我们可以在论坛的配置参数里加入“<include file=“blog.config”>”节点引入“博客”的配置参数。

C、各应用程序的配置可以统一存放。比如在WEB环境下，我们有A、B、C三个站点，这三个站点都需要用到同一个数据库，于是我们分别在这三个站点下写了一个同样用户名与密码的“ConnectionString“配置参数，当某一天，我们修改了数据库的用户密码，那我们就要分别打开这三个站点的目录去修改“ConnectionString”配置参数。而如果我们将A、B、C三个站点的KT配置的基路径设置为同一个目录，那我们就只要打开一个目录就可以修改到三个站点的参数了。

本文链接

我的KT库之-----对象池

2011-08-11T10:43:00Z

了解或者认识KT：

http://www.cnblogs.com/kingthy/archive/2011/08/08/2130973.html

在项目中如何使用KT？

KT是一个库，所以将KT的dll文件引用到您的项目上即可使用KT里的函数功能。

本节将介绍大家认识KT库里的对象池和如何使用它们。KT里的对象池对象都存放在“KT.Core.ObjectPool“下，当你已在你的项目里引用了KT库后，则写下以下代码就可以使用到KT里的所有对象池了。

using KT.Core.ObjectPool;

先了解一下对象池

对象池，顾名思义就是用于存储对象的池（汗-_-!!)，在它的生命周期内维护着它里面的所有对象，确保在同一个生命周期内对象池里的数据的唯一性。当对象池被销毁时，它里面的所有对象也将跟着销毁。

它的接口定义：

/// <summary>
/// 对象池接口
/// </summary>
public interface IObjectPool : IDisposable
{
    /// <summary>
    /// 添加对象，如果已存在key，则更新旧值
    /// </summary>
    /// <param name="key">键值</param>
    /// <param name="value"></param>
    void Add(object key, object value);

    /// <summary>
    /// 判断是否存在某个对象
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    bool Contains(object key);

    /// <summary>
    /// 移除某个对象
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    bool Remove(object key);

    /// <summary>
    /// 返回某个对象,如果不存在则返回null
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    object Get(object key);

    /// <summary>
    /// 返回对象池中已存储的对象数量
    /// </summary>
    int Count { get; }

    /// <summary>
    /// 清空对象池
    /// </summary>
    void Clear();
}

目前在KT里实现了此接口的共有两个对象，如下：

其中DictionaryObjectPool是采用Hashtable实现的对象池，用于向其它对象池提供基础服务。ObjectPoolBase则是一个抽象类，是其它对象池的基类。

对象池的种类

根据生命周期的不同，可分为不同种类的对象池，KT目前共有以下几种：

A、WebApplicationObjectPool: 基于ASP.NET 应用程序的对象池

对于同一个ASP.NET应用程序（同一个Web站点程序）来说，对象池里的数据都是共用的，使用示例：

WebApplicationObjectPool.Instance.Add("数据", "数据值");
var value1 = WebApplicationObjectPool.Instance.Get("数据").As<string>();

//通过扩展方法获取数据
var value2 = WebApplicationObjectPool.Instance.GetOrAdd<string>("数据1", () => "数据值1");

注意：如果需要在ASP.NET应用程序结束时自动回收数据，请在Global.asax里的Application_End事件里加上回收代码，如下示例：

protected void Application_End(object sender, EventArgs e)
{
    WebApplicationObjectPool.Instance.Dispose();
}

B、WebSessionObjectPool : 基于ASP.NET Session会话期的对象池

对于同一个Session会话来说，对象池里的数据都是共用的，使用示例：

WebSessionObjectPool.Instance.Add("数据", "数据值");
var value1 = WebSessionObjectPool.Instance.Get("数据").As<string>();

//通过扩展方法获取数据
var value2 = WebSessionObjectPool.Instance.GetOrAdd<string>("数据1", () => "数据值1");

注意：如果需要在Session失效时自动回收数据，请在Global.asax里的Session_End事件里加上回收代码，如下示例：

protected void Session_End(object sender, EventArgs e)
{
    WebSessionObjectPool.Instance.Dispose();
}

C、WebRequestObjectPool : 基于ASP.NET Request请求上下文的对象池

对于同一个Http Web Request会话来说，对象池里的数据都是共用的，使用示例：

WebRequestObjectPool.Instance.Add("数据", "数据值");
var value1 = WebRequestObjectPool.Instance.Get("数据").As<string>();

//通过扩展方法获取数据
var value2 = WebRequestObjectPool.Instance.GetOrAdd<string>("数据1", () => "数据值1");

注意：如果需要在Http Request完成时自动回收数据，请在web.config里注册WebRequestObjectPoolModule，如下示例：

<httpModules>
            <add name="WebRequestObjectPoolModule" type="KT.Core.ObjectPool.WebRequestObjectPoolModule" />
        </httpModules>

D、ThreadCallObjectPool : 基于线程调用的对象池。此对象池可以在ASP.NET和Application环境下使用。

对于同一个线程来说，对象池里的数据是共用的。使用示例：

public class Program
{
    static void Main(string[] args)
    {
        for (var i = 0; i < 100; i++)
        {
            Thread th = new Thread(()=>{
                var name = ThreadCallObjectPool.Instance.GetOrAdd<string>("K", ()=>Thread.CurrentThread.Name);
                Console.WriteLine("Thread: {0}, K={1}", Thread.CurrentThread.Name, name);
                Thread.Sleep(10);
                Console.WriteLine("Thread: {0}, K={1}", Thread.CurrentThread.Name, ThreadCallObjectPool.Instance.Get("K"));
            });
            th.Name = i.ToString();
            th.Start();
        }
        Console.Read();
    }
}

使用对象池上下文

KT里提供一个当前上下文的对象池调用“ObjectPoolContext”，此对象会自动根据您所处的上下文环境，调用对应的对象池实例。比如你当前的程序是运行在ASP.NET Web环境下，则会调用WebRequestObjectPool而如果是在Application环境下则会调用ThreadCallObjectPool对象池，如下示例代码：

/// <summary>
/// 商家模块
/// </summary>
public IMerchantsModule MerchantsModule
{
    get
    {
        return ObjectPoolContext.Current.GetOrAdd<IMerchantsModule>(
            typeof(MerchantsModule), () =>
            {
                return new MerchantsModule(this.DbHelper);
            });
    }
}
以上代码，不管是在ASP.NET环境还是在Application环境都可以正常运行。

本文链接

我的KT库之-----扩展方法

2011-08-08T09:17:00Z

了解或者认识KT：

http://www.cnblogs.com/kingthy/archive/2011/08/08/2130973.html

在项目中如何使用KT？

KT是一个库，所以将KT的dll文件引用到您的项目上即可使用KT里的函数功能。

本节将介绍大家认识KT库里的扩展方法和如何去使用扩展方法。KT里的扩展方法存放在“KT.Core.Extensions“下，当你已在你的项目里引用了KT库后，则写下以下代码就可以使用到KT里的所有扩展方法了。

using KT.Core.Extensions;

目前KT库只针对“Object”、“String”、“DateTime”、“IDictionary”,“NameValueCollection”等对象数据进行了方法扩展。

A、Object的扩展方法

1）、As<T>方法 : 万能转换方法

将某种类型的数据转换为另外一种类型数据，如果转换失败则返回对应类型的默认值，如下示例代码：

int i = "1".As<int>(); //i = 1
 float f = "0.22".As<float>(); //f = 0.22f
 DayOfWeek dayOfWeek = "Friday".As<DayOfWeek>(); //dayOfWeek = Friday
 DateTime time = "2011-01-01".As<DateTime>(); //time = 2011-01-01
 Stream stream = (new MemoryStream()).As<Stream>(); //stream = MemoryStream

 object value = null;
 long l = value.As<long>(); //l = 0L

从上面的示例代码可以看出，As<T>扩展方法有点类似于as操作符与Convert类的结合体。但As<T>和Convert类又有几点不同。

A)、如果类型转换失败，As<T>扩展不会抛出任何的错误，只是返回对应类型的默认值。如上面例子中的“long l = value.As<long>();“，因为null无法转换为long类型，所以返回long类型的默认值“0”。

B)、支持转换为枚举类型。如上例中将“Friday”字符串转换为DayofWeek枚举，如果转换失败，则返回枚举定义中的第一个项！

注：此方法还有一个重载方法，即是多了一个默认值参数，当转换失败时返回方法传递的默认值。如下示例：

object value = null;
long l = value.As<long>(-1L); //l = -1L

因为value=null，无法转换为long类型的值，所以返回-1L。

2)、ToJson方法: 将对象解析为Json格式的字符串

如果对象值为DateTime则返回一个JavaScript脚本的Date对象;如果是字符串，则对于非英文字母、数字的字符，将解析为“\uxxxx“格式的字符。

示例代码：

            User user = new User();
            user.Age = 12;
            user.Name = "张三";
            user.CreatedTime = DateTime.Now;
            user.Location.Address = "广东广州";
            user.Location.Zipcode = "510000";
            Console.WriteLine(user.ToJson());

运行后，将输出以下数据：

{"Name":"\u5f20\u4e09","Age":12,"CreatedTime":new Date(1312790227779),"Address":"\u5e7f\u4e1c\u5e7f\u5dde","Zipcode":"510000","Location":{"Address":"\u5e7f\u4e1c\u5e7f\u5dde","Zipcode":"510000"}}

3)、IfNull<T>方法：如果对象为null则调用委托方法。

有时我们会经常这样做if条件判断：

        static void GetCurrentUserData(User user)
        {
            if (user == null)
            {
                //如果user为null则获取当前会话的用户
                user = GetCurrentContextUser();
            }
            //其它操作代码
        }

有了此IfNull<T>扩展方法后，我们就可以省去此if了，可以直接写成这样：

static void GetCurrentUserData(User user)
 {
 user = user.IfNull<User>(GetCurrentContextUser);
 //其它操作代码
 }

B、String的扩展方法

1)、MD5方法：采用UTF-8编码获取字符串的MD5哈希值（小写输出）

示例代码：

Console.WriteLine("管理员".MD5()); //b1dae9bc5cabbc13e4bee21af11cdb8d
Console.WriteLine("管理员".MD5(Encoding.GetEncoding("gbk"))); //8178134ede762c42e41a7b1695082e28

注：此方法有一个重载方法，用于设置求取MD5哈希值时使用的文本编码。如上例代码，对于汉字，如果采用不同编码获取到的哈希值是不同的。

2)、IfEmpty方法：如果字符串为null或空字符值，则返回替代值或调用委托函数获取新值，类似于Object的IfNull<T>方法

3)、IsInteger方法：判断字符串是否都是由阿拉伯数字组成的，即是否由（0-9）数字组成的字符串

4)、IsDateTime方法：判断是否是日期时间格式的字符串

5)、IsValidEmail方法：判断字符串的格式是否是邮件地址格式（注：此方法判断的邮件格式要求较宽松，只要符合XXX@XXX.XX格式的都会认为符合）

6)、IsMatch方法：判断字符串是否符合某种正则表达式的模式格式，如下面代码就是IsInteger方法的实现：

"0123123".IsMatch(@"^\d+$")

7)、IsContain方法：判断字符串中是否包含有某个分隔项。示例代码：

            Console.WriteLine("A,B,C,D".IsContain("A",","));   //true
            Console.WriteLine("A,B,C,D".IsContain("E", ",")); //false
            Console.WriteLine("A,B,C,D".IsContain("a", ",")); //false
            Console.WriteLine("A,B,C,D".IsContain("a", ",", true)); //true

注：此方法有一个重载方法，用于指示判断时是否区分大小写

8)、Replace方法：字符串替换方法

此方法有几种不同的重载方法。

a)、是否不区分大小写替换,示例代码：

"AbabAe".Replace("a", "C", true); //CbCbCe

b)、带前缀、后缀的整批替换（集合），示例代码：

Dictionary<string, string> items = new Dictionary<string, string>();
 items.Add("姓名", "张三");
 items.Add("年龄", "20");
 items.Add("婚否", "未婚");

 Console.WriteLine("用户：[姓名]，今年[年龄]岁，婚姻状况：[婚否]".Replace(items, "[", "]")); //输出：“用户：张三，今年20岁，婚姻状况：未婚”

c)、带前缀、后缀的整批替换（委托）、示例代码：

//UBB转换示例
 string text = "[b]粗体[/b][i]斜体[/i][red]红色[/red]";
 text = text.Replace(key =>
 {
 switch (key.ToLower())
 {
 case "b":
 return "";
 case "/b":
 return "";
 case "i":
 return "";
 case "/i":
 return "";
 case "red":
 return "";
 case "/red":
 return "";
 default:
 return null;
 }
 }, "[", "]");
 Console.WriteLine(text); //输出:"粗体斜体红色"

9)、ToJavaScriptString方法：将字符串格式化为Javascript脚本里的字符串，对于非英文字母、数字的字符将格式为“\uxxxx”格式的字符。

10)、ConvertTo方法：将字符串值转换为其它类型。此方法是Object里的As<T>方法的核心方法。

11）、ReadAllLines方法：将字符串按行读取，并返回所有行数据数组。

C、DateTime的扩展方法

1)、ToTimestamp方法：获取某个日期时间的时间戳值，时间戳值的计算是从1970-01-01 0:0:0开始计算的总毫秒数

2)、FromTimestamp方法：将某个时间戳值转换为当前时间值。

3)、ToRFC822Time方法：获取某个日期时间的RFC822定义的格式字符串，此格式时间在邮件交互里经常使用到。如"Thu, 21 Dec 2000 16:01:07 +0800"

D、IDictionary的扩展方法

1)、GetOrDefault方法：从IDictionary对象里获取数据，如果没有数据则返回一个默认的值

2)、GetOrAdd方法：从IDictionary对象里获取数据，如果没有数据则调用委托获取数据并添加到集合后返回。示例代码：

Dictionary<string, string> items = new Dictionary<string, string>();
 Console.WriteLine(items.GetOrDefault("姓名", "张三")); //张三
 Console.WriteLine(items.GetOrAdd("姓名", () => "李四")); //李四
 Console.WriteLine(items.GetOrDefault("姓名", "张三")); //李四

E、NameValueCollection的扩展方法

1)、Get<T>方法：从NameValueCollection获取某个值，并且转换为对应类型，如果转换失败返回默认值

2)、TrimGet<T>方法：从NameValueCollection获取某个值，并去掉值的前后空白后转换为对应类型，如果转换失败则返回默认值。

示例代码：

int i = Request.QueryString.Get<int>("id");
string name = Request.QueryString.TrimGet<string>("name");
int year = Request.Form.Get<int>("year",2011);
DateTime time = Request.From.Get<DateTime>("createdtime",DateTime.Now);

3）、CopyTo<T>方法：将NameValueCollection里的所有数据复制到某个对象中

假如我们的Web表格里提交了如下数据：

name=张三&age=12&location.zipcode=510000&location.city=广州&createdtime=2011-01-01 12:00:00

User user = new User();
Request.From.CopyTo(user);
Response.Write(user.ToJson());

运行以上代码后，user里的各个属性字段将对应取得上面提交的值。

好了，目前KT里的扩展方法只提供了这么多，虽然少，但却都是非常有用的功能函数。如果你有更好的扩展方法或建议，希望你能加入到KT项目的更新开发中来：）

本文链接

Id	int
UserId	int
City	nvarchar(30)
Address	nvarchar(200)
Zipcode	nvarchar(6)