博客园_The blog of Madream

3.用ASP.NET缓存提高站点性能

2010-04-16T10:58:00Z

ASP.NET提供三种主要形式的缓存：页面级输出缓存、用户控件级输出缓存（或称为片段缓存）和缓存API。输出缓存和片段缓存的优点是非常易于实现，在大多数情况下，使用这两种缓存就足够了。而缓存API则提供了额外的灵活性（实际上是相当大的灵活性），可用于在应用程序的每一层利用缓存。本文全面介绍了这三种缓存技术在系统各层中的应用。

　　在ASP.NET提供的许多特性中，缓存支持无疑是我最欣赏的特性，我这样说当然是有充分理由的。相比ASP.NET的所有其他特性，缓存对应用程序的性能具有最大的潜在影响，利用缓存和其他机制，ASP.NET开发人员可以接受使用开销很大的控件（例如，DataGrid）构建站点时的额外开销，而不必担心性能会受到太大的影响。为了在应用程序中最大程度地利用缓存，您应该考虑在所有程序级别上都实现缓存的方法。

　　Steve的缓存提示

　　尽早缓存；经常缓存

　　您应该在应用程序的每一层都实现缓存。向数据层、业务逻辑层、UI或输出层添加缓存支持。内存现在非常便宜-因此，通过以智能的方式在整个应用程序中实现缓存，可以获得很大的性能提高。

　　缓存可以防止许多过失

　　缓存是一种无需大量时间和分析就可以获得“足够良好的”性能的方法。这里再次强调，内存现在非常便宜，因此，如果您能通过将输出缓存30秒，而不是花上一整天甚至一周的时间尝试优化代码或数据库就可以获得所需的性能，您肯定会选择缓存解决方案（假设可以接受30秒的旧数据）。缓存正是那些利用20%付出获得80%回报的特性之一，因此，要提高性能，应该首先想到缓存。不过，如果设计很糟糕，最终却有可能带来不良的后果，因此，您当然也应该尽量正确地设计应用程序。但如果您只是需要立即获得足够高的性能，缓存就是您的最佳选择，您可以在以后有时间的时候再重新设计应用程序。

　　页面级输出缓存

　　作为最简单的缓存形式，输出缓存只是在内存中保留为响应请求而发送的HTML的副本。其后再有请求时将提供缓存的输出，直到缓存到期，这样，性能有可能得到很大的提高（取决于需要多少开销来创建原始页面输出-发送缓存的输出总是很快，并且比较稳定）。

　　实现

　　要实现页面输出缓存，只要将一条OutputCache指令添加到页面即可。

＜%@ OutputCache Duration="60" VaryByParam="*" %＞

　　如同其他页面指令一样，该指令应该出现在ASPX页面的顶部，即在任何输出之前。它支持五个属性（或参数），其中两个是必需的。

　　Duration 必需属性。页面应该被缓存的时间，以秒为单位。必须是正整数。

　　Location 指定应该对输出进行缓存的位置。如果要指定该参数，则必须是下列选项之一：Any、Client、Downstream、None、Server或ServerAndClient。

　　VaryByParam 必需属性。Request中变量的名称，这些变量名应该产生单独的缓存条目。“none”表示没有变动。“*”可用于为每个不同的变量数组创建新的缓存条目。变量之间用“;”进行分隔。

　　VaryByHeader 基于指定的标头中的变动改变缓存条目。

　　VaryByCustom 允许在global.asax中指定自定义变动（例如，“Browser”）。

　　利用必需的Duration和VaryByParam选项的组合可以处理大多数情况。例如，如果您的产品目录允许用户基于categoryID和页变量查看目录页，您可以用参数值为“categoryID;page”的VaryByParam将产品目录缓存一段时间（如果产品不是随时都在改变，一小时还是可以接受的，因此，持续时间是3600秒）。这将为每个种类的每个目录页创建单独的缓存条目。每个条目从其第一个请求算起将维持一个小时。
VaryByHeader和VaryByCustom主要用于根据访问页面的客户端对页面的外观或内容进行自定义。同一个URL可能需要同时为浏览器和移动电话客户端呈现输出，因此，需要针对不同的客户端缓存不同的内容版本。或者，页面有可能已经针对IE进行了优化，针对Netscape或Opera则应取消这种优化功能。后一个例子非常普遍，我们将提供一个说明如何实现此目标的示例：

　　示例：VaryByCustom用于支持浏览器自定义

　　为了使每个浏览器都具有单独的缓存条目，VaryByCustom的值可以设置为“browser”。此功能已经内置在缓存模块中，并且将针对每个浏览器名称和主要版本插入单独的页面缓存版本。

＜%@ OutputCache Duration="60" VaryByParam="None" VaryByCustom="browser"%＞

　　片段缓存，用户控件输出缓存

　　缓存整个页面通常并不可行，因为页面的某些部分是针对用户定制的。不过，页面的其他部分是整个应用程序共有的。这些部分最适合使用片段缓存和用户控件进行缓存。此外，菜单和其他布局元素，尤其是那些从数据源动态生成的元素，也可以用这种方法进行缓存。

　　如果需要，可以按以下条件选择需要缓存的控件：

　　（1）某控件的属性已改变

　　（2）由页面级输出缓存所支持的任何一种页面或控件状态改变

　　一旦对某些控件进行了缓存，使用它们的几百个页面就可以共享这些控件，而不再需要为每个页面保留单独的控件缓存版本。

　　实现

　　片段缓存使用的语法与页面级输出缓存一样，但其应用于用户控件（.ascx文件）而不是Web窗体（.aspx文件）。除了Location属性，对于OutputCache在Web窗体上支持的所有属性，用户控件也同样支持。用户控件还支持名为VaryByControl的OutputCache属性，该属性将根据用户控件（通常是页面上的控件，例如，DropDownList）的成员的值改变该控件的缓存。如果指定了VaryByControl，可以省略VaryByParam。最后，在默认情况下，对每个页面上的每个用户控件都单独进行缓存。不过，如果一个用户控件不随应用程序中的页面改变，并且在所有页面都使用相同的名称，则可以设置参数Shared的值为“true”，该参数将使用户控件的缓存版本供引用该控件的所有页面使用。

　　示例

＜%@ OutputCache Duration="60" VaryByParam="*" %＞

　　该示例将缓存用户控件60秒，并且将针对查询字符串的每个变动、针对此控件所在的每个页面创建单独的缓存条目。

＜%@ OutputCache Duration="60" VaryByParam="none"
VaryByControl="CategoryDropDownList" %＞

　　该示例将缓存用户控件60秒，并且将针对CategoryDrop

　　DownList控件的每个不同的值、针对此控件所在的每个页面创建单独的缓存条目。

＜%@ OutputCache Duration="60" VaryByParam="none" VaryByCustom="browser"
Shared="true" %＞

　　最后，该示例将缓存用户控件60秒，并且将针对每个浏览器名称和主要版本创建一个缓存条目。然后，每个浏览器的缓存条目将由引用此用户控件的所有页面共享（只要所有页面都用相同的ID引用该控件即可）。

缓存API，使用Cache对象

　　页面级和用户控件级输出缓存的确是一种可以迅速而简便地提高站点性能的方法，但是在ASP.NET中，缓存的真正灵活性和强大功能是通过Cache对象提供的。使用Cache对象，您可以存储任何可序列化的数据对象，基于一个或多个依赖项的组合来控制缓存条目到期的方式。这些依赖项可以包括自从某对象被缓存后经过的时间、自从某对象上次被访问后经过的时间、对文件或文件夹的更改以及对其他缓存对象的更改，在略作处理后还可以包括对数据库中特定表的更改。

　　在Cache中存储数据

　　在Cache中存储数据的最简单的方法就是使用一个键为其赋值，就像HashTable或Dictionary对象一样：

Cache["key"] = "value";

　　这种做法将在缓存中存储项，同时不带任何依赖项，因此它不会到期，除非缓存引擎为了给其他缓存数据提供空间而将其删除。要包括特定的缓存依赖项，可使用Add()或Insert()方法。其中每个方法都有几个重载。Add()和Insert()之间的唯一区别是，Add()返回对已缓存对象的引用，而Insert()没有返回值（在C#中为空，在VB中为Sub）。

　　示例

Cache.Insert("key", myXMLFileData, new
System.Web.Caching.CacheDependency(Server.MapPath("users.xml")));

　　该示例可将文件中的xml数据插入缓存，无需在以后请求时从文件读取。CacheDependency的作用是确保缓存在文件更改后立即到期，以便可以从文件中提取最新数据，重新进行缓存。如果缓存的数据来自若干个文件，还可以指定一个文件名的数组。

Cache.Insert("dependentkey", myDependentData, new
System.Web.Caching.CacheDependency(new string[] {}, new string[]
{"key"}));

　　该示例可插入键值为“key”的第二个数据块（取决于是否存在第一个数据块）。如果缓存中不存在名为“key”的键，或者如果与该键相关联的对象已到期或被更新，则“dependentkey”的缓存条目将到期。

Cache.Insert("key", myTimeSensitiveData, null,
DateTime.Now.AddMinutes(1), TimeSpan.Zero);

　　绝对到期：此示例将对受时间影响的数据缓存一分钟，一分钟过后，缓存将到期。注意，绝对到期和滚动到期（见下文）不能一起使用。

Cache.Insert("key", myFrequentlyAccessedData, null,
System.Web.Caching.Cache.NoAbsoluteExpiration,
TimeSpan.FromMinutes(1));

　　动态滚动到期：此示例将缓存一些频繁使用的数据。数据将在缓存中一直保留下去，除非数据未被引用的时间达到了一分钟。注意，动态滚动到期和绝对到期不能一起使用。

　　更多选项

　　除了上面提到的依赖项，我们还可以指定项的优先级（依次为low、high、NotRemovable，它们是在System.Web.Caching.CacheItemPriority枚举中定义的）以及当缓存中的对象到期时调用的CacheItemRemovedCallback函数。大多数时候，默认的优先级已经足够了-缓存引擎可以正常完成任务并处理缓存的内存管理。CacheItemRemovedCallback选项考虑到一些很有趣的可能性，但实际上它很少使用。不过，为了说明该方法，我将提供它的一个使用示例：

　　CacheItemRemovedCallback示例

System.Web.Caching.CacheItemRemovedCallback callback = new System.Web.Caching.CacheItemRemovedCallback (OnRemove);
Cache.Insert("key",myFile,null,
　System.Web.Caching.Cache.NoAbsoluteExpiration,
　TimeSpan.Zero,
　System.Web.Caching.CacheItemPriority.Default, callback);
. . .
public static void OnRemove(string key, object cacheItem,
　System.Web.Caching.CacheItemRemovedReason reason)
{
　AppendLog("The cached value with key '" + key +
"' was removed from the cache. Reason: " +
　reason.ToString());
}

　　该示例将使用AppendLog()方法中定义的任何逻辑来记录缓存中的数据到期的原因。通过在从缓存中删除项时记录这些项并记录删除的原因，您可以确定是否在有效地使用缓存或者您是否可能需要增加服务器上的内存。注意，callback是一个静态（在VB中为Shared）方法，建议使用该方法的原因是，如果不使用它，保存回调函数的类的实例将保留在内存中，以支持回调（对static/Shared方法则没有必要）。

　　该特性有一个潜在的用处-在后台刷新缓存的数据，这样用户永远都不必等待数据被填充，但数据始终保持相对较新的状态。但实际上，此特性并不适用于当前版本的缓存API，因为在从缓存中删除缓存的项之前，不触发或不完成回调。因此，用户将频繁地发出尝试访问缓存值的请求，然后发现缓存值为空，不得不等待缓存值的重新填充。我希望在未来的ASP.NET版本中看到一个附加的回调，可以称为CachedItemExpiredBut

　　NotRemovedCallback，如果定义了该回调，则必须在删除缓存项之前完成执行。

本文链接

2.ASP.NET性能提升之站点部署与内容传输

2010-04-16T10:53:00Z

在将站点部署和到产品服务器之前，如果你正在使用ASP.NET 2.0 Membership Provider，你应该对你的web.config文件做一些调整:

第一篇：ASP.NET性能提升秘诀之管道与进程优化

在Profile Provider中添加applicationname特性。如果你不这里添加一个具体的名称，Profile provider将使用一个GUID。因此，你在的本地机器上，你将有一个GUID并且在产品服务器上你将有另一个GUID。如果你将本地数据库拷贝到产品服务器上，则在本地数据库中你将不能够重用这些记录并且ASP.NET将在产品服务器上创建一个新的应用程序。下面就是你需要添加的内容:

无论一个页面得到请求什么时候完成，Profile provider都将自动保存Profile信息。因此，这可能会导致一些不必要的结果，就是更新了具有重大性能损失的数据库。因此，关掉这个自动保存功能并在代码中显式使用Profile.Save()方法。
<profile enabled="true" automaticSaveEnabled="false" >

角色管理会一直查询数据库以便获得用户的角色。这样会有很大的性能损失。虽然你可以让角色管理器缓存这些角色信息到一个cookie中来避免。但是这会导致用户没有足够的权限去工作，因为cookie的最大存储量为2KB。因此，你可以安全地存储角色信息到一个cookie中并且在每次请求到*.aspx 和*.asmx.时保存到数据库中。

上面三个设置都必须要求站点具有高容量。

内容传输网络

每个请求从浏览器到你的服务器都会通过覆盖世界各地的骨干网络。跨越很多国家、大陆、海洋的到达你服务器的请求会变得很慢。例如，如果你在美国有多服务器并且有人从澳大利亚浏览你的站点，这样每个请求都会从地球的一端到另一端再到达你的服务器然后再返回到浏览器上。

如果你的站点包涵有大量的静态文件诸如图片、CSS、JavaScript等；为它们单独发送请求并下载它们将会花费大量的时间。如果你能够在澳大利亚配置一台服务器并重定向用户到你的澳大利亚服务器，那么每个请求相对于发送到美国来说几乎影响很小。不仅是网络延迟将降低，而且数据传输速度将更快，从而静态内容下载也快得多。

如果你的网站以静态内容为主的花，这将对用户来说有足够的性能提升。此外，针对国家范围的网络相比于互联网而言，ISPs提供了更快的速度，因为每个国家一般都有少数部分连接到了骨干网中，这些骨干网由同一国家的多个ISPs进行共享。结果，用户有4兆的带宽连接将从相同国家的服务器上获得整整4兆的速度。但是在国外它们从服务器上获得的速度又会降低到512KB。因此，在同一国家有一台服务器将大大提高站点的下载速度和响应速度。

除了提高站点的加载速度以外，CDN也会从你的网站服务器上减少流量。因为它涉及静态缓存内容，你的网站服务器会很少访问到这些内容。因此，你的访问将大大减少网站服务器的点击并且网站服务器就可以腾出更多的资源来处理动态请求。你的网站服务器也节省了大量的IIS日志空间，因为IIS对于静态内容不需要进行日志请求。如果在你的网站上有很多图片、CSS、以及JavaScript，那么每天你就可以保存上GB的IIS日志。

上面的数字展示了位于华盛顿特区的www.pageflakes.com站点的平均响应时间，那里的服务器位于得克萨斯州的达拉斯。其平均响应时间大约为4秒。该响应也包括了服务器端的执行时间。一般来说在服务器上会花费大约0.3到0.35秒的时间来执行页面。因此，花费在网络上的时间大概是0.05秒或者50毫秒。这已经是一个非常快的速度了，因为只有4到6个点就可以从华盛顿特区到达达拉斯。

这一数字展示了来自澳大利亚，悉尼的平均响应时间。平均响应时间是1.5秒，这明显高于华盛顿。与美国相比几乎相差四倍。大约仅仅只有1.2秒的网络开销。此外，从悉尼到达拉斯大约只有17到23个点。因此，相比于在美国的任何地方，从澳大利亚的站点下载速度至少要慢四倍之多。

内容传递网络（CDN）一个跨越互联网的系统计算机网络。计算机之间透明地为终端用户传递内容（尤其是大型媒体内容）。CDN节点（在指定位置的服务器集群）被部署在多个位置，常常会跨越多个骨干网络。这些节点彼此相互协作为终端用户发出的内容请求作出回应。它们也透明地将内容移动到后台并优化传递过程。CDN服务器请求会智能的选择最近的服务器。它会在你的计算机和你所寻找内容的最近节点之间建立快速链接。

在不同国家的节点数量以及一些冗余骨干网络的数量链接到一个CDN时其效果都不一样。一些受欢迎的CDNs有Akamai、 Limelight、EdgeCast。Akamai被很多大公司使用诸如：微软、雅虎、AOL等。一般来说，这是一个比较昂贵的解决方案。然而，Akamai提供的服务器在全球都是最佳的，因为它们在世界上很多著名的城市都有服务器。此外，Akamai的服务费用也非常贵，他们只接受能够每个月最少花费5千加币在CDN服务上的客户。对于一些小公司，Edgecast是一个更合理的解决方案。

这个数字展示了与浏览器拦截流量和服务器响应最近的节点。如果在缓存中没有响应，它会使用一条更快的路线以及相比于浏览器的ISP所能提供的最优化链接从源服务器上去抓取数据。如果该内容已经缓存，那么会直接从节点上提取数据而不需要在从源服务器上。

一般来说，会有两种类型的CDNs。一种是通过FTP的方式将内容上传到CDN的服务器上，这种方式你可以在它们的服务器上获得一个子域诸如dropthings.somecdn.net这种形式。你可以从CDN域改变站点上所有的静态内容URL来下载内容而不是指向你自己域的相对URL。因此，一个像/logo.Gif这样的URL会被重命名为http://dropthings.somecdn.net/logo.gif。虽然这种方式很容易配置，但是会出现维护问题。你将不得不一直保持CDN的文件的异步存储。部署会变得十分复杂，因为你需要同时更新你的网站和CDN存储。这种类型的CDN（这种类型费用很便宜）的一个例子就是Cachefly。

在你自己站点上存储静态内容还有一个更加简便的方法，但是需要使用域别名。你可以在一个指向你自己域诸如.dropthings.com的子域中来存储你的内容。然后你再使用CNAME来将子域映射到一个像cache.somecdn.net这样的CDN服务器上。当浏览器试图解析static.dropthigns.com域名时，DNS会通过CDN命名服务器查找请求。然后命名服务器返回一个离你最近并能提供最快下载性能的CDN节点的IP。然后，浏览器为文件发送请求到CDN节点上。

当CDN节点看到这些请求时，它会检查这些内容是否已经进行了缓存。如果缓存了，它会直接从本地存储中读取内容。如果没有，会发出一个到服务器的请求，然后查看在响应中产生的缓存头。根据缓存头，系统会决定将响应缓存多长时间。同时，浏览器不会等待CDN节点来获得内容并返回它。CDN在互联网骨干网络上做了一个有趣的技巧是将请求路由到源服务器以便浏览器直接从源服务器获得响应，而CDN却一直在更新缓存。有时候CDN扮演了一个代理的角色，截取每个请求然后使用一个更快的路由和经过优化的链接到源服务器的方式从源服务器上抓取未缓存的内容。这种CDN类型的例子是Edgecast。

本文链接

1.ASP.NET性能提升秘诀之管道与进程优化

2010-04-16T10:49:00Z

ASP.NET 2.0中包涵了很多秘密，当你发现它时，可以为你的程序带来更大的性能和扩展性提升。例如，了解了在Membership和Profile provider提供程序中所隐藏的秘密瓶颈后就可以方便地的解决验证问题并使得授权操作的速度加快。

第二篇：ASP.NET性能提升之站点部署与内容传输

另外，ASP.NET HTTP管道为了避免针对每次请求所要执行的必要代码而发生阻塞。不仅那样，ASP.NET工作者进程能够推动其限制而获得更高的性能。页面碎片在浏览器端的输出缓存（不是在服务器端）可以显著节约回访者的下载时间。按需求的用户界面下载可以让你的站点给人快速流畅的感觉。

最后内容传输网络和HTTP缓存头的恰当使用可以让你的网站惊人的快速。在这篇文章中，你将学习到这些技术，它能够使你的ASP.NET应用程序获得更高的性能、更好的扩展性，并且可以在任何ASP.NET的网站上实现，尤其是那些应用了ASP.NET 2.0 Membership 和Profile provider的站点。

ASP.NET管道优化

位于请求管道中的很多ASP.NET默认的HttpModules用于拦截客户端所发出的每个请求。例如，SessionStateModule拦截每个请求，并解析对应的会话cookie，然后在HttpContext中加载适当的会话。实时证明，并不是所有的modules都是必要的。

例如，如果你不使用Membership和Profile provider提供程序，那么你就可以不需要FormsAuthentication module。如果你需要为你的用户使用Windows验证，那么你就可以不需要WindowsAuthentication。位于管道中的这些modules仅仅在每次请求到来时执行一些不必要的代码。

默认的modules都定义在了machine.config文件中（位于$WINDOWS$\Microsoft.NET\Framework\$VERSION$\CONFIG目录下）。

你可以通过在站点的web.config文件中添加<remove>节点到你的网站应用程序中来删除这些默认的modules。例如：

上面的配置对于使用了数据库并基于Forms验证的网站来说非常适合，它们并不需要任何会话的支持。因此，所有这些modules都可以安全的删除

ASP.NET 进程配置优化

ASP.NET进程模型配置定义了一些进程级别的属性，像ASP.NET使用的线程数量、超时前阻止线程花费了多长时间、多少请求在继续等待IO工作完成等等。默认情况下，很多方面都具有太多的限制。当今，硬件已经变得十分便宜了，即使是采用双核多GB的RAM服务器也变得非常平常的选择了。

因此，进程模型配置能够减少ASP.NET进程消耗更多的系统资源并提供为每台服务器提供更好的扩展性。

执行一次规则的ASP.NET安装将会在machine.config文件中创建如下配置的节点：

<system.web>
<processModel autoConfig="true" />

你需要减少这种自动配置并针对不同的特性使用一些特定的值以便自定义ASP.NET工作者进程的工作方式。例如：

除了下面几个不为默认值以外，其余均为系统默认值：

maxWorkerThreads
每次处理默认为20，在一台双核的计算机上，ASP.NET的处理就需要40了。这意味着ASP.NET在一台并行的双核服务器上可以每次处理40个请求。我将数量增加到100以便为ASP.NET的每次处理提供更多的线程。如果你有一个应用程序，它的CPU处理能力并不是很强但是它却能够每秒更容易地处理多个请求，那么你就可以增加这个值。

尤其是你的Web应用程序使用了大量的Web服务调用或者下载/上传了很多不会对CPU产生压力的数据时。当ASP.NET用完这些工作者线程时，它会停止出来发来的多个请求。此时请求会放置到一个队列中并持续等待直到出现一个空闲的工作者线程。通常到你的站点开始接受超过预期的点击时会发生这样的情况。那样的话，如果你需要节省CPU的使用，可以增加每次处理的工作者线程数来达到目的。

maxIOThreads
每次处理默认为20，在一台双核的计算机上，ASP.NET进行的I/O操作就需要40个线程了。这意味着ASP.NET在一台并行的双核服务器上可以每次处理40个I/O请求。I/O请求能够进行的文件读/写、数据库操作、web服务调用、从Web 应用程序中产生的HTTP请求等等。因此，如果你的服务器有足够的系统资源来处理更多的I/O请求，你可以将该值设置为100。特别是当你的Web应用程序在并行模式下进行下载/上传数据、调用很多外部Web服务时，非常有用。

minWorkerThreads
当空闲的ASP.NET工作者线程数量低于这个数字时，ASP.NET就会开始将这些发来的请求推入队列中。因此，你可以为改值设定一个较低的值以便可以增加当前请求的数量。此外，建议不要将该值设置得过低，因为Web应用程序的代码可能需要做一些后台处理和并行处理，此时会需要更多的空闲工作者线程支持。

minIOThreads
除了它是针对I/O线程以外，其它与minWorkerThreads的方式相同。然而你可以将该值设置得比minWorkerThreads还低。因为就I/O线程而言，这里不会发生并行处理的问题。

memoryLimit
指定内存大小所允许的最大值，作为整个系统内存的百分比，以便ASP.NET在启动一个新的进程并重新分派存在的请求之前这些工作者进程能够进行消费。如果在你的服务器上仅仅只运行了你的网站应用程序，而且没有其它的进程需要RAM，你可以设置一个更高的值，比如80。

然而，如果你同时有一个会发生内存泄漏的应用程序，那么最好是把该值设置为一个较低的值以便在出现大问题之前泄漏的内存能得到及时的回收从而保持你的站点稳定。尤其是当你使用COM组件并发生内存泄漏时。然而，这只是针对该问题的一个临时解决方案；当然需要你去解决泄漏问题。

除了processModel以外，另外还有一个非常重要的节点system.net，你能够指定发出请求作为单独IP的最大数量。

<system.net>
  <connectionManagement>
    <add address="*" maxconnection="100" />
  </connectionManagement>
</system.net>

默认值为2，设置得比较低。这就意味着你不能从你的Web应用程序用一个IP地址同时链接多于2个的链接。站点获得外部内容很多都是由于默认设置而遭到阻塞。这里我将其设置为100。如果你的Web应用程序会对某一个指定的服务器进行大量的调用，你甚至可以考虑设置一个更高的值。

本文链接

HttpModule与HttpHandler详解

2010-04-15T02:50:00Z

ASP.NET对请求处理的过程：
当请求一个*.aspx文件的时候，这个请求会被inetinfo.exe进程截获，它判断文件的后缀（aspx）之后，将这个请求转交给 ASPNET_ISAPI.dll，ASPNET_ISAPI.dll会通过http管道（Http PipeLine）将请求发送给ASPNET_WP.exe进程，在ASPNET_WP.exe进程中通过HttpRuntime来处理这个请求，处理完毕将结果返回客户端。
    inetinfo.exe进程：是www服务的进程，IIS服务和ASPNET_ISAPI.DLL都寄存在此进程中。
    ASPNET_ISAPI.DLL：是处理.aspx文件的win32组件。其实IIS服务器是只能识别.html文件的，当IIS服务器发现被请求的文件是.aspx文件时，IIS服务器将其交给aspnet_isapi.dll来处理。
    aspnet_wp.exe进程：ASP.NET框架进程，提供.net运行的托管环境，.net的CLR(公共语言运行时)就是寄存在此进程中。

ASP.NET Framework处理一个Http Request的流程：
HttpRequest-->inetinfo.exe-->ASPNET_ISAPI.dll-->ASPNET_WP.exe-->HttpRuntime-->HttpApplication Factory-->HttpApplication-->HttpModule-->HttpHandler Factory-->HttpHandler-->HttpHandler.ProcessRequest()

ASP.NET请求处理过程是基于管道模型的，这个管道模型是由多个HttpModule和HttpHandler组成，ASP.NET 把http请求依次传递给管道中各个HttpModule，最终被HttpHandler处理，处理完成后，再次经过管道中的HTTP模块，把结果返回给客户端。我们可以在每个HttpModule中都可以干预请求的处理过程。
注意：在http请求的处理过程中，只能调用一个HttpHandler，但可以调用多个HttpModule。
当请求到达HttpModule的时候，系统还没有对这个请求真正处理，但是我们可以在这个请求传递到处理中心（HttpHandler）之前附加一些其它信息，或者截获的这个请求并作一些额外的工作，也或者终止请求等。在HttpHandler处理完请求之后，我们可以再在相应的HttpModule中把请求处理的结果进行再次加工返回客户端。

HttpModule
    HTTP模块是实现了System.Web.IhttpModule接口的类。
    IHttpModule接口的声明：
        public interface IHttpModule
        {
            void Init (HttpApplication context);
            void Dispose ();
        }
        Init 方法：系统初始化的时候自动调用，这个方法允许HTTP模块向HttpApplication 对象中的事件注册自己的事件处理程序。
        Dispose方法：这个方法给予HTTP模块在对象被垃圾收集之前执行清理的机会。此方法一般无需编写代码。

    HTTP模块可以向System.Web.HttpApplication对象注册下面一系列事件：
        AcquireRequestState 当ASP.NET运行时准备好接收当前HTTP请求的对话状态的时候引发这个事件。
        AuthenticateRequest 当ASP.NET 运行时准备验证用户身份的时候引发这个事件。
        AuthorizeRequest 当ASP.NET运行时准备授权用户访问资源的时候引发这个事件。
        BeginRequest 当ASP.NET运行时接收到新的HTTP请求的时候引发这个事件。
        Disposed 当ASP.NET完成HTTP请求的处理过程时引发这个事件。
        EndRequest 把响应内容发送到客户端之前引发这个事件。
        Error 在处理HTTP请求的过程中出现未处理异常的时候引发这个事件。
        PostRequestHandlerExecute 在HTTP处理程序结束执行的时候引发这个事件。
        PreRequestHandlerExecute 在ASP.NET开始执行HTTP请求的处理程序之前引发这个事件。在这个事件之后，ASP.NET 把该请求转发给适当的HTTP处理程序。
        PreSendRequestContent 在ASP.NET把响应内容发送到客户端之前引发这个事件。这个事件允许我们在内容到达客户端之前改变响应内容。我们可以使用这个事件给页面输出添加用于所有页面的内容。例如通用菜单、头信息或脚信息。
        PreSendRequestHeaders 在ASP.NET把HTTP响应头信息发送给客户端之前引发这个事件。在头信息到达客户端之前，这个事件允许我们改变它的内容。我们可以使用这个事件在头信息中添加cookie和自定义数据。
        ReleaseRequestState 当ASP.NET结束所搜有的请求处理程序执行的时候引发这个事件。
        ResolveRequestCache 我们引发这个事件来决定是否可以使用从输出缓冲返回的内容来结束请求。这依赖于Web应用程序的输出缓冲时怎样设置的。
        UpdateRequestCache 当ASP.NET完成了当前的HTTP请求的处理，并且输出内容已经准备好添加给输出缓冲的时候，引发这个事件。这依赖于Web应用程序的输出缓冲是如何设置的。

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

BeginRequest和PreRequestHandlerExecute之间的事件是在服务器执行HttpHandler处理之前触发。
    PostRequestHandlerExecute和PreSendRequestContent之间的事件是在服务器执行Handler处理之后触发。

    下面我们看一下如何使用HttpModule来实现我们日常的应用：
        HttpModule通过在某些事件中注册，把自己插入ASP.NET请求处理管道。当这些事件发生的时候，ASP.NET调用对相应的HTTP模块，这样该模块就能处理请求了。
       1、向每个页面动态添加一些备注或说明性的文字：
            有的网站每一个页面都会弹出一个广告或在每个页面都以注释形式（）加入网站的版权信息。如果在每个页面教编写这样的JS代码的话，对于大一点的网站，这种JS代码的编写与维护可是一个很繁琐枯燥的工作。
            有了HttpModule我们就可以很简单地解决这个问题了。HttpModule是客户端发出请求到客户端接收到服务器响应之间的一段必经之路。我们完全可以在服务器处理完请求之后，并在向客户端发送响应文本之前这段时机，把这段注释文字添加到页面文本之后。这样，每一个页面请求都会被附加上这段注释文字。
            这段代码究竟该在哪个事件里实现呢？ PostRequestHandlerExecute和PreSendRequestContent之间的任何一个事件都可以，但我比较喜欢在EndRequest事件里编写代码。
            第一步：创建一个类库ClassLibrary831。
            第二步：编写一个类实现IHttpModule接口
                class TestModule:IHttpModule
                {
                    public void Dispose()
                    {
                    }
                    public void Init(HttpApplication context)
                    {
                    }
                }
            第三步：在Init事件中注册EndRequest事件，并实现事件处理方法
               class TestModule:IHttpModule
                {
                    public void Dispose(){}
                    public void Init(HttpApplication context)
                    {
                        context.EndRequest += new EventHandler(context_EndRequest);
                    }
                    void context_EndRequest(object sender, EventArgs e)
                    {
                        HttpApplication ha = (HttpApplication)sender;
                        ha.Response.Write("");
                    }
                }
            第四步：在Web.Conofig中注册一下这个HttpModule模块
          <httpModules>
           <add name="TestModule" type="ClassLibrary831.TestModule,ClassLibrary831"></add>
          </httpModules>
          name：模块名称，一般是类名
          type：有两部分组成，前半部分是命名空间和类名组成的全名，后半部分是程序集名称，如果类是直接放在App_Code文件夹中，那程序名称是App_Code。
                这样在Web站点是添加该类库的引用后，运行每个页面，会发现其源文件中都会加入“”这句话。同样的方法你也可以在其中加入JS代码。
       2、身份检查
            大家在作登录时，登录成功后，一般要把用户名放在Session中保存，在其它每一个页面的Page_Load事件中都检查Session中是否存在用户名，如果不存在就说明用户未登录，就不让其访问其中的内容。
            在比较大的程序中，这种做法实在是太笨拙，因为你几乎要在每一个页面中都加入检测Session的代码，导致难以开发和维护。下面我们看看如何使用HttpModule来减少我们的工作量
            由于在这里我们要用到Session中的内容，我们只能在AcquireRequestState和PreRequestHandlerExecute事件中编写代码，因为在HttpModule中只有这两事件中可以访问Session。这里我们选择PreRequestHandlerExecute事件编写代码。
            第一步：创建一个类库ClassLibrary831。
            第二步：编写一个类实现IHttpModule接口
                class TestModule:IHttpModule
                {
                    public void Dispose()
                    {
                    }
                    public void Init(HttpApplication context)
                    {
                    }
                }
            第三步：在Init事件中注册PreRequestHandlerExecute事件，并实现事件处理方法
               class AuthenticModule:IHttpModule
                {
                    public void Dispose(){}
                    public void Init(HttpApplication context)
                    {
                        context.PreRequestHandlerExecute += new EventHandler(context_PreRequestHandlerExecute);
                    }
                    void context_PreRequestHandlerExecute(object sender, EventArgs e)
                    {
                        HttpApplication ha = (HttpApplication)sender;
                        string path = ha.Context.Request.Url.ToString();
                        int n = path.ToLower().IndexOf("Login.aspx");
                        if (n == -1) //是否是登录页面，不是登录页面的话则进入{}
                        {
                            if (ha.Context.Session["user"] == null) //是否Session中有用户名，若是空的话，转向登录页。
                            {
                                ha.Context.Response.Redirect("Login.aspx?source=" + path);
                            }
                        }
                    }
                }
            第四步：在Login.aspx页面的“登录”按钮中加入下面代码
                protected void Button1_Click(object sender, EventArgs e)
                {
                    if(true)    //判断用户名密码是否正确
                    {
                        if (Request.QueryString["source"] != null)
                        {
                            string s = Request.QueryString["source"].ToLower().ToString();   //取出从哪个页面转来的
                            Session["user"] = txtUID.Text;
                            Response.Redirect(s); //转到用户想去的页面
                        }
                        else
                        {
                            Response.Redirect("main.aspx");    //默认转向main.aspx
                        }
                    }
                }
            第五步：在Web.Conofig中注册一下这个HttpModule模块
          <httpModules>
           <add name="TestModule" type="ClassLibrary831.TestModule,ClassLibrary831"></add>
          </httpModules>
       3、多模块的操作
            如果定义了多个HttpModule，在web.config文件中引入自定义HttpModule的顺序就决定了多个自定义HttpModule在处理一个HTTP请求的接管顺序。

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

HttpHandler是HTTP请求的处理中心，真正地对客户端请求的服务器页面做出编译和执行，并将处理过后的信息附加在HTTP请求信息流中再次返回到HttpModule中。
    HttpHandler与HttpModule不同，一旦定义了自己的HttpHandler类，那么它对系统的HttpHandler的关系将是“覆盖”关系。
    IHttpHandler接口声明
    public interface IHttpHandler
    {
        bool IsReusable { get; }
        public void ProcessRequest(HttpContext context); //请求处理函数
    }

    示例：把硬盘上的图片以流的方式写在页面上
        class TestHandler : IHttpHandler
        {
            public void ProcessRequest(HttpContext context)
            {
                FileStream fs = new FileStream(context.Server.MapPath("worm.jpg"), FileMode.Open);
                byte[] b = new byte[fs.Length];
                fs.Read(b, 0, (int)fs.Length);
                fs.Close();
                context.Response.OutputStream.Write(b, 0, b.Length);
            }
            public bool IsReusable
            {
                get
                {
                    return true;
                }
            }
        }
        Web.Config配置文件
      <httpHandlers>
       <add verb="*" path="*" type="ClassLibrary831.TestHandler,ClassLibrary831"></add>
      </httpHandlers>
           Verb属性：指定了处理程序支持的HTTP动作。*－支持所有的HTTP动作;“GET”－支持Get操作;“POST”－支持Post操作;“GET, POST”－支持两种操作。
　　Path属性：指定了需要调用处理程序的路径和文件名（可以包含通配符）。“*”、“*.aspx”、“showImage.aspx”、“test1.aspx,test2.aspx”
　　Type属性：用名字空间、类名称和程序集名称的组合形式指定处理程序或处理程序工厂的实际类型。ASP.NET运行时首先搜索bin目录中的DLL，接着在GAC中搜索。
        这样程序运行的效果是该网站的任何一个页面都会显示worm.jpg图片。如何只让一个页面（default21.aspx）执行HttpHandler 中的ProcessRequest方法呢？最简单的办法是在Web.Config文件中把path配置信息设为default21.aspx。
        根据这个例子大家可以考虑一下如何编写“验证码”了。

IHttpHandler工厂
    IHttpHandlerFactory的作用是对IHttpHandler进行管理。工厂的作用请见http://hi.baidu.com/grayworm/blog/item/4a832160f8c9de46eaf8f8c1.html"
    IHttpHandlerFactory接口的声明：
        public interface IHttpHandlerFactory
        {
            IHttpHandler GetHandler (HttpContext context,string requestType,string url,string pathTranslated);
            void ReleaseHandler (IHttpHandler handler);
        }
       GetHandler返回实现IHttpHandler接口的类的实例，ReleaseHandler使工厂可以重用现有的处理程序实例。
    示例：两个用IHttpHandlerFactory来实现对不同HttpHandler的调用。
    有两个HttpHandler：将图片显示在页面上的HttpHandler和生成验证码的Handler
        //将图片显示在页面上的Handler
        class TestHandler : IHttpHandler
        {
            public void ProcessRequest(HttpContext context)
            {
                FileStream fs = new FileStream(context.Server.MapPath("worm.jpg"), FileMode.Open);
                byte[] b = new byte[fs.Length];
                fs.Read(b, 0, (int)fs.Length);
                fs.Close();
                context.Response.OutputStream.Write(b, 0, b.Length);
            }
            public bool IsReusable
            {
                get
                {
                    return true;
                }
            }
        }
        //生成验证码的Handler
        class CodeHandler:IHttpHandler
        {
            public bool IsReusable
            {
                get
                {
                    return true;
                }
            }
            public void ProcessRequest(HttpContext context)
            {
                Image b = new Bitmap(50,20);
                Graphics g = Graphics.FromImage(b);
                SolidBrush sb = new SolidBrush(Color.White);
                Font f = new Font("宋体", 12);
                string str = "";
                Random r = new Random();
                for (int i = 0; i < 4; i++)
                {
                    str += r.Next(10);
                }
                g.DrawString(str,f,sb,0,0);
                b.Save(context.Response.OutputStream, System.Drawing.Imaging.ImageFormat.Jpeg);
            }
        }
         IHttpHandler工厂
         class TestHandlerFactory : IHttpHandlerFactory
         {
            public IHttpHandler GetHandler(HttpContext context, string requestType, string url, string pathTranslated)
            {

                string fname = url.Substring(url.IndexOf('/') + 1);
                while (fname.IndexOf('/') != -1)
                    fname = fname.Substring(fname.IndexOf('/') + 1);
                string cname = fname.Substring(0, fname.IndexOf('.'));
                string className ="";

                className = "ClassLibrary831.CodeHandler";
                object h = null;
                try
                {
                    //h = new TestHandler();
                    h = Activator.CreateInstance(Type.GetType(className));
                }
                catch (Exception e)
                {
                    throw new HttpException("工厂不能为类型" + cname + "创建实例。", e);
                }
                return (IHttpHandler)h;
            }
            public void ReleaseHandler(IHttpHandler handler)
            {
            }
         }(车延禄)
        配置文件
    <httpHandlers>
    <add verb="*" path="default21.aspx,default22.aspx" type="ClassLibrary831.TestHandlerFactory,ClassLibrary831"></add>
   </httpHandlers>
   这样TestHandlerFactory就会根据请求的不同页面执行不同的HttpHandler处理程序了。

HttpHandler使用会话
如果要在处理程序中使用Session，那必须把该HttpHandler实现IRequiresSessionState接口，,IRequiresSessionState接口是个空接口，它没有抽象方法，只是一个标记。此处就不作例子验证了

本文链接

使用ashx文件响应来自JQuery的JSON请求

2010-03-29T15:33:00Z

ashx文件是.net 2.0新加的文件类型(其实在.net 1.0下已经可用,但是没有公开提供).

ashx文件和aspx文件有什么不同? 我们先新建一个ashx文件看看:

<%@ WebHandler Language="C#" %>
using System;
using System.Web;
public class Handler : IHttpHandler
{
　　public void ProcessRequest (HttpContext context)

{
　　　context.Response.ContentType = "text/plain";
　　　context.Response.Write("Hello World");
　　}
　　public bool IsReusable

{
　　　　get

{

return false;

}
　　}
}
看,比aspx简洁多了吧.只有一个文件,没有后台cs文件(基于代码安全考虑,后边我们会自己添加这个文件).ashx对比aspx文件,就好像少了cs文件.其实这就是ashx和aspx不同的地方,因为aspx要将前后台显示和处理逻辑分开,所以就弄成了两个文件,其实,在最终编译的时候,aspx和cs还是会编译到同一个类中去.这中间就要设计html的一些逻辑处理.而ashx不同,它只是简单的对web http请求的直接返回你想要返回的结果.比aspx少处理了html的过程.理论上,比aspx要快.

看看.net config文件中对两个文件类型请求的配置吧

<add path="*.aspx" verb="*" type="System.Web.UI.PageHandlerFactory" validate="True" />
<add path="*.ashx" verb="*" type="System.Web.UI.SimpleHandlerFactory" validate="True" />
可以看到两个文件处理的类不一样(ashx处理的类叫SimpleHandleFactory,既然叫Simple,应该处理过程也比较Simple.响应速度也应该快点吧:)

鼓捣完了你就大概明白了ashx不过.net里面自定义好的一个请求格式,ashx文件类的文件的处理过程要比aspx要简单得多.

不说这些东西了.说会怎么利用ashx文件来实现我们的AJAX请求吧(其实实现和JQuery和JSON关系不大)

看看JS代码:

function getSecondaryContent(menuId){
$.getJSON("Article/FreshNews.ashx", function(data) {
    var txt = "<ul class=\"news\">";
    $.each(data,function(i,n){
      if(n.Url == "#")
        　　txt += "<li><a href=\"#\" onclick=\"articleTitle_onclick('"+ n.ArticleId +"')\">"+ n.Title +"</a></li>";
     else
       　　txt += "<li><a href=\""+ n.Url +"\" target=\"_blank\">"+ n.Title +"</a></li>";
    });
    txt += "</ul>";
    $("#"+menuId).after(txt);
});
}

和用其他文件没有差别吧?天下乌鸦一般黑!(汗~~~忽然冒出这个比喻.自己都觉得汗-_-||)

ashx文件如下:
<%@ WebHandler Language="C#" %>
怎么样?是不是发觉少了点东西?和新建的文件不同了吧?呵呵,其实是我们将上边这句话以外的所有代码都放到App_Code里面了.
using System;
using System.Web;
public class FreshNews : IHttpHandler{
public void ProcessRequest(HttpContext context)

{
    　　//context.Response.ContentType = "text/plain";
    　　context.Response.ContentType = "application/json";
    　　context.Response.Charset = "utf-8";
    　　string txt = "[{\"Title\":\"学习使用AJAX技术\",\"Url\":\"#\",\"ArticleId\":\"Art1234\"},{\"Title\":\"使用JQuery构建网站

\",\"Url\":\"#\",\"ArticleId\":\"Art1235\"},{\"Title\":\"使用JSON文件传输数据\",\"Url\":\"#\",\"ArticleId\":\"Art1236\"}]";
    　　context.Response.Write(txt);
}

public bool IsReusable

{
　　get{return false;}
}
}
为什么要这样?因为MS说系统发布的时候ashx和asmx类型文件都是"生成程序集。原始文件保留在原位置，作为完成请求的占位符。",为了发布后不让人随便看到我们的代码,我们只有把代码移到App_Code里面了.不过,.net的反编译比什么都容易-_-|| 聊胜于无,心理安慰吧!

还有一个小插曲:因为我在web.config里面的设置是:

<globalization fileEncoding="utf-8" requestEncoding="utf-8" responseEncoding="utf-8" responseHeaderEncoding="utf-8" />
就是因为JSON文件只支持Unicode编码,所以我就一狠心将所有编码都改成utf-8,想着这样做就一定没有错了.谁知道,js接收的数据中文死活是乱码,无论我怎么设置ContentType都是一样,差点没有把我气疯.

后来千辛万苦才想起好像这些编码和当前区域设置有关,续步尝试之下,发现只有将fileEncoding设置为"gb2312"才算正确获取到数据:
<globalization fileEncoding="gb2312" requestEncoding="utf-8" responseEncoding="utf-8" responseHeaderEncoding="utf-8" />
忘了顺便说一句:在ashx文件用使用Session必须实现 IRequiresSessionState 接口

本文链接

C#设计模式之Singleton

2010-03-26T06:18:00Z

近来，我在学习如何在C#语言中使用设计模式中读到一些资料，其中有关Singleton设计模式引起了我的注意。

学过设计模式的开发者都知道Singleton模式。我想简要地解释一下这个设计模式是为那些尚未学习过设计模式的朋友。Singleton设计模式是告诉您如何在你的应用程序创建一个唯一类示例的全局对象，也就是说，这个对象只能被实例化一次，这个对象同时提供一个访问它的一个全局的访问点。这种对象如应用程序中的窗口管理器或者是打印假脱机、数据库连接池等。

现在让我们先看一下设计模式一书中对Singleton模式的C++实现（为了方便比较，我把实现的代码写成内联的方式）：

class Singleton

{

public:

static Singleton* Instance()

{

if(_instance==0)

{

_instance=new Singleton;

}

return _instance;

}

protected:

Singleton();

Private:

Static Singleton* _instance;

};

Stington* Singleton::_instance=0;

这里我不想对上述的代码作解释，大家可以参阅本文后面提供的参考文献。

为了更好的理解C#，我这里也出示一下Java中的Singleton模式实现代码（不是有人认为C#是对Java的剽窃吗J）：

class Singleton

{

public Singleton Instance()

{

if(_instace==null)

{

synchronized (Class.forName("Singleton"))

{

if (_instance == null)

{

_instance = new Singleton();

}

return _instance;

}

protected Singleton() {}

private static Singleton _instance = null;

}

在上述的Java代码中使用了双重检测机制，来避免多个线程的Singleton实例化问题。同样，我也不想对上述的代码做任何解释。

首先，让我们看一下C#中类似Java的实现：

class Singleton

{

public static Singleton Instance()

{

if(_instance==null)

{

lock (typeof(Singleton))

{

if(_instace==null)

{

_instance=new Singleton();

}

return _instance;

}

protected Singleton(){}

private static volatile Singleton _instance=null;

}

现在，是我们睁大眼睛的时候了，下面是利用.NET Framework平台优势实现Singleton模式的代码：

sealed class Singleton

{

private Singleton();

public static readonly Singleton Instance=new Singleton();

}

非常吃惊是不是，不仅代码减少了许多，同时也解决了线程问题带来的性能上损失。有避免了编译器优化的问题。上述的代码真的能正常工作吗？如果能，那么它又是怎样工作的呢？

注意到，Singleton类被声明为sealed，以此保证它自己不会被继承，其次没有了Instance的方法，将原来_instance成员变量变成public readonly，并在声明时被初始化。通过这些改变，我们确实得到了Singleton的模式，原因是在JIT的处理过程中，如果类中的static属性被任何方法使用时，.NET Framework将对这个属性进行初始化，于是在初始化Instance属性的同时Singleton类实例得以创建和装载。而私有的构造函数和readonly(只读)保证了Singleton不会被再次实例化，这正是Singleton设计模式的意图。

本文不是要讨论设计模式，而只是想通过这个例子来说明一件事，那就是精通.NET Framework并将它灵活运用对实际应用开发的重要性。

本文链接

C#设计模式之简单工厂篇应用场景

2010-03-26T03:10:00Z

首先定义一个接口，具体名为Idatabase,在这个接口中，定义好数据库操作的方法名和参数，以及返回值，本案例中我定义如下方法：

public interface IDatabase

{

bool Connect(string ConnectString);

bool Open();

bool Command(string SQL);

void Close();

}

重要提醒：“接口一生唯谨慎,定义大事不糊涂”，编写接口时一定要考虑周全，并对参数、返回值进行反复推敲，为什么？因为所有的实现类都是要根据该接口的规范进行代码具体编写，也即接口的定义是公用的，一旦改动了接口，后果就是所有的实现类也都必须相应调整。

然后就是编写具体的实现类了，客户要求多少不同类型的数据库，你就定义多少个Idatabase的实现类，虽然工作量大了点，可当你看到客户满意的笑容时，你心里也就会有一种由衷的幸福感，好了，SqlServer实现类代码如下：

public class SqlServer : IDatabase

{

SqlConnection conn;

SqlCommand command;

public bool Connect(string ConnectString)

{

try

{

conn = new SqlConnection(ConnectString);

return true;

}

catch(SqlException)

{

return false;

}

public bool Open()

{

try

{

conn.Open();

return true;

}

catch(SqlException)

{

return false;

}

public bool Command(string SQL)

{

try

{

command = new SqlCommand(SQL,conn);

command.ExecuteNonQuery();

return true;

}

catch(SqlException)

{

return false;

}

public void Close()

{

conn.Close();

conn.Dispose();

}

呵呵，有点长，咬着牙读完，心里明白了就会很舒服的，如果你现在有这种感觉了，好，再接再厉，再为Oracle实现类编写具体代码吧，依葫芦画瓢，大家有空就画一下吧，我就画个雏形了：

public class Oracle : IDatabase

{

public Oracle()

{

}

public bool Connect(string ConnectString)

{

return true;

}

public bool Open()

{

return true;

}

public bool Command(string SQL)

{

return true;

}

public void Close()

{

}

嗯，不错，你有多少种数据库就编写不同的实现类代码吧，这里就不赘述了，接下来呢？聪明的读者一定会想到这个问题：这个接口和这么多的实现类怎么用啊？我们再定义一个称之为工厂的类，由它来决定选用哪种数据库为进行操作，这个类比较简单：

public class Factory

{

public static IDatabase SelectDatabase(string DatabaseType)

{

switch(DatabaseType)

{

case "SqlServer":

return new SqlServer();

case "Oracle":

return new Oracle();

default:

return new SqlServer();

}

最好的方式是不用switch,根据类名去创建,另加以下方式:

public class Factory

{

public static IDatabase CreateDatabase(string ClassName)

{

public IDatabase myDB=null;

try

{

Type type = Type.GetType(ClassName,true); //获取一个类

myDB= (IDatabase)Activator.CreateInstance(type); //根据类创建一个实例

}

catch (TypeLoadException e)

Console.WriteLine("I dont know this kind of fruit,exception caught - {0}" ,e.Message);

return myDB;

}

看明白了吗？好了，我们该让尊敬的、永远高贵的客户出场了，只有他，唯有他才有决定用哪种数据库的最高权限，你看，他这样用：

public class Client

{

public static void Main()

{

//Get the database information from Web.Config.

string DBType = ConfigurationSettings.AppSettings["DBType"];

string DBConnectString = ConfigurationSettings.AppSettings["DBConn"];

IDatabase DB = Factory.SelectDatabase(DBType);

//Connect the selected database.

if(DB.Connect(DBConnectString)==false)

{

Console.WriteLine("The database {0} can't be connected.",DBType);

return;

}

//Open database.

if(DB.Open()==false)

{

Console.WriteLine("The database {0} can't be opened, the connect string is {1}.",DBType,DBConnectString);

return;

}

//Execute SQL Command.

string SQL = "update Order set price = price * 0.07 where productID = '002'";

if(DB.Command(SQL))

{

//Do something...

}

else

{

Console.WriteLine("The Operator is not success. SQL statament is {0}",SQL);

DB.Close();

return;

}

DB.Close();

}

好了，工程峻工了，你们明白了没有？

思考题：简单工厂的应用场合和局限性？

作业题：假如要开发一个多媒体播放器，既能用Window MediaPlayer播放，又能用RealPlayer播放，还能用QuickTime播放，具体用什么播放器，由客户选择，请你画出UML图并写出代码。

本文链接

一个简单O/R M组件(HFSoft.Data).NET

2010-03-26T01:49:00Z

一直想用O/R M的模式去开应用系统；但在。NET下又没有成熟的产品，nhibernate虽然不错但结构比较复杂，如果出现问题维护起来也比较麻烦。所以打算自己编写这样一个组件，在使用、维护和扩展方面的都比较容易把握；对项目的后期维护也比较有利。组件功能上也远比不上nhibernate,只实现了单表和视图的映射操作、查询对象化等功能。在设计的过程也参考了nhibernate的设计方式，毕竟nhibernate的设计不错可以直接拿过来使用。根据自己的情况修改一下就可以了。

在设计时第一个考虑的问题就是组件对多类型数据库的支持，所以针对数据库提供者提取接口；在设计这个接口时nhibernate给我带来很大的启发；可以说是直接引用了它的设计原理。当数据库提供者接口完成后，就可以针对这个接口做数据库处理的工作了。

组件大体框架如下：

IDataSession

数据操作描述，包括找开连接、启用事务、插入对象、删除对象等操作。

IDriverType

数据库提供者描述，主要用于描述数据库类型关键的东西，如果数据库连接对象、对应的Command类型等。

IExpression

条件表达式描述，用于处理查询过程中的条件；从些接口实现的条件表达式有:=、>、<>、like、in等；

组件还有很多对象进行内部处理的：类的映射信息，主要和忝相就应的SQL语句和命令对象；缓存类用于缓存操作命令对象、命令对持久化接口等。

类和数据库的关系映射

实体类和数据库表的关联采用了XML文件描述，相应对nhibernate业说比较简单.

以下是描述employees类和employees表对映象关系。

类文件

using System;

namespace NorthWind.Entitys

{

/// <summary>

/// Employees

/// </summary>

public class Employees

{

public Employees()

{

// TODO: 在此处添加构造函数逻辑

}

public const string F_EmployeeID="EmployeeID";

private Int32 mEmployeeID;

/// <summary>

/// [int identity]

/// </summary>

public Int32 EmployeeID

{

get

{

return mEmployeeID;

}

set

{

mEmployeeID = value;

}

public const string F_LastName="LastName";

private String mLastName;

/// <summary>

/// [nvarchar]

/// </summary>

public String LastName

{

get

{

return mLastName;

}

set

{

mLastName = value;

}

public const string F_FirstName="FirstName";

private String mFirstName;

/// <summary>

/// [nvarchar]

/// </summary>

public String FirstName

{

get

{

return mFirstName;

}

set

{

mFirstName = value;

}

………………..

映射关系的XML文件

<?xml version="1.0" encoding="utf-8" ?>

</class>

组件的使用

当类和映射文件建立以后，就通过组件对类的操作来实现数据操作。为了实现动态配置，组件配置的方式和nhibernate是一样的，只是配置节有所不同。

</configSections>

</MappingAssemblys>

</dataconfig>

添加一条雇员信息

HFSoft.Data.MappingContainer mapContainer = HFSoft.Data.MappingContainer.ConfigContainer;

using(HFSoft.Data.IDataSession session = mapContainer.OpenSession())

{

session.Open();

NorthWind.Entitys.Employees emp = new NorthWind.Entitys.Employees();

emp.ReportsTo = 3;

emp.FirstName ="fan";

emp.LastName = "henry";

emp.Photo = new byte[0];

emp.HireDate = DateTime.Parse("2002-12-31");

emp.BirthDate = DateTime.Parse("1979-1-28");

emp.City ="广州";

emp.Country ="中国";

session.Save(emp);

MessageBox.Show(emp.EmployeeID.ToString());

}

获取所有雇员信息

using(HFSoft.Data.IDataSession session = mapContainer.OpenSession())

{

session.Open();

System.Collections.IList myDS = session.List(typeof(NorthWind.Entitys.Employees),null);

this.dataGrid1.DataSource = myDS;

}

多条件查询（雇员编号大于等于3并且小于等于10或者姓包含fan）

HFSoft.Data.Expression expression = new HFSoft.Data.Expression();

expression.Add(new HFSoft.Data.RtEqExpression(NorthWind.Entitys.Employees.F_EmployeeID,3));

expression.Add(new HFSoft.Data.LeEqExpression(NorthWind.Entitys.Employees.F_EmployeeID,10));

expression.Add(HFSoft.Data.UintType.Or,new HFSoft.Data.LikeExpression(NorthWind.Entitys.Employees.F_FirstName,"fan%"));

using(HFSoft.Data.IDataSession session = mapContainer.OpenSession())

{

session.Open();

System.Collections.IList myDS = session.List(typeof(NorthWind.Entitys.Employees),expression);

this.dataGrid1.DataSource = myDS;

}

获取雇员信息并修改

using(HFSoft.Data.IDataSession session = mapContainer.OpenSession())

{

session.Open();

NorthWind.Entitys.Employees emp = (NorthWind.Entitys.Employees)session.Load(typeof(NorthWind.Entitys.Employees),41);

emp.FirstName ="kfc";

session.Update(emp);

}

组件为了提高效率，增加了缓存机制。可以通过配置文件制定对插入数据、修改数据的命令对象进行缓存的数量。当组件需要调用对象的插入命令时就会从缓存中找，当找不到的情况下才创建相关命令对象，这样会减少创建所带来的性能问题；同样缓存会占用相应的内存资源。组件现在还决少查询命令对象、数据集、实体对象的缓存。实体对象缓存比较复杂，中间还存在着和数据库信息同步、频繁锁的问题；还没有想到较好的解决方法，暂时没有打算把实体缓存集成到组件中。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/henryfan1/archive/2005/09/06/472651.aspx

本文链接

无刷新分页控件(原创)(jQuery+json+ashx)(Ajax)

2010-03-25T05:58:00Z

近来在做一个项目,

有很多基本的信息表.

但这些信息都只有一些增删改查的相关操作

大多数表没有业务流的相关操作.

要是每个表的增删改查相关功能都一个个去做一个管理页

不单麻烦,也不算是一个程序员有的思想(不知道偷懒人程序员不算一个好的程序员)

三四十来张表.每张表做两个管理页.就是七八十人页面.

那我不想死.

所以.就打算做一个通用的增删改查控件

标题只是说一个分页显示控件,那还只是一个小点.

主要是看到现在园子里对这个做的人比效多.可能会有些点击吧.呵.

主要是以前我也做过一个那个无刷新分页的.

一下园子里就有好多人加我QQ,

有的是要源代码(那个版本JS压缩了一下),

有的是要我教jQuery,

有是就是问我那个控件怎么用.

只不过那个是用ACCESS+VS2008(jQuery+ashx+json)做的

只不过看看现在的开发.用ACC来做数据库的(大项目).那是不可能的吧

我们这个项目是用的SQL2005+VS2008

所以就在原来的基础上.更加一层的开发

(jQuery+ashx+json)

中间用到了josn的序列化与反序列化

反射,做了跨数据库接口等

当然,开始做的时候.

有一个好的设计方案是不可少的.

做的项目越多.就知道前期工作的重要性的.以前不怎么重视

在那个上面吃了大亏,就有了这个教训了

第一部分

下面是我的数据库设计,还有测试数据表结构设计

上面的五张表是控件要用的.

下面五张表是测试数据设计

第二部分

目录结构

Library里面,大家都是开发人员.这个结构看得懂吧(不知道这现设计好不好)

AjaxPages里面就是放ashx请求处理的页面的

主要是做了两个用户控件

EditGradView.ascx和ShowGradView.ascx

在ShowPage.aspx,EditPage.aspx分别引用这两个用户控件

先来看看效果吧

1.上面的按钮是功能操作的,选择结果是一个接口

就是第一列,有选择框,当你选择了哪里行的时候.点那个选择结果就会把相应的主键值传给用户,

让用户自行处理怎么操作,

当然,在我这个项目里就做了个批量删除功能了

2.增加记录

就会根据你在配置表里配置的数据,

自动生成一个表单,这个表单就是这样的

这里实现了几种控件,

文本框,密码框,日期选择框,文件上传框,下拉框,多行文本框

文本框里又有正则表达式验证(在配置表里配置你要验证的类型),

日期就会自动出来一个日历控件

文件上传.就会通过一个假的(ajax:实际是创建一个iframe)新上传.把你文件上传上去.返回一个文件名到那个框里

下拉框:当然只有外键和字典的时候.就会出来下拉了

3查询

点击查询的时候.也会自动根据你在配置表里配置的数据

自动在页页生成一个查询表单

同样也把你查询到的结果分页

3.编辑,删除,自定义

会在每行的后面出现功能操作,当然你可以配置可以不可以有这些操作

在这里.编辑就会跳到一个编辑表单让你修改

也是和增加记录的表单一样.只不过这里还要把编辑的数据绑定上去

当然,在这里功能操作里,都有相应的接口

比如我点删除的时候,要自己写一个方法,

所以我就在每个功能操作里写了一个用户接口

只要你引用了的页面里写了一个这样的接口,

就会去调用你自己写的方法,没有的话.就执行自己写的方法

这样的话.我那个项目,三四十张表.

就可以只要配置一个配置表里面的信息

就全都可以自动的实现增删改查了

http://liuju150.cacacoo.com/

在这里可以看到效果.只不过这不是我的空间,放到别人空间上去的

那里的SQL数据库的排序规则不和我的相同.

所以中文有些乱码了.

只不过还是可以看到效果的喽.

json实体帮助类

Code

json数据表帮助类

Code
namespace GradView.WebApp.App_Code
{
    public static class JsonTableHelper
    {
        /// <summary>
        /// 返回对象序列化
        /// </summary>
        /// <param name="obj">源对象</param>
        /// <returns>json数据</returns>
        public static string ToJson(this object obj)
        {
            JavaScriptSerializer serialize = new JavaScriptSerializer();
            return serialize.Serialize(obj);
        }

        /// <summary>
        /// 控制深度
        /// </summary>
        /// <param name="obj">源对象</param>
        /// <param name="recursionDepth">深度</param>
        /// <returns>json数据</returns>
        public static string ToJson(this object obj, int recursionDepth)
        {
            JavaScriptSerializer serialize = new JavaScriptSerializer();
            serialize.RecursionLimit = recursionDepth;
            return serialize.Serialize(obj);
        }

        /// <summary>
        /// DataTable转为json
        /// </summary>
        /// <param name="dt">DataTable</param>
        /// <returns>json数据</returns>
        public static string ToJson(DataTable dt)
        {
            Dictionary<string, object> dic = new Dictionary<string, object>();

            int index = 0;
            foreach (DataRow dr in dt.Rows)
            {
                Dictionary<string, object> result = new Dictionary<string, object>();

                foreach (DataColumn dc in dt.Columns)
                {
                    result.Add(dc.ColumnName, dr[dc].ToString());
                }
                dic.Add(index.ToString(), result);
                index++;
            }
            return ToJson(dic);
        }
    }
}

http://www.cnblogs.com/liuju150/archive/2009/09/11/1565009.html
这里是表单的反射操作

数据操作方法

namespace GradView.Library.Data
{
    /// <summary>
    ///Title: Classinfo类
    ///Description: Classinfo业务逻辑操作类
    ///@author LiuJu
    ///@version 1.0.0.0
    ///@date 2009-8-29
    ///@modify
    ///@date
    /// </summary>
    [DataObject(true)]
    public partial class BizClassinfo
    {
        private static IDataBaseOperate< Classinfo> baseOperate =(IDataBaseOperate< Classinfo>) DaoFactory.CreateInstance("DaoClassinfo");

        BaseOperation
    }
}

续前面的无刷新分页控件,编辑,修改控件的实现,

(这里是地址:http://www.cnblogs.com/liuju150/archive/2009/09/11/1564994.html)

那么,有三四十张表的话,

前台表单是自动生成的.

只不过生成的实体和数据库里的表名都是有规律可以找的.

还有操作实体的类,

所以我只要通过前台把表单传过来.

我就可以知道要反射到哪个实体,

然后对实体进行相应的赋值.

再反射一个实体操作的类.

就可以实现对实体的增删改操作了

上面是我的数据库表名

下面是我的实体,和实体操作的类名

private void InsertAndUpdateObj(HttpContext context)
        {
            string ClassName = context.Request.Form["ClassName"].ToString();
            string ClassData = context.Request.Form["ClassData"].ToString();
            string IntOrUpd = context.Request.Form["isIns"].ToString();

            string[] ClassNameArray = ClassName.Split('_');
            string CNStr = "";
            for (int i = 0; i < ClassNameArray.Length; i++)
            {
                CNStr += ClassNameArray[i].Substring(0, 1).ToUpper() + ClassNameArray[i].Substring(1).ToLower();
            }
            ClassName = CNStr;

            //反射实体
            Assembly Ab = Assembly.Load("GradView.Library");
            Type type = Ab.GetType("GradView.Library.Data." + ClassName, true, false);
            object obj = Activator.CreateInstance(type);
            DataContractJsonSerializer dcjs = new DataContractJsonSerializer(type);
            MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(ClassData));
            obj = dcjs.ReadObject(ms);

            //反射业务操作
            string opName = "Biz" + ClassName;
            string opMethod = "Insert";
            switch (IntOrUpd)
            {
                case "0": opMethod = "Update"; break;
                case "1": opMethod = "Insert"; break;
                case "2": opMethod = "Delete"; break;
                default: opMethod = "Insert"; break;
            }
            Type opType = Ab.GetType("GradView.Library.Data." + opName, true, false);
            object opObj = Activator.CreateInstance(opType);
            MethodInfo[] mi = opType.GetMethods();
            for (int i = 0; i < mi.Length; i++)
            {
                if (mi[i].Name == opMethod)
                {
                    object[] par = {
                                       obj
                                   };
                    try
                    {
                        mi[i].Invoke(opObj, par);
                        break;
                    }
                    catch
                    {
                    }
                }
            }
        }

所以我只要写这样的方法来实现,

前台就可以通过jQuery把表单里的值组成json

后台接收这个json

就可以对实体进行相应的操作了

本文链接

CodeSmith生成多个表

2010-03-23T06:00:00Z

一、把选中的多个表生成实体类
我们会生成一个表的实体类了，那么一次生成多个表的实体类就可以在此基础上实现了。
实现思路：
在前面我们制作的实体类生成模板只能生成一个表，现在我们编写一个新的模板，在该模板中注册原来实体类模板。这样我们就可以在这个新的模板中生成多个原实体类模板的对象，然后调用原对象的呈现方法，来生成代码
例：己有一个实体类生成模板EntitySingle.cst,现在我们制作一个新的模板，并在新模板中注册EntitySingle.cst模板
<%@ CodeTemplate Language="C#" TargetLanguage="Text" Src="" Inherits="" Debug="False" Description="" %>
<%@ Property Name="TDB" Type="SchemaExplorer.TableSchemaCollection" Default="" Optional="False" Category=""%>
<%@ Register Name="SE" Template="EntitySingle.cst" MergeProperties="False" ExcludeProperties="" %>
<%@ Assembly Name="SchemaExplorer" %>
<%@ Assembly Name="System.Data" %>
<%@ Import Namespace="SchemaExplorer" %>
<%@ Import Namespace="System.Data" %>
<%@ Import Namespace="System.Collections" %>
<%
foreach(TableSchema ts in TDB)
{
  SE s = new SE();
   s.TTable = ts;
   s.Render(this.Response);
}
%>
<script runat="template">
</script>
说明：
<%@ Register Name="SE" Template="EntitySingle.cst" MergeProperties="False" ExcludeProperties="" %>
这句就是把EntitySingle.cst注册到当前模板中，名称是SE。

<%@ Property Name="TDB" Type="SchemaExplorer.TableSchemaCollection" Default="" Optional="False" Category=""%>
这句定义了一个表集合的属性，以便用户从中选择多个表来生成它们的实体类

SE s = new SE();
实例化SE这个模板对象

s.TTable = ts;
为EntitySingle.cst模板实例中的TTable属性进行赋值

s.Render(this.Response);
调用SE对象（EntitySingle.cst模板实例）的呈现方法，把该表的实体类代码生成出来。
运行结果：

二、把单个表的实体类生成到文件中去
上面的例子中虽然可以同时生成多个实体类，但是它全都显示在右边的输出区域，还需要我们收动复制粘贴放到源文件中去。这里我们主要研究如何把生成的代码输出到指定的文件中去。
在CodeSmith中，CodeTemplate.Render方法用来修改CodeSmith输出时的事件处理。可以通过重写Render方法来修改模版输出时的方式。
Render方法：
public override void Render(TextWriter writer)
｛}
例：在模板的默认输出的基础上，加上把结果输出到文件的功能
public override void Render(TextWriter tw)
{
   StreamWriter fs1 = new StreamWriter("c:\\"+TTable.Name.ToString()+".cs",true);
   this.Response.AddTextWriter(fs1);
   base.Render(tw);
   fs1.Close();
}
说明：这里一定要加入base.Render(tw)的调用，否则得不到默认的输出。

FileNameEditor类：
FileNameEditor类给我们提供了在CodeSmith属性面板中弹出打开或保存文件对话框的方式，在使用时，首先在模版中得添加对程序集CodeSmith.CustomProperties的引用。然后就可以在模版中定义一个属性来使用FileNameEditor。
<%@ CodeTemplate Language="C#" TargetLanguage="Text" Src="" Inherits="" Debug="False" Description="" %>
<%@ Assembly Name="CodeSmith.CustomProperties" %>
<%@ Import Namespace="CodeSmith.CustomProperties" %>
<script runat="template">
   private string _filename;
  [Editor(typeof(FileNameEditor),typeof(System.Drawing.Design.UITypeEditor)),FileDialogAttribute(FileDialogType.Save,Title="save as",Filter="C# File|(*.cs)")]
   public string TargetFileName
   {
    get
    {
     return _filename;
    }
    set
    {
     _filename = value;
    }
   }
</script>
FileDialogAttribute类：设置对话框的样式
   FileDialogType：对话框的方式(打开/关闭)，如：FileDialogType.Save
   Filter：文件类型过滤器，如：Filter="C# File|(*.cs)"
   Title：对话框的标题。如：Title="保存"
   DefaultExtension：文件默认的扩展名
   CheckFileExists：true-只能选择己存在的文件
   CheckPathExists：true-只允许使用己存在路径

以下代码将生成的实体类输出到对应的.CS文件中去
<%@ CodeTemplate Language="C#" TargetLanguage="Text" Src="" Inherits="" Debug="False" Description="Template description here." %>
<%@ Property Name="TTable" Type="SchemaExplorer.TableSchema" Default="" Optional="False" Category="" Description="" OnChanged="" Editor="" EditorBase="" Serializer="" %>
<%@ Assembly Name="CodeSmith.CustomProperties" %>
<%@ Assembly Name="System.Data" %>
<%@ Assembly Name="SchemaExplorer" %>
<%@ Import Namespace="System.Data" %>
<%@ Import Namespace="SchemaExplorer" %>
<%@ Import Namespace="System.IO" %>
<%@ Import Namespace="CodeSmith.CustomProperties" %>
using System;
<%
string classname = TTable.Name.ToUpper().Substring(0,1)+TTable.Name.ToLower().Substring(1,TTable.Name.Length-1);
string entitytype="";
string entityname="";
%>
public class <%=classname%>Data
{
   <%for(int i=0;i<TTable.Columns.Count;i++){%>
    <%if(!TTable.Columns[i].IsForeignKeyMember){%>
    private <%=CreateColumnType(TTable.Columns[i])%> _<%=TTable.Columns[i].Name.ToLower()%>;
    <%}
    else
    {
     foreach(TableKeySchema tks in TTable.ForeignKeys)
     {
      foreach(MemberColumnSchema mcs in tks.ForeignKeyMemberColumns)
      {
       if(mcs.Name == TTable.Columns[i].Name)
       {
        entityname = tks.PrimaryKeyTable.Name.ToUpper().Substring(0,1)+tks.PrimaryKeyTable.Name.ToLower().Substring(1,tks.PrimaryKeyTable.Name.Length-1);
        entitytype = entityname+"Data";
        break;
       }
      }
     }
    %>
    private <%=entitytype%> _<%=entityname.ToLower()%>;
    <%}%>
    <%if(!TTable.Columns[i].IsForeignKeyMember){%>
    public <%=CreateColumnType(TTable.Columns[i])%> <%=TTable.Columns[i].Name.ToUpper().Substring(0,1)+TTable.Columns[i].Name.ToLower().Substring(1,TTable.Columns[i].Name.Length-1)%>
    {
     get
     {
      return _<%=TTable.Columns[i].Name.ToLower()%>;
     }
     set
     {
      _<%=TTable.Columns[i].Name.ToLower()%> = value;
     }
    }
    <%}else{%>
    public <%=entitytype%> <%=entityname.ToUpper().Substring(0,1)+entityname.ToLower().Substring(1,entityname.Length-1)%>
    {
     get
     {
      return _<%=entityname.ToLower()%>;
     }
     set
     {
      _<%=entityname.ToLower()%> = value;
     }
    }
    <%}%>
   <%}%>
}

<script runat="template">
private string _savefile;
[Editor(typeof(FileNameEditor),typeof(System.Drawing.Design.UITypeEditor)),FileDialogAttribute(FileDialogType.Save,Title="save as",Filter="C# File|(*.cs)")]
public string SaveFile
{
   get
   {
    return _savefile;
   }
   set
   {
    _savefile = value;
   }
}
public override void Render(TextWriter tw)
{
   StreamWriter fs1 = new StreamWriter(_savefile,true);
   this.Response.AddTextWriter(fs1);
   base.Render(tw);
   fs1.Close();
}
private string CreateColumnType(ColumnSchema cs)
{
   switch(cs.DataType)
   {
    case DbType.AnsiString:
    case DbType.String:
    return "string";
    case DbType.Binary:
    return "byte[]";
    case DbType.Boolean:
    return "bool";
    case DbType.Date:
    case DbType.DateTime:
    case DbType.Time:
    return "DateTime";
    case DbType.Int16:
    case DbType.Int32:
    case DbType.Int64:
    case DbType.UInt16:
    case DbType.UInt32:
    case DbType.UInt64:
    return "int";
    default:
    return "object";
   }
}
</script>
三、将多个表的实体类生成到文件中去
将多个表的实体类生成到文件中去实际上是把上面两种方法进行结合。
思路：
1.建立能够生成一个实体类的模板A，并设置一个TableSchema属性和文件路径属性
2.建立另一个模板B，其中注册引用上面的实体类模板
3.在模板B中加入一个TableSchemaCollection的属性，以选择对哪些表生成实体类
4.在模板B中加入一个属性用以选择将生成的实体类文件放在哪个目录中
5.在模板B中生成模板A的实例，并为模板A的两个属性赋值
6.设用Render方法实现输出

FolderNameEditor类：路径选择对话框
<script runat="template">
private string _filename;
[Editor(typeof(System.Windows.Forms.Design.FileNameEditor),typeof(System.Drawing.Design.UITypeEditor))]
public string TargetFileName
{
   get
   {
    return _filename;
   }
   set
   {
    _filename = value;
   }
}

代码：
<%@ CodeTemplate Language="C#" TargetLanguage="Text" Src="" Inherits="" Debug="False" Description="Template description here." %>
<%@ Property Name="tb" Type="SchemaExplorer.TableSchemaCollection" Default="" Optional="True" Category="Strings" Description="This is a sample string property." %>
<%@ Register Name="sge" Template="Entitysingle.cst" MergeProperties="False" ExcludeProperties="" %>
<%@ Assembly Name="CodeSmith.CustomProperties" %>
<%@ Assembly Name="SchemaExplorer" %>
<%@ Assembly Name="System.Data" %>
<%@ Import Namespace="SchemaExplorer" %>
<%@ Import Namespace="System.Data" %>
<%@ Import Namespace="System.IO" %>
<%@ Import Namespace="System.Windows.Forms.Design" %>
<%@ Import Namespace="CodeSmith.CustomProperties" %>
<%
foreach(TableSchema ts in tb)
{
sge s = new sge();
s.TTable = ts;
s.SaveFile = this.GeneratePath+"\\"+s.TTable.Name.ToString()+".cs";
s.Render(this.Response);
}

%>
<script runat="template">
private string _path;
[Editor(typeof(System.Windows.Forms.Design.FolderNameEditor),typeof(System.Drawing.Design.UITypeEditor))]
public string GeneratePath
{
get
{
return _path;
}
set
{
_path = value;
}
}
</script>

本文链接