在通用方法中获得更复杂类型的适当类型推断

Question

我正在.NET 2.0框架中工作。我有一些代码工作，只是希望它更加优雅一点。

我有一个需要有效地“镜子” Dictionary对象，例如，如果我们有这样的

Dictionary<TKey,TValue> StartDictionary; 

的对象开始，我们可以镜像像这样

Dictionary<TValue,TKey> MirroredDictionary = MirrorDictionary(StartDictionary); 

，我们将结束在每个KeyValuePair上都要交换一个新的字典，每个KeyValuePair都被交换。在任何人问我为什么之前，源字典相当大并且从re加载一次当我的程序加载时，flection调用。我不想再次运行相同的反射调用来加载镜像字典。创建一个镜像字典并按照我提出的方式填充它的值和密钥在我看来似乎成本更低。

因此，作为一种讨厌重写事物的人，我决定在助手类中编写泛型方法，我必须使用泛型来完成镜像。

现在想起你，我以前也写过简单的通用方法一般标量类型

这就是我想出了

public static TOutDic MirrorDictionary<TInDic, TOutDic>(TInDic InDictionary) 
    where TInDic : IDictionary 
    where TOutDic : IDictionary 
{ 
    Type[] KVPTypes = typeof(TInDic).GetGenericArguments(); 
    Type TKey = KVPTypes[0]; 
    Type TValue = KVPTypes[1]; 
    Type TDic = typeof(Dictionary<,>).MakeGenericType(TValue, TKey); 
    IDictionary OutDic = (IDictionary)Activator.CreateInstance(TDic); 
    foreach (DictionaryEntry DE in (IDictionary)InDictionary) OutDic.Add(DE.Value, DE.Key); 
    return (TOutDic)OutDic; 
} 

一点点的存在，但它的工作原理，加载了的类型键和值并创建镜像字典的实例

然后只循环遍历InDictionary的基本DictionaryEntries，它将项目添加到OutDic并返回它将其转换为预期的类型

编译就好现在

当我去调用它，我会在我所说的通用方法，我可以只使用我们的代码标量型觉得就像snippits上面说

Dictionary<TValue,TKey> MirroredDictionary = MirrorDictionary(StartDictionary); 

但是，不编译给我

方法MirrorDictionary（TInDic）'的类型参数不能从用法推断。尝试明确指定类型参数。

所以，如果我把它而不是像这样

 Dictionary<TValue, TKey> MirrorDic = MirrorDictionary<Dictionary<Tkey, TValue>, Dictionary<TValue,TKey>>(StringDic); 

它编译和作品就像一个魅力。

现在的问题变成如何正确地推断传入此方法的类型时传入的类型和传出的类型是复杂的类型，如在此示例中？

Answer 1

您可以让生活更轻松编译器通过告诉它的键和值类型如下：

public static Dictionary<TValue, TKey> MirrorDictionary<TKey, TValue> 
    (Dictionary<TKey, TValue> source) 
{ 
    Dictionary<TValue, TKey> destination = new Dictionary<TValue, TKey>(); 

    foreach (KeyValuePair<TKey, TValue> kvp in source) 
    { 
     destination.Add(kvp.Value, kvp.Key); 
    } 

    return destination; 
} 

我不认为你需要在这里反思。

使用范例：

static void Main(string[] args) 
{ 
    Dictionary<int, string> source = new Dictionary<int, string>(); 
    source.Add(3, "foo"); 
    source.Add(4, "bar"); 

    DumpDic(source); 

    DumpDic(MirrorDictionary(source)); 

    Console.ReadLine(); 

} 

其中DumpDic是：

public static void DumpDic<TK, TV>(Dictionary<TK, TV> dic) 
{ 
    foreach (KeyValuePair<TK, TV> keyValuePair in dic) 
    { 
     Console.WriteLine("{0} => {1}", keyValuePair.Key, keyValuePair.Value); 
    } 
} 

Answer 2

您可以将Out字典定义为out参数。类型推断不会查看您要分配的变量的类型，而仅仅是参数的类型。这就是不能编译的原因。

Answer 3

你需要告诉它TValue和TKey是什么。除非它们在调用此代码的方法的签名中定义，否则它们没有任何特定的类型。你需要给它的东西，如：

Dictionary<string, int> MirroredDictionary = MirrorDictionary(StartDictionary); 

Answer 4

这里有一个3.5的解决方案

IDictionary<TValue, TKey> MirrorDictionary<TKey, TValue>(IDictionary<TKey, TValue> dict) 
{ 
    return dict.ToDictionary(kvp => kvp.Value, kvp => kvp.Key); 
} 

和纯2.0解决方案（你也可以在2.0与VS2008和LinqBridge使用它）

IDictionary<TValue, TKey> MirrorDictionary<TKey, TValue>(IDictionary<TKey, TValue> dict) 
{ 
    Dictionary<TValue, TKey> newDict = new Dictionary<TValue, TKey>(); 
    foreach(KeyValuePair<TKey, TValue> kvp in dict) 
    { 
     newDict.Add(kvp.Value, kvp.Key); 
    } 
    return newDict; 
} 

类型推断应该对两种解决方案都适用（因为它们具有相同的签名）