4.3.1  CacheDependency接口

PetShop 4.0引入了SqlCacheDependencyç‰ÒŽ€§ï¼Œå¯¹Category、Productå’ŒItem数据表对应的¾~“存实施了SQL Cache Invalidation技术。当对应的数据表数据发生更改后，该技术能够将相关™å¹ä»Ž¾~“存中移除。实现这一技术的核心是SqlCacheDependency¾c»ï¼Œå®ƒç‘ô承了CacheDependency¾c…R€‚然而äؓ了保证整个架构的可扩展性，我们也允许设计者徏立自定义的CacheDependency¾c»ï¼Œç”¨ä»¥æ‰©å±•¾~“存依赖。这ž®±æœ‰å¿…要为CacheDependency建立抽象接口åQŒåƈ在web.configæ–‡äšg中进行配¾|®ã€?/p>

在PetShop 4.0的命名空间PetShop.ICacheDependency中，定义了名为IPetShopCacheDependency接口åQŒå®ƒä»…包含了一个接口方法：
public interface IPetShopCacheDependency
{      
    AggregateCacheDependency GetDependency();
}

AggregateCacheDependencyæ˜?Net Framework 2.0新增的一个类åQŒå®ƒè´Ÿè´£ç›‘视依赖™å¹å¯¹è±¡çš„集合。当˜q™ä¸ªé›†åˆä¸­çš„ä»ÀL„ä¸€ä¸ªä¾èµ–项对象发生改变æ—Óž¼Œè¯¥ä¾èµ–项对象对应的缓存对象都ž®†è¢«è‡ªåŠ¨¿U»é™¤ã€?br /> AggregateCacheDependency¾c»è“våˆîCº†¾l„合CacheDependency对象的作用，它可以将多个CacheDependency对象甚至于不同类型的CacheDependency对象与缓存项建立兌™”。由于PetShop需要äØ“Category、Productå’ŒItem数据表徏立依赖项åQŒå› è€ŒIPetShopCacheDependency的接口方法GetDependency()其目的就是返回徏立了˜q™äº›ä¾èµ–™å¹çš„AggregateCacheDependency对象ã€?/p>

4.3.2  CacheDependency实现

CacheDependency的实现正是äØ“Category、Productå’ŒItem数据表徏立了对应的SqlCacheDependency¾cÕdž‹çš„依赖项åQŒå¦‚代码所½Cºï¼š
public abstract class TableDependency : IPetShopCacheDependency
{
    // This is the separator that's used in web.config
    protected char[] configurationSeparator = new char[] { ',' };

    protected AggregateCacheDependency dependency = new AggregateCacheDependency();
    protected TableDependency(string configKey)
    {
        string dbName = ConfigurationManager.AppSettings["CacheDatabaseName"];
        string tableConfig = ConfigurationManager.AppSettings[configKey];
        string[] tables = tableConfig.Split(configurationSeparator);

        foreach (string tableName in tables)
            dependency.Add(new SqlCacheDependency(dbName, tableName));
    }
    public AggregateCacheDependency GetDependency()
   {
        return dependency;
    }
}

需要徏立依赖项的数据库与数据表都配¾|®åœ¨web.configæ–‡äšg中，其设¾|®å¦‚下：
<add key="CacheDatabaseName" value="MSPetShop4"/>
<add key="CategoryTableDependency" value="Category"/>
<add key="ProductTableDependency" value="Product,Category"/>
<add key="ItemTableDependency" value="Product,Category,Item"/>

æ ÒŽ®å„个数据表间的依赖关¾p»ï¼Œå› è€Œä¸åŒçš„数据表需要徏立的依赖™å¹ä¹Ÿæ˜¯ä¸ç›¸åŒçš„，从配¾|®æ–‡ä»¶ä¸­çš„value值可以看出。然而不½Ž¡å¾ç«‹ä¾èµ–项的多寡，其创建的行äؓ逻辑都是ç›æ€¼¼çš„，因而在设计æ—Óž¼ŒæŠ½è±¡äº†ä¸€ä¸ªå…±åŒçš„¾c»TableDependencyåQŒåƈ通过建立带参数的构造函敎ͼŒå®Œæˆå¯¹ä¾èµ–项的徏立。由于接口方法GetDependency()的实çŽîC¸­åQŒè¿”回的对象dependency是在受保护的构造函数创建的åQŒå› æ­¤è¿™é‡Œçš„实现方式也可以看作是Template Method模式的灵‹z»è¿ç”¨ã€‚例如TableDependency的子¾c»ProductåQŒå°±æ˜¯åˆ©ç”¨çˆ¶¾cȝš„构造函数徏立了Product、Category数据表的SqlCacheDependency依赖åQ?br /> public class Product : TableDependency
{
    public Product() : base("ProductTableDependency") { }
}

如果需要自定义CacheDependencyåQŒé‚£ä¹ˆåˆ›å»ÞZ¾èµ–项的方式又有不同。然而不½Ž¡æ˜¯åˆ›å¾SqlCacheDependency对象åQŒè¿˜æ˜¯è‡ªå®šä¹‰çš„CacheDependency对象åQŒéƒ½æ˜¯å°†˜q™äº›ä¾èµ–™åÒŽ·»åŠ åˆ°AggregateCacheDependency¾cÖM¸­åQŒå› è€Œæˆ‘们也可以ä¸ø™‡ªå®šä¹‰CacheDependency建立专门的类åQŒåªè¦å®žçŽ°IPetShopCacheDependency接口卛_¯ã€?/p>

4.3.3  CacheDependency工厂

¾l§æ‰¿äº†æŠ½è±¡ç±»TableDependencyçš„Product、Categoryå’ŒItem¾cÕd‡éœ€è¦åœ¨è°ƒç”¨æ—¶åˆ›å»ºå„自的对象。由于它们的父类TableDependency实现了接口IPetShopCacheDependencyåQŒå› è€Œå®ƒä»¬ä¹Ÿé—´æŽ¥å®žçŽ°äº†IPetShopCacheDependency接口åQŒè¿™ä¸ºå®žçŽ°å·¥åŽ‚模式提供了前提ã€?/p>

在PetShop 4.0中，依然利用了配¾|®æ–‡ä»¶å’Œåå°„技术来实现工厂模式。命名空间PetShop.CacheDependencyFactory中，¾c»DependencyAccess即äؓ创徏IPetShopCacheDependency对象的工厂类åQ?br /> public static class DependencyAccess
{       
    public static IPetShopCacheDependency CreateCategoryDependency()
    {
        return LoadInstance("Category");
    }
    public static IPetShopCacheDependency CreateProductDependency()
    {
        return LoadInstance("Product");
    }
    public static IPetShopCacheDependency CreateItemDependency()
    {
        return LoadInstance("Item");
    }
    private static IPetShopCacheDependency LoadInstance(string className)
    {
        string path = ConfigurationManager.AppSettings["CacheDependencyAssembly"];
        string fullyQualifiedClass = path + "." + className;
        return (IPetShopCacheDependency)Assembly.Load(path).CreateInstance(fullyQualifiedClass);
    }
}
整个工厂模式的实现如å›?-3所½Cºï¼š

 å›?-3 CacheDependency工厂

虽然DependencyAccess¾cÕdˆ›å»ÞZº†å®žçŽ°äº†IPetShopCacheDependency接口的类Category、Product、ItemåQŒç„¶è€Œæˆ‘们之所以引入IPetShopCacheDependency接口åQŒå…¶ç›®çš„ž®±åœ¨äºŽèŽ·å¾—创å»ÞZº†ä¾èµ–™å¹çš„AggregateCacheDependency¾cÕdž‹çš„对象。我们可以调用对象的接口æ–ÒŽ³•GetDependency()åQŒå¦‚下所½Cºï¼š
AggregateCacheDependency dependency = DependencyAccess.CreateCategoryDependency().GetDependency();

ä¸ÞZº†æ–¹ä¾¿è°ƒç”¨è€…，ä¼ég¹Žæˆ‘们可以对DependencyAccess¾c»è¿›è¡Œæ”¹˜q›ï¼Œž®†åŽŸæœ‰çš„CreateCategoryDependency()æ–ÒŽ³•åQŒä¿®æ”¹äؓ创徏AggregateCacheDependency¾cÕdž‹å¯¹è±¡çš„方法ã€?/p>

然而这æ ïLš„做法æ‰îCؕ了作为工厂类的DependencyAccess的本íw«èŒè´£ï¼Œä¸”创建IPetShopCacheDependency接口对象的行ä¸ÞZ»ç„¶æœ‰å¯èƒ½è¢«è°ƒç”¨è€…调用，所以保留原有的DependencyAccess¾cÖM»ç„¶æ˜¯æœ‰å¿…要的ã€?/p>

在PetShop 4.0的设计中åQŒæ˜¯é€šè¿‡å¼•å…¥Facade模式以方便调用者更加简单地获得AggregateCacheDependency¾cÕdž‹å¯¹è±¡ã€?/p>

4.3.4  引入Facade模式

利用Facade模式可以ž®†ä¸€äº›å¤æ‚的逻辑˜q›è¡ŒåŒ…装åQŒä»¥æ–¹ä¾¿è°ƒç”¨è€…对˜q™äº›å¤æ‚逻辑的调用。就好像提供一个统一的门面一般，ž®†å†…部的子系¾lŸå°è£…è“v来，¾lŸä¸€ä¸ÞZ¸€ä¸ªé«˜å±‚次的接口。一个典型的Facade模式½Cºæ„å›‘Ö¦‚下所½Cºï¼š

�-4 Facade模式

Facade模式的目的åƈ非要引入一个新的功能，而是在现有功能的基础上提供一个更高层‹Æ¡çš„抽象åQŒä‹É得调用者可以直接调用，而不用关心内部的实现方式。以CacheDependency工厂ä¸ÞZ¾‹åQŒæˆ‘们需要äؓ调用者提供获得AggregateCacheDependency对象的简便方法，因而创å»ÞZº†DependencyFacade¾c»ï¼š
public static class DependencyFacade
{
    private static readonly string path = ConfigurationManager.AppSettings["CacheDependencyAssembly"];
    public static AggregateCacheDependency GetCategoryDependency()
    {
        if (!string.IsNullOrEmpty(path))
            return DependencyAccess.CreateCategoryDependency().GetDependency();
        else
            return null;
    }
    public static AggregateCacheDependency GetProductDependency()
    {
        if (!string.IsNullOrEmpty(path))
            return DependencyAccess.CreateProductDependency().GetDependency();
        else
            return null;
        }
    public static AggregateCacheDependency GetItemDependency()
    {
        if (!string.IsNullOrEmpty(path))
            return DependencyAccess.CreateItemDependency().GetDependency();
        else
            return null;
    }
}

DependencyFacade¾cÕd°è£…了获取AggregateCacheDependency¾cÕdž‹å¯¹è±¡çš„逻辑åQŒå¦‚此一来，调用者可以调用相å…Ïx–¹æ³•èŽ·å¾—创建相关依赖项的AggregateCacheDependency¾cÕdž‹å¯¹è±¡åQ?br /> AggregateCacheDependency dependency = DependencyFacade.GetCategoryDependency();

比è“v直接调用DependencyAccess¾cȝš„GetDependency()æ–ÒŽ³•è€Œè¨€åQŒé™¤äº†æ–¹æ³•æ›´½Ž€å•ä¹‹å¤–，同时它还对CacheDependencyAssembly配置节进行了判断åQŒå¦‚果其å€égØ“½Iºï¼Œåˆ™è¿”回null对象ã€?/p>

在PetShop.Webçš„App_Codeæ–‡äšg夹下åQŒé™æ€ç±»WebUtilityçš„GetCategoryName()å’ŒGetProductName()æ–ÒŽ³•è°ƒç”¨äº†DependencyFacade¾c…R€‚例如GetCategoryName()æ–ÒŽ³•åQ?br /> public static string GetCategoryName(string categoryId)
{
     Category category = new Category();
     if (!enableCaching)
            return category.GetCategory(categoryId).Name;

     string cacheKey = string.Format(CATEGORY_NAME_KEY, categoryId);

     // ‹‚€æŸ¥ç¼“存中是否存在该数据项;
     string data = (string)HttpRuntime.Cache[cacheKey];
     if (data == null)
     {
           // 通过web.config的配¾|®èŽ·å–durationå€?
           int cacheDuration = int.Parse(ConfigurationManager.AppSettings["CategoryCacheDuration"]);
           // 如果¾~“存中不存在该数据项åQŒåˆ™é€šè¿‡ä¸šåŠ¡é€»è¾‘层访问数据库获取;
           data = category.GetCategory(categoryId).Name;
           // 通过Facade¾cÕdˆ›å»ºAggregateCacheDependency对象;
           AggregateCacheDependency cd = DependencyFacade.GetCategoryDependency();
           // ž®†æ•°æ®é¡¹ä»¥åŠAggregateCacheDependency 对象存储到缓存中;
           HttpRuntime.Cache.Add(cacheKey, data, cd, DateTime.Now.AddHours(cacheDuration), Cache.NoSlidingExpiration, CacheItemPriority.High, null);
      }
      return data;
}

GetCategoryName()æ–ÒŽ³•é¦–先会检查缓存中是否已经存在CategoryName数据™å¹ï¼Œå¦‚果已经存在åQŒå°±é€šè¿‡¾~“存直接获取数据åQ›å¦åˆ™å°†é€šè¿‡ä¸šåŠ¡é€»è¾‘层调用数据访问层讉K—®æ•°æ®åº“获得CategoryNameåQŒåœ¨èŽ·å¾—了CategoryName后，会将新获取的数据˜qžåŒDependencyFacade¾cÕdˆ›å»ºçš„AggregateCacheDependency对象æ·ÕdŠ åˆ°ç¼“存中ã€?/p>

WebUtility静态类被表½Cºå±‚的许多页面所调用åQŒä¾‹å¦‚Product™åµé¢åQ?br /> public partial class Products : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        Page.Title = WebUtility.GetCategoryName(Request.QueryString["categoryId"]);
    }
}

昄¡¤º™åµé¢title的逻辑是放在Page_Load事äšgæ–ÒŽ³•ä¸­ï¼Œå› è€Œæ¯‹Æ¡æ‰“开该页面都要执行获取CategoryName的方法。如果没有采用缓存机åˆÓž¼Œå½“Category数据较多æ—Óž¼Œ™åµé¢çš„显½Cºå°±ä¼šéžå¸¸ç¼“æ…¢ã€?/p>

4.3.5  引入Proxy模式

业务逻辑层BLL中与Product、Category、Item有关的业务方法，其实现逻辑是调用数据访问层åQˆDALåQ‰å¯¹è±¡è®¿é—®æ•°æ®åº“åQŒä»¥èŽ·å–相关数据。äؓ了改善系¾lŸæ€§èƒ½åQŒæˆ‘们就需要äØ“˜q™äº›å®žçŽ°æ–ÒŽ³•å¢žåŠ ¾~“存机制的逻辑。当我们操作增加了缓存机制的业务对象æ—Óž¼Œå¯¹äºŽè°ƒç”¨è€…而言åQŒåº”与BLL业务对象的调用保持一致。也åÏx˜¯è¯ß_¼Œæˆ‘们需要引入一个新的对象去控制原来的BLL业务对象åQŒè¿™ä¸ªæ–°çš„对象就是Proxy模式中的代理对象ã€?/p>

以PetShop.BLL.Product业务对象ä¸ÞZ¾‹åQŒPetShop为其建立了代理对象ProductDataProxyåQŒåƈ在GetProductByCategory()½{‰æ–¹æ³•ä¸­åQŒå¼•å…¥äº†¾~“存机制åQŒä¾‹å¦‚：
public static class ProductDataProxy
{

    private static readonly int productTimeout = int.Parse(ConfigurationManager.AppSettings["ProductCacheDuration"]);
    private static readonly bool enableCaching = bool.Parse(ConfigurationManager.AppSettings["EnableCaching"]);
       
    public static IList
GetProductsByCategory(string category)
    {
        Product product = new Product();

        if (!enableCaching)
            return product.GetProductsByCategory(category);

        string key = "product_by_category_" + category;
        IList data = (IList )HttpRuntime.Cache[key];

        // Check if the data exists in the data cache
        if (data == null)
        {
            data = product.GetProductsByCategory(category);

            // Create a AggregateCacheDependency object from the factory
            AggregateCacheDependency cd = DependencyFacade.GetProductDependency();

            // Store the output in the data cache, and Add the necessary AggregateCacheDependency object
            HttpRuntime.Cache.Add(key, data, cd, DateTime.Now.AddHours(productTimeout), Cache.NoSlidingExpiration, CacheItemPriority.High, null);
        }
        return data;
    }
}

与业务逻辑层Product对象的GetProductsByCategory()æ–ÒŽ³•ç›¸æ¯”åQŒå¢žåŠ äº†¾~“存机制。当¾~“存内不存在相关数据™åÒŽ—¶åQŒåˆ™ç›´æŽ¥è°ƒç”¨ä¸šåŠ¡é€»è¾‘层Productçš„GetProductsByCategory()æ–ÒŽ³•æ¥èŽ·å–数据，òq¶å°†å…¶ä¸Žå¯¹åº”çš„AggregateCacheDependency对象一起存储在¾~“存中ã€?/p>

引入Proxy模式åQŒå®žçŽîCº†åœ¨ç¼“å­˜çñ”别上对业务对象的ž®è£…åQŒå¢žå¼ÞZº†å¯¹ä¸šåŠ¡å¯¹è±¡çš„控制。由于暴露在对象外的æ–ÒŽ³•æ˜¯ä¸€è‡´çš„åQŒå› è€Œå¯¹äºŽè°ƒç”¨æ–¹è€Œè¨€åQŒè°ƒç”¨ä»£ç†å¯¹è±¡ä¸ŽçœŸå®žå¯¹è±¡òq¶æ²¡æœ‰å®žè´¨çš„区别ã€?/p>

从职责分¼›ÖM¸Žåˆ†å±‚设计的角度分析，我更希望˜q™äº›Proxy对象是被定义在业务逻辑层中åQŒè€Œä¸åƒåœ¨PetShop的设计那æ øP¼Œè¢«åˆ’分到表示层UI中。此外，如果需要考虑½E‹åºçš„可扩展性与可替换性，我们˜q˜å¯ä»¥äؓ真实对象与代理对象徏立统一的接口或抽象¾c…R€‚然而，单以PetShop的表½Cºå±‚调用来看åQŒé‡‡ç”¨é™æ€ç±»ä¸Žé™æ€æ–¹æ³•çš„方式åQŒæˆ–许更为合理。我们需要è°}讎ͼŒ“˜q‡åº¦è®¾è®¡”是èÊY件设计的警戒¾Uѝ€?/p>

如果需要对UI层采用缓存机åˆÓž¼Œž®†åº”用程序数据存攑ֈ°¾~“存中，ž®±å¯ä»¥è°ƒç”¨è¿™äº›ä»£ç†å¯¹è±¡ã€‚以ProductsControl用户控äšgä¸ÞZ¾‹åQŒè°ƒç”¨æ–¹å¼å¦‚下：
productsList.DataSource = ProductDataProxy.GetProductsByCategory(categoryKey);

productsList对象属于自定义的CustomList¾cÕdž‹åQŒè¿™æ˜¯ä¸€ä¸ªæ´¾ç”Ÿè‡ªSystem.Web.UI.WebControls.DataList控äšgçš„ç±»åQŒå®ƒçš„DataSource属性可以接受IList集合对象ã€?br /> 不过在PetShop 4.0的设计中åQŒå¯¹äºŽç±»ä¼égºŽProductsControl¾cÕdž‹çš„控件而言åQŒé‡‡ç”¨çš„¾~“存机制是页输出¾~“存。我们可以从ProductsControl.ascx™åµé¢çš„Source代码中发现端倪：
<%@ OutputCache Duration="100000" VaryByParam="page;categoryId" %>

与ASP.NET 1.x的页输出¾~“存不同的是åQŒåœ¨ASP.NET 2.0中，为ASP.NET用户控äšg新引入了CachePolicy属性，该属性的¾cÕdž‹ä¸ºControlCachePolicy¾c»ï¼Œå®ƒä»¥¾~–程方式实现了对ASP.NET用户控äšg的输出缓存设¾|®ã€‚我们可以通过讄¡½®ControlCachePolicy¾cȝš„Dependency属性，来设¾|®ä¸Žè¯¥ç”¨æˆähŽ§ä»¶ç›¸å…³çš„依赖™å¹ï¼Œä¾‹å¦‚在ProductsControl用户控äšg中，˜q›è¡Œå¦‚下的设¾|®ï¼š
protected void Page_Load(object sender, EventArgs e)
{
    this.CachePolicy.Dependency = DependencyFacade.GetProductDependency();
}

采用™åµè¾“出缓存，òq¶ä¸”利用ControlCachePolicy讄¡½®è¾“出¾~“å­˜åQŒèƒ½å¤Ÿå°†ä¸šåŠ¡æ•°æ®ä¸Žæ•´ä¸ªé¡µé¢æ”¾å…¥åˆ°¾~“存中。这¿Uæ–¹å¼æ¯”起应用程序缓存而言åQŒåœ¨æ€§èƒ½ä¸Šæœ‰å¾ˆå¤§çš„提高。同æ—Óž¼Œå®ƒåˆé€šè¿‡å¼•å…¥çš„SqlCacheDependencyç‰ÒŽ€§æœ‰æ•ˆåœ°é¿å…äº?#8220;数据˜q‡æœŸ”的缺点，因而在PetShop 4.0中被òq¿æ³›é‡‡ç”¨ã€‚相反，之前为Product、Category、Item业务对象建立的代理对象则è¢?#8220;投闲散置”åQŒä»…仅作ä¸ÞZ¸€¿Uè®¾è®¡æ–¹æ³•çš„展示è€?#8220;òq¸å­˜”与整个系¾lŸçš„源代码中ã€?/p>

              #region open SqlConnection
              public static void Open() {
                   conn = new SqlConnection(connectionString);
                   if (conn.State != ConnectionState.Open)
                      conn.Open();
              }    
              #endregion

              #region close SqlConnection
              public static void Close() {
                  if (conn != null)
                  {
                      conn.Close();
                      conn.Dispose();
                  }
              }        
              #endregion

              #region prepare SqlCommand
              private static void PrepareCommand(SqlCommand cmd, CommandType cmdType, string cmdText, SqlParameter[] cmdParms) {
                  Open();
                  cmd.Connection = conn;
                  cmd.CommandType = cmdType;
                  cmd.CommandText = cmdText;

                  if (cmdParms != null)
                  {
                      foreach (SqlParameter parm in cmdParms)
                          cmd.Parameters.Add(parm);
                  }
              }
              #endregion

              #region parm cache
              /*
               使用一个哈希表来保存缓存的参数 只缓存参数名
               哈希表的特点:一个键对应一个值key对value(为object需要类型è{åŒ?        不能出现两个相同的键 否则error
         
               下面的哈希表parmCache定义为static即一‹Æ¡å®šä¹‰å…¨å±€ä½¿ç”¨
               所以可能会出现有äh在读的时候，有äh在写åQŒä¸€èˆ¬ä¼šç”¨Lockž®±åƒAsp中用Application["count"]来统计点å‡ÀL•°ä¸€æ ?br />                要先锁后解锁
               ä½?net框架提供了Synchroized          syncå’Œsyncroize中文意æ€?同步åQŒåŒæ—¶å‘ç”?br />                来提供这一操作
              */
              private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());

              public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters) {
                  parmCache[cacheKey] = commandParameters;
              }

              /*
              1、äؓ何要克隆å‘?ä¸ÞZ½•ä¸ç›´æŽ¥return cachedParms
         
              有一个参数数¾l?br />               SqlParameter[] parms={
              new SqlParameter("@num1",SqlDbType.Int,4),
              new SqlParameter("@num2",SqlDbType.Int,4)
              }
              ¾~“存该数¾l?br />               用户aå’Œb都执行插入操ä½?br />               a用户插入äº?,1
              b用户插入äº?,2
              如果不用克隆的话åQŒå‚æ•°æ•°¾l„只有一ä»?br />               è€?个用户需要根据不同的情况赋于不同的å€?br />               所以就用了克隆äº?br />         
              2ã€?ICloneable)cachedParms[i]先将HashTable转äØ“ICloneable˜q™æ ·HashTablež®±å…·æœ‰äº†Clone()克隆æ–ÒŽ³•äº?br />               克隆一份后是什么类型呢åQŒï¼Œå½“然要强制è{化äØ“(SqlParameter)äº?br />               最后将它赋值给clonedParms[i]
              */       
              public static SqlParameter[] GetCachedParameters(string cacheKey) {
                  SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];

                  if (cachedParms == null)
                      return null;
                  SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];

                  for (int i = 0; i < cachedParms.Length; i++)
                      clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();

                  return clonedParms;
              }
              #endregion        
        
              //below method support sqltext and procedure

              #region ExecuteReader
              /*
               parms的作用，˜q™ä¹Ÿæ˜¯ä¸€ä¸ªçŸ¥è¯†ç‚¹
               举例:
               ExecuteReader(*,*,null)成功˜qè¡Œ
               ExecuteReader(*,*,new SqlParameter(*))成功˜qè¡Œ
               ExecuteReader(*,*,new SqlParameter(*),new SqlParameter(*))成功˜qè¡Œ
               ExecuteReader(*,*,{new SqlParameter(*),new SqlParameter(*),})成功˜qè¡Œ
               它让参数¾cÕdž‹å’Œå‚æ•îC¸ªæ•îC“Qæ„?br />                ˜q™å¯¾l™äº†ä¸æ˜¯ä¸€èˆ¬çš„好处åQŒä½ ä¸å¿…为SqlParameterå’ŒSqlParameter[]˜q›è¡Œé‡è²åQŒå†™ä¸Šä¸¤ä¸ªå‡½æ•?br />                又äØ“null写上一个函敎ͼŒå› äØ“null会不明确调用SqlParameter的函数还是SqlParameter[]的函æ•?br />                啥你不知道我在说什么，打屁å±?那回åŽÈœ‹çœ‹c++的函数重è½?br />                */
              public static SqlDataReader ExecuteReader(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) {
            
                  SqlCommand cmd = new SqlCommand();

                  try {
                      PrepareCommand(cmd, null, cmdType, cmdText, commandParameters);
                      SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                      cmd.Parameters.Clear();
                      return rdr;
                  }
                  catch {
                      Close();
                      throw;
                  }
              }
              #endregion

              #region ExecuteNonQuery
              public static void ExecuteNonQuery(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) {

                  SqlCommand cmd = new SqlCommand();

                  PrepareCommand(cmd, cmdType, cmdText, commandParameters);
                  cmd.ExecuteNonQuery();
                  cmd.Parameters.Clear();

                  Close();
              }
              #endregion

              #region ExecuteScalar
              public static object ExecuteScalar(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) {

                  SqlCommand cmd = new SqlCommand();

                  PrepareCommand(cmd, cmdType, cmdText, commandParameters);
                  object val = cmd.ExecuteScalar();
                  cmd.Parameters.Clear();

                  Close();
                  return val;
              }
              #endregion

          }
}