Warum würde sich dieser Code über die "Arity der generischen Typdefinition" beschweren?

Question

Ich habe einen generischen Typen bekommt:

class DictionaryComparer<TKey, TValue> : IEqualityComparer<IDictionary<TKey, TValue>> 

Und eine Factory-Methode, die eine Instanz dieser Klasse für einen bestimmten Wörterbuchtyp wird (soll) erstellen.

private static IEqualityComparer<T> CreateDictionaryComparer<T>() 
    { 
     Type def = typeof(DictionaryComparer<,>); 
     Debug.Assert(typeof(T).IsGenericType); 
     Debug.Assert(typeof(T).GetGenericArguments().Length == 2); 

     Type t = def.MakeGenericType(typeof(T).GetGenericArguments()); 

     return (IEqualityComparer<T>)Activator.CreateInstance(t); 
    } 

Entfernen Sie alle überflüssigen Sachen - auch dieser Code löst die gleiche Ausnahme aus. Behauptet

private static object CreateDictionaryComparer() 
{ 
    Type def = typeof(DictionaryComparer<,>); 

    Type t = def.MakeGenericType(new Type[] { typeof(String), typeof(object) }); 

    return Activator.CreateInstance(t); 
} 

Der passieren, damit ich weiß, dass T generisch ist und hat zwei generische Argumente. Die Linie mit MakeGenericType excepts jedoch mit:

Die Anzahl der generischen Argumente zur Verfügung gestellt nicht die arity der generischen Typdefinition entsprechen.

Parametername: Instanziierung

Ich habe diese Art der Sache in der Vergangenheit getan und für das Leben von mir kann nicht herausfinden, warum dies nicht in diesem Fall arbeiten. (plus ich musste Google arity).

Answer 1

es herausgefunden.

Ich hatte DictionaryComparer als innere Klasse deklariert. Ich kann nur annehmen, dass MakeGenericType ein Query<T>.DictionaryComparer<string,object> machen wollte und nicht T zur Verfügung gestellt.

Andernfalls Code

class Program 
{ 
    static void Main(string[] args) 
    { 
     var q = new Query<int>(); 
     q.CreateError(); 
    } 
} 

public class Query<TSource> 
{ 
    public Query() 
    {  
    } 

    public object CreateError() 
    { 
     Type def = typeof(DictionaryComparer<,>); 

     Type t = def.MakeGenericType(new Type[] { typeof(String), typeof(object) }); 

     return Activator.CreateInstance(t); 
    } 

    class DictionaryComparer<TKey, TValue> : IEqualityComparer<IDictionary<TKey, TValue>> 
    { 
     public DictionaryComparer() 
     { 
     } 

     public bool Equals(IDictionary<TKey, TValue> x, IDictionary<TKey, TValue> y) 
     { 
      if (x.Count != y.Count) 
       return false; 

      return GetHashCode(x) == GetHashCode(y); 
     } 

     public int GetHashCode(IDictionary<TKey, TValue> obj) 
     { 
      int hash = 0; 
      unchecked 
      { 
       foreach (KeyValuePair<TKey, TValue> pair in obj) 
       { 
        int key = pair.Key.GetHashCode(); 
        int value = pair.Value != null ? pair.Value.GetHashCode() : 0; 
        hash ^= key^value; 
       } 
      } 
      return hash; 
     } 
    } 
} 

Answer 2

CLR erstellt eine interne Datenstruktur für jeden Typ in Verwendung durch eine application.These Datenstrukturen werden Typobjekte genannt. Ein Typ mit generischen Typ Parameter ist ein offener Typ und der CLR nicht zulässt, dass jede Instanz eines offenen Typ genannt (ähnlich wie die CLR verhindert, dass eine Instanz eines Schnittstellentyp aus aufgebaut wird) konstruiert werden.

Ändern Typ t = def.MakeGenericType (neuer Typ [] {typeof (String), typeof (Objekt)});
auf der
Type t = def.MakeGenericType (new Type [] {typeof (TSource), typeof (String), typeof (Objekt)});