C# MemberTypes.HasFlag方法代码示例

 /// <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>
        /// 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)
                    {
//.........这里部分代码省略.........

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