Can a Generic Method handle both Reference and Nullable Value types?

Question

I have a series of Extension methods to help with null-checking on IDataRecord objects, which I'm currently implementing like this:

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

and so on, for each type I need to deal with.

I'd like to reimplement these as a generic method, partly to reduce redundancy and partly to learn how to write generic methods in general.

I've written this:

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

which works as long as T is a value type, but if T is a reference type it won't.

This method would need to return either a Nullable type if T is a value type, and default(T) otherwise. How would I implement this behavior?

Answer 1

I do it this way:

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: You can ( or you should ) have a "ToDbInt32, ToDbBool, etc..." extension methods for other primitive types ofcourse.

EDIT 2: You can also extend the base class "object" with "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 2

The Nullable structure is only for Value types, because reference types are nullable anyway...

Answer 3

You can just declare your method like this:

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

This way, if T is a nullable int or any other nullable value type, it will in fact return null. If it's a regular datatype, it will just return the default value for that type.

Answer 4

I don't think you can implement this with a single function. If C# supported overloading based on return type, you might be able to, but even then I would recommend against doing so.

You should be able to accomplish the same thing by not using nullable data types and return either an actual value or null, as suggested by BFree.

Answer 5

This works:

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

You can't do it with one method but you do it with three:

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

Then to use it you would do:

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

or more 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);

and use it like this

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

Answer 8

I can't understand why the need to over complicate this whole process. Why not keep it nice and simple and use the following lines of code:

For value types where null is valid use int? iNullable = dr[ordinal] as int?;.

For value types where null is invalid use int iNonNullable = dr[ordinal] as int? ?? default(int);.

For reference types use string sValue = dr[ordinal] as string;.

For anyone who thinks that the code wont work and that dr[ordinal] will throw an exception for DBNull here is an example method that once given a valid connection string will prove the concept.

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