จะตรวจสอบว่าวัตถุนั้นเป็นโมฆะได้อย่างไร?

ฉันจะตรวจสอบว่าวัตถุที่กำหนดเป็นโมฆะในคำอื่น ๆ วิธีการใช้วิธีการดังต่อไปนี้ ...

bool IsNullableValueType(object o)
{
    ...
}

แก้ไข: ฉันกำลังมองหาประเภทค่าที่เป็นโมฆะ ฉันไม่มีประเภทอ้างอิง

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

obj ตอนนี้หมายถึงวัตถุของการพิมพ์bool( System.Boolean) trueมีค่าเท่ากับ สิ่งที่ฉันต้องการจริงๆคือประเภทของวัตถุNullable<bool>

ดังนั้นในขณะที่การทำงานรอบ ๆ ฉันตัดสินใจที่จะตรวจสอบว่า o เป็นโมฆะและสร้างเสื้อคลุม nullable รอบ obj

มีค่า null สองประเภท - Nullable<T>และชนิดอ้างอิง

จอนแก้ไขให้ฉันด้วยว่ามันยากที่จะพิมพ์ถ้าเป็นแบบกล่อง แต่คุณสามารถใช้ชื่อสามัญได้: - แล้วด้านล่างล่ะ นี่เป็นการทดสอบประเภทจริง ๆTแต่การใช้objพารามิเตอร์ล้วนสำหรับการอนุมานประเภททั่วไป (เพื่อให้ง่ายต่อการโทร) - มันจะทำงานเกือบเหมือนกันโดยไม่มีobjพารามิเตอร์แม้ว่า

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
}

แต่สิ่งนี้จะทำงานได้ไม่ดีนักหากคุณได้ใส่ค่าลงในตัวแปร object แล้ว

เอกสารของ Microsoft: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/nullable-types/how-to-identify-a-nullable-type

มีวิธีแก้ปัญหาที่ง่ายมากโดยใช้เมธอดโอเวอร์โหลด

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

ตัดตอนมา:

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

แล้วก็

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

คำถามของ "วิธีการตรวจสอบว่าประเภทเป็นโมฆะ?" เป็นจริง "วิธีการตรวจสอบว่าเป็นประเภทNullable<>" ซึ่งสามารถ generalized เพื่อ "วิธีการตรวจสอบว่าเป็นประเภททั่วไปประเภทสร้าง?" เพื่อที่จะไม่เพียง แต่ตอบคำถาม " Nullable<int>เป็นNullable<>?" แต่ยัง " List<int>เป็นList<>หรือไม่"

โซลูชันที่ให้มาส่วนใหญ่ใช้Nullable.GetUnderlyingType()วิธีการซึ่งเห็นได้ชัดว่าใช้ได้กับกรณีของNullable<>เท่านั้น ฉันไม่เห็นโซลูชันไตร่ตรองทั่วไปที่จะใช้ได้กับประเภททั่วไปใด ๆ ดังนั้นฉันตัดสินใจเพิ่มที่นี่เพื่อลูกหลานแม้ว่าคำถามนี้จะได้รับคำตอบมานานแล้ว

เพื่อตรวจสอบว่าเป็นชนิดที่เป็นรูปแบบของบางอย่างNullable<>ใช้สะท้อนอันดับแรกคุณต้องแปลงประเภททั่วไปของคุณสร้างขึ้นเช่นลงไปในการกำหนดประเภททั่วไปNullable<int> Nullable<>คุณสามารถทำได้โดยใช้GetGenericTypeDefinition()วิธีการTypeเรียน จากนั้นคุณสามารถเปรียบเทียบประเภทผลลัพธ์กับNullable<>:

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

สามารถนำไปใช้กับประเภททั่วไปใด ๆ :

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

หลายประเภทอาจดูเหมือนกัน แต่จำนวนอาร์กิวเมนต์ประเภทที่แตกต่างกันหมายความว่าเป็นประเภทที่แตกต่างอย่างสิ้นเชิง

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

เนื่องจากTypeวัตถุนั้นถูกสร้างขึ้นหนึ่งครั้งต่อประเภทคุณสามารถตรวจสอบความเท่าเทียมกันของการอ้างอิงระหว่างพวกเขาได้ ดังนั้นหากคุณต้องการตรวจสอบว่าวัตถุสองรายการนั้นมีคำจำกัดความชนิดเดียวกันหรือไม่คุณสามารถเขียน:

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

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

หากคุณต้องการตรวจสอบว่าวัตถุนั้นเป็นโมฆะหรือไม่Typeคุณสามารถใช้เทคนิคข้างต้นร่วมกับโซลูชันของ Marc Gravell เพื่อสร้างวิธีการที่ค่อนข้างง่าย:

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

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

มันใช้งานได้สำหรับฉันและดูเหมือนง่าย:

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

สำหรับประเภทค่า:

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

คุณสามารถใช้:

return !(o is ValueType);

... แต่ตัววัตถุเองนั้นไม่สามารถเป็นโมฆะหรืออย่างอื่น - ชนิดคือ คุณวางแผนที่จะใช้สิ่งนี้อย่างไร

วิธีที่ง่ายที่สุดที่ฉันสามารถหาได้คือ:

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

มีสองประเด็นที่นี่: 1) การทดสอบเพื่อดูว่าประเภทเป็นโมฆะ; และ 2) การทดสอบเพื่อดูว่าวัตถุแสดงถึงประเภท nullable

สำหรับปัญหา 1 (ทดสอบประเภท) นี่เป็นวิธีแก้ปัญหาที่ฉันใช้ในระบบของฉันเอง: TypeIsNullable-check solution

สำหรับปัญหา 2 (ทดสอบวัตถุ) โซลูชันของ Dean Chalk ด้านบนใช้งานได้กับประเภทค่า แต่มันไม่ทำงานสำหรับประเภทอ้างอิงเนื่องจากการใช้ <T> เกินพิกัดจะส่งคืนค่าเท็จเสมอ เนื่องจากประเภทการอ้างอิงนั้นเป็นโมฆะโดยเนื้อแท้การทดสอบประเภทการอ้างอิงจึงควรกลับมาจริง โปรดดูหมายเหตุ [เกี่ยวกับ "ความไร้ผล"] ด้านล่างสำหรับคำอธิบายของความหมายเหล่านี้ ดังนั้นนี่คือการแก้ไขแนวทางของ 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;
    }

และนี่คือการแก้ไขรหัสลูกค้าทดสอบของฉันสำหรับการแก้ปัญหาข้างต้น:

    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

เหตุผลที่ฉันแก้ไขแนวทางของ Dean ใน IsObjectNullable <T> (T t) คือวิธีดั้งเดิมของเขาส่งคืนเท็จเสมอสำหรับประเภทการอ้างอิง เนื่องจากวิธีการเช่น IsObjectNullable ควรสามารถจัดการค่าชนิดการอ้างอิงและเนื่องจากชนิดของการอ้างอิงทั้งหมดเป็นโมฆะโดยเนื้อแท้แล้วถ้าผ่านประเภทการอ้างอิงหรือเป็นโมฆะวิธีการควรกลับจริง

สองวิธีข้างต้นสามารถแทนที่ด้วยวิธีการเดียวต่อไปนี้และบรรลุผลลัพธ์เดียวกัน:

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

อย่างไรก็ตามปัญหาของวิธีการเดียววิธีสุดท้ายนี้คือประสิทธิภาพลดลงเมื่อใช้พารามิเตอร์ Nullable <T> ใช้เวลาประมวลผลมากขึ้นในการดำเนินการบรรทัดสุดท้ายของวิธีการเดียวนี้มากกว่าการอนุญาตให้คอมไพเลอร์เลือกวิธีที่สองเกินพิกัดที่แสดงก่อนหน้านี้เมื่อใช้พารามิเตอร์ Nullable <T> -type ในการเรียก IsObjectNullable ดังนั้นทางออกที่ดีที่สุดคือการใช้วิธีสองวิธีที่แสดงไว้ที่นี่

ถ้ำ: วิธีนี้ใช้งานได้อย่างน่าเชื่อถือเฉพาะในกรณีที่ถูกเรียกโดยใช้การอ้างอิงวัตถุดั้งเดิมหรือสำเนาที่แน่นอนดังที่แสดงในตัวอย่าง อย่างไรก็ตามหากวัตถุที่ไม่มีค่าเป็นชนิดอื่น (เช่นวัตถุเป็นต้น) แทนที่จะถูกบรรจุในรูปแบบ Nullable <> ดั้งเดิมวิธีนี้จะไม่สามารถทำงานได้อย่างน่าเชื่อถือ ถ้ารหัสที่เรียกใช้วิธีนี้ไม่ได้ใช้การอ้างอิงวัตถุต้นฉบับที่ไม่มีกล่องหรือสำเนาที่แน่นอนมันไม่สามารถตรวจสอบความถูกต้องของวัตถุได้โดยใช้วิธีนี้

ในสถานการณ์การเขียนโค้ดส่วนใหญ่ในการพิจารณาความสามารถในการลบล้างเราต้องพึ่งพาการทดสอบประเภทของวัตถุดั้งเดิมไม่ใช่การอ้างอิง (เช่นรหัสจะต้องมีการเข้าถึงประเภทดั้งเดิมของวัตถุเพื่อกำหนดความถูกต้อง) ในกรณีที่พบบ่อยเหล่านี้ IsTypeNullable (ดูลิงค์) เป็นวิธีการที่เชื่อถือได้ในการพิจารณาความสามารถในการเป็นโมฆะ

PS - เกี่ยวกับ "nullability"

ฉันควรทำซ้ำคำสั่งเกี่ยวกับความถูกต้องฉันทำในโพสต์แยกซึ่งใช้โดยตรงกับที่อยู่หัวข้อนี้อย่างถูกต้อง นั่นคือฉันเชื่อว่าจุดเน้นของการอภิปรายที่นี่ไม่ควรเป็นวิธีการตรวจสอบเพื่อดูว่าวัตถุเป็นชนิด Nullable ทั่วไปหรือไม่ แต่จะว่าใครสามารถกำหนดค่า null ให้กับวัตถุประเภทนั้น ในคำอื่น ๆ ฉันคิดว่าเราควรจะกำหนดว่าประเภทวัตถุเป็นโมฆะไม่ว่าจะเป็นโมฆะ ความแตกต่างในความหมายคือเหตุผลที่เป็นประโยชน์ในการกำหนดความไร้ซึ่งมักเป็นเรื่องที่

ในระบบที่ใช้ออบเจ็กต์ที่มีชนิดที่ไม่รู้จักจนกระทั่งถึงเวลาใช้งาน (บริการบนเว็บการโทรทางไกลฐานข้อมูลฟีดและอื่น ๆ ) ข้อกำหนดทั่วไปคือการพิจารณาว่า null สามารถกำหนดให้กับวัตถุหรืออาจมีวัตถุ เป็นโมฆะ การดำเนินการดังกล่าวกับประเภทที่ไม่เป็นโมฆะอาจทำให้เกิดข้อผิดพลาดซึ่งมักจะมีข้อยกเว้นซึ่งมีราคาแพงมากทั้งในแง่ของประสิทธิภาพและความต้องการการเข้ารหัส ในการใช้แนวทางที่เป็นที่ต้องการอย่างสูงในการหลีกเลี่ยงปัญหาดังกล่าวจำเป็นต้องพิจารณาว่าวัตถุประเภทใด ๆ ที่มีความสามารถในการบรรจุโมฆะหรือไม่ นั่นคือไม่ว่าจะเป็น 'nullable' โดยทั่วไป

ในทางปฏิบัติและโดยทั่วไปแล้วความสามารถในการลบล้างใน. NET นั้นไม่ได้หมายความว่าประเภทของวัตถุนั้นเป็นรูปแบบของความว่างเปล่า ในความเป็นจริงหลาย ๆ กรณีวัตถุมีประเภทอ้างอิงสามารถมีค่าเป็นโมฆะและทำให้เป็นโมฆะทั้งหมด; สิ่งเหล่านี้ไม่มีประเภทที่เป็นโมฆะ ดังนั้นเพื่อจุดประสงค์ในทางปฏิบัติในสถานการณ์ส่วนใหญ่การทดสอบควรทำสำหรับแนวคิดทั่วไปเกี่ยวกับความไร้ประสิทธิภาพและแนวคิดที่ขึ้นกับการนำไปปฏิบัติของ Nullable ดังนั้นเราไม่ควรวางสายโดยเน้นที่. NET Nullable แต่เพียงอย่างเดียว แต่รวมความเข้าใจของเราเกี่ยวกับข้อกำหนดและพฤติกรรมในกระบวนการของการมุ่งเน้นที่แนวคิดทั่วไปที่ใช้งานได้จริง

โซลูชันที่ง่ายที่สุดที่ฉันใช้คือการใช้โซลูชันของ Microsoft ( วิธีการ: ระบุประเภท Nullable Type (คู่มือการเขียนโปรแกรม C #) ) เป็นวิธีการขยาย:

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

สิ่งนี้สามารถถูกเรียกเช่นนั้น:

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

นี่ก็ดูเหมือนจะเป็นวิธีที่มีเหตุผลในการเข้าถึงIsNullable()เพราะมันสอดคล้องกับIsXxxx()วิธีการอื่นทั้งหมดของTypeชั้นเรียน

ระวังตัวด้วยการชกมวยประเภทที่ไม่สามารถใช้การได้ ( Nullable<int>หรือ int เป็นต้น):

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

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

มันเป็นประเภทการอ้างอิงที่แท้จริงดังนั้นคุณสูญเสียความจริงที่ว่ามันเป็นโมฆะ

อาจเป็นหัวข้อเล็กน้อย แต่ก็ยังมีข้อมูลที่น่าสนใจ ฉันพบผู้คนจำนวนมากที่ใช้Nullable.GetUnderlyingType() != nullระบุตัวตนหากประเภทเป็นโมฆะ เห็นได้ชัดว่าใช้งานได้ แต่ Microsoft แนะนำต่อไปนี้type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)(ดูhttp://msdn.microsoft.com/en-us/library/ms366789.aspx )

ฉันมองสิ่งนี้จากมุมมองด้านการแสดง บทสรุปของการทดสอบ (หนึ่งล้านครั้ง) ด้านล่างคือเมื่อประเภทเป็นโมฆะตัวเลือก Microsoft จะให้ประสิทธิภาพที่ดีที่สุด

Nullable.GetUnderlyingType (): 1335ms (ช้าลง 3 ครั้ง)

GetGenericTypeDefinition () == typeof (Nullable <>): 500ms

ฉันรู้ว่าเรากำลังพูดถึงเวลาเล็กน้อย แต่ทุกคนชอบที่จะปรับแต่งมิลลิวินาที :-)! ดังนั้นถ้าคุณเป็นเจ้านายต้องการให้คุณลดมิลลิวินาทีนี่เป็นผู้ช่วยคุณ ...

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

รุ่นนี้:

• ผลการแคชเร็วขึ้น
• ไม่ต้องการตัวแปรที่ไม่จำเป็นเช่น Method (T obj)
• ไม่ซับซ้อน :)
• แค่คลาสทั่วไปแบบสแตติกที่มีฟิลด์ที่คำนวณได้ครั้งเดียว

:

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;

นี่คือสิ่งที่ฉันเกิดขึ้นเพราะทุกอย่างดูเหมือนจะล้มเหลว - อย่างน้อยในPLC - Portable Class Library / .NET Coreด้วย> = C # 6

การแก้ไข:ขยายวิธีการแบบคงที่สำหรับประเภทใดTและNullable<T>และใช้ความจริงที่ว่าวิธีขยายคงที่ตรงกับประเภทต้นแบบจะถูกเรียกและจะเหนือกว่าทั่วไปTส่วนขยายวิธีการ

สำหรับT:

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

และสำหรับ Nullable<T>

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

การใช้ Reflection และtype.IsGenericType... ไม่ทำงานในชุด. NET Runtimes ปัจจุบันของฉัน และเอกสาร MSDN ก็ช่วยได้เช่นกัน

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

ส่วนหนึ่งเป็นเพราะ Reflection API มีการเปลี่ยนแปลงค่อนข้างมากใน. NET Core

ฉันคิดว่าสิ่งที่ใช้การทดสอบที่ Microsoft แนะนำIsGenericTypeนั้นดี แต่ในรหัสสำหรับGetUnderlyingTypeMicrosoft ใช้การทดสอบเพิ่มเติมเพื่อให้แน่ใจว่าคุณไม่ได้ผ่านการกำหนดประเภททั่วไปNullable<>:

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

วิธีง่ายๆในการทำสิ่งนี้:

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

        return true;
    }

นี่คือการทดสอบหน่วยของฉันและผ่านไปทั้งหมด

    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

การทดสอบหน่วยที่แท้จริง

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