使用反射我们如何判断 class 属性是否为可空集合并获取其数据类型？

Question

I have no problems with properties that are non-nullable collections but everything changes when the property is a nullable collection...

Given a class with nullable collection properties (int?[], long?[], List<Nullable>, ...)

public class SomeClass
{
    public int?[] PropertyX { get; set; }
    public long?[] PropertyY { get; set; }
    public float?[] PropertyZ { get; set; }
    public List<decimal?> PropertyList { get; set; }
    public string Name { get; set; }
} 

How can I tell if the property is a nullable collection ?
Does the nullable collection have any actual values ?
Lastly what is the nullable collections data type ?

public class SomeOtherClass
{
    public string Discover(SomeClass someClass)
    {
        var sb = new StringBuilder();
        foreach (var propertyInfo in someClass.GetType().GetProperties())
        {
            var propValue = propertyInfo.GetValue(someClass, new object[] { });
            if (propValue.IsNullableCollection() && propValue.HasValue())
            {
                sb.AppendFormat("{0} data type is {1}", propValue.GetDataType());
            }
        }
        return sb.ToString();
    }
}

Example:

void Main
{
  var sc = new SomeClass() 
  {
    PropertyX = new int?[2]{50,10}
  };
  var output = new SomeOtherClass().Discover(sc); 
  
  //Display Output ...
}

"PropertyX has values and data type is int."

Answer 1

I've written a method that should give you all the tools you need for your task:

public static void Discover(Type mainType)
{
    foreach (var pi in mainType.GetProperties())
    {
        var t = pi.PropertyType;
        if (t.IsArray)
        {
            (var isNullable, var innerT) = ExamineForNullable(t.GetElementType());
            Console.WriteLine($"{pi.Name} data type is an array of {innerT} (nullable: {isNullable})");
        }
        else if (t.GetInterface(nameof(ICollection)) != null)
        {
            //TODO this is true for dictionaries too!
            if (t.IsGenericType)
            {
                (var isNullable, var innerT) = ExamineForNullable(t.GetGenericArguments()[0]);
                Console.WriteLine($"{pi.Name} data type is collection of {innerT} (nullable: {isNullable})");
            }
            else
            {
                //TODO
            }

        }
        else
        {
            Console.WriteLine($"{pi.Name} data type is {t}");
        }
    }
}

static (bool nullable, Type type) ExamineForNullable(Type t)
    => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>)
            ? (true, Nullable.GetUnderlyingType(t))
            : (false, t);

Let's run it with the following class, which is a modified version of you example class:

public class SomeClass
{
    public int?[] PropertyX { get; set; }

    public List<decimal?> List1 { get; set; }

    public List<decimal> List2 { get; set; }

    public string Name { get; set; }

    public Dictionary<string, decimal?> Dictionary { get; set; }
}

(...) 

Discover(typeof(SomeClass));

Please not that you don't need an object of the class to examine the types: Discover( new SomeClass()) vs Discover(typeof(SomeClass) .

The output is:

PropertyX data type is an array of System.Int32 (nullable: True)
List1 data type is collection of System.Decimal (nullable: True)
List2 data type is collection of System.Decimal (nullable: False)
Name data type is System.String
Dictionary data type is collection of System.String (nullable: False)