Tipo nullable come parametro generico possibile?

Voglio fare qualcosa del genere:

myYear = record.GetValueOrNull<int?>("myYear"),

Notare il tipo nullable come parametro generico.

Poiché la GetValueOrNullfunzione potrebbe restituire null il mio primo tentativo è stato questo:

public static T GetValueOrNull<T>(this DbDataRecord reader, string columnName)
  where T : class
{
    object columnValue = reader[columnName];

    if (!(columnValue is DBNull))
    {
        return (T)columnValue;
    }
    return null;
}

Ma l'errore che sto ricevendo ora è:

Il tipo "int?" deve essere un tipo di riferimento per usarlo come parametro 'T' nel tipo o metodo generico

Destra! Nullable<int>è un struct! Quindi ho provato a cambiare il vincolo di classe in un structvincolo (e come effetto collaterale non può più tornare null):

public static T GetValueOrNull<T>(this DbDataRecord reader, string columnName)
  where T : struct

Ora il compito:

myYear = record.GetValueOrNull<int?>("myYear");

Fornisce il seguente errore:

Il tipo "int?" deve essere un tipo di valore non annullabile per usarlo come parametro 'T' nel tipo o metodo generico

È possibile specificare un tipo nullable come parametro generico?

Modificare il tipo restituito su Nullable e chiamare il metodo con il parametro non nullable

static void Main(string[] args)
{
    int? i = GetValueOrNull<int>(null, string.Empty);
}


public static Nullable<T> GetValueOrNull<T>(DbDataRecord reader, string columnName) where T : struct
{
    object columnValue = reader[columnName];

    if (!(columnValue is DBNull))
        return (T)columnValue;

    return null;
}

public static T GetValueOrDefault<T>(this IDataRecord rdr, int index)
{
    object val = rdr[index];

    if (!(val is DBNull))
        return (T)val;

    return default(T);
}

Usalo in questo modo:

decimal? Quantity = rdr.GetValueOrDefault<decimal?>(1);
string Unit = rdr.GetValueOrDefault<string>(2);

Basta fare due cose al codice originale: rimuovere il wherevincolo e cambiare l'ultimo returnda return nulla return default(T). In questo modo è possibile restituire qualsiasi tipo desiderato.

A proposito, puoi evitare l'uso iscambiando la tua ifdichiarazione in if (columnValue != DBNull.Value).

Disclaimer: questa risposta funziona, ma è intesa solo a scopo educativo. :) La soluzione di James Jones è probabilmente la migliore qui e sicuramente quella con cui vorrei andare.

La dynamicparola chiave di C # 4.0 rende questo ancora più semplice, se meno sicuro:

public static dynamic GetNullableValue(this IDataRecord record, string columnName)
{
  var val = reader[columnName];

  return (val == DBNull.Value ? null : val);
}

Ora non è necessario il suggerimento di tipo esplicito su RHS:

int? value = myDataReader.GetNullableValue("MyColumnName");

In effetti, non ne hai nemmeno bisogno!

var value = myDataReader.GetNullableValue("MyColumnName");

value sarà ora un int, una stringa o qualunque tipo sia stato restituito dal DB.

L'unico problema è che questo non ti impedisce di utilizzare tipi non nullable su LHS, nel qual caso otterrai un'eccezione di runtime piuttosto brutta come:

Microsoft.CSharp.RuntimeBinder.RuntimeBinderException: Cannot convert null to 'int' because it is a non-nullable value type

Come per tutto il codice che utilizza dynamic: caveat coder.

Dovevo solo fare qualcosa di incredibile simile a questo. Il mio codice:

public T IsNull<T>(this object value, T nullAlterative)
{
    if(value != DBNull.Value)
    {
        Type type = typeof(T);
        if (type.IsGenericType && 
            type.GetGenericTypeDefinition() == typeof(Nullable<>).GetGenericTypeDefinition())
        {
            type = Nullable.GetUnderlyingType(type);
        }

        return (T)(type.IsEnum ? Enum.ToObject(type, Convert.ToInt32(value)) :
            Convert.ChangeType(value, type));
    }
    else 
        return nullAlternative;
}

Penso che tu voglia gestire i tipi di riferimento e i tipi di struttura. Lo uso per convertire stringhe di elementi XML in un tipo più tipizzato. È possibile rimuovere nullAlternative con reflection. Il formatprovider è di gestire la cultura dipendente "." o ',' separatore in es. decimali o ints e doppi. Questo potrebbe funzionare:

public T GetValueOrNull<T>(string strElementNameToSearchFor, IFormatProvider provider = null ) 
    {
        IFormatProvider theProvider = provider == null ? Provider : provider;
        XElement elm = GetUniqueXElement(strElementNameToSearchFor);

        if (elm == null)
        {
            object o =  Activator.CreateInstance(typeof(T));
            return (T)o; 
        }
        else
        {
            try
            {
                Type type = typeof(T);
                if (type.IsGenericType &&
                type.GetGenericTypeDefinition() == typeof(Nullable<>).GetGenericTypeDefinition())
                {
                    type = Nullable.GetUnderlyingType(type);
                }
                return (T)Convert.ChangeType(elm.Value, type, theProvider); 
            }
            catch (Exception)
            {
                object o = Activator.CreateInstance(typeof(T));
                return (T)o; 
            }
        }
    }

Puoi usarlo in questo modo:

iRes = helper.GetValueOrNull<int?>("top_overrun_length");
Assert.AreEqual(100, iRes);



decimal? dRes = helper.GetValueOrNull<decimal?>("top_overrun_bend_degrees");
Assert.AreEqual(new Decimal(10.1), dRes);

String strRes = helper.GetValueOrNull<String>("top_overrun_bend_degrees");
Assert.AreEqual("10.1", strRes);

Questo potrebbe essere un thread morto, ma tendo a usare quanto segue:

public static T? GetValueOrNull<T>(this DbDataRecord reader, string columnName)
where T : struct 
{
    return reader[columnName] as T?;
}

Ho riscontrato lo stesso problema da solo.

... = reader["myYear"] as int?; funziona ed è pulito.

Funziona con qualsiasi tipo senza problemi. Se il risultato è DBNull, restituisce null poiché la conversione non riesce.

So che questo è vecchio, ma ecco un'altra soluzione:

public static bool GetValueOrDefault<T>(this SqlDataReader Reader, string ColumnName, out T Result)
{
    try
    {
        object ColumnValue = Reader[ColumnName];

        Result = (ColumnValue!=null && ColumnValue != DBNull.Value) ? (T)ColumnValue : default(T);

        return ColumnValue!=null && ColumnValue != DBNull.Value;
    }
    catch
    {
        // Possibly an invalid cast?
        return false;
    }
}

Ora, non ti importa se Tfosse un valore o un tipo di riferimento. Solo se la funzione restituisce true, si dispone di un valore ragionevole dal database. Uso:

...
decimal Quantity;
if (rdr.GetValueOrDefault<decimal>("YourColumnName", out Quantity))
{
    // Do something with Quantity
}

Questo approccio è molto simile a int.TryParse("123", out MyInt);

Più vincoli generici non possono essere combinati in modo OR (meno restrittivo), solo in modo AND (più restrittivo). Ciò significa che un metodo non può gestire entrambi gli scenari. Inoltre, i vincoli generici non possono essere utilizzati per creare una firma univoca per il metodo, quindi è necessario utilizzare 2 nomi di metodi separati.

Tuttavia, è possibile utilizzare i vincoli generici per assicurarsi che i metodi vengano utilizzati correttamente.

Nel mio caso, volevo specificamente che fosse restituito null e mai il valore predefinito di eventuali tipi di valore. GetValueOrDefault = bad. GetValueOrNull = buono.

Ho usato le parole "Null" e "Nullable" per distinguere tra tipi di riferimento e tipi di valore. Ed ecco un esempio di un paio di metodi di estensione che ho scritto che complimenta il metodo FirstOrDefault nella classe System.Linq.Enumerable.

    public static TSource FirstOrNull<TSource>(this IEnumerable<TSource> source)
        where TSource: class
    {
        if (source == null) return null;
        var result = source.FirstOrDefault();   // Default for a class is null
        return result;
    }

    public static TSource? FirstOrNullable<TSource>(this IEnumerable<TSource?> source)
        where TSource : struct
    {
        if (source == null) return null;
        var result = source.FirstOrDefault();   // Default for a nullable is null
        return result;
    }

Il modo più breve:

public static T ValueOrDefault<T>(this DataRow reader, string columnName) => 
        reader.IsNull(columnName) ? default : (T) reader[columnName];

ritorno 0per inte nullperint?