无缝缓存读取简化：仅Lambda表达式传递委托

以前写了一篇：无缝的缓存读取:双存储缓存购物网站排名策略，其中使用了两个存储地址交替提供缓存数据。

在其中用了两个存储指针转换以达到无缝读取缓存，在Cat Chen一语提醒以后，想了一想：的确是没有必要在缓存中使用两个存储指针的，其实一个存储地址，只要保证写入时在其它线程就能够。

更改存储介质至如下两个属性：

namespace CHCache {
    /// <summary>     /// 缓存介质     /// </summary>     public class Medium {
        /// <summary>         /// 存储区         /// </summary>         public object Store { get; set; }
        /// <summary>         /// 是否正在更新         /// </summary>         public bool IsUpdating { get; set; }
    }
}

这里存储区用于存储要缓存的实体内容，而IsUpdating则标识其是否正在更新。

对于缓存类，则更改了写入和读取方式。

/* * http://www.cnblogs.com/chsword/ * chsword * Date: 2009-3-31 * Time: 17:00 * */ using System;using System.Collections;using System.Collections.Generic;using System.Threading;namespace CHCache {
    /// <summary>     /// 双存储的类     /// </summary>     public class DictionaryCache : IEnumerable {
        /// <summary>         /// 在此缓存构造时初始化字典对象         /// </summary>         public DictionaryCache() {
            Store = new Dictionary<string, Medium>();
        }
        public void Add(string key, Func<object> func) {
            if (Store.ContainsKey(key)) {//修改，若是已经存在，再次添加时则采用其它线程                 var elem = Store[key];
                if (elem.IsUpdating) return;  //正在写入未命中                 var th = new ThreadHelper(elem, func);
                var td = new Thread(th.Doit);
                td.Start();
            }
            else {//首次添加时可能也要读取，因此要本线程执行                 Console.WriteLine("Begin first write");
                Store.Add(key, new Medium { Store = func() });
                Console.WriteLine("End first write");
            }

        }
        /// <summary>         /// 读取时所用的索引         /// </summary>         /// <param name="key"></param>         /// <returns></returns>         public object this[string key] {
            get {
                if (!Store.ContainsKey(key)) return null;
                var elem = Store[key];
                return elem.Store;
            }
        }
        Dictionary<string, Medium> Store { get; set; }
        public IEnumerator GetEnumerator() {
            return ((IEnumerable)Store).GetEnumerator();
        }
    }
}

这里在添加时只控制了首次写入缓存在主线程，而读取时则直接读取缓存内容。

而线程辅助类也进行了简化，仅将其执行并写入就行了，抛出线程彻底由DictionaryCache控制。

using System;namespace CHCache {
    /// <summary>     /// 一个线程Helper，用于帮助多抛出线程时传递参数     /// </summary>     public class ThreadHelper {
        Func<object> Fun { get; set; }
        Medium Medium { get; set; }
        /// <summary>         /// 经过构造函数来传递参数         /// </summary>         /// <param name="m"></param>         /// <param name="fun"></param>         public ThreadHelper(Medium m, Func<object> fun) {
            Medium = m;
            Fun = fun;
        }
        /// <summary>         /// 线程入口，ThreadStart委托所对应的方法         /// </summary>         public void Doit() {
            Medium.IsUpdating = true;
            Console.WriteLine("Begin write.");
            var ret = Fun.Invoke();
            Medium.Store = ret;
            Console.WriteLine("End write.");
            Medium.IsUpdating = false;
        }
    }
}

其实有的时候思考问题仍是不禁自主的向着本身的经验方向刻意安排，这样一般把问题搞复杂了。

还好有园子里的朋友帮助，才简单的解决了购物网站大全问题，这样的由简至繁，再由繁衍至简的过程其实在实际开发中发生的还真很多。