Ejemplo n.º 1
0
        public override MethodInfo[] GetAccessors(bool nonPublic)
        {
            List <MethodInfo> accessorList = new List <MethodInfo>();

            if (Associates.IncludeAccessor(m_getterMethod, nonPublic))
            {
                accessorList.Add(m_getterMethod);
            }

            if (Associates.IncludeAccessor(m_setterMethod, nonPublic))
            {
                accessorList.Add(m_setterMethod);
            }

            if ((object)m_otherMethod != null)
            {
                for (int i = 0; i < m_otherMethod.Length; i++)
                {
                    if (Associates.IncludeAccessor(m_otherMethod[i] as MethodInfo, nonPublic))
                    {
                        accessorList.Add(m_otherMethod[i]);
                    }
                }
            }
            return(accessorList.ToArray());
        }
Ejemplo n.º 2
0
        internal RuntimePropertyInfo(
            int tkProperty,
            RuntimeType declaredType,
            RuntimeTypeCache reflectedTypeCache,
            out bool isPrivate
            )
        {
            Debug.Assert(declaredType != null);
            Debug.Assert(reflectedTypeCache != null);
            Debug.Assert(!reflectedTypeCache.IsGlobal);

            MetadataImport scope = declaredType.GetRuntimeModule().MetadataImport;

            m_token = tkProperty;
            m_reflectedTypeCache = reflectedTypeCache;
            m_declaringType      = declaredType;

            scope.GetPropertyProps(tkProperty, out m_utf8name, out m_flags, out _);

            Associates.AssignAssociates(
                scope,
                tkProperty,
                declaredType,
                reflectedTypeCache.GetRuntimeType(),
                out _,
                out _,
                out _,
                out m_getterMethod,
                out m_setterMethod,
                out m_otherMethod,
                out isPrivate,
                out m_bindingFlags
                );
        }
Ejemplo n.º 3
0
 public override MethodInfo GetAddMethod(bool nonPublic)
 {
     if (!Associates.IncludeAccessor(this.m_addMethod, nonPublic))
     {
         return(null);
     }
     return(this.m_addMethod);
 }
Ejemplo n.º 4
0
 public override MethodInfo GetSetMethod(bool nonPublic)
 {
     if (!Associates.IncludeAccessor((MethodInfo)this.m_setterMethod, nonPublic))
     {
         return((MethodInfo)null);
     }
     return((MethodInfo)this.m_setterMethod);
 }
Ejemplo n.º 5
0
        public override MethodInfo?GetRaiseMethod(bool nonPublic)
        {
            if (!Associates.IncludeAccessor(m_raiseMethod, nonPublic))
            {
                return(null);
            }

            return(m_raiseMethod);
        }
Ejemplo n.º 6
0
        public override RuntimeMethodInfo?GetSetMethod(bool nonPublic)
        {
            if (!Associates.IncludeAccessor(m_setterMethod, nonPublic))
            {
                return(null);
            }

            return(m_setterMethod);
        }
Ejemplo n.º 7
0
        public override MethodInfo GetGetMethod(bool nonPublic)
        {
            if (!Associates.IncludeAccessor(m_getterMethod, nonPublic))
            {
                return(null);
            }

            return(m_getterMethod);
        }
Ejemplo n.º 8
0
        internal RuntimeEventInfo(int tkEvent, RuntimeType declaredType, RuntimeType.RuntimeTypeCache reflectedTypeCache, out bool isPrivate)
        {
            MetadataImport metadataImport = declaredType.GetRuntimeModule().MetadataImport;

            this.m_token = tkEvent;
            this.m_reflectedTypeCache = reflectedTypeCache;
            this.m_declaringType      = declaredType;
            RuntimeType runtimeType = reflectedTypeCache.GetRuntimeType();

            metadataImport.GetEventProps(tkEvent, out this.m_utf8name, out this.m_flags);
            RuntimeMethodInfo runtimeMethodInfo;

            Associates.AssignAssociates(metadataImport, tkEvent, declaredType, runtimeType, out this.m_addMethod, out this.m_removeMethod, out this.m_raiseMethod, out runtimeMethodInfo, out runtimeMethodInfo, out this.m_otherMethod, out isPrivate, out this.m_bindingFlags);
        }
        internal RuntimePropertyInfo(int tkProperty, RuntimeType declaredType, RuntimeType.RuntimeTypeCache reflectedTypeCache, out bool isPrivate)
        {
            MetadataImport metadataImport = declaredType.GetRuntimeModule().MetadataImport;

            this.m_token = tkProperty;
            this.m_reflectedTypeCache = reflectedTypeCache;
            this.m_declaringType      = declaredType;
            ConstArray constArray;

            metadataImport.GetPropertyProps(tkProperty, out this.m_utf8name, out this.m_flags, out constArray);
            RuntimeMethodInfo runtimeMethodInfo;

            Associates.AssignAssociates(metadataImport, tkProperty, declaredType, reflectedTypeCache.GetRuntimeType(), out runtimeMethodInfo, out runtimeMethodInfo, out runtimeMethodInfo, out this.m_getterMethod, out this.m_setterMethod, out this.m_otherMethod, out isPrivate, out this.m_bindingFlags);
        }
        internal unsafe RuntimePropertyInfo(int tkProperty, RuntimeType declaredType, RuntimeType.RuntimeTypeCache reflectedTypeCache, out bool isPrivate)
        {
            RuntimeMethodInfo info;
            MetadataImport    metadataImport = declaredType.GetRuntimeModule().MetadataImport;

            this.m_token = tkProperty;
            this.m_reflectedTypeCache = reflectedTypeCache;
            this.m_declaringType      = declaredType;
            metadataImport.GetPropertyProps(tkProperty, out this.m_utf8name, out this.m_flags, out MetadataArgs.Skip.ConstArray);
            int associatesCount     = metadataImport.GetAssociatesCount(tkProperty);
            AssociateRecord *result = (AssociateRecord *)stackalloc byte[(((IntPtr)associatesCount) * sizeof(AssociateRecord))];

            metadataImport.GetAssociates(tkProperty, result, associatesCount);
            Associates.AssignAssociates(result, associatesCount, declaredType, reflectedTypeCache.RuntimeType, out info, out info, out info, out this.m_getterMethod, out this.m_setterMethod, out this.m_otherMethod, out isPrivate, out this.m_bindingFlags);
        }
Ejemplo n.º 11
0
        public override MethodInfo[] GetOtherMethods(bool nonPublic)
        {
            List <MethodInfo> methodInfoList = new List <MethodInfo>();

            if (this.m_otherMethod == null)
            {
                return(new MethodInfo[0]);
            }
            for (int index = 0; index < this.m_otherMethod.Length; ++index)
            {
                if (Associates.IncludeAccessor(this.m_otherMethod[index], nonPublic))
                {
                    methodInfoList.Add(this.m_otherMethod[index]);
                }
            }
            return(methodInfoList.ToArray());
        }
Ejemplo n.º 12
0
        public override MethodInfo[] GetOtherMethods(bool nonPublic)
        {
            ArrayList list = new ArrayList();

            if (this.m_otherMethod == null)
            {
                return(new MethodInfo[0]);
            }
            for (int i = 0; i < this.m_otherMethod.Length; i++)
            {
                if (Associates.IncludeAccessor(this.m_otherMethod[i], nonPublic))
                {
                    list.Add(this.m_otherMethod[i]);
                }
            }
            return(list.ToArray(typeof(MethodInfo)) as MethodInfo[]);
        }
        internal unsafe RuntimeEventInfo(int tkEvent, RuntimeType declaredType, RuntimeType.RuntimeTypeCache reflectedTypeCache, out bool isPrivate)
        {
            RuntimeMethodInfo info;
            MetadataImport    metadataImport = declaredType.GetRuntimeModule().MetadataImport;

            this.m_token = tkEvent;
            this.m_reflectedTypeCache = reflectedTypeCache;
            this.m_declaringType      = declaredType;
            RuntimeType runtimeType = reflectedTypeCache.RuntimeType;

            metadataImport.GetEventProps(tkEvent, out this.m_utf8name, out this.m_flags);
            int associatesCount     = metadataImport.GetAssociatesCount(tkEvent);
            AssociateRecord *result = (AssociateRecord *)stackalloc byte[(((IntPtr)associatesCount) * sizeof(AssociateRecord))];

            metadataImport.GetAssociates(tkEvent, result, associatesCount);
            Associates.AssignAssociates(result, associatesCount, declaredType, runtimeType, out this.m_addMethod, out this.m_removeMethod, out this.m_raiseMethod, out info, out info, out this.m_otherMethod, out isPrivate, out this.m_bindingFlags);
        }
Ejemplo n.º 14
0
        public override MethodInfo[] GetOtherMethods(bool nonPublic)
        {
            List <MethodInfo> ret = new List <MethodInfo>();

            if ((object)m_otherMethod == null)
            {
                return(new MethodInfo[0]);
            }

            for (int i = 0; i < m_otherMethod.Length; i++)
            {
                if (Associates.IncludeAccessor((MethodInfo)m_otherMethod[i], nonPublic))
                {
                    ret.Add(m_otherMethod[i]);
                }
            }

            return(ret.ToArray());
        }
Ejemplo n.º 15
0
        internal RuntimeEventInfo(int tkEvent, RuntimeType declaredType, RuntimeTypeCache reflectedTypeCache, out bool isPrivate)
        {
            Debug.Assert(declaredType != null);
            Debug.Assert(reflectedTypeCache != null);
            Debug.Assert(!reflectedTypeCache.IsGlobal);

            MetadataImport scope = declaredType.GetRuntimeModule().MetadataImport;

            m_token = tkEvent;
            m_reflectedTypeCache = reflectedTypeCache;
            m_declaringType      = declaredType;


            RuntimeType reflectedType = reflectedTypeCache.GetRuntimeType();

            scope.GetEventProps(tkEvent, out m_utf8name, out m_flags);

            Associates.AssignAssociates(scope, tkEvent, declaredType, reflectedType,
                                        out m_addMethod, out m_removeMethod, out m_raiseMethod,
                                        out _, out _, out m_otherMethod, out isPrivate, out m_bindingFlags);
        }
Ejemplo n.º 16
0
        internal unsafe RuntimeEventInfo(int tkEvent, RuntimeType declaredType, RuntimeType.RuntimeTypeCache reflectedTypeCache, out bool isPrivate)
        {
            MetadataImport metadataImport = declaredType.GetRuntimeModule().MetadataImport;

            this.m_token = tkEvent;
            this.m_reflectedTypeCache = reflectedTypeCache;
            this.m_declaringType      = declaredType;
            RuntimeType runtimeType = reflectedTypeCache.GetRuntimeType();

            metadataImport.GetEventProps(tkEvent, out this.m_utf8name, out this.m_flags);
            MetadataImport scope         = metadataImport;
            int            mdPropEvent   = tkEvent;
            RuntimeType    declaringType = declaredType;
            RuntimeType    reflectedType = runtimeType;
            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            RuntimeMethodInfo& addOn = @this.m_addMethod;
            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            RuntimeMethodInfo& removeOn = @this.m_removeMethod;
            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            RuntimeMethodInfo& fireOn = @this.m_raiseMethod;
            RuntimeMethodInfo  runtimeMethodInfo;
            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            RuntimeMethodInfo& local = @runtimeMethodInfo;

            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            MethodInfo[]& other = @this.m_otherMethod;
            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            bool& composedOfAllPrivateMethods = @isPrivate;
            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            BindingFlags& bindingFlags = @this.m_bindingFlags;

            Associates.AssignAssociates(scope, mdPropEvent, declaringType, reflectedType, addOn, removeOn, fireOn, local, local, other, composedOfAllPrivateMethods, bindingFlags);
        }
Ejemplo n.º 17
0
        internal unsafe RuntimePropertyInfo(int tkProperty, RuntimeType declaredType, RuntimeType.RuntimeTypeCache reflectedTypeCache, out bool isPrivate)
        {
            MetadataImport metadataImport = declaredType.GetRuntimeModule().MetadataImport;

            this.m_token = tkProperty;
            this.m_reflectedTypeCache = reflectedTypeCache;
            this.m_declaringType      = declaredType;
            ConstArray signature;

            metadataImport.GetPropertyProps(tkProperty, out this.m_utf8name, out this.m_flags, out signature);
            MetadataImport    scope         = metadataImport;
            int               mdPropEvent   = tkProperty;
            RuntimeType       declaringType = declaredType;
            RuntimeType       runtimeType   = reflectedTypeCache.GetRuntimeType();
            RuntimeMethodInfo runtimeMethodInfo;
            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            RuntimeMethodInfo& local = @runtimeMethodInfo;
            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            RuntimeMethodInfo& getter = @this.m_getterMethod;
            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            RuntimeMethodInfo& setter = @this.m_setterMethod;

            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            MethodInfo[]& other = @this.m_otherMethod;
            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            bool& composedOfAllPrivateMethods = @isPrivate;
            // ISSUE: explicit reference operation
            // ISSUE: variable of a reference type
            BindingFlags& bindingFlags = @this.m_bindingFlags;

            Associates.AssignAssociates(scope, mdPropEvent, declaringType, runtimeType, local, local, local, getter, setter, other, composedOfAllPrivateMethods, bindingFlags);
        }
Ejemplo n.º 18
0
        [System.Security.SecurityCritical]  // auto-generated
        internal RuntimePropertyInfo(
            int tkProperty, RuntimeType declaredType, RuntimeTypeCache reflectedTypeCache, out bool isPrivate)
        {
            Contract.Requires(declaredType != null);
            Contract.Requires(reflectedTypeCache != null);
            Contract.Assert(!reflectedTypeCache.IsGlobal);

            MetadataImport scope = declaredType.GetRuntimeModule().MetadataImport;

            m_token = tkProperty;
            m_reflectedTypeCache = reflectedTypeCache;
            m_declaringType      = declaredType;

            ConstArray sig;

            scope.GetPropertyProps(tkProperty, out m_utf8name, out m_flags, out sig);

            RuntimeMethodInfo dummy;

            Associates.AssignAssociates(scope, tkProperty, declaredType, reflectedTypeCache.GetRuntimeType(),
                                        out dummy, out dummy, out dummy,
                                        out m_getterMethod, out m_setterMethod, out m_otherMethod,
                                        out isPrivate, out m_bindingFlags);
        }
Ejemplo n.º 19
0
        public override MethodInfo[] GetAccessors(bool nonPublic)
        {
            List <MethodInfo> methodInfoList = new List <MethodInfo>();

            if (Associates.IncludeAccessor((MethodInfo)this.m_getterMethod, nonPublic))
            {
                methodInfoList.Add((MethodInfo)this.m_getterMethod);
            }
            if (Associates.IncludeAccessor((MethodInfo)this.m_setterMethod, nonPublic))
            {
                methodInfoList.Add((MethodInfo)this.m_setterMethod);
            }
            if (this.m_otherMethod != null)
            {
                for (int index = 0; index < this.m_otherMethod.Length; ++index)
                {
                    if (Associates.IncludeAccessor(this.m_otherMethod[index], nonPublic))
                    {
                        methodInfoList.Add(this.m_otherMethod[index]);
                    }
                }
            }
            return(methodInfoList.ToArray());
        }
        public override MethodInfo[] GetAccessors(bool nonPublic)
        {
            List <MethodInfo> list = new List <MethodInfo>();

            if (Associates.IncludeAccessor(this.m_getterMethod, nonPublic))
            {
                list.Add(this.m_getterMethod);
            }
            if (Associates.IncludeAccessor(this.m_setterMethod, nonPublic))
            {
                list.Add(this.m_setterMethod);
            }
            if (this.m_otherMethod != null)
            {
                for (int i = 0; i < this.m_otherMethod.Length; i++)
                {
                    if (Associates.IncludeAccessor(this.m_otherMethod[i], nonPublic))
                    {
                        list.Add(this.m_otherMethod[i]);
                    }
                }
            }
            return(list.ToArray());
        }
Ejemplo n.º 21
0
        internal static void AssignAssociates(MetadataImport scope, int mdPropEvent, RuntimeType declaringType, RuntimeType reflectedType, out RuntimeMethodInfo addOn, out RuntimeMethodInfo removeOn, out RuntimeMethodInfo fireOn, out RuntimeMethodInfo getter, out RuntimeMethodInfo setter, out MethodInfo[] other, out bool composedOfAllPrivateMethods, out BindingFlags bindingFlags)
        {
            addOn = removeOn = fireOn = getter = setter = (RuntimeMethodInfo)null;
            Associates.Attributes attributes1 = Associates.Attributes.ComposedOfAllVirtualMethods | Associates.Attributes.ComposedOfAllPrivateMethods | Associates.Attributes.ComposedOfNoPublicMembers | Associates.Attributes.ComposedOfNoStaticMembers;
            while (RuntimeTypeHandle.IsGenericVariable(reflectedType))
            {
                reflectedType = (RuntimeType)reflectedType.BaseType;
            }
            bool isInherited = declaringType != reflectedType;
            List <MethodInfo>  methodInfoList = (List <MethodInfo>)null;
            MetadataEnumResult result;

            scope.Enum(MetadataTokenType.MethodDef, mdPropEvent, out result);
            int capacity = result.Length / 2;

            for (int index = 0; index < capacity; ++index)
            {
                int tkMethod = result[index * 2];
                MethodSemanticsAttributes semanticsAttributes = (MethodSemanticsAttributes)result[index * 2 + 1];
                RuntimeType       declaredType      = declaringType;
                RuntimeType       reflectedType1    = reflectedType;
                RuntimeMethodInfo runtimeMethodInfo = Associates.AssignAssociates(tkMethod, declaredType, reflectedType1);
                if (!((MethodInfo)runtimeMethodInfo == (MethodInfo)null))
                {
                    MethodAttributes attributes2 = runtimeMethodInfo.Attributes;
                    bool             flag1       = (attributes2 & MethodAttributes.MemberAccessMask) == MethodAttributes.Private;
                    bool             flag2       = (uint)(attributes2 & MethodAttributes.Virtual) > 0U;
                    int  num   = (attributes2 & MethodAttributes.MemberAccessMask) == MethodAttributes.Public ? 1 : 0;
                    bool flag3 = (uint)(attributes2 & MethodAttributes.Static) > 0U;
                    if (num != 0)
                    {
                        attributes1 = attributes1 & ~Associates.Attributes.ComposedOfNoPublicMembers & ~Associates.Attributes.ComposedOfAllPrivateMethods;
                    }
                    else if (!flag1)
                    {
                        attributes1 &= ~Associates.Attributes.ComposedOfAllPrivateMethods;
                    }
                    if (flag3)
                    {
                        attributes1 &= ~Associates.Attributes.ComposedOfNoStaticMembers;
                    }
                    if (!flag2)
                    {
                        attributes1 &= ~Associates.Attributes.ComposedOfAllVirtualMethods;
                    }
                    if (semanticsAttributes == MethodSemanticsAttributes.Setter)
                    {
                        setter = runtimeMethodInfo;
                    }
                    else if (semanticsAttributes == MethodSemanticsAttributes.Getter)
                    {
                        getter = runtimeMethodInfo;
                    }
                    else if (semanticsAttributes == MethodSemanticsAttributes.Fire)
                    {
                        fireOn = runtimeMethodInfo;
                    }
                    else if (semanticsAttributes == MethodSemanticsAttributes.AddOn)
                    {
                        addOn = runtimeMethodInfo;
                    }
                    else if (semanticsAttributes == MethodSemanticsAttributes.RemoveOn)
                    {
                        removeOn = runtimeMethodInfo;
                    }
                    else
                    {
                        if (methodInfoList == null)
                        {
                            methodInfoList = new List <MethodInfo>(capacity);
                        }
                        methodInfoList.Add((MethodInfo)runtimeMethodInfo);
                    }
                }
            }
            bool isPublic = (attributes1 & Associates.Attributes.ComposedOfNoPublicMembers) == (Associates.Attributes) 0;
            bool isStatic = (attributes1 & Associates.Attributes.ComposedOfNoStaticMembers) == (Associates.Attributes) 0;

            bindingFlags = RuntimeType.FilterPreCalculate(isPublic, isInherited, isStatic);
            composedOfAllPrivateMethods = (uint)(attributes1 & Associates.Attributes.ComposedOfAllPrivateMethods) > 0U;
            other = methodInfoList != null?methodInfoList.ToArray() : (MethodInfo[])null;
        }
        internal static void AssignAssociates(MetadataImport scope, int mdPropEvent, RuntimeType declaringType, RuntimeType reflectedType, out RuntimeMethodInfo addOn, out RuntimeMethodInfo removeOn, out RuntimeMethodInfo fireOn, out RuntimeMethodInfo getter, out RuntimeMethodInfo setter, out MethodInfo[] other, out bool composedOfAllPrivateMethods, out BindingFlags bindingFlags)
        {
            RuntimeMethodInfo runtimeMethodInfo;

            setter   = (runtimeMethodInfo = null);
            getter   = (runtimeMethodInfo = runtimeMethodInfo);
            fireOn   = (runtimeMethodInfo = runtimeMethodInfo);
            removeOn = (runtimeMethodInfo = runtimeMethodInfo);
            addOn    = runtimeMethodInfo;
            Associates.Attributes attributes = Associates.Attributes.ComposedOfAllVirtualMethods | Associates.Attributes.ComposedOfAllPrivateMethods | Associates.Attributes.ComposedOfNoPublicMembers | Associates.Attributes.ComposedOfNoStaticMembers;
            while (RuntimeTypeHandle.IsGenericVariable(reflectedType))
            {
                reflectedType = (RuntimeType)reflectedType.BaseType;
            }
            bool isInherited        = declaringType != reflectedType;
            List <MethodInfo>  list = null;
            MetadataEnumResult metadataEnumResult;

            scope.Enum(MetadataTokenType.MethodDef, mdPropEvent, out metadataEnumResult);
            int num = metadataEnumResult.Length / 2;

            for (int i = 0; i < num; i++)
            {
                int tkMethod = metadataEnumResult[i * 2];
                MethodSemanticsAttributes methodSemanticsAttributes = (MethodSemanticsAttributes)metadataEnumResult[i * 2 + 1];
                RuntimeMethodInfo         runtimeMethodInfo2        = Associates.AssignAssociates(tkMethod, declaringType, reflectedType);
                if (!(runtimeMethodInfo2 == null))
                {
                    MethodAttributes attributes2      = runtimeMethodInfo2.Attributes;
                    bool             flag             = (attributes2 & MethodAttributes.MemberAccessMask) == MethodAttributes.Private;
                    bool             flag2            = (attributes2 & MethodAttributes.Virtual) > MethodAttributes.PrivateScope;
                    MethodAttributes methodAttributes = attributes2 & MethodAttributes.MemberAccessMask;
                    bool             flag3            = methodAttributes == MethodAttributes.Public;
                    bool             flag4            = (attributes2 & MethodAttributes.Static) > MethodAttributes.PrivateScope;
                    if (flag3)
                    {
                        attributes &= ~Associates.Attributes.ComposedOfNoPublicMembers;
                        attributes &= ~Associates.Attributes.ComposedOfAllPrivateMethods;
                    }
                    else if (!flag)
                    {
                        attributes &= ~Associates.Attributes.ComposedOfAllPrivateMethods;
                    }
                    if (flag4)
                    {
                        attributes &= ~Associates.Attributes.ComposedOfNoStaticMembers;
                    }
                    if (!flag2)
                    {
                        attributes &= ~Associates.Attributes.ComposedOfAllVirtualMethods;
                    }
                    if (methodSemanticsAttributes == MethodSemanticsAttributes.Setter)
                    {
                        setter = runtimeMethodInfo2;
                    }
                    else if (methodSemanticsAttributes == MethodSemanticsAttributes.Getter)
                    {
                        getter = runtimeMethodInfo2;
                    }
                    else if (methodSemanticsAttributes == MethodSemanticsAttributes.Fire)
                    {
                        fireOn = runtimeMethodInfo2;
                    }
                    else if (methodSemanticsAttributes == MethodSemanticsAttributes.AddOn)
                    {
                        addOn = runtimeMethodInfo2;
                    }
                    else if (methodSemanticsAttributes == MethodSemanticsAttributes.RemoveOn)
                    {
                        removeOn = runtimeMethodInfo2;
                    }
                    else
                    {
                        if (list == null)
                        {
                            list = new List <MethodInfo>(num);
                        }
                        list.Add(runtimeMethodInfo2);
                    }
                }
            }
            bool isPublic = (attributes & Associates.Attributes.ComposedOfNoPublicMembers) == (Associates.Attributes) 0;
            bool isStatic = (attributes & Associates.Attributes.ComposedOfNoStaticMembers) == (Associates.Attributes) 0;

            bindingFlags = RuntimeType.FilterPreCalculate(isPublic, isInherited, isStatic);
            composedOfAllPrivateMethods = ((attributes & Associates.Attributes.ComposedOfAllPrivateMethods) > (Associates.Attributes) 0);
            other = ((list != null) ? list.ToArray() : null);
        }