private QueriedMemberList(int totalCount, int declaredOnlyCount, M[] members, BindingFlags[] allFlagsThatMustMatch, RuntimeTypeInfo typeThatBlockedBrowsing)
{
_totalCount = totalCount;
_declaredOnlyCount = declaredOnlyCount;
_members = members;
_allFlagsThatMustMatch = allFlagsThatMustMatch;
_typeThatBlockedBrowsing = typeThatBlockedBrowsing;
}
private static object[] CreatePerNameQueryCaches(RuntimeTypeInfo type, bool ignoreCase, bool immediateTypeOnly)
{
object[] perNameCaches = new object[MemberTypeIndex.Count];
perNameCaches[MemberTypeIndex.Constructor] = new PerNameQueryCache <ConstructorInfo>(type, ignoreCase: ignoreCase, immediateTypeOnly: immediateTypeOnly);
perNameCaches[MemberTypeIndex.Event] = new PerNameQueryCache <EventInfo>(type, ignoreCase: ignoreCase, immediateTypeOnly: immediateTypeOnly);
perNameCaches[MemberTypeIndex.Field] = new PerNameQueryCache <FieldInfo>(type, ignoreCase: ignoreCase, immediateTypeOnly: immediateTypeOnly);
perNameCaches[MemberTypeIndex.Method] = new PerNameQueryCache <MethodInfo>(type, ignoreCase: ignoreCase, immediateTypeOnly: immediateTypeOnly);
perNameCaches[MemberTypeIndex.Property] = new PerNameQueryCache <PropertyInfo>(type, ignoreCase: ignoreCase, immediateTypeOnly: immediateTypeOnly);
perNameCaches[MemberTypeIndex.NestedType] = new PerNameQueryCache <Type>(type, ignoreCase: ignoreCase, immediateTypeOnly: immediateTypeOnly);
return(perNameCaches);
}
public TypeComponentsCache(RuntimeTypeInfo type)
{
_type = type;
_perNameQueryCaches_CaseSensitive = CreatePerNameQueryCaches(type, ignoreCase: false, immediateTypeOnly: false);
_perNameQueryCaches_CaseInsensitive = CreatePerNameQueryCaches(type, ignoreCase: true, immediateTypeOnly: false);
_perNameQueryCaches_CaseSensitive_ImmediateTypeOnly = CreatePerNameQueryCaches(type, ignoreCase: false, immediateTypeOnly: true);
_perNameQueryCaches_CaseInsensitive_ImmediateTypeOnly = CreatePerNameQueryCaches(type, ignoreCase: true, immediateTypeOnly: true);
_nameAgnosticQueryCaches = new object[MemberTypeIndex.Count];
}
//
// Filter by name and visibility from the ReflectedType.
//
public static QueriedMemberList <M> Create(RuntimeTypeInfo type, string filter, bool ignoreCase, bool immediateTypeOnly)
{
RuntimeTypeInfo reflectedType = type;
MemberPolicies <M> policies = MemberPolicies <M> .Default;
NameFilter nameFilter;
if (filter == null)
{
nameFilter = null;
}
else if (ignoreCase)
{
nameFilter = new NameFilterCaseInsensitive(filter);
}
else
{
nameFilter = new NameFilterCaseSensitive(filter);
}
bool inBaseClass = false;
QueriedMemberList <M> queriedMembers = new QueriedMemberList <M>(immediateTypeOnly);
while (type != null)
{
int numCandidatesInDerivedTypes = queriedMembers._totalCount;
foreach (M member in policies.CoreGetDeclaredMembers(type, nameFilter, reflectedType))
{
policies.GetMemberAttributes(member, out MethodAttributes visibility, out bool isStatic, out bool isVirtual, out bool isNewSlot);
if (inBaseClass && visibility == MethodAttributes.Private)
{
continue;
}
if (numCandidatesInDerivedTypes != 0 && policies.IsSuppressedByMoreDerivedMember(member, queriedMembers._members, startIndex: 0, endIndex: numCandidatesInDerivedTypes))
{
continue;
}
BindingFlags allFlagsThatMustMatch = default;
allFlagsThatMustMatch |= (isStatic ? BindingFlags.Static : BindingFlags.Instance);
if (isStatic && inBaseClass)
{
allFlagsThatMustMatch |= BindingFlags.FlattenHierarchy;
}
allFlagsThatMustMatch |= ((visibility == MethodAttributes.Public) ? BindingFlags.Public : BindingFlags.NonPublic);
queriedMembers.Add(member, allFlagsThatMustMatch);
}
if (!inBaseClass)
{
queriedMembers._declaredOnlyCount = queriedMembers._totalCount;
if (immediateTypeOnly)
{
break;
}
if (policies.AlwaysTreatAsDeclaredOnly)
{
break;
}
inBaseClass = true;
}
type = type.BaseType.CastToRuntimeTypeInfo();
if (type != null && !type.CanBrowseWithoutMissingMetadataExceptions())
{
// If we got here, one of the base classes is missing metadata. We don't want to throw a MissingMetadataException now because we may be
// building a cached result for a caller who passed BindingFlags.DeclaredOnly. So we'll mark the results in a way that
// it will throw a MissingMetadataException if a caller attempts to iterate past the declared-only subset.
queriedMembers._typeThatBlockedBrowsing = type;
queriedMembers._totalCount = queriedMembers._declaredOnlyCount;
break;
}
}
return(queriedMembers);
}
public sealed override IEnumerable <ConstructorInfo> CoreGetDeclaredMembers(RuntimeTypeInfo type, NameFilter?filter, RuntimeTypeInfo reflectedType)
{
Debug.Assert(reflectedType.Equals(type)); // Constructor queries are always performed as if BindingFlags.DeclaredOnly are set so the reflectedType should always be the declaring type.
return(type.GetConstructorsCore(filter));
}
public sealed override IEnumerable <EventInfo> CoreGetDeclaredMembers(RuntimeTypeInfo type, NameFilter filter, RuntimeTypeInfo reflectedType)
{
return(type.GetEventsCore(filter, reflectedType));
}
public sealed override IEnumerable <PropertyInfo> CoreGetDeclaredMembers(RuntimeTypeInfo type, NameFilter?filter, RuntimeTypeInfo reflectedType)
{
return(type.GetPropertiesCore(filter, reflectedType));
}
public PerNameQueryCache(RuntimeTypeInfo type, bool ignoreCase, bool immediateTypeOnly)
{
_type = type;
_ignoreCase = ignoreCase;
_immediateTypeOnly = immediateTypeOnly;
}
