如何声明泛型类型的类型参数本身是通用的？

Question

Let's say that I want to implemented an expiring cache, and I want to make it generic on the underlying storage container. So I'll allow the user to tell my class which container type to use. But since I'll be filling it with a private type, I need them to tell me a generic type. So I'm trying to do something like this:

class MyCache<K, V, Container> : IDictionary<K, V>
    where Container : // what goes here?
{
    private class MyValue
    {
        public readonly V Value;
        public readonly DateTime InsertionTime;
    }

    private IDictionary<K, MyValue> m_dict = new Container<K, MyValue>(); // a specialization of the generic container

    // implement IDictionary<K, V>, checking for value expiration
    public bool TryGetValue(K key, out V val)
    {
        MyValue myval;
        if (m_dict.TryGetValue(key, out myval))
        {
            if (Expired(myval.InsertionTime))
            {
                m_dict.Remove(key);
            }
            else
            {
                val = myval.Value;
                return true;
            }
        }

        // not there or expired
        val = default(V);
        return false;
    }
}

So Container needs to be a generic type since I want to specialize it on a private type. I imagine using it like this:

var cache = new MyCache<String, String, Dictionary>();

Which would cause the implementation to use Dictionary.

Is this possible? What is the syntax for it? If it's not possible, what is the best alternative to get type safety on the containers and this level of composability?

Answer 1

This won't work, because the caller cannot create a Dictionary<K, MyValue> — MyValue is private .

But it can be done if you make MyValue public :

public class MyValue<V>
{
    public readonly V Value;
    public readonly DateTime InsertionTime;
}

You want the Container to be a IDictionary<K, MyValue<V>> and want to be able to create new Container instances. So you need the following constraints in the Container type parameter:

class MyCache<K, V, Container> : IDictionary<K, V>
    where Container : IDictionary<K, MyValue<V>>, new()
{
    private IDictionary<K, MyValue<V>> m_dict = new Container();
}

Note that the IDictionary<K, V> interface does not provide a TryGetValue Method.

Example usage:

var cache = new MyCache<string, int, Dictionary<string, MyValue<int>>>();

Answer 2

No, C# generics don't work like that. It sounds like you want something along the lines of higher order types, and C# generics just don't work that way.

EDIT: Aargh, I've just noticed what you're doing with the type arguments.

No, basically that won't work at all - you should rethink your design. You could do it with reflection, but it would be better not to. It's going to get pretty nasty.

EDIT: On reflection, you could do this by passing in a factory which then has a generic method:

public interface IDictionaryFactory
{
    IDictionary<TKey, TValue> CreateDictionary<TKey, TValue>();
}

Then your code would be:

class MyCache<K, V> : IDictionary<K, V>
{
    private class MyValue
    {
        public readonly V Value;
        public readonly DateTime InsertionTime;
    }

    private IDictionary<K, MyValue> m_dict;

    public MyCache(IDictionaryFactory dictionaryFactory)
    {
        m_dict = dictionaryFactory.CreateDictionary<K, MyValue>();
    }

    ...
}

(You could remember the factory if you needed to be able to recreate the container, of course.)

Your callers would then have to implement IDictionaryFactory - you could easily provide some simple implementations of course. This is the sort of thing which is normally made simpler with delegates, but while delegate types can be generic, the signature of the Invoke method within a delegate can't be - and that's what you want here.