/// <summary>
/// Gets the members (fields, properties, constructors, methods, and events) of the specified type,
/// with various options to control the scope of members included and optionally order the members.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="memberRelationships">OPTIONAL value that scopes the search for members based on their relationship to <paramref name="type"/>. DEFAULT is to include the members declared in or inherited by the specified type.</param>
/// <param name="memberOwners">OPTIONAL value that scopes the search for members based on who owns the member. DEFAULT is to include members owned by an object or owned by the type itself.</param>
/// <param name="memberAccessModifiers">OPTIONAL value that scopes the search for members based on access modifiers. DEFAULT is to include members having any supported access modifier.</param>
/// <param name="memberKinds">OPTIONAL value that scopes the search for members based on the kind of member. DEFAULT is to include all kinds of members.</param>
/// <param name="memberMutability">OPTIONAL value that scopes the search for members based on mutability. DEFAULT is to include members where mutability is not applicable and where applicable, include members with any kind of mutability.</param>
/// <param name="memberAttributes">OPTIONAL value that scopes the search for members based on the presence or absence of certain attributes on those members. DEFAULT is to include members that are not compiler generated.</param>
/// <param name="orderMembersBy">OPTIONAL value that specifies how to the members. DEFAULT is return the members in no particular order.</param>
/// <returns>
/// The members in the specified order.
/// </returns>
/// <exception cref="ArgumentNullException"><paramref name="type"/> is null.</exception>
public static IReadOnlyList <MemberInfo> GetMembersFiltered(
this Type type,
MemberRelationships memberRelationships = MemberRelationships.DeclaredOrInherited,
MemberOwners memberOwners = MemberOwners.All,
MemberAccessModifiers memberAccessModifiers = MemberAccessModifiers.All,
MemberKinds memberKinds = MemberKinds.All,
MemberMutability memberMutability = MemberMutability.All,
MemberAttributes memberAttributes = MemberAttributes.NotCompilerGenerated,
OrderMembersBy orderMembersBy = OrderMembersBy.None)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var result = type
.GetMembersHavingRelationshipsAndOwners(memberRelationships, memberOwners)
.FilterMembersHavingKinds(memberKinds)
.FilterMembersHavingAccessModifiers(memberAccessModifiers)
.FilterMembersHavingMutability(memberMutability)
.FilterMembersHavingAttributes(memberAttributes)
.OrderMembers(type, orderMembersBy);
return(result);
}
private static IReadOnlyList <MemberInfo> FilterMembersHavingKinds(
this IReadOnlyList <MemberInfo> members,
MemberKinds memberKinds)
{
IReadOnlyList <MemberInfo> result;
if (memberKinds == MemberKinds.None)
{
// no-op; no members to add
result = new List <MemberInfo>();
}
else if (memberKinds == MemberKinds.All)
{
// shortcut for performance
result = members;
}
else
{
var filteredMembers = new List <MemberInfo>();
foreach (var member in members)
{
var includeMember = (memberKinds.HasFlag(MemberKinds.Constructor) && (member.MemberType == MemberTypes.Constructor)) ||
(memberKinds.HasFlag(MemberKinds.Event) && (member.MemberType == MemberTypes.Event)) ||
(memberKinds.HasFlag(MemberKinds.Field) && (member.MemberType == MemberTypes.Field)) ||
(memberKinds.HasFlag(MemberKinds.Method) && (member.MemberType == MemberTypes.Method)) ||
(memberKinds.HasFlag(MemberKinds.Property) && (member.MemberType == MemberTypes.Property)) ||
(memberKinds.HasFlag(MemberKinds.NestedType) && (member.MemberType == MemberTypes.NestedType));
if (includeMember)
{
filteredMembers.Add(member);
}
}
result = filteredMembers;
}
return(result);
}
/// <summary>Makes sure a variable is not equal to specified value.</summary><param name="i">Variable.</param><param name="j">Value the variable should not be equal to.</param><param name="varName">Name of variable.</param><param name="remarks">Remarks appended to default exception report.</param><param name="varKind">Variable kind: local, field or property.</param><param name="callerName">Assigns compiler.</param>
public static void NotEquals <T>(ref T i, T j, SCG.EqualityComparer <T> comparer,
string varName = "N/A", string remarks = "", MemberKinds varKind = MemberKinds.Argument,
[CallerMemberName] string callerName = "")
{
if (!comparer.Equals(i, j))
{
string msg = varKind switch {
MemberKinds.Argument => $"Argument {nameof(T)} {varName} inside method call {callerName} should not be {j}. {remarks}",
MemberKinds.Field => $"Field {nameof(T)} {varName} inside {callerName} should not be {j}. {remarks}",
MemberKinds.LocalVar => $"Local variable {nameof(T)} {varName} inside {callerName} should not be {j}. {remarks}",
MemberKinds.Property => $"Property {nameof(T)} {varName} inside {callerName} should not be {j}. {remarks}",
_ => "A variable had a value it should not have had."
};
throw new Exception(msg);
}
}
public static EntityList <TaskMember> FindAllByWorkTaskIDAndKind(Int32 taskid, MemberKinds kind)
{
if (Meta.Count >= 1000)
{
return(FindAll(new String[] { __.WorkTaskID, __.Kind }, new Object[] { taskid, kind }));
}
else // 实体缓存
{
return(Meta.Cache.Entities.FindAll(e => e.WorkTaskID == taskid && e.MemberKind == kind));
}
}
/// <summary>
/// Gets idiomatic members of a type corresponding to member kinds.
/// </summary>
/// <param name="type">
/// A type to enumerate the idiomatic members.
/// </param>
/// <param name="memberKinds">
/// The member kinds.
/// </param>
/// <returns>
/// The idiomatic members.
/// </returns>
public static IEnumerable<MemberInfo> GetIdiomaticMembers(this Type type, MemberKinds memberKinds)
{
return new IdiomaticMembers(type, memberKinds);
}
