ASP.NET Core C# 反射 & 表达式树 (第二篇)

前言 

上一篇讲到了各种反射的操作方式, 这一篇主要说说如何找到类型.

Type Information

在找类型的时候, 除了依据简单的 string 以外, 还会用到很多类型属性来做判断.

比如它是不是 value type, 它是不是 Enum, 它是不是 interface, 它是不是继承了某一个类型.

常用到的识别

// is inherit other class
var yes1 = typeof(Dog).IsAssignableTo(typeof(Animal)); // true
var yes2 = typeof(Animal).IsAssignableFrom(typeof(Dog)); // true

var yes3 = typeof(int).IsValueType; // true
var yes4 = typeof(string).IsValueType; // false
var yse5 = typeof(Enum1).IsEnum; // true
var yes6 = typeof(Interface1).IsInterface; // true

// have generic ?
var yes7 = typeof(HaveGeneric<>).IsGenericType; // true

Is nullable string?

从 .NET 6 开始, 反射可以检查出是不是 nullable string 和 reference 了.

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

Announcing .NET 6 Preview 7

var type = typeof(Person);
var context = new NullabilityInfoContext();
var nameProperty = type.GetProperty("Name")!;
var nameInfo = context.Create(nameProperty);
var isNullable = nameInfo.ReadState == NullabilityState.Nullable; // true

BindingFlags

BindingFlags 能在获取 properties, methods, fields, etc. 的时候, 指定 private, public, static, etc. 的范围.

比较常用到的

图片l来源: 详解 .NET 反射中的 BindingFlags 以及常用的 BindingFlags 使用方式 

常用的方式

var constructors = type.GetConstructors(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
var properties = type.GetProperties();
var methods = type.GetMethods(); // 不包括 constructor
var fields = type.GetFields();
var members = type.GetMembers(); // 全部东西

默认就是 Public, Instance, Static

Generic 高级

var type    = typeof(Animal<,>);
var yes     = type.IsGenericType; // 虽然还没有填充内容, 它依旧是一个 GenericType
var yes1    = type.ContainsGenericParameters; // 表示它还没有填充内容 (虽然字面意思好像是反过来 /.\, 但总之 true 就表示还没有 MakeGenericType 就对了...)
type.MakeGenericType(new Type[] { typeof(string), typeof(int) });
var yes2    = type.ContainsGenericParameters; // 依然是 true, 因为填充不是 void method
var newType = type.MakeGenericType(new Type[] { typeof(string), typeof(int) });
var no      = newType.ContainsGenericParameters; // false, 这就表示已经有填充内容了.
var yes3    = type == typeof(Animal<,>); // yes
var yes4    = newType == typeof(Animal<string,int>); // yes
var yes5    = newType.GetGenericTypeDefinition() == typeof(Animal<,>); // yes 通过 GetGenericTypeDefinition 可以返回还没填充的类型

上一篇只是讲了简单的导入，导出. 这篇补上一些其它小细节. 

1. MakeGenericType 不是 void method 哦

2. ContainsGenericParameters = true 表示这个 type 还没有被填充 MakeGenericType, false 表示已经有内容了.

3. IsGenericType 不管有没有内容, 只要是 Generic 就是 true 

4. GetGenericTypeDefinition 返回还没有填充的 Generic Type

Class has implement some interface?

要判断一个 class 是否有 implement 某个 interface, 最好的方式就是拿这个 class type 的所有 interfaces 出来对比

/// <summary>
/// check if class implement interface
/// </summary>
/// <param name="classType"></param>
/// <param name="interfaceType">if interface is empty generic [,] then class will use empty generic too for compare, if not then == compare</param>
/// <returns></returns>
public static bool HasImplementInterface(Type classType, Type interfaceType)
{
    var requireIsGenericType = interfaceType.IsGenericType;
    var requireIsEmptyGeneric = interfaceType.ContainsGenericParameters; // is empty <,> ?
    return classType.GetInterfaces().Where(classInterface =>
    {
        if (requireIsGenericType && requireIsEmptyGeneric)
        {
            if (!classInterface.IsGenericType) return false;
            return classInterface.GetGenericTypeDefinition() == interfaceType;
        }
        else
        {
            return classInterface == interfaceType;
        }
    }).Any();
}

Get Right Overload Method

当方法有重载的时候, 就不可以仅仅通过方法名来获取到正确的方法.

需要判断它的 Generic, 还有它的 Parameters 类型

public static MethodInfo GetMethod(Type classType, string methodName, List<Type> genericTypes = null!, List<Type> parameterTypes = null!)
{
    genericTypes ??= new();
    parameterTypes ??= new();
    return classType.GetMethods()
            .Where(
                m => m.Name == methodName &&
                m.GetGenericArguments().Length == genericTypes.Count &&
                m.GetParameters().Length == parameterTypes.Count
            )
            .Select(m => genericTypes.Count > 0 ? m.MakeGenericMethod(genericTypes.ToArray()) : m)
            .Single(m => m.GetParameters().Select(p => p.ParameterType).SequenceEqual(parameterTypes));
}

首先是 name, generic count, parameter count 要对

然后把 generic type 填充进去 method type, 然后才可以对比 parameters. 

因为 generic 可能就会用到 parameter 上, 如果没有填充好的话, 对比 parameter type 就会错了.

Get Right Overload Constructor

public static ConstructorInfo GetConstructor(Type classType, List<Type> paramTypes = null!)
{
    paramTypes ??= new();
    return classType.GetConstructors()
            .Where(m => m.GetParameters().Length == paramTypes.Count)
            .Single(m => m.GetParameters().Select(p => p.ParameterType).SequenceEqual(paramTypes));
}

这个就比较简单, 因为 Constructor 不会有 Generic, 有 Generic 的是它的 Class

总结

到这里, 反射就算有个基本功了. 下一篇来看看表达式树.