errore di sovraccarico C# per tipo generico

Question

Desidero utilizzare il metodo overload per ottenere risultati diversi in base a diversi tipi generici. Non funziona. Il mio codice lo mostra chiaramente.

static class Helper 
{ 

    public static bool Can(int i) 
    { 
     return true; 
    } 

    public static bool Can(Object o) 
    { 
     return false; 
    } 
} 

class My<T> 
{ 
    public static bool can = Helper.Can(default(T)); 
} 

Console.WriteLine(Helper.Can(default(int)));//True,it is OK 

Console.WriteLine(My<int>.can);//false?? why the overload doesn't work 
Console.WriteLine(My<Object>.can);//false 

Perché My<int> chiamate Helper.Can (Object o) piuttosto che Helper.Can (int i)?

Answer 1

Non funziona in questo modo.

I sovraccarichi vengono risolti interamente in fase di compilazione; i parametri di tipo generico vengono risolti in fase di esecuzione.
Dal momento che il compilatore non sa che è , il tuo codice chiamerà sempre Can(Object).

Answer 2

è un po 'prolisso, ma si potrebbe ottenere quello che vuoi utilizzando Riflessione:

class My<T> 
{ 
    static bool doStuff() 
    { 
     var rightMehod = typeof(Helper).GetMethods().Where(p => 
      { 
       if (!p.Name.Equals("Can")) 
        return false; 

       if (!p.ReturnType.Equals(typeof(bool))) 
        return false; 

       if (p.GetParameters().Length != 1) 
        return false; 

       var par = p.GetParameters().First(); 
       return par.ParameterType.Equals(typeof(T)); 
      }).FirstOrDefault(); 

     if (rightMehod == null) 
     { 
      return Helper.Can(default(T)); 
     } 
     else 
     { 
      return (bool)rightMehod.Invoke(null, new object[] { default(T) }); 
     } 
    } 

    public static bool can = doStuff(); 
} 

In questo modo,

My<string>.can == false 
My<int>.can == true 
My<object>.can == false 

Naturalmente, con un po' di mestiere in più (e utilizzo di tipi generici), si sarebbe in grado di riutilizzare questo snippet estensivamente per molte situazioni diverse.

Un'osservazione aggiuntiva: in questo esempio, ho utilizzato il confronto diretto dei tipi per l'esempio specifico. Nota che questo non funzionerà correttamente quando si ha a che fare con tipi ereditati (e, naturalmente, ci sono anche altre ambiguità :).

Answer 3

In generale, si risolverà ad oggetto al momento della compilazione, ma si può dire che aspettare fino al runtime utilizzando la parola chiave dinamica:

class My<T> 
{ 
    public static bool can = CanWithDynamic(); 

    private static bool CanWithDynamic() { 
     dynamic runtimeT = default(T); 
     return Helper.Can(runtimeT); 
} 

Quindi, questo lavoro per quello che stai cercando da fare e verrà chiamato il sovraccarico giusto. Tuttavia, come per tutto ciò che viene risolto in fase di esecuzione, è associato a un costo delle prestazioni. Probabilmente non granché, ma se chiami spesso questo metodo potrebbe avere un impatto.