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; })); }