Jak warunkowo wywołać ogólną metodę z ograniczeniami?

Question

Załóżmy, że mam nieograniczoną ogólną metodę, która działa na wszystkich typach wspierających równość. Wykonuje parami kontroli równości a więc pracuje w O (n):

public static int CountDuplicates<T>(IList<T> list) 
{ 
    /* ... */ 
} 

również mieć ograniczony sposób ogólny, który pracuje tylko z rodzaju wsparcie sortowania. Zaczyna się od sortowania listy w O (n log n), a następnie zlicza wszystkie duplikaty w jednym przebiegu:

public static int CountDuplicatesFast<T>(IList<T> list) 
    where T : IComparable<T> 
{ 
    /* ... */ 
} 

Tak, dzwoniący może wybrać, aby wywołać szybką metodę, jeśli jest on statycznie wiadomo, że typ elementów listy obsługuje zamawianie. Może się zdarzyć, że wywołujący działa z generycznym IList<T>, gdzie T jest nieograniczony, więc jest jedyną opcją wywołania pierwszej (powolnej) metody.

Teraz chcę pierwsza metoda, by sprawdzić w czasie wykonywania, jeśli typ T faktycznie implementuje interfejs IComparable<T> a jeśli tak, to wywołać szybką metodę:

public static int CountDuplicates<T>(IList<T> list) 
{ 
    if (typeof(IComparable<T>).IsAssignableFrom(typeof(T))) 
    { 
     return CountDuplicatesFast(list); 
    } 
    else 
    { 
     /* use the slow algorithm */ 
    } 
} 

Problemem jest kompilator odrzuca wezwanie CountDuplicatesFast(list):

błąd CS0314: typu „T” nie może być stosowana jako parametr typu „T” w ogólnym typie lub metodą „Program.CountDuplicatesFast <T> (System.Collections.Generic.IList <T>) ". Nie ma konwersji boksu lub konwersji parametrów z "T" na "System.IComparable <T>".

Czy można przekonać kompilator, aby zaufał mi, że wiem, co robię, i pominąć kontrolę ograniczenia?

Answer 1

Oto sposób to zrobić przy użyciu dynamic:

if (typeof(IComparable<T>).IsAssignableFrom(typeof(T))) 
{ 
    return CountDuplicatesFast((dynamic)list); 
} 

Albo z refleksji:

if (typeof(IComparable<T>).IsAssignableFrom(typeof(T))) 
{ 
    var method = typeof(MyType).GetMethod("CountDuplicatesFast"); 
    var generic = method.MakeGenericMethod(typeof(T)); 
    return (int)generic.Invoke(null, new object[] { list }); 
} 

Nie sądzę, że istnieje sposób, aby to zrobić statycznie (czyli bez odbicia lub dynamic).

Answer 2

Można użyć klasy pomocnika i dynamic typ pominąć kontrole kompilacji:

sealed class CountDuplicatesFastCaller 
{ 
    public int Call<T>(IList<T> list) where T : IComparable<T> 
    { 
     return CountDuplicatesFast(list); 
    } 
} 

public static int CountDuplicates<T>(IList<T> list) 
{ 
    if (typeof (IComparable<T>).IsAssignableFrom(typeof (T))) 
    { 
     return ((dynamic) new CountDuplicatesFastCaller()).Call(list); 
    } 
    else 
    { 
     /* use the slow algorithm */ 
    } 
} 

To powinno być szybsze niż czystej refleksji ponieważ mechanizmów buforowania DLR.