Example #1
0
        public static MemberInfo GetMemberInfoFromType(Type targetType, MemberInfo memberInfo)
        {
            if (TypeExtensions.MemberType(memberInfo) != MemberTypes.Property)
            {
                return(Enumerable.SingleOrDefault(targetType.GetMember(memberInfo.Name, TypeExtensions.MemberType(memberInfo), BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)));
            }
            PropertyInfo propertyInfo = (PropertyInfo)memberInfo;

            Type[] types = Enumerable.ToArray(Enumerable.Select(propertyInfo.GetIndexParameters(), p => p.ParameterType));
            return(targetType.GetProperty(propertyInfo.Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, propertyInfo.PropertyType, types, null));
        }
Example #2
0
        public static void SetMemberValue(MemberInfo member, object target, object value)
        {
            ValidationUtils.ArgumentNotNull(member, "member");
            ValidationUtils.ArgumentNotNull(target, "target");
            switch (TypeExtensions.MemberType(member))
            {
            case MemberTypes.Field:
                ((FieldInfo)member).SetValue(target, value);
                break;

            case MemberTypes.Property:
                ((PropertyInfo)member).SetValue(target, value, null);
                break;

            default:
                throw new ArgumentException(StringUtils.FormatWith("MemberInfo '{0}' must be of type FieldInfo or PropertyInfo", CultureInfo.InvariantCulture, member.Name), "member");
            }
        }
Example #3
0
        public static Type GetMemberUnderlyingType(MemberInfo member)
        {
            ValidationUtils.ArgumentNotNull(member, "member");
            switch (TypeExtensions.MemberType(member))
            {
            case MemberTypes.Event:
                return(((EventInfo)member).EventHandlerType);

            case MemberTypes.Field:
                return(((FieldInfo)member).FieldType);

            case MemberTypes.Property:
                return(((PropertyInfo)member).PropertyType);

            default:
                throw new ArgumentException("MemberInfo must be of type FieldInfo, PropertyInfo or EventInfo", "member");
            }
        }
Example #4
0
        public static bool CanSetMemberValue(MemberInfo member, bool nonPublic, bool canSetReadOnly)
        {
            switch (TypeExtensions.MemberType(member))
            {
            case MemberTypes.Field:
                FieldInfo fieldInfo = (FieldInfo)member;
                return((!fieldInfo.IsInitOnly || canSetReadOnly) && (nonPublic || fieldInfo.IsPublic));

            case MemberTypes.Property:
                PropertyInfo propertyInfo = (PropertyInfo)member;
                if (!propertyInfo.CanWrite)
                {
                    return(false);
                }
                return(nonPublic || propertyInfo.GetSetMethod(nonPublic) != null);

            default:
                return(false);
            }
        }
Example #5
0
        public static bool CanReadMemberValue(MemberInfo member, bool nonPublic)
        {
            switch (TypeExtensions.MemberType(member))
            {
            case MemberTypes.Field:
                FieldInfo fieldInfo = (FieldInfo)member;
                return(nonPublic || fieldInfo.IsPublic);

            case MemberTypes.Property:
                PropertyInfo propertyInfo = (PropertyInfo)member;
                if (!propertyInfo.CanRead)
                {
                    return(false);
                }
                return(nonPublic || propertyInfo.GetGetMethod(nonPublic) != null);

            default:
                return(false);
            }
        }
Example #6
0
        private static bool IsOverridenGenericMember(MemberInfo memberInfo, BindingFlags bindingAttr)
        {
            switch (TypeExtensions.MemberType(memberInfo))
            {
            case MemberTypes.Field:
            case MemberTypes.Property:
                Type declaringType = memberInfo.DeclaringType;
                if (!TypeExtensions.IsGenericType(declaringType))
                {
                    return(false);
                }
                Type genericTypeDefinition = declaringType.GetGenericTypeDefinition();
                if (genericTypeDefinition == null)
                {
                    return(false);
                }
                MemberInfo[] member = genericTypeDefinition.GetMember(memberInfo.Name, bindingAttr);
                return(member.Length != 0 && GetMemberUnderlyingType(member[0]).IsGenericParameter);

            default:
                throw new ArgumentException("Member must be a field or property.");
            }
        }
Example #7
0
        public static object GetMemberValue(MemberInfo member, object target)
        {
            ValidationUtils.ArgumentNotNull(member, "member");
            ValidationUtils.ArgumentNotNull(target, "target");
            switch (TypeExtensions.MemberType(member))
            {
            case MemberTypes.Field:
                return(((FieldInfo)member).GetValue(target));

            case MemberTypes.Property:
                try
                {
                    return(((PropertyInfo)member).GetValue(target, null));
                }
                catch (TargetParameterCountException ex)
                {
                    throw new ArgumentException(StringUtils.FormatWith("MemberInfo '{0}' has index parameters", CultureInfo.InvariantCulture, member.Name), ex);
                }

            default:
                throw new ArgumentException(StringUtils.FormatWith("MemberInfo '{0}' is not of type FieldInfo or PropertyInfo", CultureInfo.InvariantCulture, CultureInfo.InvariantCulture, member.Name), "member");
            }
        }