C#: il metodo generico non chiama il metodo specifico overload

Question

Sto cercando di creare un metodo generico in C#, che chiamerà diversi metodi basati sul tipo di argomento argomento nel suo corpo ed elaborerà i risultati successivamente. Sto cercando di ottenere questo risultato creando un metodo generico di wrapper e quindi fornendo diversi overload del metodo di elaborazione, incluso uno generico che verrà utilizzato se non è disponibile un sovraccarico specifico.

Quando chiamo direttamente il metodo di elaborazione, la versione appropriata è selezionata correttamente. Tuttavia, quando lo chiamo dal metodo wrapper, seleziona sempre quello generico, anche se c'è un sovraccarico corrispondente per il tipo di dati specifico che gli ho passato.

C'è un modo per regolare il codice per farlo funzionare nel modo in cui è necessario? O devo usare un approccio diverso.

Ho bisogno che il codice sia compatibile con Mono 2.6.

using System; 

class Program 
{ 
    static void Func<T>(T val) 
    { 
     Console.WriteLine("Generic Func"); 
    } 

    static void Func(int val) 
    { 
     Console.WriteLine("Int Func"); 
    } 

    static void Func(string val) 
    { 
     Console.WriteLine("String Func"); 
    } 

    static void FuncWrap<T>(T val) 
    { 
     Console.Write("Wrap: "); 
     Func(val); 
    } 

    static void Main(string[] args) 
    { 
     Func(2); 
     Func("Potato"); 
     Func(2.0); 

     FuncWrap(2); 
     FuncWrap("Potato"); 
     FuncWrap(2.0); 

     Console.Read(); 
    } 
} 

Answer 1

Esiste un modo corretto questo comportamento?

È già il comportamento corretto in base alle specifiche del linguaggio C#. Il sovraccarico di Func chiamato in FuncWrap è normalmente determinato in fase di compilazione, quindi non è possibile selezionare un diverso sovraccarico Func in base al tipo di esecuzione.

Un modo per cambiare il comportamento, tuttavia, è quello di utilizzare la tipizzazione dinamica:

static void FuncWrap<T>(T val) 
{ 
    Console.Write("Wrap: "); 
    dynamic x = val; 
    Func(x); 
} 

che saranno ora eseguire la risoluzione di sovraccarico in fase di esecuzione in base al reale tipo del valore di x. Ciò comporta un costo in termini di prestazioni, ma dovrebbe fare ciò che si desidera.

In alternativa, si potrebbe codificare la conoscenza dei sovraccarichi:

static void FuncWrap<T>(T val) 
{ 
    Console.Write("Wrap: "); 
    if (typeof(T) == typeof(string)) 
    { 
     Func((string)(object)val); 
    } 
    else if (typeof(T) == typeof(int)) 
    { 
     Func((int)(object)val); 
    } 
    else 
    { 
     Func(val); 
    } 
} 

Questo è chiaramente abbastanza orribile però.