public Module Module; // ex RunCode_00002.dll
public TypeValueInfo(Type sourceType, MemberInfo memberInfo)
{
SourceType = sourceType;
Name = memberInfo.Name;
TreeName = memberInfo.Name;
ParentName = null;
Type valueType = memberInfo.zGetValueType();
Type enumerableType = null;
if (valueType != typeof(string))
enumerableType = zReflection.GetEnumerableType(valueType);
if (enumerableType != null)
{
ValueType = enumerableType;
IsEnumerable = true;
}
else
{
ValueType = valueType;
IsEnumerable = false;
}
IsValueType = TypeReflection.IsValueType(ValueType);
DeclaringType = memberInfo.DeclaringType;
ReflectedType = memberInfo.ReflectedType;
MemberTypes = memberInfo.MemberType;
MetadataToken = memberInfo.MetadataToken;
Module = memberInfo.Module;
}
public MapCallInfo(Type targetType, Type[] genericTypes, Flags bindingFlags, MemberTypes memberTypes, string name, Type[] parameterTypes, MemberInfo memberInfo, bool isReadOperation, Type sourceType, MemberTypes sourceMemberTypes, MemberTypes targetMemberTypes, string[] names) : base(targetType, genericTypes, bindingFlags, memberTypes, name, parameterTypes, memberInfo, isReadOperation)
{
SourceType = sourceType;
SourceMemberTypes = sourceMemberTypes;
TargetMemberTypes = targetMemberTypes;
Names = names;
}
public PermissionMember (MemberTypes member_type, BaseTypeRef type_ref, string name, object value)
{
this.member_type = member_type;
this.type_ref = type_ref;
this.name = name;
this.value = value;
}
// Constructor.
public MemberInfoSerializationHolder(SerializationInfo info,
StreamingContext context)
{
if(info == null)
{
throw new ArgumentNullException("info");
}
memberType = (MemberTypes)(info.GetInt32("MemberType"));
name = info.GetString("Name");
signature = info.GetString("Signature");
String assemblyName = info.GetString("AssemblyName");
String className = info.GetString("ClassName");
if(assemblyName == null || className == null)
{
throw new SerializationException
(_("Serialize_StateMissing"));
}
Assembly assembly = FormatterServices.GetAssemblyByName
(assemblyName);
if(assembly == null)
{
throw new SerializationException
(_("Serialize_StateMissing"));
}
containingType = FormatterServices.GetTypeFromAssembly
(assembly, className);
}
private void GetSerializationInfo(SerializationInfo info, string name, Type reflectedClass, string signature, MemberTypes type, Type[] genericArguments)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
AssemblyName asmname = reflectedClass.Assembly.GetName();
asmname.Version = new Version(_version, 0, 0, 0);
string fullName = asmname.ToString();
string str2 = reflectedClass.FullName;
Type t = typeof(int).Assembly.GetType("System.Reflection.MemberInfoSerializationHolder");
info.SetType(t);
for (int i = 0; i < genericArguments.Length; ++i)
{
genericArguments[i] = new FakeType(genericArguments[i], _version);
}
// This is here to prevent a de-serialization bug
if (genericArguments.Length > 0)
{
info.AddValue("DUMMY", genericArguments[0]);
}
info.AddValue("GenericArguments", genericArguments, typeof(Type[]));
info.AddValue("Name", name, typeof(string));
info.AddValue("AssemblyName", fullName, typeof(string));
info.AddValue("ClassName", str2, typeof(string));
info.AddValue("Signature", signature, typeof(string));
info.AddValue("MemberType", (int)type);
}
public WiredToAttribute(MemberTypes memberType, string name, Type typeWiredTo)
{
WiredMemberType = memberType;
WiredMemberName = name;
TypeWiredTo = typeWiredTo;
}
public WiredToAttribute(MemberTypes memberType, string name, string qualifiedTypeNameWiredTo)
{
WiredMemberType = memberType;
WiredMemberName = name;
TypeWiredTo = Type.GetType(qualifiedTypeNameWiredTo, true, false);
}
public static void GetSerializationInfo(
SerializationInfo info,
String name,
RuntimeType reflectedClass,
String signature,
String signature2,
MemberTypes type,
Type[] genericArguments)
{
if (info == null)
throw new ArgumentNullException(nameof(info));
Contract.EndContractBlock();
String assemblyName = reflectedClass.Module.Assembly.FullName;
String typeName = reflectedClass.FullName;
info.SetType(typeof(MemberInfoSerializationHolder));
info.AddValue("Name", name, typeof(String));
info.AddValue("AssemblyName", assemblyName, typeof(String));
info.AddValue("ClassName", typeName, typeof(String));
info.AddValue("Signature", signature, typeof(String));
info.AddValue("Signature2", signature2, typeof(String));
info.AddValue("MemberType", (int)type);
info.AddValue("GenericArguments", genericArguments, typeof(Type[]));
}
public ThinMember(ThinType declaringType, string memberName, string returnType, MemberTypes memberType,
IncludeStatus includeStatus, ITypeDefinitionMember memberNode, VisibilityOverride visibility)
: this(declaringType, memberName, returnType, memberType,
includeStatus, memberNode, visibility, SecurityTransparencyStatus.Transparent)
{
}
MemberInfoSerializationHolder(SerializationInfo info, StreamingContext ctx)
{
string assemblyName;
string typeName;
assemblyName = info.GetString("AssemblyName");
typeName = info.GetString("ClassName");
_memberName = info.GetString("Name");
_memberSignature = info.GetString("Signature");
_memberType = (MemberTypes) info.GetInt32("MemberType");
#if NET_2_0
try {
_genericArguments = null;
// FIXME: this doesn't work at present. It seems that
// ObjectManager doesn't cope with nested IObjectReferences.
// _genericArguments = (Type[]) info.GetValue("GenericArguments", typeof(Type[]));
} catch (SerializationException) {
// expected (old NET_1_0 protocol)
}
#endif
// Load type
Assembly asm = Assembly.Load(assemblyName);
_reflectedType = asm.GetType(typeName, true, true);
}
public NodeInfo(Type type, string name, MemberTypes mtype, ParameterInfo[] parameters)
{
this.NodeType = type;
this.Name = name;
this.MemberType = mtype;
this.Parameters = parameters;
}
public void SetMainMember(IField field)
{
this.Member = field;
this.MemberType = MemberTypes.Field;
this.SubMemberType = this.MemberType;
this.SubMember = this.Member;
}
protected AbstractEmitter(Type targetType, BindingFlags bindingFlags, MemberTypes memberTypes, Type[] parameterTypes, MemberInfo memberInfo)
{
_targetType = targetType;
_bindingFlags = bindingFlags;
_memberTypes = memberTypes;
_parameterTypes = parameterTypes;
_memberInfo = memberInfo;
}
private static MemberInfo FindMember(Type t, string name, MemberTypes types)
{
return t
.FindMembers(types, BindingFlags.Instance | BindingFlags.Public, Type.FilterNameIgnoreCase, name)
.OrderByDescending(x => x.Name == name)
.ThenByDescending(x => x.MemberType == MemberTypes.Property)
.FirstOrDefault();
}
internal JSPredefinedField(string name, MemberTypes memberType, GlobalObjectInstance globalObject)
: base(name, 0, null)
{
m_memberType = memberType;
m_globalObject = globalObject;
// predefined fields cannot be crunched
CanCrunch = false;
}
protected override Expression Error_MemberLookupFailed (Type container_type, Type qualifier_type,
Type queried_type, string name, string class_name, MemberTypes mt, BindingFlags bf)
{
Report.Error (1935, loc, "An implementation of `{0}' query expression pattern could not be found. " +
"Are you missing `System.Linq' using directive or `System.Core.dll' assembly reference?",
name);
return null;
}
private object InvokeStaticMember(object[] arguments, MemberTypes memberTypes, string memberName = null)
{
var clazz = this.Class;
var candidates = new List<MethodBase>();
if ((memberTypes & MemberTypes.Constructor) != 0) {
candidates.AddRange(clazz.GetConstructors(BindingFlags.Public | BindingFlags.Instance));
}
if ((memberTypes & MemberTypes.Method) != 0) {
candidates.AddRange(
clazz.GetMethods(BindingFlags.Static | BindingFlags.Public)
.Where(mi => mi.Name == memberName));
}
if ((memberTypes & MemberTypes.Property) != 0) {
candidates.AddRange(
clazz.GetProperties(BindingFlags.Static | BindingFlags.Public)
.Where(pi => pi.Name == memberName)
.SelectMany(pi => new MethodInfo[] { pi.GetGetMethod(), pi.GetSetMethod() })
.Where(mi => mi != null));
}
candidates = candidates.FindAll(mi => mi.GetParameters().Length == arguments.Length);
foreach (var mi in candidates) {
var pis = mi.GetParameters();
bool accepted = true;
for(int i = 0; i < pis.Length; i++) {
var pi = pis[i];
var arg = arguments[i];
if (!pi.ParameterType.IsAssignableFrom(arg.GetType())) {
accepted = false;
break;
}
}
if (accepted) { // we found a good candidate
if (mi is ConstructorInfo)
return ((ConstructorInfo)mi).Invoke(arguments);
else
return mi.Invoke(null, arguments);
}
}
// if we've reached this point but we still have a partially matching method,
// just try to forcefully cast the args to what the method expects
if (candidates.Count > 0) {
var mi = candidates[0];
var miParams = mi.GetParameters();
var newArgs = (object[])arguments.Clone();
for (int i = 0; i < arguments.Length; i++) {
newArgs[i] = Convert.ChangeType(arguments[i], miParams[i].ParameterType);
}
return mi.Invoke(null, newArgs);
}
throw new MissingMemberException(String.Format("Could not find a compatible member named '{0}' in class '{1}'", memberName, this.Class));
}
public LazyMemberInfo(MemberTypes memberType, Func<MemberInfo[]> accessorsCreator)
{
EnsureSupportedMemberType(memberType, "memberType");
Requires.NotNull(accessorsCreator, "accessorsCreator");
this._memberType = memberType;
this._accessors = null;
this._accessorsCreator = accessorsCreator;
}
public MappingDefinition AddMappingFromDocumentWithHeaders(Document doc,MemberTypes memberType=MemberTypes.Property)
{
if(!doc.HaveHeader) throw new InvalidDataException("document does not have headers");
foreach (var header in doc.Header)
{
AddFieldMapping(header, header, memberType);
}
return this;
}
public static void Test_SerializedMemberParser_Should_Find_No_Members(MemberTypes memberInfoType, Type typeToParse)
{
//arranges
IEnumerable objects = new SerializedMemberParser().Parse(memberInfoType, typeToParse);
//assert
//It should be empty but non-null
Assert.IsNotNull(objects);
Assert.IsEmpty(objects);
}
public AutoCompleteItem(string displayName, string value, MemberTypes? memberType = null, Type type = null)
{
Should.NotBeNull(displayName, nameof(displayName));
Should.NotBeNull(value, nameof(value));
Type = type ?? typeof(object);
DisplayName = memberType.HasValue
? $"{displayName} ({Type.Name} - {(memberType.Value == MemberTypes.Custom ? "Attached" : memberType.Value.ToString())})"
: displayName;
Value = value;
MemberType = memberType.GetValueOrDefault(MemberTypes.Custom);
}
internal c00010e(c000068 p0, c00007f p1, Type p2, string p3, bool p4, bool p5, MemberTypes p6, bool p7)
{
this.f000028 = p0;
this.f000018 = p1;
this.f00000d = p2;
this.f000006 = p3;
this.f00000a = p4;
this.f000056 = p5;
this.f000189 = p6;
this.f0000a0 = p7;
}
/// <summary>
/// Initializes a new instance of the <see cref="NamedIdMemberConvention" /> class.
/// </summary>
/// <param name="names">The names.</param>
/// <param name="memberTypes">The member types.</param>
/// <param name="bindingFlags">The binding flags.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public NamedIdMemberConvention(IEnumerable<string> names, MemberTypes memberTypes, BindingFlags bindingFlags)
{
if (names == null)
{
throw new ArgumentNullException("names");
}
_names = names;
_memberTypes = memberTypes;
_bindingFlags = bindingFlags | BindingFlags.DeclaredOnly;
}
// Serialize a unity object.
public static void Serialize(SerializationInfo info,
MemberTypes memberType,
String name, String signature,
Type containingType)
{
info.SetType(typeof(MemberInfoSerializationHolder));
info.AddValue("Name", name);
info.AddValue("AssemblyName", containingType.Assembly.FullName);
info.AddValue("ClassName", containingType.FullName);
info.AddValue("Signature", signature);
info.AddValue("MemberType", (int)memberType);
}
public override MemberElement CreateMemberElement(TypeElement type, string memberName, string returnType, MemberTypes memberType, IncludeStatus includeStatus, VisibilityOverride visibilityOverride, SecurityTransparencyStatus securityTransparencyStatus)
{
// Identify the member by category (method/prop/field/event), name, and return type. These
// strings are what matched by ModelSigFormatter
string memberSig = memberType.ToString() + " : " + memberName;
if (returnType != null) memberSig = memberSig + " : " + returnType;
CodeMemberElement member = new CodeMemberElement(includeStatus, visibilityOverride, securityTransparencyStatus, memberSig, returnType, memberType, memberName);
(type as CodeTypeElement).m_members.Add(memberSig, member);
return member;
}
public AutoCompleteItem(string displayName, string value, MemberTypes? memberType = null, Type type = null)
{
Should.NotBeNull(displayName, "displayName");
Should.NotBeNull(value, "value");
Type = type ?? typeof(object);
DisplayName = memberType.HasValue
? string.Format("{0} ({1} - {2})", displayName, Type.Name,
memberType.Value == MemberTypes.Custom ? "Attached" : memberType.Value.ToString())
: displayName;
Value = value;
MemberType = memberType.GetValueOrDefault(MemberTypes.Custom);
}
public static void Serialize(SerializationInfo info, String name, Type klass, String signature, MemberTypes type, Type[] genericArguments)
{
info.SetType( typeof(MemberInfoSerializationHolder));
info.AddValue("AssemblyName", klass.Module.Assembly.FullName, typeof(String));
info.AddValue("ClassName", klass.FullName, typeof(String));
info.AddValue("Name", name, typeof(String));
info.AddValue("Signature", signature, typeof(String));
info.AddValue("MemberType",(int)type);
info.AddValue("GenericArguments", genericArguments, typeof (Type[]));
}
public static MemberInfo[] GetMember2(this Type type, string name, MemberTypes memberTypes, BindingFlags bindingFlags)
{
MemberInfo[] members = type.GetMember(name, memberTypes, bindingFlags);
List<MemberInfo> membersList = new List<MemberInfo>();
foreach (MemberInfo info in members)
{
if ((bindingFlags & BindingFlags.DeclaredOnly) != 0 && info.DeclaringType != type)
{
continue;
}
membersList.Add(info);
}
return membersList.ToArray();
}
/// <summary>
/// Get a list of the members of a group.
/// </summary>
/// <remarks>
/// The call must be signed on behalf of a Flickr member, and the ability to see the group membership will be determined by the Flickr member's group privileges.
/// </remarks>
/// <param name="groupId">Return a list of members for this group. The group must be viewable by the Flickr member on whose behalf the API call is made.</param>
/// <param name="page">The page of the results to return (default is 1).</param>
/// <param name="perPage">The number of members to return per page (default is 100, max is 500).</param>
/// <param name="memberTypes">The types of members to be returned. Can be more than one.</param>
/// <param name="callback">Callback method to call upon return of the response from Flickr.</param>
public void GroupsMembersGetListAsync(string groupId, int page, int perPage, MemberTypes memberTypes, Action<FlickrResult<MemberCollection>> callback)
{
CheckRequiresAuthentication();
Dictionary<string, string> parameters = new Dictionary<string, string>();
parameters.Add("method", "flickr.groups.members.getList");
parameters.Add("api_key", apiKey);
if (page > 0) parameters.Add("page", page.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
if (perPage > 0) parameters.Add("per_page", perPage.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
if (memberTypes != MemberTypes.None) parameters.Add("membertypes", UtilityMethods.MemberTypeToString(memberTypes));
parameters.Add("group_id", groupId);
GetResponseAsync<MemberCollection>(parameters, callback);
}
public ThinMember(ThinType declaringType, ThinMember memberToCopy)
{
_declaringType = declaringType;
_memberNode = memberToCopy._memberNode;
_memberFullName = memberToCopy._memberFullName;
_returnType = memberToCopy._returnType;
_memberType = memberToCopy._memberType;
_includeStatus = memberToCopy._includeStatus;
_visibility = memberToCopy._visibility;
_securityTransparencyStatus = memberToCopy._securityTransparencyStatus;
CheckVisibility();
}
/// <summary>
/// Extendeds the properties are.
/// </summary>
/// <param name="extendedProperty">The extended property.</param>
/// <param name="memberTypes">The member types.</param>
/// <param name="bindingFlags">The binding flags.</param>
/// <returns></returns>
public AutoMappingProfileBuilder ExtendedPropertiesAre(Func <MemberInfo, bool> extendedProperty, MemberTypes memberTypes, BindingFlags bindingFlags)
{
_profile.Conventions.ExtendedPropertiesConvention = new DelegateExtendedPropertiesConvention(extendedProperty, memberTypes, bindingFlags);
return(this);
}
internal ClassMember(string name, System.Reflection.BindingFlags bindingFlags, MemberTypes memberType)
{
this._name = name;
this._bindingFlags = bindingFlags;
this._memberType = memberType;
}
public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
{
Debug.Assert(false, "NYI");
return(base.GetMember(name, type, bindingAttr));
}
/// <summary>
/// Gets a dictionary with all public and non-public instance members on the given <paramref name="type"/>
/// and their associated attributes. Only members of the given <paramref name="memberTypes"/> will
/// be included in the result.
/// The list of attributes associated with each member can optionally be filtered by supplying a list of
/// <paramref name="attributeTypes"/>, in which case only members with at least one of these will be
/// included in the result.
/// </summary>
/// <returns>An dictionary mapping all matching members to their associated attributes. This value
/// will never be null. The attribute list associated with each member in the dictionary will likewise
/// never be null.</returns>
public static IDictionary <MemberInfo, List <Attribute> > MembersAndAttributes(this Type type,
MemberTypes memberTypes,
params Type[] attributeTypes)
{
return(type.MembersAndAttributes(memberTypes, Flags.InstanceAnyVisibility, null));
}
public static void GetSerializationInfo(SerializationInfo info, string name, RuntimeType reflectedClass, string signature, MemberTypes type)
{
MemberInfoSerializationHolder.GetSerializationInfo(info, name, reflectedClass, signature, (string)null, type, (Type[])null);
}
public override MemberInfo[] FindMembers(MemberTypes memberType, BindingFlags bindingAttr, MemberFilter filter, object filterCriteria)
{
return(this.GetResolvedType().FindMembers(memberType, bindingAttr, filter, filterCriteria));
}
public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NonReflectedType"));
}
public static IEnumerable <MemberInfo> GetMember(this Type type, string name, MemberTypes memberType, BindingFlags bindingFlags)
{
#if (UNITY_WSA || UNITY_WINRT)
return(type.GetMemberInternal(name, memberType, bindingFlags));
#else
return(type.GetMember(name, bindingFlags).Where(m =>
{
if (m.MemberType() != memberType)
{
return false;
}
return true;
}));
#endif
}
public static void Serialize(SerializationInfo info, string name, Type klass, string signature, MemberTypes type, Type[] genericArguments)
{
info.SetType(typeof(MemberInfoSerializationHolder));
info.AddValue("AssemblyName", klass.Module.Assembly.FullName, typeof(string));
info.AddValue("ClassName", klass.FullName, typeof(string));
info.AddValue("Name", name, typeof(string));
info.AddValue("Signature", signature, typeof(string));
info.AddValue("MemberType", (int)type);
info.AddValue("GenericArguments", genericArguments, typeof(Type[]));
}
public static void Serialize(SerializationInfo info, string name, Type klass, string signature, MemberTypes type)
{
MemberInfoSerializationHolder.Serialize(info, name, klass, signature, type, null);
}
public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
{
return(_tb.GetMember(name, type, bindingAttr));
}
protected override void AddMembers(string memberName, MemberTypes memberType, ICollection <MemberInfo> targetCollection)
{
var members = Target.FindMembers(memberType, bindFlags, Options.MemberFilter, memberName);
AddMemberRange(members, targetCollection);
}
/// <summary>
/// 获取下拉框数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="memberTypes"></param>
/// <param name="startIndex"></param>
/// <returns></returns>
public static IEnumerableData <ComboBoxData> GetIEnumerableData <T>(MemberTypes memberTypes = MemberTypes.Field, int startIndex = 1)
{
return(new IEnumerableData <ComboBoxData>(Get <T>(memberTypes, startIndex)));
}
/// <summary>
/// Finds all members with the given attribute accross the type chain.
/// </summary>
/// <param name="targetType">The type on which to search for members.</param>
/// <param name="attributeType">The attribute that should be present on the members of the type.</param>
/// <param name="memberFilter">What members should be included in the result.</param>
/// <param name="bindingFlags">What binding flags should be used for the members.</param>
/// <returns>The set of members that have the attribute defined.</returns>
public static IEnumerable <MemberInfo> FindAllMembersWithAttribute(Type targetType, Type attributeType, MemberTypes memberFilter = DefaultMemberTypes, BindingFlags bindingFlags = DefaultBindingFlags)
{
IEnumerable <MemberInfo> membersWithAttribute = Enumerable.Empty <MemberInfo>();
while ((targetType != ObjectType) && (targetType != null))
{
membersWithAttribute = membersWithAttribute
.Concat(
targetType
.GetMembers(bindingFlags | BindingFlags.DeclaredOnly) // Because we're going down the type chain anyway, we only get what is defined on this type.
.Where(m => memberFilter.HasMemberFlag(m.MemberType) && Attribute.IsDefined(m, attributeType, true)));
targetType = targetType.BaseType;
}
return(membersWithAttribute.Distinct());
}
/// <summary>
/// Explicit implementation to prevent a memory alloc.
/// </summary>
/// <param name="m">The enum member value.</param>
/// <param name="flagToTest">The flag(s) to test whether they are present in the value or not.</param>
/// <returns>True if present, false otherwise.</returns>
private static bool HasMemberFlag(this MemberTypes m, MemberTypes flagToTest)
{
return((m & flagToTest) == flagToTest);
}
public override MemberInfo[] GetMember(String name, MemberTypes type, BindingFlags bindingAttr)
{
throw new NotSupportedException();
}
public override MemberInfo[] FindMembers(MemberTypes memberType, BindingFlags bindingAttr, MemberFilter filter, object filterCriteria)
{
Debug.Assert(false, "NYI");
return(base.FindMembers(memberType, bindingAttr, filter, filterCriteria));
}
public static void GetSerializationInfo(SerializationInfo info, string name, Type reflectedClass, string signature, MemberTypes type, Type[] genericArguments)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
string fullName = reflectedClass.Module.Assembly.FullName;
string str2 = reflectedClass.FullName;
info.SetType(typeof(MemberInfoSerializationHolder));
info.AddValue("Name", name, typeof(string));
info.AddValue("AssemblyName", fullName, typeof(string));
info.AddValue("ClassName", str2, typeof(string));
info.AddValue("Signature", signature, typeof(string));
info.AddValue("MemberType", (int)type);
info.AddValue("GenericArguments", genericArguments, typeof(Type[]));
}
public static IEnumerable <MemberInfo> GetMember(this Type type, string name, MemberTypes memberType, BindingFlags bindingFlags)
{
return(type.GetMembers(bindingFlags).Where(m =>
{
if (name != null && name != m.Name)
{
return false;
}
if (m.MemberType() != memberType)
{
return false;
}
return true;
}));
}
public sealed override MemberInfo[] FindMembers(MemberTypes memberType, BindingFlags bindingAttr, MemberFilter filter, object filterCriteria) => base.FindMembers(memberType, bindingAttr, filter, filterCriteria);
/// <summary>
/// Gets a dictionary with all members on the given <paramref name="type"/> and their associated attributes.
/// Only members of the given <paramref name="memberTypes"/> and matching <paramref name="bindingFlags"/> will
/// be included in the result.
/// The list of attributes associated with each member can optionally be filtered by supplying a list of
/// <paramref name="attributeTypes"/>, in which case only members with at least one of these will be
/// included in the result.
/// </summary>
/// <returns>An dictionary mapping all matching members to their associated attributes. This value
/// will never be null. The attribute list associated with each member in the dictionary will likewise
/// never be null.</returns>
public static IDictionary <MemberInfo, List <Attribute> > MembersAndAttributes(this Type type,
MemberTypes memberTypes,
Flags bindingFlags,
params Type[] attributeTypes)
{
var members = from m in type.Members(memberTypes, bindingFlags)
let a = m.Attributes(attributeTypes)
where a.Count() > 0
select new { Member = m, Attributes = a.ToList() };
return(members.ToDictionary(m => m.Member, m => m.Attributes));
}
public static void GetSerializationInfo(SerializationInfo info, string name, Type reflectedClass, string signature, MemberTypes type)
{
GetSerializationInfo(info, name, reflectedClass, signature, type, null);
}
/// <summary>
/// Gets all members of the given <paramref name="memberTypes"/> on the given <paramref name="type"/>
/// that match the specified <paramref name="bindingFlags"/> and are decorated with an
/// <see href="Attribute"/> of the given type <typeparamref name="T"/>.
/// </summary>
/// <param name="type">The type on which to reflect.</param>
/// <param name="memberTypes">The <see href="MemberTypes"/> to include in the search.</param>
/// <param name="bindingFlags">The <see cref="BindingFlags"/> or <see cref="Flags"/> combination
/// used to define the search behavior and result filtering.</param>
/// <returns>A list of all matching members on the type. This value will never be null.</returns>
public static IList <MemberInfo> MembersWith <T>(this Type type, MemberTypes memberTypes, Flags bindingFlags)
{
return(type.MembersWith(memberTypes, bindingFlags, typeof(T)));
}
public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
{
throw not_supported();
}
/// <summary>
/// Gets all public and non-public instance members on the given <paramref name="type"/>.
/// The resulting list of members can optionally be filtered by supplying a list of
/// <paramref name="attributeTypes"/>, in which case only members decorated with at least one of
/// these will be included.
/// </summary>
/// <param name="type">The type on which to reflect.</param>
/// <param name="memberTypes">The <see href="MemberTypes"/> to include in the search.</param>
/// <param name="attributeTypes">The optional list of attribute types with which members should
/// be decorated. If this parameter is <c>null</c> or empty then all fields and properties
/// will be included in the result.</param>
/// <returns>A list of all matching members on the type. This value will never be null.</returns>
public static IList <MemberInfo> MembersWith(this Type type, MemberTypes memberTypes,
params Type[] attributeTypes)
{
return(type.MembersWith(memberTypes, Flags.InstanceAnyVisibility, attributeTypes));
}
public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
{
return(this.GetResolvedType().GetMember(name, type, bindingAttr));
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="predicate"></param>
/// <param name="memberTypes">类的成员类型</param>
/// <param name="startIndex">从startIndex开始</param>
/// <returns></returns>
public static ComboBoxData FirstOrDefault <T>(Func <ComboBoxData, bool> predicate, MemberTypes memberTypes = MemberTypes.All, int startIndex = 0)
{
return(Get <T>(memberTypes, startIndex).FirstOrDefault(predicate));
}
/// <summary>
/// Idses the are.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="memberTypes">The member types.</param>
/// <param name="bindingFlags">The binding flags.</param>
/// <returns></returns>
public AutoMappingProfileBuilder IdsAre(Func <MemberInfo, bool> id, MemberTypes memberTypes, BindingFlags bindingFlags)
{
_profile.Conventions.IdConvention = new DelegateIdConvention(id, memberTypes, bindingFlags);
return(this);
}
/// <summary>
/// Idses the are named.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="memberTypes">The member types.</param>
/// <param name="bindingFlags">The binding flags.</param>
/// <returns></returns>
public AutoMappingProfileBuilder IdsAreNamed(string name, MemberTypes memberTypes, BindingFlags bindingFlags)
{
_profile.Conventions.IdConvention = new DelegateIdConvention(m => m.Name == name, memberTypes, bindingFlags);
return(this);
}
public static IEnumerable <MemberInfo> GetMember(this Type type, string name, MemberTypes memberType, Newtonsoft.Json.Utilities.BindingFlags bindingFlags)
{
return(type.GetTypeInfo().GetMembersRecursive().Where(m =>
{
if (name != null && name != m.Name)
{
return false;
}
if (m.MemberType() != memberType)
{
return false;
}
if (!TestAccessibility(m, bindingFlags))
{
return false;
}
return true;
}));
}
