HttpApplication对象对于做ASP.NET开发的朋友，我想没有人不熟悉它。在ASP.NET开发中，经常避免不了要在HttpApplication中执行一些操作，如使用了ASP.NET MVC框架，就会在Application_Start 事件中避免不了这样的路由规则配置代码：

protected void Application_Start()
{
    RouteTable.Routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

    RouteTable.Routes.MapRoute(
        "Default",                                              // Route name
        "{controller}/{action}/{id}",                           // URL with parameters
        new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
    );
}

如果仅仅是这一条，看起来倒不觉的有什么问题，但如果同时在应用程序中使用了工作流，又避免不了在Application_Start出现启动工作流运行时的代码：

protected void Application_Start()
{
    // 注册路由规则
    RouteTable.Routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
    RouteTable.Routes.MapRoute(
        "Default",                                              // Route name
        "{controller}/{action}/{id}",                           // URL with parameters
        new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
    );

    // 启动工作流
    WorkflowRuntime workflowRuntime = new WorkflowRuntime("workflowServicesConfig");
    ExternalDataExchangeService externalDataExchangeService = new ExternalDataExchangeService();
    workflowRuntime.AddService(externalDataExchangeService);
    workflowRuntime.StartRuntime();
}

试想一下，现在我们仅仅是有了ASP.NET MVC路由规则的配置、WF运行时的启动，如果在应用程序中使用某种DI框架，如微软的Unity，是不是又避免不了要出现这样的容器初始化代码呢？

protected void Application_Start()
{
    // 注册路由规则
    RouteTable.Routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
    RouteTable.Routes.MapRoute(
        "Default",                                              // Route name
        "{controller}/{action}/{id}",                           // URL with parameters
        new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
    );

    // 启动工作流
    WorkflowRuntime workflowRuntime = new WorkflowRuntime("workflowServicesConfig");
    ExternalDataExchangeService externalDataExchangeService = new ExternalDataExchangeService();
    workflowRuntime.AddService(externalDataExchangeService);
    workflowRuntime.StartRuntime();

    // 初始化DI容器
    IContainerContext repositoryContainer = ContainerManager.GetContainer("repositoryContainer");
    repositoryContainer.Initialize();
}

再看看Application_Start事件中的代码，有ASP.NET MVC的工作，有WF的工作，也有Unity的工作，不知道将来还会有什么？这些原本互相之间没有任何联系的代码，现在却同时堆在了一起，当每一部分（或者说每一个框架）变化的时候，都会涉及到Application_Start中代码的修改，显然违反了OCP原则。那么有没有一种机制，让这些互不相干的模块之间互相独立，各自发生变化时不影响对HttpApplication？此时我们就需要对HttpApplication进行扩展，提供一个扩展点，让其他模块的程序附加到HttpApplication上面。

可扩展对象模式

我们知道WCF提供了非常完美的扩展机制，几乎在服务执行过程中的每一个环节上都提供有扩展点，如ServiceHostBase、OperationContext、InstanceContext、IContextChannel，这些对象都属于可扩展对象，它们都通过Extensions属性获取用于所有扩展的集合。我们能不能使用这种方式对HttpApplication也进行扩展呢，答案自然是肯定的。查阅一下MSDN就会知道在System.ServiceModel命名空间下面提供了这样的一组接口：IExtensibleObject、IExtension和IExtensionCollection，这是可扩展对象模式中最重要的三个接口，也只有这三个接口。

IExtensibleObject自然是定义了可扩展对象，即我们要对谁进行扩展，它的定义非常简单，仅仅是提供了一个只读的属性Extensions，用来提供所有扩展对象的集合，如下代码所示：

public interface IExtensibleObject<T> where T : IExtensibleObject<T>
{
    IExtensionCollection<T> Extensions { get; }
}

IExtension定义了扩展对象的契约，使对象可以通过聚合扩展另一个对象（此处的另一个对象，就是指上面所讲的扩展宿主IExtensibleObject），在IExtension中定义了两个非常重要的方法Attach和Detach方法，分别用来提供聚合或解聚的通知。

public interface IExtension<T> where T : IExtensibleObject<T>
{
    void Attach(T owner);
    void Detach(T owner);
}

当一个扩展对象IExtension附加到可扩展对象的扩展集合中时，它的Attach方法将会被调用；反之如果从集合中移除一个扩展对象时，它的Detach方法会被调用。这一点我们可以通过Reflector来得到验证，如下代码所示：

protected override void InsertItem(int index, IExtension<T> item)
{
    lock (base.SyncRoot)
    {
        item.Attach(this.owner);
        base.InsertItem(index, item);
    }
}

protected override void RemoveItem(int index)
{
    lock (base.SyncRoot)
    {
        base.Items[index].Detach(this.owner);
        base.RemoveItem(index);
    }
}

最后一个接口是IExtensionCollection，它是IExtension对象的集合。

对HttpApplication进行扩展

下面我们就看一下如何使用可扩展对象模式对HttpApplication进行扩展，首先定义可扩展对象，让ExtensibleHttpApplication派生于HttpApplication，并实现了IExtensibleObject接口，泛型的参数类型就是它自身，如下代码所示：

public class ExtensibleHttpApplication : HttpApplication,
    IExtensibleObject<ExtensibleHttpApplication>
{
    private IExtensionCollection<ExtensibleHttpApplication> _extensions;
    
    public ExtensibleHttpApplication()
    {
        this._extensions = new ExtensionCollection<ExtensibleHttpApplication>(this);
    }

    public IExtensionCollection<ExtensibleHttpApplication> Extensions
    {
        get
        {
            return this._extensions;
        }
    }
}

有了可扩展的HttpApplication之后，需要在HttpApplication中实现任何功能，都可以作为一个扩展附加到ExtensibleHttpApplication上去，如实现ASP.NET MVC路由，可以定义一个如下代码所示的扩展对象：

public class MvcHttpApplication : IExtension<ExtensibleHttpApplication>
{
    public void Attach(ExtensibleHttpApplication owner)
    {
        RouteTable.Routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

        RouteTable.Routes.MapRoute(
            "Default",                                              // Route name
            "{controller}/{action}/{id}",                           // URL with parameters
            new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
        );
    }

    public void Detach(ExtensibleHttpApplication owner)
    {
        //nothing
    }
}

同样如果要在HttpApplication中启动Workflow，可以再针对Workflow定义一个扩展对象，如下示例代码所示：

public class WorkflowHttpApplication : IExtension<ExtensibleHttpApplication>
{
    private WorkflowRuntime workflowRuntime;
    public void Attach(ExtensibleHttpApplication owner)
    {
        workflowRuntime = new WorkflowRuntime("workflowServicesConfig");
        ExternalDataExchangeService externalDataExchangeService = new ExternalDataExchangeService();
        workflowRuntime.AddService(externalDataExchangeService);
        workflowRuntime.StartRuntime();
    }

    public void Detach(ExtensibleHttpApplication owner)
    {
        workflowRuntime.StopRuntime();
    }
}

我们已经定义好了相应的扩展对象，只需要在相应的HttpApplication把扩展对象附加到ExtensibleHttpApplication上即可，修改Global.asax中的代码如下所示：

public class MvcApplication : ExtensibleHttpApplication
{
    protected void Application_Start()
    {
        this.Extensions.Add(new MvcHttpApplication());
        this.Extensions.Add(new WorkflowHttpApplication());
    }
}

现在代码是不是看起来优雅多了？现在如果要在Application_Start中，添加另外一些执行代码，只需要编写相应的扩展对象，并将其添加到Extension集合中即可。也许有朋友会问，这样每添加一些新的代码，还是要修改Application_Start中的代码啊？别忘了，可以通过配置可以解决这个问题，WCF中的扩展不也是可以采用配置方式实现，不是吗？同样，如果我们需要在Application_End事件中释放某些对象，可以直接从扩展集合中移除它，此时将会调用它的Detach方法。

总结

本文介绍了如何使用WCF中提供的可扩展对象模式扩展HttpApplication，事实上可扩展对象模式的作用远不在此，它可以扩展.NET类库中任何我们想对其进行扩展的对象，或者是一个自定义的类型，都可以使用可扩展对象模式对其进行扩展。

特别鸣谢：Jesse Qu

注1：由于TerryLee最近一段时间忙于别的事务，无暇顾及Blog，所以有大量的评论和E-mail都没能回复，请大家见谅。

注2：由TerryLee撰写的《Silverlight 2完美征程》一书，即将于本月底上市，敬请期待，详情大家可以访问本书官方网站http://www.dotneteye.cn/silverlight了解。

Velocity是微软推出的分布式缓存解决方案，为开发可扩展性，可用的，高性能的应用程提供支持，可以缓存各种类型的数据，如CLR对象、XML、二进制数据等，并且支持集群模式的缓存服务器。Velocity也将集成在.NET Framework 4.0中，本文将介绍Velocity中的悲观锁定，缓存项版本、日志记录、客户端缓存以及路由表等知识。

悲观锁定

在Velocity提供了一套悲观锁定模型，即在某个缓存项数据处理过程中，数据将处于锁定状态，来自于其它客户端应用程序将无法对该缓存项进行处理。提供悲观锁定的方法主要三个，如下代码所示：

GetAndLock()：获取缓存项并对数据加锁；

PutAndUnlock()：更新加锁的数据并释放锁；

Unlock()：释放锁定。

先来看GetAndLock()方法，在获取缓存项时并加锁，此时如果其它客户端试图获取该数据并加锁（即调用GetAndLock方法）将会失败，而不会阻塞；但客户端如果只想获取数据（即调用Get方法），则会返回相应数据，可以用图1形象的来表示：

图 1

可以看到，ClientA获取数据成功并加锁；ClientB再次想获取数据并加锁时，将会失败；ClientC能够获取数据。

使用GetAndLock()方式可以指定锁过期时间，并且会有输出参数LockHandle，该参数将会在PutAndUnlock()方法或Unlock()中来释放锁，如下代码所示：

Cache cache = GetCurrentCache();
LockHandle handle = new LockHandle();
Customer item = (Customer)cache.GetAndLock("C20081117005",
         new TimeSpan(0, 30, 0), out handle);

Customer customer = new Customer()
{
    ID = "C20081117005",
    FirstName = "Terry",
    LastName = "Lee",
    Age = 25,
    Email = "lhj_cauc[#AT#]163.com"
};
cache.PutAndUnlock(customer.ID, customer, handle, null);

日志记录

Velocity中同样提供了日志记录的功能，我们可以在应用程序配置文件中进行设置，它支持基于控制台、基于文件以及Windows事件跟踪三种方式的记录，在配置文件中首先添加配置区：

<section name="fabric" type="System.Data.Fabric.Common.ConfigFile, FabricCommon"
         allowLocation="true" allowDefinition="Everywhere"/>

然后可以进行配置，如设置日志记录级别等：

<fabric>
  <section name="logging" path="">
    <collection name="sinks" collectionType="list">
      <customType className="System.Data.Fabric.Common.EventLogger,FabricCommon"
                  sinkName="System.Data.Fabric.Common.ConsoleSink,FabricCommon"
                  sinkParam="" defaultLevel="-1"/>
      <customType className="System.Data.Fabric.Common.EventLogger,FabricCommon"
                  sinkName="System.Data.Fabric.Common.FileEventSink,FabricCommon"
                  sinkParam="CacheClientLog" defaultLevel="1"/>
      <customType className="System.Data.Fabric.Common.EventLogger,FabricCommon"
                  sinkName="System.Data.Caching.ETWSink, CacheBaseLibrary"
                  sinkParam="" defaultLevel="-1" />
    </collection>
  </section>
</fabric>

同样也可以在代码中设置，调用CacheFactory的两个静态方法CreateLogSinks和DisableLogSinks，如下代码所示：

private Cache GetCurrentCache()
{
    List<LogSink> sinklist = new List<LogSink>(2);
    LogSink fileBasedSink = new LogSink(SinkType.FILE,
        TraceLevel.Warning, "DCache/dd-hh-mm");
    LogSink consoleBasedSink = new LogSink(SinkType.CONSOLE,
        TraceLevel.Warning);
    sinklist.Add(fileBasedSink);
    sinklist.Add(consoleBasedSink);
    // 启用
    CacheFactory.CreateLogSinks(sinklist);

    // 禁用
    CacheFactory.DisableLogSinks();

    Cache dCache;
    ServerEndPoint[] servers = new ServerEndPoint[1];
    servers[0] = new ServerEndPoint("localhost", 22233, "DistributedCacheService");
    bool routingClient = true;
    bool localCache = false;

    var factory = new CacheFactory(servers, routingClient, localCache);
    dCache = factory.GetCache("default");

    return dCache;
}

缓存项版本

在Velocity中提供了一种基于版本的更新功能，当使用GetCacheItem()方法时将返回一个缓存项，并携带有版本信息，当每次对缓存项做更新时，在内部都会对它的版本增加。如下面的示例，有两个客户应用程序，它们同时获取了同一个缓存项：

ClientA

CacheItem item = cache.GetCacheItem("Customers", "C2008");

ClientB

CacheItem item = cache.GetCacheItem("Customers", "C2008");

并且同时对缓存项做修改：

ClientA

((Customer)item.CacheObject).FirstName = "Huijun";

ClientB

((Customer)item.CacheObject).FirstName = "Terry";

如果ClientA首先提交更改，在提交更改时携带版本信息，由于版本信息与内部的版本一致，所以提交成功：

ClientA

cache.Put("Customers", "C2008", item.CacheObject, item.Version);

此时内部版本将会增加，现在ClientB如果再提交更改，将会失败，因为版本无法匹配，如图2表示：

图 2

客户端缓存

在Velocity中还支持客户端缓存，如果启用了客户端缓存后，在从缓存集群中取回数据时，将会放在客户端缓存中，这样下次取数据时将会直接从客户端缓存中取出，能够极大的提高效率，有点像是缓存的缓存。当集群中的数据发生变化时，Velocity将会使用事件通知机制通知客户端缓存刷新数据，如图3所示：

图 3

要启用客户端缓存，一是使用配置文件，设置IsEnabled属性为True，如下代码所示：

<dcacheClient deployment="routing">
  <localCache isEnabled="true" sync="TTLBased" ttlValue="300" />
  <hosts>
    <host name="localhost" cachePort="22233" 
          cacheHostName="DistributedCacheService"/>
  </hosts>
</dcacheClient>

直接指定启用客户端缓存即可，另外也可以在创建CacheFactory时指定，如下代码所示：

Cache dCache;
ServerEndPoint[] servers = new ServerEndPoint[1];
servers[0] = new ServerEndPoint("localhost", 22233, "DistributedCacheService");
bool routingClient = true;
bool localCache = false;

var factory = new CacheFactory(servers, routingClient, localCache);
dCache = factory.GetCache("default");

return dCache;

路由客户端

Velocity中在缓存客户端，提供了一种路由客户端Routing Client，它能够提供比简单客户端Simple Client更好的性能，在Routing Client中会有一个路由表Routing Table，它用来跟踪缓存对象，它是全局缓存中的分区映射的一个子集，同时分发缓存操作（Put、Get等）到确定的缓存宿主。路由客户端使用此路由表来优化性能，因为该表可以跟踪缓存对象，所以当有请求到缓存宿主时，可以进行物理上的定位。如图4所示：

图4

是否在应用程序中启用路由客户端，可以由开发者来确定，如在配置中启用路由客户端，这里可以通过指示deployment来设定是路由客户端（routing）还是简单客户端（simple）：

<dcacheClient deployment="routing">
  <localCache isEnabled="true" sync="TTLBased" ttlValue="300" />
  <hosts>
    <host name="localhost" cachePort="22233" 
          cacheHostName="DistributedCacheService"/>
  </hosts>
</dcacheClient>

另外还可以通过代码来设置，如下面的代码，在创建CacheFactory时指定构造函数参数：

Cache dCache;
ServerEndPoint[] servers = new ServerEndPoint[1];
servers[0] = new ServerEndPoint("localhost", 22233, "DistributedCacheService");
bool routingClient = true;
bool localCache = false;

var factory = new CacheFactory(servers, routingClient, localCache);
dCache = factory.GetCache("default");

return dCache;

Velocity组成

最后我们再看一幅图，来了解一下Velocity的组成部分，可以看到它可以分为客户端缓存、服务端缓存以及管理工具三部分，如图5所示：

图 5

总结

本文介绍了Velocity中的悲观锁定，缓存项版本、日志记录、客户端缓存以及路由表等知识，希望对大家有用。至此，关于微软的分布式缓存服务Velocity就用短短的三篇文章介绍到这里，期待在.NET Framework 4.0中Velocity能够为我们带来更多的惊喜。

相关文章：

1. 使用微软分布式缓存服务Velocity Part 1

2. 使用微软分布式缓存服务Velocity Part 2

Velocity是微软推出的分布式缓存解决方案，为开发可扩展性，可用的，高性能的应用程提供支持，可以缓存各种类型的数据，如CLR对象、XML、二进制数据等，并且支持集群模式的缓存服务器。Velocity也将集成在.NET Framework 4.0中，本文将介绍Velocity中的配置模型、缓存复杂数据和创建分区、使用标签以及ASP.NET SessionState提供者。

配置模型

在本文开始之前，先简单介绍一下Velocity中的配置模型，主要包括三方面的配置，缓存集群的配置，缓存宿主服务器配置以及应用程序的配置，如下图所示：

缓存集群的配置，可以基于XML、SQL Server CE或者SQL Server数据库来进行存储，包括各个服务器以及所有的命名缓存、是否过期等配置，当我们使用Windows PowerShell管理工具进行配置时，将会修改该配置文件，如下代码所示：

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <section name="dcache" type="System.Data.Caching.DCacheSection, 
             CacheBaseLibrary, Version=1.0.0.0, Culture=neutral,
             PublicKeyToken=89845dcd8080cc91" />
  </configSections>
  <dcache cluster="localhost" size="Small">
    <caches>
      <cache type="partitioned" consistency="strong" name="default">
        <policy>
          <eviction type="lru" />
          <expiration defaultTTL="10" isExpirable="true" />
        </policy>
      </cache>
      <cache type="partitioned" consistency="strong" name="other">
        <policy>
          <eviction type="lru" />
          <expiration defaultTTL="10" isExpirable="true" />
        </policy>
      </cache>
    </caches>
    <hosts>
      <host clusterPort="22234" hostId="1319514812" size="1024" quorumHost="true"
          name="TERRYLEE-PC" cacheHostName="DistributedCacheService"
          cachePort="22233" />
    </hosts>
    <advancedProperties>
      <partitionStoreConnectionSettings providerName="System.Data.SqlServerCe.3.5"
          connectionString="D:\CacheShare\ConfigStore.sdf" />
    </advancedProperties>
  </dcache>
</configuration>

在上一篇的示例中，并没有使用应用程序配置文件，事实上使用配置文件是更好的编程实践，首先需要添加一个配置区：

<section name="dcacheClient"
type="System.Data.Caching.DCacheSection, 
      CacheBaseLibrary, Version=1.0.0.0, 
      Culture=neutral, PublicKeyToken=89845dcd8080cc91"/>

配置信息包括部署方式，是否启用本地缓存以及缓存宿主等，如下代码所示：

<dcacheClient>
  <localCache isEnabled="true" sync="TTLBased" ttlValue="300" />
  <hosts>
    <host name="localhost" cachePort="22233" 
          cacheHostName="DistributedCacheService"/>
  </hosts>
</dcacheClient>

现在Velocity CTP2对于应用程序使用配置的支持似乎有些问题。缓存宿主的配置放在DistributedCache.exe.config文件中，可以在Velocity安装目录下找到。

缓存复杂数据类型

在Velocity中，可以缓存任何类型的数据，如CLR对象、XML或者二进制数据等。现在看一个简单的示例，如何缓存复杂类型数据，定义一个如下的Customer类，注意要能够序列化：

[Serializable]
public class Customer
{
    public String ID { get; set; }

    public String FirstName { get; set; }

    public String LastName { get; set; }

    public int Age { get; set; }

    public String Email { get; set; }
}

对应用程序做配置，参考本文的配置模型部分，使用方法与简单数据类型的基本一致，如添加缓存项，使用Customer主键作为缓存键，其中GetCurrentCache()方法的实现请参考上一篇文章：

Cache cache = GetCurrentCache();
Customer customer = new Customer()
{
    ID = "C20081117002",
    FirstName = "Terry",
    LastName = "Lee",
    Age = 25,
    Email = "lhj_cauc[#AT#]163.com"
};

cache.Add(customer.ID, customer);

获取缓存项：

Cache cache = GetCurrentCache();
Customer customer = cache.Get("C20081117002") as Customer;

移除缓存项：

Cache cache = GetCurrentCache();
cache.Remove("C20081117002");

更新缓存中数据，可以有两种方法，一是直接使用缓存索引，如果确保缓存键存在：

Cache cache = GetCurrentCache();
Customer customer = new Customer()
{
    ID = "C20081117002",
    FirstName = "Huijui",
    LastName = "Li",
    Age = 26,
    Email = "lhj_cauc[#AT#]163.com"
};
cache["C20081117002"] = customer;

另外一种是使用Put方法，如果缓存键不存在，它将会新增到缓存中，否则会进行覆盖，如下代码所示：

Cache cache = GetCurrentCache();
Customer customer = new Customer()
{
    ID = "C20081117002",
    FirstName = "Huijui",
    LastName = "Li",
    Age = 26,
    Email = "lhj_cauc[#AT#]163.com"
};
cache.Put(customer.ID, customer);

使用分区

在实际部署中，经常会出现多个应用程序共享同一个缓存集群，这不可避免的会出现缓存键冲突，如上面的示例中使用CustomerID作为缓存键，此时可以使用Velocity中的分区功能，它会在逻辑上把各个命名缓存再进行分区，这样可以完全保持数据隔离，如下图所示：

图中共有三个命名缓存，其中在缓存Catalog中又分区为Sports和Arts。在Velocity中对于分区的操作提供了如下三个方法，可以用于创建分区，删除分区以及清空分区中所有的对象：

public void ClearRegion(string region);
public bool CreateRegion(string region, bool evictable);
public bool RemoveRegion(string region);

如下代码所示，创建了一个名为“Customers”的分区，在调用Add方法时可以指定数据将会缓存到哪个分区：

Cache cache = GetCurrentCache();
string regionName = "Customers";
cache.CreateRegion(regionName, false);

Customer customer = new Customer()
{
    ID = "C20081117003",
    FirstName = "Terry",
    LastName = "Lee",
    Age = 25,
    Email = "lhj_cauc[#AT#]163.com"
};

cache.Add(regionName, customer.ID, customer);

可以使用Get-CacheRegion命令在Windows PowerShell中来查看一下当前缓存集群中所有的分区信息，如下图所示：

同样在检索缓存数据时，仍然可以使用分区名进行检索。

使用标签

在Velocity还允许对加入到缓存中的缓存项设置Tag，可以是一个或者多个，使用了Tag，就可以从多个方面对缓存项进行描述，这样在检索数据时，就可以根据Tag来一次检索多个缓存项。为缓存项设置Tag，如下代码所示：

Cache cache = GetCurrentCache();
string regionName = "Customers";

Customer customer1 = new Customer()
{
    ID = "C20081117004",
    FirstName = "Terry",
    LastName = "Lee",
    Age = 25,
    Email = "lhj_cauc[#AT#]163.com"
};
Customer customer2 = new Customer()
{
    ID = "C20081117005",
    FirstName = "Terry",
    LastName = "Lee",
    Age = 25,
    Email = "lhj_cauc[#AT#]163.com"
};

Tag tag1 = new Tag("Beijing");
Tag tag2 = new Tag("Tianjin");
cache.Add(regionName, customer1.ID, customer1, new Tag[] { tag1, tag2 });
cache.Add(regionName, customer2.ID, customer2, new Tag[] { tag2 });

这样就可以对设置了Tag的缓存项进行检索，根据实际需求选择使用如下三个方法之一：

GetAllMatchingTags(string region, Tag[] tags)
GetAnyMatchingTag(string region, Tag[] tags)
GetByTag(string region, Tag tag)

第一个检索匹配所有Tag的数据，第二个检索匹配所有Tag中的任意一个即可，最后只使用一个Tag，如下代码所示：

string regionName = "Customers";
Tag[] tags = new Tag[] { new Tag("Beijing"), 
           new Tag("Tianjin")};

List<KeyValuePair<string, object>> result
    = cache.GetAllMatchingTags(regionName, tags);

使用Tag功能对于检索缓存项提供了极大的灵活性，对于任何一个数据，都可以使用多个Tag从很多方面去描述它。

ASP.NET SessionState提供者

Velocity还提供了对于ASP.NET SessionState提供者的支持，可以通过配置把Session信息缓存到缓存集群中，添加Velocity配置区：

<section name="dcacheClient"
         type="System.Data.Caching.DCacheSection, 
         CacheBaseLibrary, Version=1.0.0.0, 
         Culture=neutral, PublicKeyToken=89845dcd8080cc91"/>

配置缓存客户端信息：

<dcacheClient>
  <localCache isEnabled="true" sync="TTLBased" ttlValue="300" />
  <hosts>
    <host name="localhost" cachePort="22233" 
          cacheHostName="DistributedCacheService"/>
  </hosts>
</dcacheClient>

配置SessionState信息：

<sessionState mode="Custom" customProvider="Velocity">
  <providers>
    <add name="Velocity" 
         type="System.Data.Caching.SessionStoreProvider,ClientLibrary"
         cacheName="default"/>
  </providers>
</sessionState>

需要指定使用哪个命名缓存，但是该功能似乎到目前还存在问题，无法测试通过L

总结

本文简单介绍了Velocity的配置模型，以及如何缓存复杂数据类型，对命名缓存分区，为缓存项设置Tag，以及对于ASP.NET SessionState的支持，希望对大家有用。

相关文章：

1. 使用微软分布式缓存服务Velocity Part 1

Velocity是微软推出的分布式缓存解决方案，为开发可扩展性，可用的，高性能的应用程提供支持，可以缓存各种类型的数据，如CLR对象、XML、二进制数据等，并且支持集群模式的缓存服务器。Velocity也将集成在.NET Framework 4.0中，本文将介绍Velocity的一些预备知识、安装配置以及开发一个简单的示例。

简介

既然是分布式的缓存平台，客户端应用程序能够与缓存服务器集群中的任何一台服务器通信，并且执行缓存操作，如新增缓存项，移除缓存项等。在Velocity中，提供了一套统一的API，开发者可以使用任何一种.NET语言来访问这些API，如图1所示：

图 1

物理模型

在整个Velocity分布式缓存解决方案中，从物理模型上来看，主要涉及到如下几个元素：缓存宿主，缓存集群，Velocity提供的基于Windows PowerShell的管理工具，对于服务器集群配置的存储。缓存宿主是指一个或者多个以Windows服务形式运行的服务器，每台服务器都可以运行缓存宿主服务；缓存集群是一个或者多个缓存宿主实例的集合；当缓存集群启动时，它将从集群配置存储位置处来获取配置信息，Velocity提供了多种方式的集群配置信息存储，可以基于XML文件、SQL Server数据库或者SQL Server CE等；基于PowerShell的管理工具后面会详细讲到。 如图2所示：

图 2

逻辑模型

从逻辑模型上来看，在Velocity中主要有命名缓存，在命名缓存中我们还可以继续分区，命名缓存，可以理解为内存中的一个独立的存储结构单元，它们之间完全互相隔离，互不干扰，当有多个应用程序共享同一个缓存集群时，可以为每个应用程序分别建立命名缓存；在同一个命名缓存中，还可以对命名缓存进行分区，这样即可以解决数据冲突的问题，再配合Velocity中的“标签”功能，可以极大的提高检索效率。如图3所示：

图 3

安装

Velocity当前最新的版本是CTP 2，大家可以到微软官方站点下载，由于Velocity中提供了一套基于Windows PowerShell的管理工具，所以在安装之前需要首先安装Windows PowerShell。在安装过程中，其中有一步需要进行服务器集群的配置，如图4所示：

图 4

需要设置服务及集群端口号，集群配置的存储位置，集群配置存储的Provider，可以基于XML存储或者基于SQL Server CE存储等。另外可以访问如下站点获得一些资源：

团队博客：http://blogs.msdn.com/velocity/ 

示例代码：http://code.msdn.microsoft.com/velocity

安装完成后，请在Windows Service中启动Microsoft project code named "Velocity"服务。

管理工具

Velocity提供了基于Windows PowerShell的管理工具，对于Windows PowerShell不熟悉的可以参考《回归Dos操作的快感，进入PowerShell世界》这篇文章。使用Windows PowerShell可以非常方便的对Velocity缓存集群、缓存宿主等进行管理。使用如下命令金额图对启动、停止、重启服务器集群：

Start-CacheCluster 
Stop-CacheCluster 
Restart-CacheCluster 

使用如下命令可以启动、停止缓存宿主、获取命名缓存、获取缓存分区等：

Get-CacheHost 
Get-CacheConfig 
Set-CacheConfig 
Start-CacheHost 
Stop-CacheHost 
Get-CacheStatistics 
Get-Cache 
Get-CacheRegion 

如使用Get-CacheHost命令获取缓存宿主的信息，如图5所示，可以看到宿主对应的服务名以及服务状态等：

图 5

使用Get-Cache命名查看所有的命名缓存，如图6所示：

图 6

使用该管理工具还可以创建、移除命名缓存等，这里不再叙述。

简单示例

经过前面一大堆的理论介绍，现在来看一个最简单的示例。首先要把CacheBaseLibrary和ClientLibrary这两个程序集添加到应用程中，在Velocity安装目录下可以找到，并且引入命名空间：

using System.Data.Caching;

在使用Velocity缓存数据时，首先需要创建一个命名缓存，它可以通过CacheFactory来创建，如下代码所示：

private Cache GetCurrentCache()
{
    Cache dCache;
    ServerEndPoint[] servers = new ServerEndPoint[1];
    servers[0] = new ServerEndPoint("localhost", 22233, "DistributedCacheService");
    bool routingClient = true;
    bool localCache = false;
    var factory = new CacheFactory(servers, routingClient, localCache);
    dCache = factory.GetCache("default");

    return dCache;
}

此处首先指定了所有的服务器信息，当然这些都可以放在应用程序配置文件中，将会在下篇中介绍，有了Cache对象，其它的使用就非常方便了，如我们可以使用Add、Put、Remove、Get等方法来对缓存项进行操作，

添加缓存项：

Cache dCache = GetCurrentCache();

String key = keyTextbox.Text;
String val = valueTxtBox.Text;

if (key == "" || val == "") return;

dCache.Add(key, val);
statusLabel.Text =
    String.Format("Successfully added key {0} to cache.", key);

获取缓存项：

Cache dCache = GetCurrentCache();
String key = keyTextbox.Text;

if (key == "") return;

String val = dCache.Get(key).ToString();
valueTxtBox.Text = val;
statusLabel.Text =
    String.Format("Successfully did Get of key {0} from cache", key);

运行程序可以测试，数据被正确的缓存，如图7所示：

图 7

总结

本文简单介绍了微软的分布式缓存解决方案Velocity的一些概念以及开发了一个简单的示例，希望对大家有用。在下篇文章中，我们将会更深入学习缓存复杂数据类型以及Velocity的编程模型和配置模型。

相关文章：

1. 使用微软分布式缓存服务Velocity Part 2