启用完整可空上下文的C#中，如何检查方法返回类型是否可空？

问题背景 #

项目已启用<Nullable>enable</Nullable>，需要检查指定命名空间下接口中方法的返回类型，仅当Task<T>的第一层泛型T带有?可空标记时，判定为可空。以下是预期判定规则的示例：

public sealed class Dto
{
    public int Test { get; set; }
}

public sealed class Dto3
{
    public int? Test { get; set; }
}

// 应被识别为可空：Task后的第一层泛型Dto带有?标记
public async Task<Dto?> GetSomething()
{
}

// 不应被识别为可空：Task后的第一层泛型Dto3无?标记
public async Task<Dto3> GetSomething2()
{
}

// 不应被识别为可空：Task后的第一层泛型List<Dto>无?标记
public async Task<List<Dto>> GetSomething3()
{
}

// 不应被识别为可空：Task后的第一层泛型List<Dto?>无?标记（仅内层Dto带?不满足）
public async Task<List<Dto?>> GetSomething3()
{
}

现有代码 #

已有遍历指定命名空间下接口及方法的代码：

var assembly = Assembly.GetAssembly(typeof(ISomethingService));

if (assembly is null)
{
    throw new InvalidOperationException("This should never happen");
}

var classes = assembly.GetTypes().Where(type => 
 (type.Namespace == typeof(ISomethingService).Namespace || type.Namespace == typeof(ISomethingService2).Namespace) && type.IsInterface);

foreach (var @class in classes)
{
    var methods = @class.GetMethods();

    foreach (var method in methods)
    {
        foreach (var genericType in method.ReturnType.GenericTypeArguments)
        {
            if (IsNullable(genericType))
            {
                Console.WriteLine($"Return type of method {@class.Name}.{method.Name} is nullable: {genericType.Name}");
            }
        }
    }
 }

当前的IsNullable方法未达到预期效果：

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

解决方案 #

要检测Task<T>的第一层泛型是否带有可空标记，需要利用.NET中表示可空引用类型的类型注解信息——普通Type对象无法直接区分Dto和Dto?，可空引用类型的标记是通过编译时嵌入的NullableAttribute实现的。

正确的可空检测方法 #

using System.Reflection;
using System.Runtime.CompilerServices;

private static bool IsTaskGenericTypeNullable(Type taskReturnType)
{
    // 先确认返回类型是Task<T>或ValueTask<T>
    if (!taskReturnType.IsGenericType || 
        (taskReturnType.GetGenericTypeDefinition() != typeof(Task<>) && 
         taskReturnType.GetGenericTypeDefinition() != typeof(ValueTask<>)))
    {
        return false;
    }

    // 获取Task的第一层泛型参数
    Type genericArg = taskReturnType.GetGenericArguments()[0];

    // 检查该泛型参数是否带有NullableAttribute
    var nullableAttr = genericArg.CustomAttributes
        .FirstOrDefault(attr => attr.AttributeType == typeof(NullableAttribute));
    
    if (nullableAttr == null)
    {
        return false;
    }

    // 解析NullableAttribute的参数：0表示不可空，1表示可空
    var args = nullableAttr.ConstructorArguments;
    if (args.Count == 0)
    {
        // 无参数的NullableAttribute直接表示可空（C# 8.0+）
        return true;
    }

    var flag = args[0].Value as byte[];
    return flag != null && flag.Length > 0 && flag[0] == 1;
}

修改遍历逻辑 #

将原遍历代码中的判断逻辑替换为：

foreach (var @class in classes)
{
    var methods = @class.GetMethods();

    foreach (var method in methods)
    {
        Type returnType = method.ReturnType;
        if (IsTaskGenericTypeNullable(returnType))
        {
            Type genericArg = returnType.GetGenericArguments()[0];
            Console.WriteLine($"Return type of method {@class.Name}.{method.Name} is nullable: {genericArg.Name}");
        }
    }
}

说明 #

• 该方法仅针对Task<T>和ValueTask<T>的第一层泛型参数做检查，完全符合你要求的判定规则。
• 对于值类型的可空（如int?），Nullable.GetUnderlyingType仍然有效，但这里聚焦于引用类型的可空标记，因此通过NullableAttribute判断更为准确。

内容的提问来源于stack exchange，提问作者FranzHuber23