Exemplo n.º 1
0
        /// <summary>
        /// Creates a delegate which can set the value of the field specified by <paramref name="name"/> and
        /// matching <paramref name="bindingFlags"/> on the given <paramref name="type"/>.
        /// </summary>
        public static MemberSetter DelegateForSetFieldValue(this Type type, string name, Flags bindingFlags)
        {
            var callInfo = new CallInfo(type, null, bindingFlags, MemberTypes.Field, name, null, null, false);

            return((MemberSetter) new MemberSetEmitter(callInfo).GetDelegate());
        }
Exemplo n.º 2
0
 /// <summary>
 /// Returns true if at least one of the values in the given <paramref name="mask"/> are set in the current Flags instance.
 /// </summary>
 public bool IsAnySet(Flags mask)
 {
     return((flags & mask) != 0);
 }
Exemplo n.º 3
0
 /// <summary>
 /// Gets all public and non-public instance fields and properties on the given <paramref name="type"/>
 /// that match the specified <paramref name="bindingFlags"/>, including members defined on base types.
 /// </summary>
 /// <returns>A list of all matching members on the type. This value will never be null.</returns>
 public static IList <MemberInfo> FieldsAndProperties(this Type type, Flags bindingFlags)
 {
     return(type.Members(MemberTypes.Field | MemberTypes.Property, bindingFlags, null));
 }
Exemplo n.º 4
0
 /// <summary>
 /// Sets the field specified by <paramref name="name"/> and matching <paramref name="bindingFlags"/>
 /// on the given <paramref name="obj"/> to the specified <paramref name="value" />.
 /// </summary>
 /// <returns><paramref name="obj"/>.</returns>
 public static object SetFieldValue(this object obj, string name, object value, Flags bindingFlags)
 {
     DelegateForSetFieldValue(obj.GetTypeAdjusted(), name, bindingFlags)(obj, value);
     return(obj);
 }
 /// <summary>
 /// Creates a delegate which can invoke the constructor whose parameter types are <paramref name="parameterTypes" />
 /// and matching <paramref name="bindingFlags"/> on the given <paramref name="type"/>.
 /// Leave <paramref name="parameterTypes"/> empty if the constructor has no argument.
 /// </summary>
 public static ConstructorInvoker DelegateForCreateInstance(this Type type, Flags bindingFlags,
                                                            params Type[] parameterTypes)
 {
     return((ConstructorInvoker) new CtorInvocationEmitter(type, bindingFlags, parameterTypes).GetDelegate());
 }
Exemplo n.º 6
0
        /// <summary>
        /// Gets all members of the given <paramref name="memberTypes"/> on the given <paramref name="type"/> that
        /// match the specified <paramref name="bindingFlags"/>, optionally filtered by the supplied <paramref name="names"/>
        /// list (in accordance with the given <paramref name="bindingFlags"/>).
        /// </summary>
        /// <param name="type">The type to reflect on.</param>
        /// <param name="memberTypes">The <see href="MemberTypes"/> to include in the result.</param>
        /// <param name="bindingFlags">The <see cref="BindingFlags"/> or <see cref="Flags"/> combination used to define
        /// the search behavior and result filtering.</param>
        /// <param name="names">The optional list of names against which to filter the result. If this parameter is
        /// <c>null</c> or empty no name filtering will be applied. The default behavior is to check for an exact,
        /// case-sensitive match. Pass <see href="Flags.ExcludeExplicitlyImplemented"/> to exclude explicitly implemented
        /// interface members, <see href="Flags.PartialNameMatch"/> to locate by substring, and
        /// <see href="Flags.IgnoreCase"/> to ignore case.</param>
        /// <returns>A list of all matching members on the type. This value will never be null.</returns>
        public static IList <MemberInfo> Members(this Type type, MemberTypes memberTypes, Flags bindingFlags,
                                                 params string[] names)
        {
            if (type == null || type == typeof(object))
            {
                return(new MemberInfo[0]);
            }

            bool recurse         = bindingFlags.IsNotSet(Flags.DeclaredOnly);
            bool hasNames        = names != null && names.Length > 0;
            bool hasSpecialFlags = bindingFlags.IsAnySet(Flags.ExcludeBackingMembers | Flags.ExcludeExplicitlyImplemented | Flags.ExcludeHiddenMembers);

            if (!recurse && !hasNames && !hasSpecialFlags)
            {
                return(type.FindMembers(memberTypes, bindingFlags, null, null));
            }

            var members = GetMembers(type, memberTypes, bindingFlags);

            members = hasSpecialFlags ? members.Filter(bindingFlags) : members;
            members = hasNames ? members.Filter(bindingFlags, names) : members;
            return(members);
        }
Exemplo n.º 7
0
 /// <summary>
 /// Creates a delegate which can invoke the method <paramref name="name"/> with arguments matching
 /// <paramref name="parameterTypes"/> and matching <paramref name="bindingFlags"/> on the given <paramref name="type"/>.
 /// Leave <paramref name="parameterTypes"/> empty if the method has no arguments.
 /// </summary>
 public static MethodInvoker DelegateForCallMethod(this Type type, string name, Flags bindingFlags, params Type[] parameterTypes)
 {
     return(DelegateForCallMethod(type, null, name, bindingFlags, parameterTypes));
 }
 /// <summary>
 /// Invokes a constructor whose parameter types are inferred from <paramref name="parameters" /> and
 /// matching <paramref name="bindingFlags"/> on the given <paramref name="type"/>
 /// with <paramref name="parameters" /> being the arguments.
 /// Leave <paramref name="parameters"/> empty if the constructor has no argument.
 /// </summary>
 /// <remarks>
 /// All elements of <paramref name="parameters"/> must not be <c>null</c>.  Otherwise,
 /// <see cref="NullReferenceException"/> is thrown.  If you are not sure as to whether
 /// any element is <c>null</c> or not, use the overload that accepts <c>paramTypes</c> array.
 /// </remarks>
 /// <seealso cref="CreateInstance(System.Type,System.Type[],Fasterflect.Flags,object[])"/>
 public static object CreateInstance(this Type type, Flags bindingFlags, params object[] parameters)
 {
     return(DelegateForCreateInstance(type, bindingFlags, parameters.ToTypeArray())(parameters));
 }
Exemplo n.º 9
0
 /// <summary>
 /// Returns a new Flags instance returns a new Flags instance with the values from <paramref name="flags"/>
 /// that were not in <paramref name="mask"/> if <paramref name="condition"/> is true, and otherwise returns
 /// the supplied <paramref name="flags"/>.
 /// </summary>
 public static Flags ClearIf(Flags flags, Flags mask, bool condition)
 {
     return(condition ? (Flags)(flags & ~mask) : flags);
 }
Exemplo n.º 10
0
 /// <summary>
 /// Invoke generic method.  See the overload with same parameters except for <paramref name="genericTypes"/>.
 /// </summary>
 /// <seealso cref="CallMethod(object,string,Type[],Flags,object[])"/>
 public static object CallMethod(this object obj, Type[] genericTypes, string name, Type[] parameterTypes, Flags bindingFlags,
                                 params object[] parameters)
 {
     return(DelegateForCallMethod(obj.GetTypeAdjusted(), genericTypes, name, bindingFlags, parameterTypes)
                (obj, parameters));
 }
Exemplo n.º 11
0
 /// <summary>
 /// Returns a new Flags instance with the union of the values from <paramref name="flags"/> and
 /// <paramref name="mask"/> if <paramref name="condition"/> is true, and otherwise returns a new
 /// Flags instance with the values from <paramref name="flags"/> that were not in <paramref name="mask"/>.
 /// </summary>
 public static Flags SetOnlyIf(Flags flags, Flags mask, bool condition)
 {
     return(condition ? flags | mask : (Flags)(flags & ~mask));
 }
Exemplo n.º 12
0
 /// <summary>
 /// Returns a new Flags instance with the union of the values from <paramref name="flags"/> and
 /// <paramref name="mask"/> if <paramref name="condition"/> is true, and otherwise returns the
 /// supplied <paramref name="flags"/>.
 /// </summary>
 public static Flags SetIf(Flags flags, Flags mask, bool condition)
 {
     return(condition ? flags | mask : flags);
 }
Exemplo n.º 13
0
 /// <summary>
 /// Returns true if all values in the given <paramref name="mask"/> are not set in the current Flags instance.
 /// </summary>
 public bool IsNotSet(Flags mask)
 {
     return((flags & mask) == 0);
 }
Exemplo n.º 14
0
 /// <summary>
 /// Invokes the method specified by <paramref name="name"/> on the given <paramref name="obj"/>
 /// matching <paramref name="bindingFlags"/> using <paramref name="parameters"/> as arguments.
 /// Leave <paramref name="parameters"/> empty if the method has no argument.
 /// </summary>
 /// <returns>The return value of the method.</returns>
 /// <remarks>If the method has no return type, <c>null</c> is returned.</remarks>
 /// <remarks>
 /// All elements of <paramref name="parameters"/> must not be <c>null</c>.  Otherwise,
 /// <see cref="NullReferenceException"/> is thrown.  If you are not sure as to whether
 /// any element is <c>null</c> or not, use the overload that accepts <c>paramTypes</c> array.
 /// </remarks>
 /// <seealso cref="CallMethod(object,string,System.Type[],Fasterflect.Flags,object[])"/>
 public static object CallMethod(this object obj, string name, Flags bindingFlags, params object[] parameters)
 {
     return(DelegateForCallMethod(obj.GetTypeAdjusted(), null, name, bindingFlags, parameters.ToTypeArray())
                (obj, parameters));
 }
Exemplo n.º 15
0
        /// <summary>
        /// Create a delegate to invoke a generic method.  See the overload with same parameters except for <paramref name="genericTypes"/>.
        /// </summary>
        /// <seealso cref="DelegateForCallMethod(Type,string,Flags,Type[])"/>
        public static MethodInvoker DelegateForCallMethod(this Type type, Type[] genericTypes, string name, Flags bindingFlags,
                                                          params Type[] parameterTypes)
        {
            var callInfo = new CallInfo(type, genericTypes, bindingFlags, MemberTypes.Method, name, parameterTypes, null, true);

            return((MethodInvoker) new MethodInvocationEmitter(callInfo).GetDelegate());
        }
Exemplo n.º 16
0
 /// <summary>
 /// Gets all constructors matching the given <paramref name="bindingFlags"/> (and that are not abstract)
 /// on the given <paramref name="type"/>.
 /// </summary>
 /// <param name="type">The type to reflect on.</param>
 /// <param name="bindingFlags">The search criteria to use when reflecting.</param>
 /// <returns>A list of matching constructors. This value will never be null.</returns>
 public static IList <ConstructorInfo> Constructors(this Type type, Flags bindingFlags)
 {
     return(type.GetTypeInfo().GetConstructors(bindingFlags));              //.Where( ci => !ci.IsAbstract ).ToList();
 }
Exemplo n.º 17
0
 /// <summary>
 /// Gets the method with the given <paramref name="name"/> and matching <paramref name="bindingFlags"/>
 /// on the given <paramref name="type"/>.
 /// </summary>
 /// <param name="type">The type on which to reflect.</param>
 /// <param name="name">The name of the method to search for. This argument must be supplied. The
 /// default behavior is to check for an exact, case-sensitive match. Pass <see href="Flags.ExplicitNameMatch"/>
 /// to include explicitly implemented interface members, <see href="Flags.PartialNameMatch"/> to locate
 /// by substring, and <see href="Flags.IgnoreCase"/> to ignore case.</param>
 /// <param name="bindingFlags">The <see cref="BindingFlags"/> or <see cref="Flags"/> combination used to define
 /// the search behavior and result filtering.</param>
 /// <returns>The specified method or null if no method was found. If there are multiple matches
 /// due to method overloading the first found match will be returned.</returns>
 public static MethodInfo Method(this Type type, string name, Flags bindingFlags)
 {
     return(type.Method(name, null, bindingFlags));
 }
Exemplo n.º 18
0
 /// <summary>
 /// Invokes a constructor whose parameter types are <paramref name="parameterTypes" /> and
 /// matching <paramref name="bindingFlags"/> on the given <paramref name="type"/>
 /// with <paramref name="parameters" /> being the arguments.
 /// </summary>
 public static object CreateInstance(this Type type, Type[] parameterTypes, Flags bindingFlags, params object[] parameters)
 {
     return(DelegateForCreateInstance(type, bindingFlags, parameterTypes)(parameters));
 }
Exemplo n.º 19
0
 /// <summary>
 /// Gets a generic method.  See the overload with same arguments exception for <paramref name="genericTypes"/>.
 /// </summary>
 /// <seealso cref="Method(Type,string,Flags)"/>
 public static MethodInfo Method(this Type type, Type[] genericTypes, string name, Flags bindingFlags)
 {
     return(type.Method(genericTypes, name, null, bindingFlags));
 }
Exemplo n.º 20
0
 /// <summary>
 /// Gets all public and non-public instance members on the given <paramref name="type"/> that
 /// match the specified <paramref name="bindingFlags"/>.
 /// </summary>
 /// <returns>A list of all matching members on the type. This value will never be null.</returns>
 /// <param name="type">The type to reflect on.</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> Members(this Type type, Flags bindingFlags)
 {
     return(type.Members(MemberTypes.All, bindingFlags, null));
 }
Exemplo n.º 21
0
 /// <summary>
 /// Gets the method with the given <paramref name="name"/> and matching <paramref name="bindingFlags"/>
 /// on the given <paramref name="type"/> where the parameter types correspond in order with the
 /// supplied <paramref name="parameterTypes"/>.
 /// </summary>
 /// <param name="type">The type on which to reflect.</param>
 /// <param name="name">The name of the method to search for. This argument must be supplied. The
 ///   default behavior is to check for an exact, case-sensitive match. Pass <see href="Flags.ExplicitNameMatch"/>
 ///   to include explicitly implemented interface members, <see href="Flags.PartialNameMatch"/> to locate
 ///   by substring, and <see href="Flags.IgnoreCase"/> to ignore case.</param>
 /// <param name="parameterTypes">If this parameter is supplied then only methods with the same parameter signature
 ///   will be included in the result. The default behavior is to check only for assignment compatibility,
 ///   but this can be changed to exact matching by passing <see href="Flags.ExactBinding"/>.</param>
 /// <param name="bindingFlags">The <see cref="BindingFlags"/> or <see cref="Flags"/> combination used to define
 ///   the search behavior and result filtering.</param>
 /// <returns>The specified method or null if no method was found. If there are multiple matches
 /// due to method overloading the first found match will be returned.</returns>
 public static MethodInfo Method(this Type type, string name, Type[] parameterTypes, Flags bindingFlags)
 {
     return(type.Method(null, name, parameterTypes, bindingFlags));
 }
Exemplo n.º 22
0
        private static IList <MemberInfo> GetMembers(Type type, MemberTypes memberTypes, Flags bindingFlags)
        {
            bool recurse = bindingFlags.IsNotSet(Flags.DeclaredOnly);

            if (!recurse)
            {
                return(type.FindMembers(memberTypes, bindingFlags, null, null));
            }

            bindingFlags |= Flags.DeclaredOnly;
            bindingFlags &= ~BindingFlags.FlattenHierarchy;

            var members = new List <MemberInfo>();

            members.AddRange(type.FindMembers(memberTypes, bindingFlags, null, null));
            Type baseType = type.BaseType;

            while (baseType != null && baseType != typeof(object))
            {
                members.AddRange(baseType.FindMembers(memberTypes, bindingFlags, null, null));
                baseType = baseType.BaseType;
            }
            return(members);
        }
Exemplo n.º 23
0
        /// <summary>
        /// Gets the method with the given <paramref name="name"/> and matching <paramref name="bindingFlags"/>
        /// on the given <paramref name="type"/> where the parameter types correspond in order with the
        /// supplied <paramref name="parameterTypes"/>.
        /// </summary>
        /// <param name="type">The type on which to reflect.</param>
        /// <param name="genericTypes">Type parameters if this is a generic method.</param>
        /// <param name="name">The name of the method to search for. This argument must be supplied. The
        ///   default behavior is to check for an exact, case-sensitive match. Pass <see href="Flags.ExplicitNameMatch"/>
        ///   to include explicitly implemented interface members, <see href="Flags.PartialNameMatch"/> to locate
        ///   by substring, and <see href="Flags.IgnoreCase"/> to ignore case.</param>
        /// <param name="parameterTypes">If this parameter is supplied then only methods with the same parameter signature
        ///   will be included in the result. The default behavior is to check only for assignment compatibility,
        ///   but this can be changed to exact matching by passing <see href="Flags.ExactBinding"/>.</param>
        /// <param name="bindingFlags">The <see cref="BindingFlags"/> or <see cref="Flags"/> combination used to define
        ///   the search behavior and result filtering.</param>
        /// <returns>The specified method or null if no method was found. If there are multiple matches
        /// due to method overloading the first found match will be returned.</returns>
        public static MethodInfo Method(this Type type, Type[] genericTypes, string name, Type[] parameterTypes, Flags bindingFlags)
        {
            bool hasTypes        = parameterTypes != null;
            bool hasGenericTypes = genericTypes != null && genericTypes.Length > 0;
            // we need to check all methods to do partial name matches or complex parameter binding
            bool processAll = bindingFlags.IsAnySet(Flags.PartialNameMatch | Flags.TrimExplicitlyImplemented);

            processAll |= hasTypes && bindingFlags.IsSet(Flags.IgnoreParameterModifiers);
            processAll |= hasGenericTypes;
            if (processAll)
            {
                //TODO: Might have to do the same polymorphic parameter type check for generics
                return(type.Methods(genericTypes, parameterTypes, bindingFlags, name).FirstOrDefault().MakeGeneric(genericTypes));
            }

            //TODO: Check fasterflect cache first
            //TODO: Find out why we needed to call HasParameterSignature for polymorphism
            var result = hasTypes
                                ? type.GetTypeInfo().GetMethods(bindingFlags).FirstOrDefault(mi => mi.Name == name && mi.HasParameterSignature(parameterTypes))
                                : type.GetTypeInfo().GetMethod(name, bindingFlags);

            if (result == null && bindingFlags.IsNotSet(Flags.DeclaredOnly))
            {
                if (type.GetTypeInfo().BaseType != typeof(object) && type.GetTypeInfo().BaseType != null)
                {
                    //TODO: Added slow polymorphic type checking
                    //TODO: Check fasterflect cache first
                    if (hasTypes)
                    {
                        return(type.GetTypeInfo().BaseType.GetTypeInfo().GetMethods(bindingFlags).FirstOrDefault(mi => mi.Name == name && mi.HasParameterSignature(parameterTypes)));
                    }
                    else
                    {
                        return(type.GetTypeInfo().BaseType.Method(name, parameterTypes, bindingFlags));
                    }
                }
            }
            bool hasSpecialFlags =
                bindingFlags.IsAnySet(Flags.ExcludeBackingMembers | Flags.ExcludeExplicitlyImplemented | Flags.ExcludeHiddenMembers);

            if (hasSpecialFlags)
            {
                var methods = new List <MethodInfo> {
                    result
                }.Filter(bindingFlags);
                return((methods.Count > 0 ? methods[0] : null).MakeGeneric(genericTypes));
            }
            return(result.MakeGeneric(genericTypes));
        }
Exemplo n.º 24
0
 /// <summary>
 /// Sets the first field with the given <paramref name="name"/> on the given <paramref name="obj"/> object
 /// to the supplied <paramref name="value"/>. Returns true if a value was assigned to a field and false otherwise.
 /// Use the <paramref name="bindingFlags"/> parameter to limit the scope of the search.
 /// </summary>
 /// <param name="obj">The source object on which to find the field</param>
 /// <param name="name">The name of the field whose value should be retrieved</param>
 /// <param name="value">The value that should be assigned to the field</param>
 /// <param name="bindingFlags">A combination of Flags that define the scope of the search</param>
 /// <returns>True if the value was assigned to a field and false otherwise</returns>
 public static bool TrySetFieldValue(this object obj, string name, object value, Flags bindingFlags)
 {
     try
     {
         obj.SetFieldValue(name, value, bindingFlags);
         return(true);
     }
     catch (MissingFieldException)
     {
         return(false);
     }
 }
Exemplo n.º 25
0
 /// <summary>
 /// Gets all methods on the given <paramref name="type"/> that match the given lookup criteria.
 /// </summary>
 /// <param name="type">The type on which to reflect.</param>
 /// <param name="parameterTypes">If this parameter is supplied then only methods with the same parameter signature
 /// will be included in the result. The default behavior is to check only for assignment compatibility,
 /// but this can be changed to exact matching by passing <see href="Flags.ExactBinding"/>.</param>
 /// <param name="bindingFlags">The <see cref="BindingFlags"/> or <see cref="Flags"/> combination used to define
 /// the search behavior and result filtering.</param>
 /// <param name="names">The optional list of names against which to filter the result. If this parameter is
 /// <c>null</c> or empty no name filtering will be applied. The default behavior is to check for an exact,
 /// case-sensitive match. Pass <see href="Flags.ExcludeExplicitlyImplemented"/> to exclude explicitly implemented
 /// interface members, <see href="Flags.PartialNameMatch"/> to locate by substring, and
 /// <see href="Flags.IgnoreCase"/> to ignore case.</param>
 /// <returns>A list of all matching methods. This value will never be null.</returns>
 public static IList <MethodInfo> Methods(this Type type, Type[] parameterTypes, Flags bindingFlags, params string[] names)
 {
     return(type.Methods(null, parameterTypes, bindingFlags, names));
 }
Exemplo n.º 26
0
 /// <summary>
 /// Gets the value of the field specified by <paramref name="name"/> and matching <paramref name="bindingFlags"/>
 /// on the given <paramref name="obj"/>.
 /// </summary>
 public static object GetFieldValue(this object obj, string name, Flags bindingFlags)
 {
     return(DelegateForGetFieldValue(obj.GetTypeAdjusted(), name, bindingFlags)(obj));
 }
Exemplo n.º 27
0
        /// <summary>
        /// Gets all methods on the given <paramref name="type"/> that match the given lookup criteria.
        /// </summary>
        /// <param name="type">The type on which to reflect.</param>
        /// <param name="genericTypes">If this parameter is supplied then only methods with the same generic parameter
        /// signature will be included in the result. The default behavior is to check only for assignment compatibility,
        /// but this can be changed to exact matching by passing <see href="Flags.ExactBinding"/>.</param>
        /// <param name="parameterTypes">If this parameter is supplied then only methods with the same parameter signature
        /// will be included in the result. The default behavior is to check only for assignment compatibility,
        /// but this can be changed to exact matching by passing <see href="Flags.ExactBinding"/>.</param>
        /// <param name="bindingFlags">The <see cref="BindingFlags"/> or <see cref="Flags"/> combination used to define
        /// the search behavior and result filtering.</param>
        /// <param name="names">The optional list of names against which to filter the result. If this parameter is
        /// <c>null</c> or empty no name filtering will be applied. The default behavior is to check for an exact,
        /// case-sensitive match. Pass <see href="Flags.ExcludeExplicitlyImplemented"/> to exclude explicitly implemented
        /// interface members, <see href="Flags.PartialNameMatch"/> to locate by substring, and
        /// <see href="Flags.IgnoreCase"/> to ignore case.</param>
        /// <returns>A list of all matching methods. This value will never be null.</returns>
        public static IList <MethodInfo> Methods(this Type type, Type[] genericTypes, Type[] parameterTypes, Flags bindingFlags,
                                                 params string[] names)
        {
            if (type == null || type == typeof(object))
            {
                return(new MethodInfo[0]);
            }
            bool recurse         = bindingFlags.IsNotSet(Flags.DeclaredOnly);
            bool hasNames        = names != null && names.Length > 0;
            bool hasTypes        = parameterTypes != null;
            bool hasGenericTypes = genericTypes != null && genericTypes.Length > 0;
            bool hasSpecialFlags =
                bindingFlags.IsAnySet(Flags.ExcludeBackingMembers | Flags.ExcludeExplicitlyImplemented | Flags.ExcludeHiddenMembers);

            if (!recurse && !hasNames && !hasTypes && !hasSpecialFlags)
            {
                return(type.GetTypeInfo().GetMethods(bindingFlags) ?? new MethodInfo[0]);
            }

            var methods = GetMethods(type, bindingFlags);

            methods = hasNames ? methods.Filter(bindingFlags, names) : methods;
            methods = hasGenericTypes ? methods.Filter(genericTypes) : methods;
            methods = hasTypes ? methods.Filter(bindingFlags, parameterTypes) : methods;
            methods = hasSpecialFlags ? methods.Filter(bindingFlags) : methods;
            return(methods);
        }
 /// <summary>
 /// Creates a delegate which can get the value of the property <param name="propInfo"/> matching the
 /// specified <param name="bindingFlags" />.
 /// </summary>
 public static MemberGetter DelegateForGetPropertyValue( this PropertyInfo propInfo, Flags bindingFlags )
 {
     return (MemberGetter) new MemberGetEmitter( propInfo, bindingFlags ).GetDelegate();
 }
Exemplo n.º 29
0
 /// <summary>
 /// Returns true if all values in the given <paramref name="mask"/> are set in the current Flags instance.
 /// </summary>
 public bool IsSet(Flags mask)
 {
     return((flags & mask) == mask);
 }