ReflectionUtilities.cs

Go to the documentation of this file.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.Serialization;
 
using AnalyzeRe.Attributes;
 
namespace AnalyzeRe.Utilities
{
    public static class ReflectionUtilities
    {
        public const BindingFlags PublicInstanceBindingFlags =
            BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance;
        
        public static string GetPropertyName<TObject>(Expression<Func<TObject, object>> propertyExpression) =>
            GetMemberInfo(propertyExpression).Name;
 
        public static MemberInfo GetMemberInfo<T>(Expression<T> expression)
        {
            Expression body = expression.Body;
            // If this is a chained expression, get the final property referenced
            while (body is UnaryExpression unaryExpression)
                body = unaryExpression.Operand;
            if (body is MemberExpression memberExpression)
                return memberExpression.Member;
            throw new ArgumentException("No MemberExpression found in " + expression.GetType().NiceTypeName());
        }
 
        public static bool IsSubclassOfRawGeneric(this Type toCheck, Type generic)
        {
            while (toCheck != null && toCheck != typeof(object))
            {
                Type cur = toCheck.IsGenericType ? toCheck.GetGenericTypeDefinition() : toCheck;
                if (generic == cur)
                    return true;
                toCheck = toCheck.BaseType;
            }
            return false;
        }
 
        public static bool PropertyHasAttribute<T>(Expression<T> expression, Type attributeType)
        {
            // Automatically determine from presence of the validation attribute.
            MemberInfo propertyInfo = GetMemberInfo(expression);
            return propertyInfo.IsAttributeDefinedFast(attributeType);
        }
 
        #region Cached Attribute Retrieval
        private static readonly ConcurrentDictionary<Tuple<string, Type, Type>, object>
            CachedPropertyAttributes = new ConcurrentDictionary<Tuple<string, Type, Type>, object>();
 
        public static bool IsAttributeDefinedFast<T>(this MemberInfo member)
        {
            return IsAttributeDefinedFast(member, typeof(T));
        }
 
        public static bool IsAttributeDefinedFast(this MemberInfo member, Type attributeType)
        {
            return member.GetCustomAttributeFast(attributeType) != null;
        }
 
        public static T GetCustomAttributeFast<T>(this MemberInfo member)
        {
            return (T)GetCustomAttributeFast(member, typeof(T));
        }
 
        public static object GetCustomAttributeFast(this MemberInfo member, Type attributeType)
        {
            Tuple<string, Type, Type> cacheKey =
                Tuple.Create(member.Name, member.DeclaringType, attributeType);
            object result = CachedPropertyAttributes.GetOrAdd(cacheKey, key =>
            {
                try { return Attribute.GetCustomAttribute(member, attributeType, true); }
                catch (Exception ex) { return ex; }
            });
            if (result is Exception exceptionResult)
                throw exceptionResult;
            return result;
        }
        #endregion Cached Attribute Retrieval
 
        #region GetUserFacingProperties
        private static readonly ConcurrentDictionary<Tuple<Type, bool, bool, bool>, PropertyInfo[]>
            CachedUserFacingProperties = new ConcurrentDictionary<Tuple<Type, bool, bool, bool>, PropertyInfo[]>();
 
        public static PropertyInfo[] GetUserFacingProperties(this Type type,
            bool excludeServerGenerated = false,
            bool excludeNotWritable = false,
            bool excludeNotSerialized = false)
        {
            if (type == null)
                throw new ArgumentNullException(nameof(type), "Could not determine the declaring type.");
 
            return CachedUserFacingProperties.GetOrAdd(
                Tuple.Create(type, excludeServerGenerated, excludeNotWritable, excludeNotSerialized),
                CachedUserFacingProperties_OnAdd);
        }
 
        private static PropertyInfo[] CachedUserFacingProperties_OnAdd(
            Tuple<Type, bool, bool, bool> key)
        {
            Type type = key.Item1;
            bool excludeServerGenerated = key.Item2;
            bool excludeNotWritable = key.Item3;
            bool excludeNotSerialized = key.Item4;
 
            IEnumerable<PropertyInfo> filtered = GetPublicProperties_Fast(type)
                .Where(pi => pi.CanRead &&
                    !pi.IsAttributeDefinedFast<InternalMemberAttribute>() &&
                    !pi.IsAttributeDefinedFast<ObsoleteAttribute>());
            if(excludeServerGenerated)
                filtered = filtered.Where(pi => !pi.IsAttributeDefinedFast<ServerGenerated>());
            if (excludeNotWritable)
                filtered = filtered.Where(pi => pi.CanWrite);
            if (excludeNotSerialized)
                filtered = filtered.Where(pi => !pi.IsAttributeDefinedFast<IgnoreDataMemberAttribute>());
 
            // Iterate over all properties that meet the specified criteria, adding them to a
            // dictionary to enforce uniqueness by property name.
            // If the list of properties already contains a property name, use the propertyInfo
            // from the type that inherits from (supersedes) the other.
            Dictionary<string, PropertyInfo> propertiesByName = new Dictionary<string, PropertyInfo>();
            foreach (PropertyInfo property in filtered)
            {
                if (!propertiesByName.TryGetValue(property.Name, out PropertyInfo conflicting) ||
                    conflicting.DeclaringType.IsAssignableFrom(property.DeclaringType))
                    propertiesByName[property.Name] = property;
            }
 
            return propertiesByName.Values.ToArray();
        }
        #endregion GetUserFacingProperties
 
        #region GetPublicProperties
        private static readonly ConcurrentDictionary<Type, PropertyInfo[]> CachedPublicProperties =
            new ConcurrentDictionary<Type, PropertyInfo[]>();
 
        public static PropertyInfo[] GetPublicProperties_Fast(this Type type)
        {
            if (type == null)
                throw new ArgumentNullException(nameof(type), "Could not determine the declaring type.");
            return CachedPublicProperties.GetOrAdd(type, GetPublicProperties_Fast_OnAdd);
        }
 
        private static PropertyInfo[] GetPublicProperties_Fast_OnAdd(Type type)
        {
            // Simple case, instantiable types have a method for this
            if (!type.IsInterface)
                return type.GetProperties(PublicInstanceBindingFlags);
            // Interfaces take more work
            List<PropertyInfo> propertyInfos = new List<PropertyInfo>();
            List<Type> considered = new List<Type>();
            Queue<Type> queue = new Queue<Type>();
            considered.Add(type);
            queue.Enqueue(type);
            while (queue.Count > 0)
            {
                Type subType = queue.Dequeue();
                foreach (Type subInterface in subType.GetInterfaces()
                    .Where(subInterface => !considered.Contains(subInterface)))
                {
                    considered.Add(subInterface);
                    queue.Enqueue(subInterface);
                }
                IEnumerable<PropertyInfo> newPropertyInfos =
                    subType.GetProperties(PublicInstanceBindingFlags)
                    .Where(x => !propertyInfos.Contains(x));
                propertyInfos.InsertRange(0, newPropertyInfos);
            }
            return propertyInfos.ToArray();
        }
        #endregion GetPublicProperties
 
        #region GetPublicFields
        private static readonly ConcurrentDictionary<Type, FieldInfo[]> CachedPublicFields =
            new ConcurrentDictionary<Type, FieldInfo[]>();
 
        public static FieldInfo[] GetPublicFields_Fast(this Type type)
        {
            if (type == null)
                throw new ArgumentNullException(nameof(type), "Could not determine the declaring type.");
            // Interfaces cannot define fields.
            return type.IsInterface ? new FieldInfo[] { } :
                CachedPublicFields.GetOrAdd(type, t => t.GetFields(PublicInstanceBindingFlags));
        }
        #endregion GetPublicFields
 
        public static T ShallowCopy<T>(T toCopy)
        {
            T obj = Activator.CreateInstance<T>();
            // Copy over all public gettable and settable properties
            foreach (PropertyInfo propertyInfo in typeof(T).GetPublicProperties_Fast()
                    .Where(p => p.CanWrite))
                propertyInfo.SetValue(obj, propertyInfo.GetValue(toCopy, null), null);
            // Copy over all public gettable and settable fields
            foreach (FieldInfo fieldInfo in typeof(T).GetPublicFields_Fast())
                fieldInfo.SetValue(obj, fieldInfo.GetValue(toCopy));
            return obj;
        }
    }
}