¿Cómo hago para que los genéricos funcionen con valores devueltos que requieren un casting cuidadoso?

Question

Tengo un código de capa de acceso a datos que llama a un proceso almacenado y devuelve valores escalares de varios tipos de datos. La sintaxis es ExecuteDecimal, ExecuteString, etc. Yo quiero que sea Execute<string> o Execute<decimal>

Intento esta aplicación y no puedo compilar, a menos que yo estoy haciendo la fundición a "valor (T)", si intento verifica el tipo y llama a un método para hacer el casting, sin tanta suerte.

pregunta ACTUALIZADA ¿Por qué tengo que convertir a objeto antes de convertir a T?

código actualizado

internal T Execute<T>(string storedProcName, Hashtable parameters) 
{ 
     //Next lines do compile (thanks to suggestions from answers!) 
     if (typeof(T) == typeof(string)) 
      return (T) (object) ExecuteScalar(storedProcName, parameters).ToString(); 
     else if (typeof(T) == typeof(int)) 
      return (T)(object) Convert.ToInt32(ExecuteScalar(storedProcName, parameters)); 
     //Next line compiles, but not all things boxed in an object can 
     //be converted straight to type T (esp db return values that might contain DbNull.Value, etc) 
     return (T)ExecuteScalar(storedProcName, parameters); 
} 

Answer 1

Prueba esto:

var result = ExecuteScalar(storedProcName, parameters); 
if(Convert.IsDBNull(result)) 
    return default(T) 
if(result is T) // just unbox 
    return (T)result; 
else   // convert 
    return (T)Convert.ChangeType(result, typeof(T)); 

Actualizado: DBNull fijo manejo

Answer 2

typeof(T) == typeof(string) 

y para la comprobación de valor nulo en contra DBNull.Value

método global:

internal T Execute<T>(string storedProcName, Hashtable parameters) 
{ 
     object res = ExecuteScalar(storedProcName, parameters); 
     if (Convert.IsDBNull(res)) 
     return default(T); //or handle somehow 
     return (T)Convert.ChangeType(res, typeof(T)); 
} 

Answer 3

probar el 'como' palabra clave

object o = ExecuteScalar(storedProcName, parameters); 
string s; 
int i; 
// .. more 

if ((s = o as string) != null) 
{ 
    return s; 
} 
if ((i = o as int?) != null) // can't use as for value types, so use nullable 
{ 
    return Convert.ToInt32(o); 
} 
return o as T; 

Answer 4

Tal vez su función en lugar podría ser alterado para permitir la función de conversión de objeto que se aprobó en:

internal T Execute<T>(string storedProcName, Hashtable parameters, Func<object, T> resultConverter) 
{ 
} 

Luego puede crear sobrecargas para las que conoce:

internal string ExecuteForString(string storedProcName, Hashtable parameters) 
{ 
    return Execute(storedProcName, parameters, (o) => o.ToString()); 
} 

internal int ExecuteForInt(string storedProcName, Hashtable parameters) 
{ 
    return Execute(storedProcName, parameters, Convert.ToInt32); 
} 

En el caso de los cheques DBNull, podría volver ya sea default(T) o se puede añadir otra sobrecarga de pasar en un valor por defecto si no se devuelve DBNull - por ejemplo, en el caso de un int, es mejor recuperar -1 en lugar de 0.