Czy dopuszcza się typ zerowy jako parametr ogólny?

Chcę zrobić coś takiego:

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

Zwróć uwagę na typ zerowalny jako parametr ogólny.

Ponieważ GetValueOrNullfunkcja może zwrócić null, moja pierwsza próba była następująca:

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

Ale błąd, który teraz otrzymuję, to:

Wpisz „int?” musi być typem odniesienia, aby można go było używać jako parametru „T” w typie lub metodzie ogólnej

Dobrze! Nullable<int>jest struct! Próbowałem więc zmienić ograniczenie klasy na structograniczenie (i jako efekt uboczny nie mogę już nullwięcej powrócić ):

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

Teraz zadanie:

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

Daje następujący błąd:

Wpisz „int?” musi być niedopuszczalnym typem wartości, aby użyć go jako parametru „T” w typie lub metodzie ogólnej

Czy w ogóle możliwe jest podanie typu zerowalnego jako parametru ogólnego?

Zmień typ zwracany na Nullable i wywołaj metodę z parametrem innym niż 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);
}

Po prostu użyj tego w ten sposób:

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

Po prostu zrób dwie rzeczy z oryginalnym kodem - usuń whereograniczenie i zmień ostatnią returnz return nullna return default(T). W ten sposób możesz zwrócić dowolny typ.

Nawiasem mówiąc, możesz uniknąć używania is, zmieniając swoje ifoświadczenie na if (columnValue != DBNull.Value).

Oświadczenie: Ta odpowiedź działa, ale jest przeznaczona wyłącznie do celów edukacyjnych. :) Rozwiązanie Jamesa Jonesa jest prawdopodobnie najlepsze tutaj i na pewno takie, z którym bym poszedł.

Słowo dynamickluczowe w C # 4.0 czyni to jeszcze łatwiejszym, jeśli mniej bezpiecznym:

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

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

Teraz nie potrzebujesz wyraźnego podpowiedzi typu na RHS:

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

W rzeczywistości nawet go nie potrzebujesz!

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

value będzie teraz liczbą całkowitą, ciągiem znaków lub dowolnym typem zwróconym z bazy danych.

Jedynym problemem jest to, że nie przeszkadza to w używaniu typów nie dopuszczających wartości zerowej w LHS, w którym to przypadku otrzymasz dość nieprzyjemny wyjątek czasu wykonywania, taki jak:

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

Podobnie jak w przypadku wszystkich kodów, które używają dynamic: kodera zastrzeżeń.

Musiałem zrobić coś niesamowitego do tego. Mój kod:

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

Myślę, że chcesz obsługiwać typy referencyjne i typy struktur. Używam go do konwersji ciągów elementów XML na bardziej typowe typy. Możesz usunąć nullAlternative z odbiciem. Dostawca formatu ma obsługiwać zależne od kultury „.” lub separator „,” np. ułamki dziesiętne lub liczby całkowite i podwójne. Może to działać:

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

Możesz użyć tego w następujący sposób:

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

To może być martwy wątek, ale zwykle używam następujących elementów:

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

Właśnie sam spotkałem ten sam problem.

... = reader["myYear"] as int?; działa i jest czysty.

Działa z każdym rodzajem bez problemu. Jeśli wynikiem jest DBNull, zwraca wartość null, ponieważ konwersja nie powiodła się.

Wiem, że to stare, ale oto inne rozwiązanie:

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

Teraz nie obchodzi cię, czy Tbył to typ wartości czy referencyjny. Tylko jeśli funkcja zwróci true, masz rozsądną wartość z bazy danych. Stosowanie:

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

To podejście jest bardzo podobne do int.TryParse("123", out MyInt);

Wiele ogólnych ograniczeń nie może być łączonych w sposób OR (mniej restrykcyjny), tylko w sposób AND (bardziej restrykcyjny). Oznacza to, że jedna metoda nie obsługuje obu scenariuszy. Ograniczeń ogólnych nie można również użyć do utworzenia unikalnego podpisu dla metody, dlatego trzeba będzie użyć 2 oddzielnych nazw metod.

Można jednak użyć ogólnych ograniczeń, aby upewnić się, że metody są używane poprawnie.

W moim przypadku chciałem zwrócić wartość null, a nigdy domyślną wartość dowolnego możliwego typu wartości. GetValueOrDefault = zły. GetValueOrNull = dobra.

Użyłem słów „Null” i „Nullable”, aby rozróżnić typy referencyjne i typy wartości. A oto przykład kilku metod rozszerzenia, które napisałem, które uzupełniają metodę FirstOrDefault w klasie 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;
    }

Krótsza droga:

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

powrót 0do int, a nulldlaint?