如何实现一个线程安全的单例字典类进行缓存？

Question

我试图实现一个线程安全字典单例类用于缓存目的。

namespace SingletomDict
{
public sealed class MySingleton:IDisposable
{
    private static readonly Lazy<MySingleton> coll = new Lazy<MySingleton>(() => new MySingleton());

    private static Dictionary<string, object> mycoll;

    public static MySingleton Instance 
    {
        get
        {
            return coll.Value;
        }
    }

    private MySingleton()
    {
        mycoll = new Dictionary<string, object>();
    }

    private void SetProperty<T>(string name, T value)
    {
        mycoll.Add(name, value);
    }

    private object GetProperty(string name)
    {
        object value = mycoll[name];
        return value;
    }

    public dynamic this[string index]
    {
        get { return GetProperty(index); }
        set { SetProperty(index, value); }
    }
    public void ReSet()
    {
        mycoll = new Dictionary<string, object>();
    }
}

在main方法中，我将调用该对象作为

  MySingleton.Instance["LS"] = "AAA";

  MySingleton.Instance["AB"] = "BBB";

  MySingleton.Instance.ReSet();

我做了一些研究以找到正确的实现。但我找不到合适的例子。谢谢

Answer 1

首先声明一个描述如何使用它的接口。也许ICache有一个get和set方法。 （我避开了dynamic。）

public interface ICache
{
    T Get<T>(string key);
    void Set(string key, object value);
}

然后编写一个实现。您的实现不需要指定内部是什么。

public class Cache : ICache
{
    private readonly ConcurrentDictionary<string, object> _cache 
        = new ConcurrentDictionary<string, object>();
    public T Get<T>(string key)
    {
        object cached;
        if(_cache.TryGetValue(key, out cached) && cached is T)
        {
            return(T) cached;
        }
        return default(T);
    }

    public void Set(string key, object value)
    {
        _cache.AddOrUpdate(key, value, (s, o) => value);
    }
}

如果要使其成为单例，可以将构造函数设为私有并创建静态单例实例。我倾向于不这样做。对于其他类来说，依赖于ICache接口比在实现上更好，并且接口没有静态方法。

取决于接口意味着您可以用不同的实现替换它，例如依赖于MemoryCache的实现。

public class InMemoryCache : ICache
{
    private readonly MemoryCache _cache = MemoryCache.Default;

    public T Get<T>(string key)
    {
        var cached = _cache[key];
        return cached is T ? (T) cached : default(T);
    }

    public void Set(string key, object value)
    {
        _cache[key] = value;
    }
}

如果您使用依赖注入（IoC）容器，您可以告诉它哪个ICache实现用于需要它的实例的类，并且您可以指定每次都应该提供相同的实例。这样你就可以使用你的类的单个实例，就好像它是一个单例而不必将它编码为单例。