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

Property Info

一些常用到的 property info 判断

public class Person
{
    public string Name1 { get; private set; } = ""; // setter is private
    public string Name2 { private get; set; } = ""; // getter is private
    public string Name3 { get; } = ""; // get only
    public string Name4 { get; init; } = ""; // setter is init
    // public string SetOnly { set; } = ""; // 报错, 不可以只有 set
    // private string Name3 { public get; set; } // 报错, 前面 private 后面 public 是不行的
}

1. BindingFlags.Public, 只要前面是 public 就获取得到, setter 是 private 无所谓.

2.CanWrite

typeof(Person).GetProperty("Name1")!.CanWrite

除非完全没有 set, 要不然 CanWrite 就是 true, init 依然是 true.

3. GetSetMethod 可以用来判断是不是 private, 参考: How to check if property setter is public

var t1 = typeof(Person).GetProperty("Name1")!.GetSetMethod(); // null
var t2 = typeof(Person).GetProperty("Name2")!.GetSetMethod(); // ok
var t3 = typeof(Person).GetProperty("Name3")!.GetSetMethod(); // null
var t4 = typeof(Person).GetProperty("Name4")!.GetSetMethod(); // ok
var person = Activator.CreateInstance(typeof(Person));
typeof(Person).GetProperty("Name1")!.SetValue(person, "dada"); // ok
typeof(Person).GetProperty("Name2")!.SetValue(person, "dada"); // ok
typeof(Person).GetProperty("Name3")!.SetValue(person, "dada"); // error, can't set
typeof(Person).GetProperty("Name4")!.SetValue(person, "dada"); // ok

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

注: 这里是判断 Type, 如果是实例, 直接 object is Interface 就可以了, 不过那个就不是反射了.

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

总结

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