¿Puede un método genérico manejar los tipos de valores de referencia y valores anulables?

Question

que tienen una serie de métodos de extensión para ayudar con nula comprobación en objetos IDataRecord, que estoy actualmente de aplicación como esta:

public static int? GetNullableInt32(this IDataRecord dr, int ordinal) 
{ 
    int? nullInt = null; 
    return dr.IsDBNull(ordinal) ? nullInt : dr.GetInt32(ordinal); 
} 

public static int? GetNullableInt32(this IDataRecord dr, string fieldname) 
{ 
    int ordinal = dr.GetOrdinal(fieldname); 
    return dr.GetNullableInt32(ordinal); 
} 

y así sucesivamente, para cada tipo tengo que tratar.

Me gustaría volver a implementar esto como un método genérico, en parte para reducir la redundancia y en parte para aprender a escribir métodos genéricos en general.

He escrito esto:

public static Nullable<T> GetNullable<T>(this IDataRecord dr, int ordinal) 
{ 
    Nullable<T> nullValue = null; 
    return dr.IsDBNull(ordinal) ? nullValue : (Nullable<T>) dr.GetValue(ordinal); 
} 

que funciona siempre y cuando T es un tipo de valor, pero si T es un tipo de referencia no lo hará.

Este método debería devolver un tipo anulable si T es un tipo de valor y, por defecto, (T). ¿Cómo implementaría este comportamiento?

Answer 1

puede declarar su método como este:

public static T GetNullable<T>(this IDataRecord dr, int ordinal) 
{ 
    return dr.IsDBNull(ordinal) ? default(T) : (T) dr.GetValue(ordinal); 
} 

De esta manera, si T es un int anulable o cualquier otro tipo de valor que admite nulos, de hecho devolverá nulo. Si se trata de un tipo de datos normal, simplemente devolverá el valor predeterminado para ese tipo.

Answer 2

lo hago de esta manera:

DataRow record = GetSomeRecord(); 
int? someNumber = record[15] as int? 
Guid? someUID = record["MyPrimaryKey"] as Guid?; 
string someText = GetSomeText(); 
record["Description"] = someText.ToDbString(); 

// ........ 

public static class StringExtensionHelper { 
    public static object ToDbString(this string text) { 
     object ret = null != text ? text : DBNull.Value 
     return ret; 
    } 
} 

EDIT: Usted puede (o debe) tener un "ToDbInt32, ToDbBool, etc ..." métodos de extensión para otros tipos primitivos por supuesto.

EDIT 2: También puede ampliar la clase base "objeto" con "ToDbValue".

public static class StringExtensionHelper { 
    public static object ToDbValue(this object value) { 
     object ret = object.ReferenceEquals(value, null) ? (object)DBNull.Value : value; 
     return ret; 
    } 
} 

Answer 3

La estructura anulable es sólo para los tipos de valor, porque los tipos de referencia son anulables todos modos ...

Answer 4

No creo que pueda implementar esto con una sola función. Si C# admite la sobrecarga en función del tipo de devolución, es posible que pueda hacerlo, pero incluso así recomendaría que no lo haga.

Debería poder lograr lo mismo al no usar tipos de datos que aceptan nulos y devolver un valor real o nulo, como suggested por BFree.

Answer 5

Esto funciona:

public static T Get<T>(this IDataRecord dr, int ordinal) 
{ 
    T nullValue = default(T); 
    return dr.IsDBNull(ordinal) ? nullValue : (T) dr.GetValue(ordinal); 
} 


public void Code(params string[] args) 
{ 
    IDataRecord dr= null; 
    int? a = Get<int?>(dr, 1); 
    string b = Get<string>(dr, 2); 
} 

Answer 6

No se puede hacer con un método, pero lo hace con tres:

public static T GetData<T>(this IDataReader reader, Func<int, T> getFunc, int index) 
{ 
    if (!reader.IsClosed) 
    { 
     return getFunc(index); 
    } 
    throw new ArgumentException("Reader is closed.", "reader"); 
} 

public static T GetDataNullableRef<T>(this IDataReader reader, Func<int, T> getFunc, int index) where T : class 
{ 
    if (!reader.IsClosed) 
    { 
     return reader.IsDBNull(index) ? null : getFunc(index); 
    } 
    throw new ArgumentException("Reader is closed.", "reader"); 
} 

public static T? GetDataNullableValue<T>(this IDataReader reader, Func<int, T> getFunc, int index) where T : struct 
{ 
    if (!reader.IsClosed) 
    { 
     return reader.IsDBNull(index) ? (T?)null : getFunc(index); 
    } 
    throw new ArgumentException("Reader is closed.", "reader"); 
} 

Luego de usar que puede hacer:

private static Whatever CreateObject(IDataReader reader) 
{ 
    Int32? id = reader.GetDataNullableValue<Int32>(reader.GetInt32, 0); 
    string name = reader.GetDataNullableRef<string>(reader.GetString, 1); 
    Int32 x = reader.GetData<Int32>(reader.GetInt32, 2); 
} 

Answer 7

public static T Get<T>(this IDataRecord rec, Func<int, T> GetValue, int ordinal) 
{ 
    return rec.IsDBNull(ordinal) ? default(T) : GetValue(ordinal); 
} 

o más performant

public static T Get<T>(this IDataRecord rec, Func<IDataRecord, int, T> GetValue, int ordinal) 
{ 
    return rec.IsDBNull(ordinal) ? default(T) : GetValue(rec, ordinal); 
} 

public static Func<IDataRecord, int, int> GetInt32 = (rec, i) => rec.GetInt32(i); 
public static Func<IDataRecord, int, bool> GetBool = (rec, i) => rec.GetBoolean(i); 
public static Func<IDataRecord, int, string> GetString = (rec, i) => rec.GetString(i); 

y utilizar de esta manera

rec.Get(GetString, index); 
rec.Get(GetInt32, index); 

Answer 8

No puedo entender por qué la necesidad de complicar todo este proceso. ¿Por qué no mantenerlo simple y agradable y utilizar las siguientes líneas de código:

Para los tipos de valor donde null es válido use int? iNullable = dr[ordinal] as int?;.

Para los tipos de valor donde null no es válido, use int iNonNullable = dr[ordinal] as int? ?? default(int);.

Para tipos de referencia use string sValue = dr[ordinal] as string;.

Para cualquiera que piense que el código no funcionará y que dr[ordinal] arrojará una excepción para DBNull, aquí hay un método de ejemplo que una vez que se le da una cadena de conexión válida demostrará el concepto.

private void Test() 
{ 
    int? iTestA; 
    int? iTestB; 
    int iTestC; 
    string sTestA; 
    string sTestB; 

    //Create connection 
    using (SqlConnection oConnection = new SqlConnection(@"")) 
    { 
    //Open connection 
    oConnection.Open(); 

    //Create command 
    using (SqlCommand oCommand = oConnection.CreateCommand()) 
    { 
     //Set command text 
     oCommand.CommandText = "SELECT null, 1, null, null, '1'"; 

     //Create reader 
     using (SqlDataReader oReader = oCommand.ExecuteReader()) 
     { 
     //Read the data 
     oReader.Read(); 

     //Set the values 
     iTestA = oReader[0] as int?; 
     iTestB = oReader[1] as int?; 
     iTestC = oReader[2] as int? ?? -1; 
     sTestA = oReader[3] as string; 
     sTestB = oReader[4] as string; 
     } 
    } 
    } 
}