¿Cómo hago que el tipo de devolución de un método sea genérico?

¿Hay alguna manera de hacer que este método sea genérico para que pueda devolver una cadena, bool, int o double? En este momento, está devolviendo una cadena, pero si puede encontrar "verdadero" o "falso" como el valor de configuración, me gustaría devolver un bool, por ejemplo.

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

Debe convertirlo en un método genérico, como este:

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

Pero la persona que llama tendrá que especificar el tipo que espera. A continuación, podría utilizar Convert.ChangeType, suponiendo que todos los tipos relevantes son compatibles:

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

No estoy completamente convencido de que todo esto sea una buena idea, eso sí ...

Podrías usar Convert.ChangeType():

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

Hay muchas formas de hacerlo (enumeradas por prioridad, específicas para el problema del OP)

1. Opción 1: enfoque directo: cree varias funciones para cada tipo que espera en lugar de tener una función genérica.

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

2. Opción 2: cuando no desee utilizar métodos sofisticados de conversión : convierta el valor en objeto y luego en tipo genérico.

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

   Nota: Esto arrojará un error si el lanzamiento no es válido (su caso). No recomendaría hacer esto si no está seguro sobre el tipo de conversión, prefiera la opción 3.

3. Opción 3: Genérico con seguridad de tipo : cree una función genérica para manejar la conversión de tipo.

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

   Nota: T es el tipo esperado, tenga en cuenta la restricción where aquí (el tipo de U debe ser IConvertible para salvarnos de los errores)

Debe convertir el tipo de valor de retorno del método al tipo genérico que pasa al método durante la llamada.

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

Debe pasar un tipo que sea de tipo castable para el valor que devuelve a través de ese método.

Si desea devolver un valor que no es de tipo casteable al tipo genérico que pasa, es posible que deba modificar el código o asegurarse de pasar un tipo que sea casteable para el valor de retorno del método. Por lo tanto, este enfoque no se recomienda.

Cree una función y pase el parámetro put como de tipo genérico.

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

Por favor, intente debajo del código:

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;
    }

Estaba realizando esto en todo mi código y quería una forma de ponerlo en un método. Quería compartir esto aquí porque no tuve que usar Convert.ChangeType para mi valor de retorno. Puede que esta no sea una buena práctica, pero funcionó para mí. Este método toma una matriz de tipo genérico y un valor para agregar al final de la matriz. La matriz se copia con el primer valor eliminado y el valor tomado en el método se agrega al final de la matriz. Lo último es que devuelvo la matriz genérica.