C# 将静态类重构为多个实现

我正在使用缓存项，如所述

但是，我需要开发这个类的许多实现，它们在DataContext项中使用不同的表

这个类是一个静态类，所以我需要将其更改为单例，然后从定义了GetItem和AddOrGetExisting方法的抽象继承。或者创建两个单独的类并使用反射返回正确的实例

解决这个问题的最好办法是什么

实施1

public static class Consent1Cache
{
    private static MemoryCache _cache = new MemoryCache("ConsentType1Cache");

    public static object GetItem(string key)
    {
        return AddOrGetExisting(key, () => InitItem(key));
    }

    private static T AddOrGetExisting<T>(string key, Func<T> valueFactory)
    {
        var newValue = new Lazy<T>(valueFactory);
        var oldValue = _cache.AddOrGetExisting(key, newValue, new CacheItemPolicy()) as Lazy<T>;
        try
        {
            return (oldValue ?? newValue).Value;
        }
        catch
        {
            // Handle cached lazy exception by evicting from cache.
            _cache.Remove(key);
            throw;
        }
    }

    public static string InitItem(string consentNumber)
    {
        using (DLL.ConsentDataContext db = new DLL.ConsentDataContext())
        {
            return db.vw_ConsentType1.Where(x => x.ConsentNumber == consentNumber).Select(c => c.ConsentNumber + " - " + c.Proposal).FirstOrDefault();
        };
    }
}

公共静态类缓存
{
私有静态MemoryCache_cache=新的MemoryCache（“同意类型1Cache”）；
公共静态对象GetItem（字符串键）
{
返回AddOrGetExisting（key，（）=>InitItem（key））；
}
私有静态T AddOrGetExisting（字符串键，Func valueFactory）
{
var newValue=new Lazy（valueFactory）；
var oldValue=_cache.AddOrGetExisting（key，newValue，new CacheItemPolicy（））为惰性；
尝试
{
返回值（旧值？？新值）；
}
抓住
{
//通过从缓存中逐出来处理缓存的惰性异常。
_缓存。删除（键）；
投掷；
}
}
公共静态字符串InitItem（字符串编号）
{
使用（DLL.approvedatacontext db=new DLL.approvedatacontext（））
{
返回db.vw_approvementype1.Where（x=>x.approvementNumber==approvementNumber）。选择（c=>c.approvementNumber+“-”+c.Proposal）。FirstOrDefault（）；
};
}
}

实施2

public static class Consent2Cache
{
    private static MemoryCache _cache = new MemoryCache("ConsentType2Cache");

    public static object GetItem(string key)
    {
        return AddOrGetExisting(key, () => InitItem(key));
    }

    private static T AddOrGetExisting<T>(string key, Func<T> valueFactory)
    {
        var newValue = new Lazy<T>(valueFactory);
        var oldValue = _cache.AddOrGetExisting(key, newValue, new CacheItemPolicy()) as Lazy<T>;
        try
        {
            return (oldValue ?? newValue).Value;
        }
        catch
        {
            // Handle cached lazy exception by evicting from cache.
            _cache.Remove(key);
            throw;
        }
    }

    public static string InitItem(string consentNumber)
    {
        using (DLL.ConsentDataContext db = new DLL.ConsentDataContext())
        {
            return db.vw_ConsentType2.Where(x => x.ConsentNumber == consentNumber).Select(c => c.ConsentNumber + " - " + c.Proposal).FirstOrDefault();
        };
    }
}

公共静态类缓存
{
私有静态MemoryCache_cache=新的MemoryCache（“同意类型2Cache”）；
公共静态对象GetItem（字符串键）
{
返回AddOrGetExisting（key，（）=>InitItem（key））；
}
私有静态T AddOrGetExisting（字符串键，Func valueFactory）
{
var newValue=new Lazy（valueFactory）；
var oldValue=_cache.AddOrGetExisting（key，newValue，new CacheItemPolicy（））为惰性；
尝试
{
返回值（旧值？？新值）；
}
抓住
{
//通过从缓存中逐出来处理缓存的惰性异常。
_缓存。删除（键）；
投掷；
}
}
公共静态字符串InitItem（字符串编号）
{
使用（DLL.approvedatacontext db=new DLL.approvedatacontext（））
{
返回db.vw_approvementype2.Where（x=>x.approvementNumber==approvementNumber）。选择（c=>c.approvementNumber+“-”+c.Proposal）。FirstOrDefault（）；
};
}
}

你也不应该这样做。实现这一点的现代方法是使用依赖项注入，并使其成为一个合适的接口。如果DI真的不是这样，但你可以实现一个服务定位器模式，我通常会发现它更容易让人们理解，实现起来也更快。请注意，服务定位器被认为是一个有点反模式的东西，如果你缓存结果，它会让你非常痛苦…@BradleyDotNET是的，我说DI首先不需要恐慌。但是我必须在这里为SL辩护，因为我已经提到它的实现要简单得多，而且根据经验，人们更容易理解它。如果他不是在开发一个有多个开发者和许多单元测试的大型应用程序，我真的不认为SL有什么不好的地方；没有什么对你不利的（我自己也在小项目上使用SL）。我最近遇到了一个问题，在使用SignalR的SL时，注册顺序很重要，因为注册对象的构造函数在构造函数中查找其他依赖项并缓存答案；导致未来注册无效。非常有趣的bug。@FilipCordas感谢我在这里如何使用DI，比如如何在InitItem中插入用于查询的表？将其从静态更改为线程安全吗？我知道一点知识是危险的：）