Question

我有像这样的抽象基类：

public abstract class CacheValueProviderBase<T> where T : ICacheItem
    {

    protected ConcurrentDictionary<int,T> dataList = new ConcurrentDictionary<int, T>();
        public virtual void Add(T model){ // add code }
        public virtual bool Remove(int id){ //remove code }
        public abstract string getName();
        public abstract void UpdateForceFromDataBase();
        public abstract void UpdateForceFromCacheServer();
        public virtual bool allowForUpdater
        {
            get
            {
                return true;
            }
        }
        public virtual bool beforeUpdate()
        {
            return true;
        }
    }

我有多个从该抽象类派生的类。下面的Slider_CacheValueProvider类作为示例。

public class Slider_CacheValueProvider : CacheValueProviderBase<Cache_Home_Slider_Model>
    {
        public override string getName()
        {
            return "Slider_Cache";
        }

        public override void UpdateForceFromCacheServer()
        { // updating from cache server
        }

        public override void UpdateForceFromDataBase()
        { // updating from database
        }
    }

滑块缓存模型：

public class Cache_Home_Slider_Model : ICacheItemID
    {
        public int ID { get; set; }

        public string SlideImage { get; set; }

        public string Link { get; set; }
    }

所有缓存模型都依赖于ID属性，并仅出于简单的crup操作实现此接口：

public interface ICacheItemID
    {
        int ID { get; set; }
    }

信息：我的缓存机制有2个步骤。第一步是内部缓存。第二步是外部缓存服务器。

我有缓存更新程序。它会定期更新缓存，具体取决于抽象类的“ allowForUpdater”属性。首先，我发现了所有派生类：

public static List<Type> CacheTypeList()
        {
            var type = typeof(CacheValueProviderBase<>);
            return Assembly.GetExecutingAssembly().GetTypes().Where(i => !i.IsAbstract && !i.IsInterface &&
            i.BaseType != null && i.BaseType.IsGenericType && i.BaseType.GetGenericTypeDefinition() == type
            ).ToList();
        }

如此反复：

foreach (var item in CacheTypeList())
{
    var cache= getCache(item);
    if(cache.allowForUpdater && cache.beforeUpdate())
    {
        cache.UpdateForceFromCacheServer();
    }
}

还有getCache方法：

public static CacheValueProviderBase<ICacheItem> getCache(Type type)
{
    var val = storeList.Find(i => i.Key == type).Value;
    return (CacheValueProviderBase<ICacheItem>)val;
}

storeList是静态列表，并且在应用程序中包括全局的Slider_CacheValueProvider。

问题是getCache方法。当我尝试投射时，会收到异常。 '无法转换类型为...的对象。从ICacheItem的基本和滑块模型实现继承的Slider_CacheValueProvider。问题是什么？为什么我不能投射？

更新1：

使用'out'关键字抽象类，得到以下错误： '无效的方差修饰符。只能将接口和委托类型参数指定为变体'。

所以我用接口更改了抽象类。界面是：

public interface ICacheProvider<T> where T : ICacheItemID
    {
        DateTime LastModifiedTime { get; set; }

        void Add(T model);

        bool Remove(int id);

        bool Update(T model);

        T Where(Func<T, bool> expression);

        void Clear();

        int Count(int id);


        IEnumerable<T> GetList();

        void AddList(IEnumerable<T> model);

        void RemoveList(IEnumerable<int> model);

        void RemoveByFunc(Func<KeyValuePair<int, T>, bool> expression);

        IEnumerable<T> WhereList(Func<T, bool> expression);


        string getName();

        void UpdateForceFromDataBase(bool updateCache = true);

        void UpdateForceFromCacheServer();

        bool allowForUpdater { get; }

        bool beforeUpdate();
    }

当前的抽象类如下：

public abstract class CacheValueProviderBase<T> : ICacheProvider<T> where T : ICacheItemID

如果我将接口更改为“ out T”，则在Add，Update，AddList，RemoveByFunc上出错。错误是：

“无效的方差，类型参数'T'在ICacheProvider.Add（T）（或其他方法名称）上必须是反有效的。'T'是协变量。“

更新2：

我更改了代码。我为更新程序创建了新的界面，如下所示：

public interface ICacheUpdaterImplements
{
        string getName();

        void UpdateForceFromDataBase();

        void UpdateForceFromCacheServer();

        bool allowForUpdater();
}

我得到这样的界面：

public static ICacheUpdaterImplements getCacheUpdaterImplements(Type type)
        {
            return (ICacheUpdaterImplements)storeList.Single(i => i.Key == type).Value;
        }

并更改更新程序代码，如下所示：

foreach (var item in CacheTypeList())
{
    var updater= getCacheUpdaterImplements(item);
    if(updater.allowForUpdater())
    {
        updater.UpdateForceFromCacheServer();
    }
}

所以，我知道我的设计有误。我更改了代码并解决了问题。

Answer 1

到目前为止，给出的答案均不正确。正确的是，问题在于您的类型不是协变的，但在建议的解决方案中是错误的，这是非法的，无法编译。

您的示例非常复杂，因此让我们看一个简单的示例。如果您有：

class Animal {}
class Giraffe : Animal {}
class Tiger : Animal {}

然后此转换是合法的：

IEnumerable<Giraffe> giraffes = new List<Giraffe>() { new Giraffe() };
IEnumerable<Animal> animals = giraffes;

这是协变转换。协变转换是一种转换，其中转换的理由是“长颈鹿可转换为动物，因此长颈鹿序列可转换为动物序列”。也就是说，协变转换是现有转换证明更复杂的泛型转换的一种。

但是，这种转换是不合法的：

IList<Giraffe> giraffes = new List<Giraffe>() { new Giraffe() };
IList<Animal> animals = giraffes;

为什么不允许这种转换？因为它可以被滥用！我们现在可以说

animals.Add(new Tiger());

动物列表仍然是长颈鹿列表。您不能将老虎添加到长颈鹿列表中。您可以将老虎添加到动物列表中。因此，即使长颈鹿是动物的亚型，“长颈鹿的列表”也不是“动物列表”的子类型。 IEnumerable<T>允许协方差，因为无法将老虎插入到长颈鹿序列中。 IList<T>不允许使用协方差，因为有一种方法可以滥用协方差。

在以下情况下，C＃允许像您希望的那样进行协变转换：

协变量转换中涉及的通用类型参数-即<>中的内容---必须 all 是引用类型。即使List<int>可转换为IEnumerable<object>，也不能说将int转换为object。 int不是引用类型。
要转换为的“外部”泛型类型必须是接口或委托类型，而不是类或结构。
必须将接口或委托声明为支持协方差，并且编译器必须能够检查该声明是否有效并且从不会产生一种情况，您可以将老虎放入只能容纳长颈鹿的盒子。

我不知道如何立即重做复杂的逻辑以使其按您希望的方式工作。您可能想使用一种不太复杂的解决方案，该解决方案不需要太多依赖泛型。

Answer 2

尝试此实现，它应该可以为您提供所需的信息...由于您正在广泛使用泛型，因此这是要走的路-但是，如果您是我，我会再三考虑一下，因为我认为您将无法调用此方法（只能使用反射）

public ICacheProvider<T> getCache<T>() where T : ICacheItem
{
    var val = storeList.Single(i => i.Key == typeof(T)).Value;
    return (ICacheProvider<T>)val;
}

从泛型抽象类派生的类和转换错误？

2 个答案: