How to use .NET reflection to check for nullable reference type

by

In .NET 6, APIs were added to handle this, see this answer.

Prior to this, you need to read the attributes yourself. This appears to work, at least on the types I’ve tested it with.

public static bool IsNullable(PropertyInfo property) =>
    IsNullableHelper(property.PropertyType, property.DeclaringType, property.CustomAttributes);

public static bool IsNullable(FieldInfo field) =>
    IsNullableHelper(field.FieldType, field.DeclaringType, field.CustomAttributes);

public static bool IsNullable(ParameterInfo parameter) =>
    IsNullableHelper(parameter.ParameterType, parameter.Member, parameter.CustomAttributes);

private static bool IsNullableHelper(Type memberType, MemberInfo? declaringType, IEnumerable<CustomAttributeData> customAttributes)
{
    if (memberType.IsValueType)
        return Nullable.GetUnderlyingType(memberType) != null;

    var nullable = customAttributes
        .FirstOrDefault(x => x.AttributeType.FullName == "System.Runtime.CompilerServices.NullableAttribute");
    if (nullable != null && nullable.ConstructorArguments.Count == 1)
    {
        var attributeArgument = nullable.ConstructorArguments[0];
        if (attributeArgument.ArgumentType == typeof(byte[]))
        {
            var args = (ReadOnlyCollection<CustomAttributeTypedArgument>)attributeArgument.Value!;
            if (args.Count > 0 && args[0].ArgumentType == typeof(byte))
            {
                return (byte)args[0].Value! == 2;
            }
        }
        else if (attributeArgument.ArgumentType == typeof(byte))
        {
            return (byte)attributeArgument.Value! == 2;
        }
    }

    for (var type = declaringType; type != null; type = type.DeclaringType)
    {
        var context = type.CustomAttributes
            .FirstOrDefault(x => x.AttributeType.FullName == "System.Runtime.CompilerServices.NullableContextAttribute");
        if (context != null &&
            context.ConstructorArguments.Count == 1 &&
            context.ConstructorArguments[0].ArgumentType == typeof(byte))
        {
            return (byte)context.ConstructorArguments[0].Value! == 2;
        }
    }

    // Couldn't find a suitable attribute
    return false;
}

See this document for details.

The general gist is that either the property itself can have a [Nullable] attribute on it, or if it doesn’t the enclosing type might have [NullableContext] attribute. We first look for [Nullable], then if we don’t find it we look for [NullableContext] on the enclosing type.

The compiler might embed the attributes into the assembly, and since we might be looking at a type from a different assembly, we need to do a reflection-only load.

[Nullable] might be instantiated with an array, if the property is generic. In this case, the first element represents the actual property (and further elements represent generic arguments). [NullableContext] is always instantiated with a single byte.

A value of 2 means “nullable”. 1 means “not nullable”, and 0 means “oblivious”.

More Related Contents:

  1. Nullable reference types: How to specify “T?” type without constraining to class or struct
  2. Why GetType returns System.Int32 instead of Nullable? [duplicate]
  3. Getting all types that implement an interface
  4. Type.GetType(“namespace.a.b.ClassName”) returns null
  5. How costly is .NET reflection?
  6. Conditional operator assignment with Nullable types?
  7. Select Right Generic Method with Reflection
  8. C# Using Reflection to copy base class properties
  9. Is there a way to set properties on struct instances using reflection?
  10. getting type T from IEnumerable
  11. Recursively Get Properties & Child Properties Of A Class
  12. GetMethod for generic method [duplicate]
  13. What are lifted operators?
  14. How to set enum to null
  15. Type of conditional expression cannot be determined because there is no implicit conversion between ‘int’ and
  16. AddEventHandler using reflection
  17. Instantiating a constructor with parameters in an internal class with reflection
  18. How does comparison operator works with null int?
  19. How to get the value of private field using reflection?
  20. Dynamic Lang. Runtime vs Reflection
  21. How to hide public methods from IntelliSense
  22. How to find out if a property is an auto-implemented property with reflection?
  23. Create object instance of a class from its name in string variable
  24. Serializing a Nullable in to XML
  25. Implementations of interface through Reflection
  26. IsAssignableFrom() returns false when it should return true
  27. How to recursively print the values of an object’s properties using reflection
  28. Get derived class type from a base’s class static method
  29. How to use Activator to create an instance of a generic Type and casting it back to that type?
  30. Run a method before all methods of a class

Leave a Comment