Làm thế nào để kiểm tra nếu một đối tượng là nullable?

Làm cách nào để kiểm tra xem một đối tượng đã cho là nullable hay nói cách khác là cách thực hiện phương thức sau ...

bool IsNullableValueType(object o)
{
    ...
}

EDIT: Tôi đang tìm kiếm các loại giá trị nullable. Tôi đã không có loại ref trong tâm trí.

//Note: This is just a sample. The code has been simplified 
//to fit in a post.

public class BoolContainer
{
    bool? myBool = true;
}

var bc = new BoolContainer();

const BindingFlags bindingFlags = BindingFlags.Public
                        | BindingFlags.NonPublic
                        | BindingFlags.Instance
                        ;


object obj;
object o = (object)bc;

foreach (var fieldInfo in o.GetType().GetFields(bindingFlags))
{
    obj = (object)fieldInfo.GetValue(o);
}

Bây giờ obj đề cập đến một đối tượng loại bool( System.Boolean) có giá trị bằng true. Những gì tôi thực sự muốn là một đối tượng của loạiNullable<bool>

Vì vậy, bây giờ với tư cách là một công việc xung quanh, tôi quyết định kiểm tra xem o là nullable và tạo một trình bao bọc nullable xung quanh obj.

Có hai loại nullable - Nullable<T>và loại tham chiếu.

Jon đã sửa cho tôi rằng thật khó để có được loại nếu được đóng hộp, nhưng bạn có thể với thuốc generic: - vậy làm thế nào về bên dưới. Đây thực sự là loại thử nghiệm T, nhưng sử dụng objtham số hoàn toàn cho suy luận kiểu chung (để dễ gọi) - objmặc dù vậy nó sẽ hoạt động gần như giống hệt nhau mà không cần tham số.

static bool IsNullable<T>(T obj)
{
    if (obj == null) return true; // obvious
    Type type = typeof(T);
    if (!type.IsValueType) return true; // ref-type
    if (Nullable.GetUnderlyingType(type) != null) return true; // Nullable<T>
    return false; // value-type
}

Nhưng điều này sẽ không hoạt động tốt nếu bạn đã đóng hộp giá trị cho một biến đối tượng.

Tài liệu của Microsoft: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/nullable-types/how-to-identify-a-nullable-type

Có một giải pháp rất đơn giản là sử dụng phương thức quá tải

http://deanchalk.com/is-it-nullable/

đoạn trích:

public static class ValueTypeHelper
{
    public static bool IsNullable<T>(T t) { return false; }
    public static bool IsNullable<T>(T? t) where T : struct { return true; }
}

sau đó

static void Main(string[] args)
{
    int a = 123;
    int? b = null;
    object c = new object();
    object d = null;
    int? e = 456;
    var f = (int?)789;
    bool result1 = ValueTypeHelper.IsNullable(a); // false
    bool result2 = ValueTypeHelper.IsNullable(b); // true
    bool result3 = ValueTypeHelper.IsNullable(c); // false
    bool result4 = ValueTypeHelper.IsNullable(d); // false
    bool result5 = ValueTypeHelper.IsNullable(e); // true
    bool result6 = ValueTypeHelper.IsNullable(f); // true

Câu hỏi "Làm thế nào để kiểm tra nếu một loại là nullable?" thực ra là "Làm thế nào để kiểm tra xem một loại có phải Nullable<>không?", có thể được khái quát thành "Làm thế nào để kiểm tra xem một loại có phải là loại được xây dựng của một số loại chung không?", để nó không chỉ trả lời câu hỏi "Là Nullable<int>một Nullable<>?", mà còn "là List<int>một List<>?".

Hầu hết các giải pháp được cung cấp sử dụng Nullable.GetUnderlyingType()phương pháp, rõ ràng sẽ chỉ hoạt động với trường hợp Nullable<>. Tôi không thấy giải pháp phản xạ chung sẽ hoạt động với bất kỳ loại chung nào, vì vậy tôi quyết định thêm nó vào đây cho hậu thế, mặc dù câu hỏi này đã được trả lời từ lâu.

Để kiểm tra xem một loại có phải là một dạng Nullable<>sử dụng sự phản chiếu hay không, trước tiên bạn phải chuyển đổi loại chung được xây dựng của mình, ví dụ Nullable<int>, thành định nghĩa loại chung , Nullable<>. Bạn có thể làm điều đó bằng cách sử dụng GetGenericTypeDefinition()phương thức của Typelớp. Sau đó, bạn có thể so sánh loại kết quả với Nullable<>:

Type typeToTest = typeof(Nullable<int>);
bool isNullable = typeToTest.GetGenericTypeDefinition() == typeof(Nullable<>);
// isNullable == true

Điều tương tự có thể được áp dụng cho bất kỳ loại chung chung:

Type typeToTest = typeof(List<int>);
bool isList = typeToTest.GetGenericTypeDefinition() == typeof(List<>);
// isList == true

Một số loại có vẻ giống nhau, nhưng một số đối số loại khác nhau có nghĩa là nó là một loại hoàn toàn khác.

Type typeToTest = typeof(Action<DateTime, float>);
bool isAction1 = typeToTest.GetGenericTypeDefinition() == typeof(Action<>);
bool isAction2 = typeToTest.GetGenericTypeDefinition() == typeof(Action<,>);
bool isAction3 = typeToTest.GetGenericTypeDefinition() == typeof(Action<,,>);
// isAction1 == false
// isAction2 == true
// isAction3 == false

Vì Typeđối tượng được khởi tạo một lần cho mỗi loại, bạn có thể kiểm tra sự bằng nhau tham chiếu giữa chúng. Vì vậy, nếu bạn muốn kiểm tra xem hai đối tượng có cùng định nghĩa kiểu chung hay không, bạn có thể viết:

var listOfInts = new List<int>();
var listOfStrings = new List<string>();

bool areSameGenericType =
    listOfInts.GetType().GetGenericTypeDefinition() ==
    listOfStrings.GetType().GetGenericTypeDefinition();
// areSameGenericType == true

Nếu bạn muốn kiểm tra xem một đối tượng có thể là null hay không Type, thì bạn có thể sử dụng kỹ thuật trên cùng với giải pháp của Marc Gravell để tạo ra một phương thức khá đơn giản:

static bool IsNullable<T>(T obj)
{
    if (!typeof(T).IsGenericType)
        return false;

    return typeof(T).GetGenericTypeDefinition() == typeof(Nullable<>);
}

Điều này làm việc cho tôi và có vẻ đơn giản:

static bool IsNullable<T>(T obj)
{
    return default(T) == null;
}

Đối với loại giá trị:

static bool IsNullableValueType<T>(T obj)
{
    return default(T) == null && typeof(T).BaseType != null && "ValueType".Equals(typeof(T).BaseType.Name);
}

Vâng, bạn có thể sử dụng:

return !(o is ValueType);

... nhưng bản thân một đối tượng không thể rỗng hoặc nói cách khác - một loại là. Làm thế nào bạn có kế hoạch sử dụng này?

Cách đơn giản nhất tôi có thể tìm ra là:

public bool IsNullable(object obj)
{
    Type t = obj.GetType();
    return t.IsGenericType 
        && t.GetGenericTypeDefinition() == typeof(Nullable<>);
}

Có hai vấn đề ở đây: 1) thử nghiệm để xem liệu Loại có thể không; và 2) thử nghiệm để xem liệu một đối tượng đại diện cho Loại không thể.

Đối với sự cố 1 (kiểm tra Loại), đây là giải pháp tôi đã sử dụng trong các hệ thống của riêng mình: Giải pháp kiểm tra TypeIsNullable-check

Đối với vấn đề 2 (kiểm tra một đối tượng), giải pháp của Dean Powder ở trên hoạt động đối với các loại giá trị, nhưng nó không hoạt động đối với các loại tham chiếu, vì sử dụng quá tải <T> luôn trả về sai. Vì các loại tham chiếu vốn đã vô hiệu, nên việc kiểm tra một loại tham chiếu sẽ luôn trả về giá trị true. Vui lòng xem ghi chú [Giới thiệu về "nullable"] bên dưới để được giải thích về các ngữ nghĩa này. Vì vậy, đây là sửa đổi của tôi đối với cách tiếp cận của Dean:

    public static bool IsObjectNullable<T>(T obj)
    {
        // If the parameter-Type is a reference type, or if the parameter is null, then the object is always nullable
        if (!typeof(T).IsValueType || obj == null)
            return true;

        // Since the object passed is a ValueType, and it is not null, it cannot be a nullable object
        return false; 
    }

    public static bool IsObjectNullable<T>(T? obj) where T : struct
    {
        // Always return true, since the object-type passed is guaranteed by the compiler to always be nullable
        return true;
    }

Và đây là sửa đổi của tôi đối với mã kiểm tra máy khách cho giải pháp trên:

    int a = 123;
    int? b = null;
    object c = new object();
    object d = null;
    int? e = 456;
    var f = (int?)789;
    string g = "something";

    bool isnullable = IsObjectNullable(a); // false 
    isnullable = IsObjectNullable(b); // true 
    isnullable = IsObjectNullable(c); // true 
    isnullable = IsObjectNullable(d); // true 
    isnullable = IsObjectNullable(e); // true 
    isnullable = IsObjectNullable(f); // true 
    isnullable = IsObjectNullable(g); // true

Lý do tôi đã sửa đổi cách tiếp cận của Dean trong IsObjectNullable <T> (T t) là cách tiếp cận ban đầu của anh ta luôn trả về sai cho loại tham chiếu. Vì một phương thức như IsObjectNullable sẽ có thể xử lý các giá trị loại tham chiếu và vì tất cả các loại tham chiếu đều là null, nên nếu một kiểu tham chiếu hoặc null được truyền, thì phương thức sẽ luôn trả về đúng.

Hai phương thức trên có thể được thay thế bằng phương thức đơn sau đây và đạt được cùng một đầu ra:

    public static bool IsObjectNullable<T>(T obj)
    {
        Type argType = typeof(T);
        if (!argType.IsValueType || obj == null)
            return true;
        return argType.IsGenericType && argType.GetGenericTypeDefinition() == typeof(Nullable<>);
    }

Tuy nhiên, vấn đề với cách tiếp cận phương thức đơn cuối cùng này là hiệu năng bị ảnh hưởng khi sử dụng tham số Nullable <T>. Phải mất nhiều thời gian xử lý hơn để thực thi dòng cuối cùng của phương thức này so với việc cho phép trình biên dịch chọn quá tải phương thức thứ hai được hiển thị trước đó khi tham số Nullable <T> -type được sử dụng trong lệnh gọi IsObjectNullable. Do đó, giải pháp tối ưu là sử dụng phương pháp hai phương pháp được minh họa ở đây.

CAVEAT: Phương thức này chỉ hoạt động đáng tin cậy nếu được gọi bằng cách sử dụng tham chiếu đối tượng ban đầu hoặc một bản sao chính xác, như trong các ví dụ. Tuy nhiên, nếu một đối tượng nullable được đóng hộp vào Loại khác (chẳng hạn như đối tượng, v.v.) thay vì còn lại ở dạng Nullable <> ban đầu, phương thức này sẽ không hoạt động đáng tin cậy. Nếu mã gọi phương thức này không sử dụng tham chiếu đối tượng gốc, không có hộp hoặc một bản sao chính xác, thì nó không thể xác định một cách đáng tin cậy tính vô hiệu của đối tượng bằng phương thức này.

Trong hầu hết các kịch bản mã hóa, để xác định tính không có giá trị, người ta phải dựa vào việc kiểm tra Loại của đối tượng ban đầu, chứ không phải tham chiếu của nó (ví dụ: mã phải có quyền truy cập vào Loại ban đầu của đối tượng để xác định tính không hợp lệ). Trong những trường hợp phổ biến hơn này, IsTypeNullable (xem liên kết) là một phương pháp đáng tin cậy để xác định tính không hợp lệ.

PS - Giới thiệu về "nullable"

Tôi nên lặp lại một tuyên bố về sự vô hiệu mà tôi đã thực hiện trong một bài đăng riêng biệt, áp dụng trực tiếp để giải quyết đúng chủ đề này. Đó là, tôi tin rằng trọng tâm của cuộc thảo luận ở đây không phải là làm thế nào để kiểm tra xem một đối tượng có phải là loại Nullable chung hay không, mà là liệu người ta có thể gán giá trị null cho một đối tượng thuộc loại đó không. Nói cách khác, tôi nghĩ rằng chúng ta nên xác định xem một loại đối tượng là nullable, chứ không phải là Nullable. Sự khác biệt là về ngữ nghĩa, cụ thể là lý do thực tế để xác định tính vô hiệu, thường là tất cả những gì quan trọng.

Trong một hệ thống sử dụng các đối tượng với các loại có thể không xác định cho đến thời gian chạy (dịch vụ web, cuộc gọi từ xa, cơ sở dữ liệu, nguồn cấp dữ liệu, v.v.), một yêu cầu chung là xác định xem null có thể được gán cho đối tượng hay không hoặc liệu đối tượng có thể chứa một con số không Việc thực hiện các hoạt động như vậy trên các loại không có giá trị sẽ có thể tạo ra lỗi, thường là các trường hợp ngoại lệ, rất tốn kém cả về hiệu suất và yêu cầu mã hóa. Để thực hiện phương pháp được ưu tiên cao là chủ động tránh các vấn đề như vậy, cần xác định xem một đối tượng của Loại tùy ý có khả năng chứa null hay không; tức là, cho dù đó là "không thể".

Theo một nghĩa rất thực tế và điển hình, tính vô hiệu trong các thuật ngữ .NET hoàn toàn không ngụ ý rằng Loại của đối tượng là một dạng Nullable. Trong nhiều trường hợp trên thực tế, các đối tượng có các kiểu tham chiếu, có thể chứa giá trị null và do đó tất cả đều là null; không ai trong số này có loại Nullable. Do đó, đối với các mục đích thực tế trong hầu hết các kịch bản, thử nghiệm nên được thực hiện cho khái niệm chung về tính không có giá trị, so với khái niệm phụ thuộc vào việc thực hiện của Nullable. Vì vậy, chúng ta không nên gác máy bằng cách chỉ tập trung vào loại .NET Nullable mà nên kết hợp sự hiểu biết của chúng ta về các yêu cầu và hành vi của nó trong quá trình tập trung vào khái niệm chung, thực tế về tính vô hiệu.

Giải pháp đơn giản nhất mà tôi đã đưa ra là triển khai giải pháp của Microsoft ( Cách: Xác định loại không thể (Hướng dẫn lập trình C #) ) như một phương pháp mở rộng:

public static bool IsNullable(this Type type)
{
    return Nullable.GetUnderlyingType(type) != null;
}

Điều này sau đó có thể được gọi như vậy:

bool isNullable = typeof(int).IsNullable();

Đây cũng có vẻ là một cách hợp lý để truy cập IsNullable()vì nó phù hợp với tất cả các IsXxxx()phương thức khác của Typelớp.

Hãy cẩn thận, khi đấm bốc một loại nullable ( Nullable<int>hoặc int? Chẳng hạn):

int? nullValue = null;
object boxedNullValue = (object)nullValue;
Debug.Assert(boxedNullValue == null);

int? value = 10;
object boxedValue = (object)value;
Debug.Assert( boxedValue.GetType() == typeof(int))

Nó trở thành một kiểu tham chiếu thực sự, vì vậy bạn mất đi sự thật là nó không thể.

Có thể một chút lạc đề, nhưng vẫn còn một số thông tin thú vị. Tôi tìm thấy rất nhiều người sử dụng Nullable.GetUnderlyingType() != nullđể nhận dạng nếu một loại là nullable. Điều này rõ ràng hoạt động, nhưng Microsoft khuyên những điều sau đây type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)(xem http://msdn.microsoft.com/en-us/l Library / ms366789.aspx ).

Tôi đã xem xét điều này từ một khía cạnh hiệu suất. Kết luận của thử nghiệm (một triệu lần thử) bên dưới là khi một loại là không thể, tùy chọn Microsoft mang lại hiệu suất tốt nhất.

Nullable.GetUnderellingType (): 1335ms (chậm hơn 3 lần)

GetGenericTypeDefDef () == typeof (Không thể <>): 500ms

Tôi biết rằng chúng ta đang nói về một lượng nhỏ thời gian, nhưng mọi người đều thích điều chỉnh mili giây :-)! Vì vậy, nếu ông chủ của bạn muốn bạn giảm một vài phần nghìn giây thì đây là vị cứu tinh của bạn ...

/// <summary>Method for testing the performance of several options to determine if a type is     nullable</summary>
[TestMethod]
public void IdentityNullablePerformanceTest()
{
    int attempts = 1000000;

    Type nullableType = typeof(Nullable<int>);

    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();
    for (int attemptIndex = 0; attemptIndex < attempts; attemptIndex++)
    {
        Assert.IsTrue(Nullable.GetUnderlyingType(nullableType) != null, "Expected to be a nullable"); 
    }

    Console.WriteLine("Nullable.GetUnderlyingType(): {0} ms", stopwatch.ElapsedMilliseconds);

    stopwatch.Restart();

    for (int attemptIndex = 0; attemptIndex < attempts; attemptIndex++)
   {
       Assert.IsTrue(nullableType.IsGenericType && nullableType.GetGenericTypeDefinition() == typeof(Nullable<>), "Expected to be a nullable");
   }

   Console.WriteLine("GetGenericTypeDefinition() == typeof(Nullable<>): {0} ms", stopwatch.ElapsedMilliseconds);
   stopwatch.Stop();
}

Phiên bản này:

• kết quả bộ nhớ đệm nhanh hơn,
• không yêu cầu các biến không cần thiết, như Phương thức (T obj)
• KHÔNG PHỨC TẠP :),
• chỉ là lớp chung tĩnh, có các trường được tính toán một lần

:

public static class IsNullable<T>
{
    private static readonly Type type = typeof(T);
    private static readonly bool is_nullable = type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
    public static bool Result { get { return is_nullable; } }
}

bool is_nullable = IsNullable<int?>.Result;

Đây là những gì tôi nghĩ ra, vì mọi thứ khác dường như thất bại - ít nhất là trên PLC - Thư viện lớp di động / .NET Core với> = C # 6

Giải pháp: Mở rộng phương pháp tĩnh cho bất kỳ loại Tvà Nullable<T>và sử dụng thực tế là phương pháp khuyến nông tĩnh, phù hợp với các loại cơ bản sẽ được gọi và được ưu tiên hơn các chung Tmở rộng-method.

Dành cho T :

public static partial class ObjectExtension
{
    public static bool IsNullable<T>(this T self)
    {
        return false;
    }
}

va cho Nullable<T>

public static partial class NullableExtension
{
    public static bool IsNullable<T>(this Nullable<T> self) where T : struct
    {
        return true;
    }
}

Sử dụng Reflection và type.IsGenericType... không hoạt động trên tập hợp .NET Runtimes hiện tại của tôi. Tài liệu MSDN cũng không giúp được gì.

if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)) {…}

Một phần vì API Reflection đã được thay đổi khá đáng kể trong .NET Core.

Tôi nghĩ rằng những ứng dụng sử dụng thử nghiệm được đề xuất của Microsoft IsGenericTypelà tốt, nhưng trong mã cho GetUnderlyingType, Microsoft sử dụng thử nghiệm bổ sung để đảm bảo bạn không vượt qua định nghĩa loại chung Nullable<>:

 public static bool IsNullableType(this Type nullableType) =>
    // instantiated generic type only                
    nullableType.IsGenericType &&
    !nullableType.IsGenericTypeDefinition &&
    Object.ReferenceEquals(nullableType.GetGenericTypeDefinition(), typeof(Nullable<>));

một cách đơn giản để làm điều này:

    public static bool IsNullable(this Type type)
    {
        if (type.IsValueType) return Activator.CreateInstance(type) == null;

        return true;
    }

đây là những bài kiểm tra đơn vị của tôi và tất cả đã qua

    IsNullable_String_ShouldReturn_True
    IsNullable_Boolean_ShouldReturn_False
    IsNullable_Enum_ShouldReturn_Fasle
    IsNullable_Nullable_ShouldReturn_True
    IsNullable_Class_ShouldReturn_True
    IsNullable_Decimal_ShouldReturn_False
    IsNullable_Byte_ShouldReturn_False
    IsNullable_KeyValuePair_ShouldReturn_False

kiểm tra đơn vị thực tế

    [TestMethod]
    public void IsNullable_String_ShouldReturn_True()
    {
        var typ = typeof(string);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Boolean_ShouldReturn_False()
    {
        var typ = typeof(bool);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Enum_ShouldReturn_Fasle()
    {
        var typ = typeof(System.GenericUriParserOptions);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Nullable_ShouldReturn_True()
    {
        var typ = typeof(Nullable<bool>);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Class_ShouldReturn_True()
    {
        var typ = typeof(TestPerson);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Decimal_ShouldReturn_False()
    {
        var typ = typeof(decimal);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Byte_ShouldReturn_False()
    {
        var typ = typeof(byte);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_KeyValuePair_ShouldReturn_False()
    {
        var typ = typeof(KeyValuePair<string, string>);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }