Loại Nullable như một tham số chung có thể?

Tôi muốn làm một cái gì đó như thế này:

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

Lưu ý loại nullable là tham số chung.

Vì GetValueOrNullhàm có thể trả về null nên lần thử đầu tiên của tôi là:

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

Nhưng lỗi tôi nhận được bây giờ là:

Loại 'int?' phải là loại tham chiếu để sử dụng nó làm tham số 'T' trong loại hoặc phương thức chung

Đúng! Nullable<int>là một struct! Vì vậy, tôi đã cố gắng thay đổi ràng buộc lớp thành một structràng buộc (và vì tác dụng phụ không thể trả lại nullnữa):

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

Bây giờ nhiệm vụ:

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

Đưa ra lỗi sau:

Loại 'int?' phải là loại giá trị không thể rỗng để sử dụng nó làm tham số 'T' trong loại hoặc phương thức chung

Là chỉ định một loại nullable là một tham số chung có thể?

Thay đổi kiểu trả về thành Nullable và gọi phương thức với tham số không 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);
}

Chỉ cần sử dụng nó như thế này:

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

Chỉ cần thực hiện hai điều với mã gốc của bạn - loại bỏ whereràng buộc và thay đổi cuối cùng returntừ return nullthành return default(T). Bằng cách này bạn có thể trả lại bất cứ loại nào bạn muốn.

Nhân tiện, bạn có thể tránh việc sử dụng isbằng cách thay đổi ifcâu lệnh của bạn thành if (columnValue != DBNull.Value).

Disclaimer: Câu trả lời này hoạt động, nhưng chỉ dành cho mục đích giáo dục. :) Giải pháp của James Jones có lẽ là tốt nhất ở đây và chắc chắn là giải pháp tôi muốn đi cùng.

dynamicTừ khóa của C # 4.0 làm cho việc này thậm chí còn dễ dàng hơn, nếu ít an toàn hơn:

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

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

Bây giờ bạn không cần gợi ý loại rõ ràng trên RHS:

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

Trên thực tế, bạn thậm chí không cần nó!

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

value bây giờ sẽ là một int, hoặc một chuỗi hoặc bất kỳ kiểu nào được trả về từ DB.

Vấn đề duy nhất là điều này không ngăn bạn sử dụng các loại không thể rỗng trên LHS, trong trường hợp đó bạn sẽ gặp một ngoại lệ thời gian chạy khá khó chịu như:

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

Như với tất cả các mã sử dụng dynamic: coder caveat.

Chỉ cần phải làm một cái gì đó đáng kinh ngạc tương tự như thế này. Mã của tôi:

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

Tôi nghĩ rằng bạn muốn xử lý các loại tham chiếu và các loại cấu trúc. Tôi sử dụng nó để chuyển đổi các chuỗi Phần tử XML thành một kiểu được gõ nhiều hơn. Bạn có thể loại bỏ nullAlternative với sự phản chiếu. Trình định dạng là để xử lý văn hóa phụ thuộc '.' hoặc dấu phân cách ',' trong ví dụ số thập phân hoặc số nguyên và số nhân. Điều này có thể làm việc:

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

Bạn có thể sử dụng nó như thế này:

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

Đây có thể là một chủ đề chết, nhưng tôi có xu hướng sử dụng như sau:

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

Tôi chỉ gặp phải vấn đề tương tự bản thân mình.

... = reader["myYear"] as int?; làm việc và sạch sẽ

Nó hoạt động với bất kỳ loại mà không có vấn đề. Nếu kết quả là DBNull, nó sẽ trả về null khi chuyển đổi không thành công.

Tôi biết điều này đã cũ, nhưng đây là một giải pháp khác:

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

Bây giờ, bạn không quan tâm nếu Tlà giá trị hoặc loại tham chiếu. Chỉ khi hàm trả về true, bạn mới có giá trị hợp lý từ cơ sở dữ liệu. Sử dụng:

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

Cách tiếp cận này rất giống với int.TryParse("123", out MyInt);

Nhiều ràng buộc chung không thể được kết hợp theo kiểu OR (ít hạn chế hơn), chỉ theo kiểu AND (hạn chế hơn). Có nghĩa là một phương thức không thể xử lý cả hai kịch bản. Các ràng buộc chung cũng không thể được sử dụng để tạo chữ ký duy nhất cho phương thức, vì vậy bạn phải sử dụng 2 tên phương thức riêng biệt.

Tuy nhiên, bạn có thể sử dụng các ràng buộc chung để đảm bảo rằng các phương thức được sử dụng đúng.

Trong trường hợp của tôi, tôi đặc biệt muốn null được trả về và không bao giờ là giá trị mặc định của bất kỳ loại giá trị nào có thể. GetValueOrDefault = xấu. GetValueOrNull = tốt.

Tôi đã sử dụng các từ "Null" và "Nullable" để phân biệt giữa các loại tham chiếu và loại giá trị. Và đây là một ví dụ về một vài phương thức mở rộng mà tôi đã viết, khen ngợi phương thức FirstOrDefault trong lớp 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;
    }

Cách ngắn hơn:

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

trả lại 0cho intvà nullchoint?