Tipo anulável como um parâmetro genérico possível?

Eu quero fazer algo assim:

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

Observe o tipo anulável como o parâmetro genérico.

Como a GetValueOrNullfunção pode retornar nula, minha primeira tentativa foi a seguinte:

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

Mas o erro que estou recebendo agora é:

O tipo 'int?' deve ser um tipo de referência para usá-lo como parâmetro 'T' no tipo ou método genérico

Certo! Nullable<int>é um struct! Então, tentei alterar a restrição de classe para uma structrestrição (e como efeito colateral não pode mais retornar null):

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

Agora a tarefa:

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

Dá o seguinte erro:

O tipo 'int?' deve ser um tipo de valor não anulável para usá-lo como parâmetro 'T' no tipo ou método genérico

É possível especificar um tipo anulável como um parâmetro genérico?

Altere o tipo de retorno para Nullable e chame o método com o parâmetro não nulo

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

Apenas use-o assim:

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

Faça duas coisas no código original - remova a whererestrição e altere a última returnde return nullpara return default(T). Dessa forma, você pode retornar o tipo que desejar.

A propósito, você pode evitar o uso isalterando sua ifdeclaração para if (columnValue != DBNull.Value).

Isenção de responsabilidade: Esta resposta funciona, mas destina-se apenas a fins educacionais. :) A solução de James Jones é provavelmente a melhor aqui e certamente a que eu escolheria.

A dynamicpalavra-chave do C # 4.0 torna isso ainda mais fácil, se menos seguro:

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

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

Agora você não precisa da dica explícita de tipo no RHS:

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

Na verdade, você nem precisa disso!

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

value agora será um int, ou uma string ou qualquer tipo que foi retornado do banco de dados.

O único problema é que isso não impede que você use tipos não anuláveis ​​no LHS; nesse caso, você receberá uma exceção de tempo de execução bastante desagradável, como:

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

Tal como acontece com todo o código que usa dynamic: caveat coder.

Só tinha que fazer algo incrível semelhante a isso. Meu código:

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

Eu acho que você deseja lidar com tipos de referência e tipos de estrutura. Eu o uso para converter seqüências de caracteres de elemento XML em um tipo mais digitado. Você pode remover o nullAlternative com reflexão. O provedor de formato é lidar com a cultura dependente '.' ou ',' separador, por exemplo, decimais ou ints e duplos. Isso pode funcionar:

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

Você pode usá-lo assim:

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

Isso pode ser um fio morto, mas eu costumo usar o seguinte:

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

Acabei de encontrar o mesmo problema.

... = reader["myYear"] as int?; funciona e está limpo.

Funciona com qualquer tipo sem problemas. Se o resultado for DBNull, ele retornará nulo quando a conversão falhar.

Eu sei que isso é antigo, mas aqui está outra solução:

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

Agora, você não se importa se Tfoi o valor ou o tipo de referência. Somente se a função retornar true, você terá um valor razoável no banco de dados. Uso:

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

Essa abordagem é muito semelhante à int.TryParse("123", out MyInt);

Múltiplas restrições genéricas não podem ser combinadas de maneira OR (menos restritivas), apenas de maneira AND (mais restritivas). Significando que um método não pode lidar com os dois cenários. As restrições genéricas também não podem ser usadas para criar uma assinatura exclusiva para o método, portanto, você deve usar 2 nomes de métodos separados.

No entanto, você pode usar as restrições genéricas para garantir que os métodos sejam usados ​​corretamente.

No meu caso, eu queria especificamente que o nulo fosse retornado e nunca o valor padrão de qualquer tipo de valor possível. GetValueOrDefault = incorreto. GetValueOrNull = bom.

Usei as palavras "Nulo" e "Nulo" para distinguir entre tipos de referência e tipos de valor. E aqui está um exemplo de alguns métodos de extensão que escrevi que complementam o método FirstOrDefault na 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;
    }

A maneira mais curta:

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

retornar 0para inte nullparaint?