Come faccio a rendere generico il tipo restituito di un metodo?

C'è un modo per rendere generico questo metodo in modo che io possa restituire una stringa, un valore bool, int o double? In questo momento, sta restituendo una stringa, ma se è in grado di trovare "true" o "false" come valore di configurazione, ad esempio, vorrei restituire un valore bool.

    public static string ConfigSetting(string settingName)
    {  
         return ConfigurationManager.AppSettings[settingName];
    }

Devi renderlo un metodo generico, come questo:

public static T ConfigSetting<T>(string settingName)
{  
    return /* code to convert the setting to T... */
}

Ma il chiamante dovrà specificare il tipo che si aspettano. È quindi possibile utilizzare potenzialmente Convert.ChangeType, supponendo che siano supportati tutti i tipi rilevanti:

public static T ConfigSetting<T>(string settingName)
{  
    object value = ConfigurationManager.AppSettings[settingName];
    return (T) Convert.ChangeType(value, typeof(T));
}

Non sono del tutto convinto che tutto ciò sia una buona idea, intendiamoci ...

Puoi usare Convert.ChangeType():

public static T ConfigSetting<T>(string settingName)
{
    return (T)Convert.ChangeType(ConfigurationManager.AppSettings[settingName], typeof(T));
}

Esistono molti modi per farlo (elencati per priorità, specifici per il problema del PO)

1. Opzione 1: approccio diretto - Crea più funzioni per ogni tipo che ti aspetti piuttosto che avere una funzione generica.

   public static bool ConfigSettingInt(string settingName)
   {  
        return Convert.ToBoolean(ConfigurationManager.AppSettings[settingName]);
   }

2. Opzione 2: quando non si desidera utilizzare metodi di conversione elaborati, eseguire il cast del valore su object e quindi su tipo generico.

   public static T ConfigSetting<T>(string settingName)
   {  
        return (T)(object)ConfigurationManager.AppSettings[settingName];
   }

   Nota: questo genererà un errore se il cast non è valido (il tuo caso). Non consiglierei di farlo se non sei sicuro del tipo di casting, piuttosto vai all'opzione 3.

3. Opzione 3: generico con sicurezza del tipo : crea una funzione generica per gestire la conversione del tipo.

   public static T ConvertValue<T,U>(U value) where U : IConvertible
   {
       return (T)Convert.ChangeType(value, typeof(T));
   } 

   Nota - T è il tipo previsto, annota qui il vincolo (il tipo di U deve essere IConvertible per salvarci dagli errori)

Devi convertire il tipo del valore di ritorno del metodo nel tipo generico che passi al metodo durante la chiamata.

    public static T values<T>()
    {
        Random random = new Random();
        int number = random.Next(1, 4);
        return (T)Convert.ChangeType(number, typeof(T));
    }

È necessario passare un tipo cast di tipo per il valore restituito tramite tale metodo.

Se si desidera restituire un valore che non è cast castabile al tipo generico che si passa, potrebbe essere necessario modificare il codice o assicurarsi di passare un tipo castable per il valore restituito del metodo. Quindi, questo approccio non è raccomandato.

Creare una funzione e passare il parametro put di tipo generico.

 public static T some_function<T>(T out_put_object /*declare as Output object*/)
    {
        return out_put_object;
    }

Si prega di provare sotto il codice:

public T? GetParsedOrDefaultValue<T>(string valueToParse) where T : struct, IComparable
{
 if(string.EmptyOrNull(valueToParse))return null;
  try
  {
     // return parsed value
     return (T) Convert.ChangeType(valueToParse, typeof(T));
  }
  catch(Exception)
  {
   //default as null value
   return null;
  }
 return null;
}

 private static T[] prepareArray<T>(T[] arrayToCopy, T value)
    {
        Array.Copy(arrayToCopy, 1, arrayToCopy, 0, arrayToCopy.Length - 1);
        arrayToCopy[arrayToCopy.Length - 1] = value;
        return (T[])arrayToCopy;
    }

Lo stavo eseguendo in tutto il mio codice e volevo un modo per inserirlo in un metodo. Volevo condividere questo qui perché non ho dovuto usare Convert.ChangeType per il mio valore di ritorno. Questa potrebbe non essere una buona pratica ma ha funzionato per me. Questo metodo accetta una matrice di tipo generico e un valore da aggiungere alla fine della matrice. L'array viene quindi copiato con il primo valore rimosso e il valore preso nel metodo viene aggiunto alla fine dell'array. L'ultima cosa è che restituisco l'array generico.