如何实现泛型方法？

Question

I have such class (some kind of factory)

   class CacheFactory
    {
        private ConfigCache m_ConfigCache = null;

        public CacheFactory(ConfigCache configCache)
        {
            m_ConfigCache = configCache;
        }

        public CACHE_TYPE GetCache<CACHE_TYPE>()
            where CACHE_TYPE : BaseCache
        {
            BaseCache result = new NOT_DEFINED_CACHE();

            .....

            return result;    <---- This line
        }
    }

And in this class I have GetCache() method, that has return type of <CACHE_TYPE> where CACHE_TYPE: BaseCache

Then in body of this method I create BaseCache instance and try to return him , but here I have an warning in line that I marked above

Cannot implicitly convert BaseCache to CACHE_TYPE...

How is it possible if CACHE_TYPE inherent from BaseCache ??

And hot to solve this issue in right way?

EDIT

Ok, if I need to return derived type I have one more class ConfigCache that inherit from BaseCache , but anyway I get the same error, that ConfigCache cannot be converter to CACHE_TYPE ... Inspite this class is derived ...

EDIT2

Thanks for everyone. There is what I have now, what do you think about it?

        private CACHE_TYPE GetCache<CACHE_TYPE>()
            where CACHE_TYPE : BaseCache, new()
        {
            var result = new CACHE_TYPE();

            if (typeof(CACHE_TYPE) == typeof(ConfigCache))
            {
                if (m_ConfigCache == null)
                {
                    m_ConfigCache = new ConfigCache();
                }

                result = m_ConfigCache as CACHE_TYPE;
            }

            return result;
        }

Answer 1

You cannot. The error message is right.

You promised to return a derived type and yet you return a base type, knowing that it will be right, because that is what you instantiated. That is not how a compiler works. result needs to be of type CACHE_TYPE .

Answer 2

I don't understand why this is necessary at all. Can you describe why this factory is needed and how it will be used? The approach itself is not very true for the factory. But for what you described, the following may come up:

class CacheFactory<TConfigCache> 
    where TConfigCache: class, BaseCache, new()
{
    public CacheFactory(TConfigCache configCache)
    {
        ConfigCache = configCache;
    }

    private TConfigCache ConfigCache { get; set; }

    public TCache GetCache<TCache>()
        where TCache: class, BaseCache, new()
    {
        if (typeof(TConfigCache) == typeof(TCache))
        {
            if (ConfigCache == null)
            {
                ConfigCache = new TConfigCache();
            }
            return ConfigCache as TCache;
        }

        return new TCache();
    }
}

Be sure to add class in the generic requirements.

EDIT

Or you can use not generic implementation.

class CacheFactory{
    public CacheFactory(ConfigCache configCache)
    {
        ConfigCache = configCache;
    }

    private ConfigCache ConfigCache { get; set; }

    public TCache GetCache<TCache>()
        where TCache: class, BaseCache, new()
    {
        if (typeof(ConfigCache) == typeof(TCache))
        {
            if (ConfigCache == null)
            {
                ConfigCache = new ConfigCache();
            }
            return ConfigCache as TCache;
        }

        return new TCache();
    }
}

EDIT 2

Its full code of my test application and its work. Maybe it will help.

interface BaseCache { }

class ConfigCache : BaseCache { }

class MyCache : BaseCache { }

class CacheFactory{
    public CacheFactory(ConfigCache configCache)
    {
        ConfigCache = configCache;
    }

    private ConfigCache ConfigCache { get; set; }

    public TCache GetCache<TCache>()
        where TCache: class, BaseCache, new()
    {
        if (typeof(ConfigCache) == typeof(TCache))
        {
            if (ConfigCache == null)
            {
                ConfigCache = new ConfigCache();
            }
            return ConfigCache as TCache;
        }

        return new TCache();
    }
}


class Program
{
    static void Main(string[] args)
    {
        var configCache = new ConfigCache();
        var factory = new CacheFactory(configCache);
        var cache1 = factory.GetCache<ConfigCache>();
        var cache2 = factory.GetCache<MyCache>();

        Print(configCache);
        Print(cache1);
        Print(cache2);
        Console.ReadKey();
    }

    static void Print(BaseCache cache)
    {
        Console.WriteLine("BaseCache: {0}, {1}", cache.GetType().FullName, cache.GetHashCode());
    }
}

Answer 3

Your return type is the derived class, but you've attempted to return a base class. This isn't allowed . If your derived class has a parameterless constructor you can add a new() constraint and do the following.

private T GetCache<T>()
    where T : BaseCache, new()
{
    var result = new T();

    return result;
}

Your edit suggests you are trying to return a member variable. I would suggest making different methods to return different variables.

private ConfigCache GetConfigCache()
{
    if (m_ConfigCache == null)
        m_ConfigCache = new ConfigCache();

    return m_ConfigCache;
}

Or even just a property.

private ConfigCache _config;

private ConfigCache Config
{
    get
    {
        if (_config == null)
            _config = new ConfigCache();

        return _config;
    }
}

Finally, I would advise against it, but if you do want to continue down your path, something like the following would work.

private T GetCache<T>()
    where T : BaseCache
{
    if (typeof(T) == typeof(ConfigCache))
    {
         if (m_ConfigCache == null)
             m_ConfigCache = new ConfigCache();

        return (T)(object)m_ConfigCache;
    }

    // Support for other types of caches.
}

Answer 4

Imagine you could do this, see what happens here:

class BaseCache {}
class NOT_DEFINED_CACHE : BaseCache {}
class OTHER_CACHE : BaseCache {}

var factory = new CacheFactory();
OTHER_CACHE cache = factory.GetCache<OTHER_CACHE>(); // Oh dear, I wanted OTHER_CACHE but got NOT_DEFINED_CACHE!

The fact is that you're trying to create a generic method that's doing something very specific ie creating a NOT_DEFINED_CACHE instance.

What you could do is create an instance of NOT_DEFINED_CACHE with the properties defined in BaseClass set:

class BaseCache
{
    int X { get; set; }
    int Y { get; set; }
    int Z { get; set; }
}
class NOT_DEFINED_CACHE : BaseCache {}

public CACHE_TYPE GetCache<CACHE_TYPE>() where CACHE_TYPE : BaseCache, new()
{
    CACHE_TYPE result = new CACHE_TYPE();
    result.X = 1:
    result.Y = 2:
    result.Z = 3:
    return result;
}