TypeResolver.cs

Go to the documentation of this file.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
 
using AnalyzeRe.Attributes;
 
namespace AnalyzeRe.Utilities
{
    public static class TypeResolver
    {
        #region All App Domain Types
        // Used for caching results of resolveReferenceType method (which uses assembly level reflection) to improve performance.
        private static readonly List<Type> CachedAppDomainTypes = new List<Type>();
        // Used to determine if the cache is populated without locking
        private static volatile bool _isCachedAppDomainTypesPopulated = false;
 
        public static List<Type> GetAppDomainTypes()
        {
            if (_isCachedAppDomainTypesPopulated)
                return CachedAppDomainTypes;
            // Lock to ensure multiple threads don't try to create the cache.
            lock (CachedAppDomainTypes)
            {
                // If another thread populated the cache since we asked for the lock, return
                if (_isCachedAppDomainTypesPopulated)
                    return CachedAppDomainTypes;
 
                // Populate a cache of assembly types so that we don't have to do this (expensive) cache again.
                CachedAppDomainTypes.AddRange(AppDomain.CurrentDomain.GetAssemblies().SelectMany(assembly =>
                {
                    try { return assembly.GetTypes(); }
                    catch (ReflectionTypeLoadException ex)
                    {
                        foreach (Exception inner in ex.LoaderExceptions)
                            Debug.WriteLine("TypeResolver could not locate assembly: " +
                                $"{assembly.FullName}. Message: {inner.Message}");
                        return new Type[] { };
                    }
                }));
 
                _isCachedAppDomainTypesPopulated = true;
                return CachedAppDomainTypes;
            }
        }
        #endregion All App Domain Types
 
        #region All App Domain AnalyzeRe IAPI Types
        // Subset of above cached items that includes only IAPIType deriving objects, since these
        // are requested most frequently by the deserializer - we want to access them first.
        private static readonly List<Type> CachedIAPITypes = new List<Type>();
        // Used to determine if the cache is populated without locking
        private static volatile bool _isCachedIAPITypesPopulated = false;
 
        public static List<Type> GetAPITypes()
        {
            if (_isCachedIAPITypesPopulated)
                return CachedAppDomainTypes;
            // Lock to ensure multiple threads don't try to create the cache.
            lock (CachedIAPITypes)
            {
                // If another thread populated the cache since we asked for the lock, return
                if (_isCachedIAPITypesPopulated)
                    return CachedAppDomainTypes;
 
                CachedIAPITypes.AddRange(
                    GetAppDomainTypes().Where(t => typeof(APIType).IsAssignableFrom(t)));
 
                _isCachedIAPITypesPopulated = true;
                return CachedIAPITypes;
            }
        }
        #endregion All App Domain AnalyzeRe IAPI Types
 
        #region API Type Names for APIType classes
        private static readonly ConcurrentDictionary<Type, string> CachedAPITypeNames =
            new ConcurrentDictionary<Type, string>();
 
        public static string GetTypeNameForAPIType(Type type)
        {
            if (type == null)
                throw new ArgumentNullException(nameof(type), "Could not determine the declaring type.");
            return CachedAPITypeNames.GetOrAdd(type, GetTypeNameForAPIType_OnAdd);
        }
 
        // Helper method for populating the above cache.
        private static string GetTypeNameForAPIType_OnAdd(Type type)
        {
            APITypeAliasAttribute overridingType = (APITypeAliasAttribute)
                Attribute.GetCustomAttribute(type, typeof(APITypeAliasAttribute));
            return overridingType != null ? overridingType.TypeName : type.Name;
        }
        #endregion API Type Names for APIType classes
 
        #region ResolveTypeByName
        // Cache of type name and base type pairs that have been mapped to a resolved type.
        private static readonly ConcurrentDictionary<Tuple<string, Type>, Type> CachedResolvedTypes =
            new ConcurrentDictionary<Tuple<string, Type>, Type>();
 
        public static bool ResolveTypeByName(string typeName, out Type resolvedType, Type requiredBaseType = null)
        {
            // Look up the value in the cache, and return it if it is there.
            Tuple<string, Type> key = new Tuple<string, Type>(typeName, requiredBaseType);
            resolvedType = CachedResolvedTypes.GetOrAdd(key, ResolveTypeByName_OnAdd);
            return resolvedType != null;
        }
 
        // Helper method for populating the above cache.
        private static Type ResolveTypeByName_OnAdd(Tuple<string, Type> parameters)
        {
            string typeName = parameters.Item1;
            Type requiredBaseType = parameters.Item2;
 
            // Loop over the cached list of APIType types and see if there's a match
            foreach (Type classAPIType in GetAPITypes())
                if (GetTypeNameForAPIType(classAPIType) == typeName &&
                    (requiredBaseType == null || requiredBaseType.IsAssignableFrom(classAPIType)))
                    return classAPIType;
            // Broaden the search and loop over the cached list of all types and see if there is a matching type.
            foreach (Type classAPIType in GetAppDomainTypes())
                if (classAPIType.Name == typeName &&
                    (requiredBaseType == null || requiredBaseType.IsAssignableFrom(classAPIType)))
                    return classAPIType;
            // If the above is unsuccessful, we do not recognize this server type.
            Debug.WriteLine("Warning: Unrecognized reference to type \"" + typeName +
                "\". Is the server using a polymorphic sub-type the client doesn't know about?");
            return null;
        }
        #endregion ResolveTypeByName
 
        #region ResolveBaseTypeByURL
        private static readonly ConcurrentDictionary<string, Type> CachedAPIResourceCollections =
            new ConcurrentDictionary<string, Type>();
        // Used to determine if the cache is populated without locking
        private static volatile bool _isCachedAPIResourceCollectionsPopulated = false;
 
        public static Type ResolveBaseTypeByURL(string href)
        {
            return ResolveBaseTypeByCollectionName(API.GetCollectionNameFromResourceHref(href));
        }
 
        public static Type ResolveBaseTypeByCollectionName(string collection)
        {
            // Prevent more than one thread from trying to populate the cache, but
            // allow immediate use of the cache if it's flagged as having been populated
            if (!_isCachedAPIResourceCollectionsPopulated)
                lock (CachedAPIResourceCollections)
                {
                    // Ensure another thread hasn't populated the cache since we asked for the lock
                    if (!_isCachedAPIResourceCollectionsPopulated)
                    {
                        IEnumerable<Type> toScrape = GetAPITypes().Where(apiType =>
                            typeof(IAPIResource).IsAssignableFrom(apiType));
                        // Scrape these APITypes for their collection names and cache them.
                        foreach (Type apiType in toScrape)
                        {
                            string collectionName = API.GetCollectionName(apiType, out Type baseType, true);
                            // Ignore classes that have not inherited a collectionName
                            if (collectionName == null)
                            {
                                Debug.WriteLine("No collection for type: " + apiType.NiceTypeName());
                                continue;
                            }
#if DEBUG
                            if (API.RequestLogging)
                            {
                                Debug.WriteLine($"Resolved collection for type: {apiType.NiceTypeName()} " +
                                    $"({collectionName}) Declaring type: {baseType.NiceTypeName()}");
                            }
#endif
                            if (!CachedAPIResourceCollections.ContainsKey(collectionName))
                                CachedAPIResourceCollections.TryAdd(collectionName, baseType);
                        }
                        _isCachedAPIResourceCollectionsPopulated = true;
                    }
                }
            CachedAPIResourceCollections.TryGetValue(collection, out Type result);
            return result;
        }
        #endregion ResolveBaseTypeByURL
 
        #region Utilities
        // Cache of type name and base type pairs that have been mapped to a resolved type.
        private static readonly ConcurrentDictionary<Type, List<Type>> CachedInstantiableSubtypes =
            new ConcurrentDictionary<Type, List<Type>>();
 
        public static List<Type> GetAllInstantiableSubtypes(Type type)
        {
            return CachedInstantiableSubtypes.GetOrAdd(type, T =>
            {
                List<Type> appDomainTypes = GetAppDomainTypes();
 
                List<Type> subTypes;
                if (T.IsGenericType && T.GetGenericArguments().Length == 1)
                {
                    Type genericTypeDefinition = T.GetGenericTypeDefinition();
                    Type genericArgumentType = T.GetGenericArguments()[0];
 
                    if (genericTypeDefinition.IsInterface || genericTypeDefinition.IsAbstract || genericArgumentType.IsGenericParameter)
                    {
                        // Brutal Hack: If the generic type definition isn't instantiable, I appear to be grabbing the first type I can find that
                        // IS instantiable and implements this generic abstract class or interface
                        genericTypeDefinition = appDomainTypes
                            .Where(tsub => tsub.IsGenericType && !tsub.IsInterface && !tsub.IsAbstract &&
                                tsub.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == genericTypeDefinition))
                            .OrderBy(elem => Guid.NewGuid()).FirstOrDefault();
                    }
                    if (genericTypeDefinition == null)
                    {
                        if (genericArgumentType.IsGenericParameter)
                        {
                            genericTypeDefinition = T.GetGenericTypeDefinition();
                            if (genericArgumentType.GetGenericParameterConstraints().Length > 0) // Maybe the first generic parameter constraint can serve as an instantiable sub-type?
                                genericArgumentType = genericArgumentType.GetGenericParameterConstraints()[0];
                            else // No constraint means it's an object.
                                genericArgumentType = typeof(object);
                        }
                        else
                            throw new Exception("Could not find a type that implements the generic interface or abstract class: " + T.GetGenericTypeDefinition().NiceTypeName());
                    }
                    subTypes = GetAllInstantiableSubtypes(genericArgumentType)
                        .Select(innerT => genericTypeDefinition.MakeGenericTypeFast(innerT)).ToList();
                }
                else if (!T.IsGenericType && T != typeof(object))
                {
                    List<Type> discovered = new List<Type>();
                    appDomainTypes.Where(tsub => T.IsAssignableFrom(tsub) && tsub.IsClass &&
                        !tsub.IsInterface && !tsub.IsAbstract).ToList().ForEach(subtype =>
                    {
                        if (subtype.ContainsGenericParameters)
                        {
                            try { discovered.AddRange(GetAllInstantiableSubtypes(subtype)); }
                            // If this sub-type ends up not being covariantly valid, don't sweat it
                            // ReSharper disable once EmptyGeneralCatchClause
                            catch (Exception) { }
                        }
                        else
                            discovered.Add(subtype);
                    });
                    subTypes = discovered;
                }
                else if (T == typeof(object))
                    subTypes = new List<Type> { typeof(object) };
                else
                    throw new Exception("Not sure how to create a new instance of type: " + T.NiceTypeName());
 
                return subTypes;
            });
        }
 
        public static Type GetGenericCovariantBase(Type T)
        {
            Type genericTypeDefinition;
            Type[] genericTypeArguments = null;
            // If this type is not a generic type definition, get the generic type definition,
            // and also remember the generic arguments in use for this specific type.
            if (T.IsGenericTypeDefinition)
                genericTypeDefinition = T;
            else
            {
                genericTypeDefinition = T.GetGenericTypeDefinition();
                genericTypeArguments = T.GetGenericArguments();
            }
            // If this generic type is not an interface, look for the generic interface
            Type selectedInterface;
            if (T.IsInterface)
                selectedInterface = T;
            else
            {
                IEnumerable<Type> baseInterfaces = genericTypeDefinition.GetInterfaces();
                selectedInterface = baseInterfaces.Last();
                // If any other interfaces are assignable to the selected interface, select them
                // instead since they are more derived.
                foreach (Type currentInterface in baseInterfaces)
                    if (selectedInterface.IsAssignableFrom(currentInterface))
                        selectedInterface = currentInterface;
            }
            // If the selected interface has no generic parameters, we can return it directly
            if (!selectedInterface.ContainsGenericParameters)
                return selectedInterface;
            // Get the generic type definition for the selected interface
            if (!selectedInterface.IsGenericTypeDefinition)
                selectedInterface = selectedInterface.GetGenericTypeDefinition();
            // If the supplied type already specified generic type arguments, use those,
            // Otherwise use the generic parameter constraints.
            if (genericTypeArguments == null)
            {
                genericTypeArguments = selectedInterface.GetGenericArguments()
                    .Select(genericArgument => genericArgument.GetGenericParameterConstraints()[0])
                    .ToArray();
            }
            Type covariantInterface = genericTypeArguments.Length == 1 ?
                selectedInterface.MakeGenericTypeFast(genericTypeArguments[0]) :
                selectedInterface.MakeGenericType(genericTypeArguments);
            return covariantInterface;
        }
 
        #region Fast MakeGenericType
        private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<Type, Type>>
            GenericSubtypeCaches = new ConcurrentDictionary<Type, ConcurrentDictionary<Type, Type>>();
 
        public static Type MakeGenericTypeFast(this Type generic_base, Type type_parameter)
        {
            ConcurrentDictionary<Type, Type> cache = GenericSubtypeCaches.GetOrAdd(generic_base,
                type => new ConcurrentDictionary<Type, Type>());
            return cache.GetOrAdd(type_parameter, type => generic_base.MakeGenericType(type));
        }
        #endregion Fast MakeGenericType
 
        #region GetEnumerableType
        private static readonly ConcurrentDictionary<Type, Type>
            EnumberableTypeCache = new ConcurrentDictionary<Type, Type>();
 
        public static Type GetEnumerableType(Type type)
        {
            return EnumberableTypeCache.GetOrAdd(type, t => t.GetInterfaces()
                .FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>))
                ?.GetGenericArguments().Single());
        }
        #endregion GetEnumerableType
 
        #region ImplementsInterface
        private static readonly ConcurrentDictionary<Tuple<Type, Type>, bool>
            ImplementsInterfaceCache = new ConcurrentDictionary<Tuple<Type, Type>, bool>();
 
        public static bool ImplementsInterface(this Type type, Type interfaceType)
        {
            Tuple<Type, Type> key = Tuple.Create(type, interfaceType);
            return ImplementsInterfaceCache.GetOrAdd(key,
                k => k.Item1.GetInterfaces().Any(i => i == interfaceType ||
                    i.IsGenericType && i.GetGenericTypeDefinition() == interfaceType));
        }
        #endregion GetEnumerableType
        #endregion Utilities
    }
}