/// <summary>
/// 字段信息
/// </summary>
/// <param name="field">字段信息</param>
/// <param name="filter">选择类型</param>
/// <param name="index">成员编号</param>
public fieldIndex(FieldInfo field, memberFilters filter, int index)
: base(field, filter, index)
{
IsField = CanGet = true;
CanSet = !field.IsInitOnly;
Type = field.FieldType;
}
/// <summary>
/// 属性信息
/// </summary>
/// <param name="property">属性信息</param>
/// <param name="filter">选择类型</param>
/// <param name="index">成员编号</param>
public propertyIndex(PropertyInfo property, memberFilters filter, int index)
: base(property, filter, index)
{
CanSet = property.CanWrite;
CanGet = property.CanRead;
Type = property.PropertyType;
}
/// <summary>
/// 成员方法
/// </summary>
/// <param name="method">成员方法信息</param>
/// <param name="filter">选择类型</param>
internal methodInfo(MethodInfo method, memberFilters filter)
: base(method, filter)
{
Method = method;
ReturnType = method.ReturnType;
Type[] genericParameters = method.GetGenericArguments();
Parameters = parameterInfo.Get(method, genericParameters);
OutputParameters = Parameters.getFindArray(value => value.Parameter.IsOut || value.Parameter.ParameterType.IsByRef);
GenericParameters = genericParameters.getArray(value => (memberType)value);
}
/// <summary>
/// 成员信息
/// </summary>
/// <param name="member">成员信息</param>
protected memberIndex(memberIndex member)
{
Member = member.Member;
Type = member.Type;
MemberIndex = member.MemberIndex;
Filter = member.Filter;
IsField = member.IsField;
CanSet = member.CanSet;
CanGet = member.CanGet;
isIgnore = member.isIgnore;
}
/// <summary>
/// 获取字段成员集合
/// </summary>
/// <typeparam name="valueType"></typeparam>
/// <typeparam name="memberAttribute"></typeparam>
/// <param name="memberFilter"></param>
/// <param name="isAllMember"></param>
/// <returns>字段成员集合</returns>
internal static subArray <FieldInfo> GetFields <valueType, memberAttribute>(memberFilters memberFilter, bool isAllMember)
where memberAttribute : ignoreMember
{
fieldIndex[] fieldIndexs = fastCSharp.code.memberIndexGroup <valueType> .GetFields(memberFilter);
subArray <FieldInfo> fields = new subArray <FieldInfo>(fieldIndexs.Length);
foreach (fieldIndex field in fieldIndexs)
{
Type type = field.Member.FieldType;
if (!type.IsPointer && (!type.IsArray || type.GetArrayRank() == 1) && !field.IsIgnore)
{
memberAttribute attribute = field.GetAttribute <memberAttribute>(true, true);
if (isAllMember ? (attribute == null || attribute.IsSetup) : (attribute != null && attribute.IsSetup))
{
fields.Add(field.Member);
}
}
}
return(fields);
}
public static subArray <methodInfo> GetMethods(Type type, memberFilters filter, bool isFilter)
{
return(getMethods(type).getFind(value => isFilter ? (value.Filter & filter) == filter : ((value.Filter & filter) != 0)));
}
/// <summary>
/// 获取字段成员集合
/// </summary>
/// <typeparam name="valueType"></typeparam>
/// <param name="memberFilter"></param>
/// <returns>字段成员集合</returns>
internal static keyValue <FieldInfo, int>[] GetFieldIndexs <valueType>(memberFilters memberFilter)
{
return(fastCSharp.code.memberIndexGroup <valueType> .GetFields(memberFilter)
.getArray(value => new keyValue <FieldInfo, int>(value.Member, value.MemberIndex)));
}
/// <summary>
/// 获取属性成员集合
/// </summary>
/// <typeparam name="valueType"></typeparam>
/// <typeparam name="memberAttribute"></typeparam>
/// <param name="memberFilter"></param>
/// <param name="isAllMember"></param>
/// <param name="isGet">是否必须可读</param>
/// <param name="isSet">是否必须可写</param>
/// <returns>属性成员集合</returns>
internal static subArray <PropertyInfo> GetProperties <valueType, memberAttribute>(memberFilters memberFilter, bool isAllMember, bool isGet, bool isSet)
where memberAttribute : ignoreMember
{
propertyIndex[] propertyIndexs = fastCSharp.code.memberIndexGroup <valueType> .GetProperties(memberFilter);
subArray <PropertyInfo> properties = new subArray <PropertyInfo>(propertyIndexs.Length);
foreach (propertyIndex property in propertyIndexs)
{
if ((!isGet || property.CanGet) && (!isSet || property.CanSet))
{
Type type = property.Member.PropertyType;
if (!type.IsPointer && (!type.IsArray || type.GetArrayRank() == 1) && !property.IsIgnore)
{
memberAttribute attribute = property.GetAttribute <memberAttribute>(true, true);
if (isAllMember ? (attribute == null || attribute.IsSetup) : (attribute != null && attribute.IsSetup))
{
properties.Add(property.Member);
}
}
}
}
return(properties);
}
public static memberInfo[] GetMembers <attributeType>(Type type, memberFilters filter, bool isAttribute, bool isBaseType, bool isInheritAttribute)
where attributeType : fastCSharp.code.ignoreMember
{
return(find <memberInfo, attributeType>(GetMembers(type, filter), isAttribute, isBaseType, isInheritAttribute));
}
/// <summary>
/// 获取匹配成员集合
/// </summary>
/// <typeparam name="attributeType">自定义属性类型</typeparam>
/// <param name="type">类型</param>
/// <param name="filter">选择类型</param>
/// <param name="isFilter">是否完全匹配选择类型</param>
/// <param name="isAttribute">是否匹配自定义属性类型</param>
/// <param name="isBaseType">指定是否搜索该成员的继承链以查找这些特性，参考System.Reflection.MemberInfo.GetCustomAttributes(bool inherit)。</param>
/// <param name="isInheritAttribute">自定义属性类型是否可继承</param>
/// <returns>匹配成员集合</returns>
public static memberIndex[] GetStatic <attributeType>(Type type, memberFilters filter, bool isFilter, bool isAttribute, bool isBaseType, bool isInheritAttribute)
where attributeType : fastCSharp.code.ignoreMember
{
return(getStatic(type).Find(filter, isFilter).getFindArray(value => isAttribute ? value.IsAttribute <attributeType>(isBaseType, isInheritAttribute) : !value.IsIgnoreAttribute <attributeType>(isBaseType, isInheritAttribute)));
}
/// <summary>
/// 获取字段成员集合
/// </summary>
/// <typeparam name="valueType"></typeparam>
/// <typeparam name="memberAttribute"></typeparam>
/// <param name="memberFilter"></param>
/// <param name="isAllMember"></param>
/// <returns>字段成员集合</returns>
public static subArray <FieldInfo> GetFields <valueType, memberAttribute>(memberFilters memberFilter, bool isAllMember)
where memberAttribute : ignoreMember
{
return((subArray <FieldInfo>)getFieldsMethod.MakeGenericMethod(typeof(valueType), typeof(memberAttribute)).Invoke(null, new object[] { memberFilter, isAllMember }));
}
/// <summary>
/// 成员信息
/// </summary>
/// <param name="index">成员编号</param>
protected memberIndex(int index)
{
MemberIndex = index;
IsField = CanSet = CanSet = true;
Filter = memberFilters.PublicInstance;
}
/// <summary>
/// 成员信息
/// </summary>
/// <param name="member">成员信息</param>
/// <param name="filter">选择类型</param>
/// <param name="index">成员编号</param>
protected memberIndex(MemberInfo member, memberFilters filter, int index)
{
Member = member;
MemberIndex = index;
Filter = filter;
}
/// <summary>
/// 成员信息
/// </summary>
/// <param name="method">成员方法信息</param>
/// <param name="filter">选择类型</param>
protected memberInfo(MethodInfo method, memberFilters filter)
: base(method, filter, 0)
{
Member = method;
MemberName = method.Name;
}
public static methodInfo[] GetMethods <attributeType>(Type type, memberFilters filter, bool isFilter, bool isAttribute, bool isBaseType, bool isInheritAttribute)
where attributeType : ignoreMember
{
return(getMethods <attributeType>(type, GetMethods(type, filter, isFilter), isAttribute, isBaseType, isInheritAttribute));
}
internal memberIndex[] Find(memberFilters filter, bool isFilter = false)
{
return(get(value => isFilter ? (value.Filter & filter) == filter : ((value.Filter & filter) != 0)));
}
/// <summary>
/// 获取属性成员集合
/// </summary>
/// <typeparam name="valueType"></typeparam>
/// <typeparam name="memberAttribute"></typeparam>
/// <param name="memberFilter"></param>
/// <param name="isAllMember"></param>
/// <param name="isGet">是否必须可读</param>
/// <param name="isSet">是否必须可写</param>
/// <returns>属性成员集合</returns>
internal static subArray <PropertyInfo> GetProperties <valueType, memberAttribute>(memberFilters memberFilter, bool isAllMember, bool isGet, bool isSet)
where memberAttribute : ignoreMember
{
return((subArray <PropertyInfo>)getPropertiesMethod.MakeGenericMethod(typeof(valueType), typeof(memberAttribute)).Invoke(null, new object[] { memberFilter, isAllMember, isGet, isSet }));
}
/// <summary>
/// 获取字段成员集合
/// </summary>
/// <typeparam name="valueType"></typeparam>
/// <param name="memberFilter"></param>
/// <returns>字段成员集合</returns>
public static keyValue <FieldInfo, int>[] GetFieldIndexs <valueType>(memberFilters memberFilter)
{
return((keyValue <FieldInfo, int>[])getFieldIndexsMethod.MakeGenericMethod(typeof(valueType)).Invoke(null, new object[] { memberFilter }));
}
public static memberInfo[] GetMembers(Type type, memberFilters filter)
{
return(getMembers(type).getFindArray(value => (value.Filter & filter) != 0));
}
