Como faço para tornar o tipo de retorno de um método genérico?

Existe uma maneira de tornar esse método genérico para que eu possa retornar uma string, bool, int ou double? No momento, ele está retornando uma string, mas se puder encontrar "true" ou "false" como o valor da configuração, eu gostaria de retornar um bool, por exemplo.

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

Você precisa torná-lo um método genérico, como este:

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

Mas o chamador terá que especificar o tipo que espera. Você poderia usar potencialmente Convert.ChangeType, assumindo que todos os tipos relevantes sejam suportados:

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

Não estou totalmente convencido de que tudo isso seja uma boa ideia, veja bem ...

Você poderia usar Convert.ChangeType():

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

Existem várias maneiras de fazer isso (listadas por prioridade, específicas ao problema do OP)

1. Opção 1: Abordagem direta - Crie várias funções para cada tipo que você espera, em vez de ter uma função genérica.

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

2. Opção 2: quando você não deseja usar métodos sofisticados de conversão - converta o valor em objeto e, em seguida, em tipo genérico.

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

   Nota - Isso gerará um erro se o elenco não for válido (seu caso). Eu não recomendaria fazer isso se você não tiver certeza sobre o tipo de conversão, em vez disso, vá para a opção 3.

3. Opção 3: Genérico com segurança de tipo - Crie uma função genérica para lidar com a conversão de tipo.

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

   Nota - T é o tipo esperado, observe a restrição where aqui (o tipo de U deve ser IConvertible para nos salvar dos erros)

Você precisa converter o tipo do seu valor de retorno do método para o tipo genérico que você passa para o método durante a chamada.

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

Você precisa passar um tipo que pode ser convertido para o valor retornado por esse método.

Se você deseja retornar um valor que não é passível de digitação para o tipo genérico que você passa, talvez seja necessário alterar o código ou certifique-se de passar um tipo que pode ser convertido para o valor de retorno do método Portanto, essa abordagem não é recomendada.

Crie uma função e passe o parâmetro put como do tipo genérico.

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

Por favor, tente o código abaixo:

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

Eu estava realizando isso em todo o meu código e queria uma maneira de colocá-lo em um método. Eu queria compartilhar isso aqui porque não precisava usar o Convert.ChangeType para o meu valor de retorno. Essa pode não ser uma prática recomendada, mas funcionou para mim. Esse método utiliza uma matriz do tipo genérico e um valor a ser adicionado ao final da matriz. A matriz é copiada com o primeiro valor retirado e o valor obtido no método é adicionado ao final da matriz. A última coisa é que eu retorno a matriz genérica.