有没有办法确定泛型类型是否是从特定的泛型类型定义构建的？

Question

我有一个通用方法：

Func<IEnumerable<T>, bool> CreateFunction<T>()

其中T 可以是任意数量的不同类型。这个方法使用反射做了很多事情，如果T是IDictionary，不管字典的TKey和TValue我需要执行字典特定的代码。

所以可以调用该方法：

var f = CreateFunction<string>();
var f0 = CreateFunction<SomePocoType>();
var f1 = CreateFunction<IDictionary<string,object>>();
var f2 = CreateFunction<Dictionary<string,object>>();
var f3 = CreateFunction<SomeDerivedDictionaryType<string,object>>();

等等

根据@Andy 的回答进行澄清

最终我想知道T 是否继承/实现IDictionary，即使T 本身是Dictionary 或派生自该接口的其他类型。

if(typeof(T) == typeof(IDictionary<,>)

不起作用，因为 T 是泛型类型而不是泛型类型定义。

在不知道 TKey 和 TValue（在编译时不知道）的情况下，我无法与运行时之前知道的任何具体类型进行比较。

我想出的唯一方法是查看类型的名称或使用反射检查其方法，寻找能让我相信它是字典的方法（即寻找 ContainsKey 和 get_Item )。

有没有直接的方法来做出这种决定？

Answer 1

您可以使用IsGenericType 和GetGenericTypeDefinition 成员来避免使用丑陋且有潜在风险的类型名称字符串检查，如下所示：

var type = typeof (T);
if (typeof (IDictionary).IsAssignableFrom(type))
{
    //non-generic dictionary
}
else if (type.IsGenericType &&
         type.GetGenericTypeDefinition() == typeof (IDictionary<,>))
{
    //generic dictionary interface
}
else if (type.GetInterfaces().Any(
            i => i.IsGenericType &&
                 i.GetGenericTypeDefinition() == typeof (IDictionary<,>)))
{
    //implements generic dictionary
}

Answer 2

简单的方法就是这样：

Type iDict = null;
if (typeof(T).GetGenericTypeDefinition() == typeof(IDictionary<,>))
    iDict = typeof(T);
else
    iDict = typeof(T).GetInterface(typeof(IDictionary<,>).Name);
if (iDict != null)
{
    var genericParams = iDict.GetGenericArguments();
    Type tKey = genericParams[0], tValue = genericParams[1];
}

请注意，如果T 实现了多个 IDictionary<,> 接口，这将不起作用（抛出异常），但这可能适合您的目的。

为了完整起见，下面是一个实现，将使用第一个接口处理具有多个 IDictionary<,> 接口的类型：

Type iDict = t.GetType().GetInterfaces()
              .Where(t => t.IsGenericType
               && t.GetGenericTypeDefinition() == typeof(IDictionary<,>))
              .FirstOrDefault();
if (iDict != null)
{
    var genericParams = iDict.GetGenericArguments();
    Type tKey = genericParams[0], tValue = genericParams[1];
}

请注意，在第二个例程中t 是一个对象，而T 在第一个例程中是一个类型。

Answer 3

你可以做类似的事情

class Program
{
    static void Main(string[] args)
    {
        Example<IDictionary<int, string>>.IsDictionary();

        Example<SortedDictionary<int, string>>.IsDictionary();

        Example<Dictionary<int, string>>.IsDictionary();

        Console.ReadKey();
    }
}

public class Example<T>
{
    public static void IsDictionary()
    {
        if (typeof(T).GetInterface(typeof(IDictionary<,>).Name) != null || typeof(T).Name.Contains("IDictionary"))
        {
            Console.WriteLine("Is IDictionary");
        }
        else
        {
            Console.WriteLine("Not IDictionary");
        }
    }
}

Answer 4

我认为如果你调用 Type.GetGenericTypeDefinition() 应该返回用于构造具体类型的“基本”泛型类型。

请注意，仅将其与IDictionary<,> 进行比较可能还不够，因为如果有人传入Dictionary<,> 的实例，我假设您也想使用它。您可以检查该类型是否实现了IDictionary<,>，或者您可以调用Type.IsAssignableFrom()，尽管根据文档我不确定这对泛型类型的效果如何。