public static string ListMembers(object obj, MemberTypes memberTypes = MemberTypes.All) { //if obj is a already a type, cast it and use it; otherwise, grab its type Type objType = obj is Type type ? type : obj.GetType(); return(objType.GetMembers().Where(member => memberTypes.HasFlag(member.MemberType)).Aggregate($"[{objType}] {memberTypes}:", (current, member) => current + $"\n\t{FormatMember(member, obj)}")); }
public static IEnumerable <MemberInfo> GetMembers(this Type type, MemberTypes types) { return(from MemberInfo member in type.GetMembers() where types.HasFlag(member.MemberType) select member); }
/// <summary> /// 获取当前 <see cref="System.Type"/> 定义的指定名称和类型的所有成员,包括其所有内部成员和继承的成员。 /// </summary> /// <param name="_this">表示待查找成员的 System.Type 对象。</param> /// <param name="name">指定的 MemberInfo 名称。</param> /// <param name="memberType">指定的 MemberTypes 成员类型;如果该参数值为 MemberTypes.All,则不按成员类型过滤返回列表。</param> /// <returns>一个表示具有指定名称的公共成员的 <see cref="System.Reflection.MemberInfo"/> 对象数组(如果找到的话);否则为空数组。</returns> public static MemberInfo[] GetAllMembers(this Type _this, string name, MemberTypes memberType) { Check.NotEmpty(name, "name"); return GetAllMembers(_this).Where(m => m.Name == name && memberType.HasFlag(m.MemberType)).ToArray(); }
/// <summary> /// 获取当前 <see cref="System.Type"/> 定义的指定类型的所有成员,包括其所有内部成员和继承的成员。 /// </summary> /// <param name="_this">表示待查找成员的 System.Type 对象。</param> /// <param name="memberType">指定的 MemberTypes 成员类型;如果该参数值为 MemberTypes.All,则不按成员类型过滤返回列表。</param> /// <returns>返回 System.Type 对象中符合过滤条件的所有 MemberInfo 成员对象。</returns> public static MemberInfo[] GetAllMembers(this Type _this, MemberTypes memberType) { return GetAllMembers(_this).Where(m => memberType.HasFlag(m.MemberType)).ToArray(); }
#pragma warning restore CA1825 // Avoid zero-length array allocations. /// <summary> /// Gets information about members. /// </summary> /// <param name="instance">A root object.</param> /// <param name="type">A type of a root object. /// If <paramref name="instance"/> is not <c>null</c>, then its type is used instead. /// </param> /// <param name="memberPath">A path to a member.</param> /// <param name="parameterTypes">Types of parameters to find methods or constructors. /// If <c>null</c> is passed, then types of parameters are ignored.</param> /// <param name="bindingFlags">Binding flags to find members.</param> /// <exception cref="TargetException"> /// An intermediate member on a path thrown an exception. See inner exception for details. /// </exception> /// <returns> /// Information about found members or an empty array if no members are found /// or /// they are not reachable /// or /// they are not accessible. /// </returns> /// <example> /// var dt = DateTime.Now; /// /// var info = Reflector.GetInfo(instance: dt, type: null, memberPath: "TimeOfDay.Negate"); /// /// // info[0].Name == "Negate"; /// // info[0].MemberType == MemberTypes.Property; /// </example> public static MemberInfo[] GetInfo( object instance, Type type, string memberPath, Type[] parameterTypes = null, BindingFlags bindingFlags = DefaultBindingFlags) { if ((instance == null && type == null) || string.IsNullOrEmpty(memberPath)) { return(EmptyMemberInfo); } var container = instance; var containerType = container?.GetType() ?? type; MemberInfo[] memberInfos = null; while (true) { var dot = memberPath.IndexOf('.'); var size = (dot == -1) ? memberPath.Length : dot; var prop = memberPath.Substring(0, size); if (dot == -1 && prop.Equals("ctor", StringComparison.OrdinalIgnoreCase)) { prop = ".ctor"; } memberInfos = containerType .GetTypeInfo() .GetMember( prop, MemberTypes.Field | MemberTypes.Property | MemberTypes.Method | MemberTypes.Constructor, bindingFlags); if (dot == -1) { break; } var found = GetNextContainer(memberInfos, ref container, ref containerType); if (!found) { return(EmptyMemberInfo); } memberPath = memberPath.Substring(prop.Length + 1); } var matchedMemberInfo = new List <MemberInfo>(); for (int i = memberInfos.Length - 1; i >= 0; i--) { var mi = memberInfos[i]; if (PropertyOrFieldMemberTypes.HasFlag(mi.MemberType) || ParameterTypesMatch(((MethodBase)mi).GetParameters(), parameterTypes)) { matchedMemberInfo.Add(mi); } } return(matchedMemberInfo.ToArray()); }
public static IEnumerable <MemberInfo> GetMembers(this Type input, BindingFlags flags, MemberTypes types, bool?hidden = null, bool?mutable = null, bool?serializable = null) { return(input.GetMembers(flags).Where(i => types.HasFlag(i.MemberType) && CheckHidden(hidden, i) && CheckMutable(mutable, i) && CheckSerializable(serializable, i))); }
/// <summary> /// Returns a list of all items that can be accessed in the current scope. /// </summary> /// <param name="ScopedBlock"></param> /// <param name="ImportCache"></param> /// <returns></returns> public static IEnumerable<INode> EnumAllAvailableMembers( IBlockNode ScopedBlock , IStatement ScopedStatement, CodeLocation Caret, IEnumerable<IAbstractSyntaxTree> CodeCache, MemberTypes VisibleMembers) { /* * Shown items: * 1) First walk through the current scope. * 2) Walk up the node hierarchy and add all their items (private as well as public members). * 3) Resolve base classes and add their non-private|static members. * * 4) Then add public members of the imported modules */ var ret = new List<INode>(); var ImportCache = ResolveImports(ScopedBlock.NodeRoot as DModule, CodeCache); #region Current module/scope related members // 1) if (ScopedStatement != null) { ret.AddRange(BlockStatement.GetItemHierarchy(ScopedStatement, Caret)); } var curScope = ScopedBlock; // 2) while (curScope != null) { // Walk up inheritance hierarchy if (curScope is DClassLike) { var curWatchedClass = curScope as DClassLike; // MyClass > BaseA > BaseB > Object while (curWatchedClass != null) { if (curWatchedClass.TemplateParameters != null) ret.AddRange(curWatchedClass.TemplateParameterNodes as IEnumerable<INode>); foreach (var m in curWatchedClass) { var dm2 = m as DNode; var dm3 = m as DMethod; // Only show normal & delegate methods if (!CanAddMemberOfType(VisibleMembers, m) || dm2 == null || (dm3 != null && !(dm3.SpecialType == DMethod.MethodType.Normal || dm3.SpecialType == DMethod.MethodType.Delegate)) ) continue; // Add static and non-private members of all base classes; // Add everything if we're still handling the currently scoped class if (curWatchedClass == curScope || dm2.IsStatic || !dm2.ContainsAttribute(DTokens.Private)) ret.Add(m); } // Stop adding if Object class level got reached if (!string.IsNullOrEmpty(curWatchedClass.Name) && curWatchedClass.Name.ToLower() == "object") break; // 3) var baseclassDefs = DResolver.ResolveBaseClass(curWatchedClass, new ResolverContext { ParseCache = CodeCache, ScopedBlock=ScopedBlock, ImportCache = ImportCache }); if (baseclassDefs == null || baseclassDefs.Length<0) break; if (curWatchedClass == baseclassDefs[0].ResolvedTypeDefinition) break; curWatchedClass = baseclassDefs[0].ResolvedTypeDefinition as DClassLike; } } else if (curScope is DMethod) { var dm = curScope as DMethod; if (VisibleMembers.HasFlag(MemberTypes.Variables)) ret.AddRange(dm.Parameters); if (dm.TemplateParameters != null) ret.AddRange(dm.TemplateParameterNodes as IEnumerable<INode>); // The method's declaration children are handled above already via BlockStatement.GetItemHierarchy(). // except AdditionalChildren: foreach (var ch in dm.AdditionalChildren) if (CanAddMemberOfType(VisibleMembers, ch)) ret.Add(ch); // If the method is a nested method, // this method won't be 'linked' to the parent statement tree directly - // so, we've to gather the parent method and add its locals to the return list if (dm.Parent is DMethod) { var parDM = dm.Parent as DMethod; var nestedBlock = parDM.GetSubBlockAt(Caret); // Search for the deepest statement scope and add all declarations done in the entire hierarchy ret.AddRange(BlockStatement.GetItemHierarchy(nestedBlock.SearchStatementDeeply(Caret), Caret)); } } else foreach (var n in curScope) { // Add anonymous enums' items if (n is DEnum && string.IsNullOrEmpty(n.Name) && CanAddMemberOfType(VisibleMembers, n)) { ret.AddRange((n as DEnum).Children); continue; } var dm3 = n as DMethod; // Only show normal & delegate methods if ( !CanAddMemberOfType(VisibleMembers, n) || (dm3 != null && !(dm3.SpecialType == DMethod.MethodType.Normal || dm3.SpecialType == DMethod.MethodType.Delegate))) continue; ret.Add(n); } curScope = curScope.Parent as IBlockNode; } #endregion #region Global members // Add all non-private and non-package-only nodes foreach (var mod in ImportCache) { if (mod.FileName == (ScopedBlock.NodeRoot as IAbstractSyntaxTree).FileName) continue; foreach (var i in mod) { var dn = i as DNode; if (dn != null) { // Add anonymous enums' items if (dn is DEnum && string.IsNullOrEmpty(i.Name) && dn.IsPublic && !dn.ContainsAttribute(DTokens.Package) && CanAddMemberOfType(VisibleMembers, i)) { ret.AddRange((i as DEnum).Children); continue; } if (dn.IsPublic && !dn.ContainsAttribute(DTokens.Package) && CanAddMemberOfType(VisibleMembers, dn)) ret.Add(dn); } else ret.Add(i); } } #endregion if (ret.Count < 1) return null; return ret; }
public static bool CanAddMemberOfType(MemberTypes VisibleMembers, INode n) { if(n is DMethod) return (n as DMethod).Name!="" && VisibleMembers.HasFlag(MemberTypes.Methods); if(n is DVariable) { var d=n as DVariable; // Only add aliases if at least types,methods or variables shall be shown. if(d.IsAlias) return VisibleMembers.HasFlag(MemberTypes.Methods) || VisibleMembers.HasFlag(MemberTypes.Types) || VisibleMembers.HasFlag(MemberTypes.Variables); return VisibleMembers.HasFlag(MemberTypes.Variables); } if (n is DClassLike) return VisibleMembers.HasFlag(MemberTypes.Types); if(n is DEnum) { var d=n as DEnum; // Only show enums if a) they're named and types are allowed or b) variables are allowed return (d.IsAnonymous ? false : VisibleMembers.HasFlag(MemberTypes.Types)) || VisibleMembers.HasFlag(MemberTypes.Variables); } return false; }
/// <summary> /// 获取当前 <see cref="System.Type"/> 定义的指定名称和类型的所有成员,包括其所有内部成员和继承的成员。 /// </summary> /// <param name="_this">表示待查找成员的 System.Type 对象。</param> /// <param name="name">指定的 MemberInfo 名称。</param> /// <param name="memberType">指定的 MemberTypes 成员类型;如果该参数值为 MemberTypes.All,则不按成员类型过滤返回列表。</param> /// <returns>一个表示具有指定名称的公共成员的 <see cref="System.Reflection.MemberInfo"/> 对象数组(如果找到的话);否则为空数组。</returns> public static MemberInfo[] GetAllMembers(this Type _this, string name, MemberTypes memberType) { Check.NotEmpty(name, "name"); return(GetAllMembers(_this).Where(m => m.Name == name && memberType.HasFlag(m.MemberType)).ToArray()); }
/// <summary> /// 获取当前 <see cref="System.Type"/> 定义的指定类型的所有成员,包括其所有内部成员和继承的成员。 /// </summary> /// <param name="_this">表示待查找成员的 System.Type 对象。</param> /// <param name="memberType">指定的 MemberTypes 成员类型;如果该参数值为 MemberTypes.All,则不按成员类型过滤返回列表。</param> /// <returns>返回 System.Type 对象中符合过滤条件的所有 MemberInfo 成员对象。</returns> public static MemberInfo[] GetAllMembers(this Type _this, MemberTypes memberType) { return(GetAllMembers(_this).Where(m => memberType.HasFlag(m.MemberType)).ToArray()); }