Microsoft.CSharp.RuntimeBinder.SymbolTable.AddNamesInInheritanceHierarchy C# (CSharp) 메소드

        private IEnumerable<MemberInfo> AddNamesInInheritanceHierarchy(string name, List<Type> inheritance)
        {
            IEnumerable<MemberInfo> result = Array.Empty<MemberInfo>();

            foreach (Type t in inheritance)
            {
                Type type = t;
                if (type.GetTypeInfo().IsGenericType)
                {
                    type = type.GetTypeInfo().GetGenericTypeDefinition();
                }
                NameHashKey key = new NameHashKey(type, name);

                // Now loop over all methods and add them.
                IEnumerable<MemberInfo> members = Enumerable.Where(type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static),
                                                                   member => member.Name == name && member.DeclaringType == type);
                IEnumerable<MemberInfo> events = Enumerable.Where(type.GetRuntimeEvents(),
                                                                  member => member.Name == name && member.DeclaringType == type);

                if (members.Any())
                {
                    CType cType = GetCTypeFromType(type);
                    if (!(cType is AggregateType))
                        continue;
                    AggregateSymbol aggregate = (cType as AggregateType).getAggregate();
                    FieldSymbol addedField = null;

                    // We need to add fields before the actual events, so do the first iteration 
                    // excludint events.
                    foreach (MemberInfo member in members)
                    {
                        if (member is MethodInfo)
                        {
                            MethodKindEnum kind = MethodKindEnum.Actual;
                            if (member.Name == SpecialNames.Invoke)
                            {
                                kind = MethodKindEnum.Invoke;
                            }
                            else if (member.Name == SpecialNames.ImplicitConversion)
                            {
                                kind = MethodKindEnum.ImplicitConv;
                            }
                            else if (member.Name == SpecialNames.ExplicitConversion)
                            {
                                kind = MethodKindEnum.ExplicitConv;
                            }
                            AddMethodToSymbolTable(
                                member,
                                aggregate,
                                kind);
                        }
                        else if (member is ConstructorInfo)
                        {
                            AddMethodToSymbolTable(
                                member,
                                aggregate,
                                MethodKindEnum.Constructor);
                        }
                        else if (member is PropertyInfo)
                        {
                            AddPropertyToSymbolTable(member as PropertyInfo, aggregate);
                        }
                        else if (member is FieldInfo)
                        {
                            // Store this field so that if we also find an event, we can
                            // mark it as the backing field of the event.
                            Debug.Assert(addedField == null);
                            addedField = AddFieldToSymbolTable(member as FieldInfo, aggregate);
                        }
                    }
                    foreach (EventInfo e in events)
                    {
                        AddEventToSymbolTable(e, aggregate, addedField);
                    }

                    result = result.Concat(members);
                }

                _namesLoadedForEachType.Add(key);
            }

            return result;
        }