Umbraco-CMS/src/Umbraco.Core/Plugins/PluginManager.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Web.Compilation;
using System.Xml.Linq;
using Umbraco.Core.Cache;
using Umbraco.Core.IO;
using Umbraco.Core.Logging;
using Umbraco.Core.Persistence.Mappers;
using Umbraco.Core.PropertyEditors;
using Umbraco.Core._Legacy.PackageActions;
using File = System.IO.File;

namespace Umbraco.Core.Plugins
{
    /// <summary>Resolves and caches all plugin types, and instanciates them.
    /// </summary>
    /// <remarks>
    /// <para>This class should be used to resolve all plugin types, the TypeFinder should not be used directly!.</para>
    /// <para>Before this class resolves any plugins it checks if the hash has changed for the DLLs in the /bin folder, if it hasn't
    /// it will use the cached resolved plugins that it has already found which means that no assembly scanning is necessary. This leads
    /// to much faster startup times.</para>
    /// </remarks>
    public class PluginManager
    {
        private const string CacheKey = "umbraco-plugins.list";
        private static object _instanceLocker = new object();
        private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim();
        private static PluginManager _instance;
        private static bool _hasInstance;

        private readonly IRuntimeCacheProvider _runtimeCache;
        private readonly ProfilingLogger _logger;
        private readonly string _tempFolder;
        private readonly HashSet<TypeList> _types = new HashSet<TypeList>();
        private long _cachedAssembliesHash = -1;
        private long _currentAssembliesHash = -1;
        private IEnumerable<Assembly> _assemblies;

        /// <summary>
        /// Initializes a new instance of the <see cref="PluginManager"/> class.
        /// </summary>
        /// <param name="runtimeCache">A runtime cache.</param>
        /// <param name="logger">A logger</param>
        /// <param name="detectChanges">A value indicating whether to detect changes.</param>
        public PluginManager(IRuntimeCacheProvider runtimeCache, ProfilingLogger logger, bool detectChanges = true)
        {
            if (runtimeCache == null) throw new ArgumentNullException(nameof(runtimeCache));
            if (logger == null) throw new ArgumentNullException(nameof(logger));

            _runtimeCache = runtimeCache;
            _logger = logger;

            // create the temp folder if it doesn't exist
            _tempFolder = IOHelper.MapPath("~/App_Data/TEMP/PluginCache");
            if (Directory.Exists(_tempFolder) == false)
                Directory.CreateDirectory(_tempFolder);

            var pluginListFile = GetPluginListFilePath();

            // check for legacy changes: before, we didn't store the TypeResolutionKind in the file, which was a mistake,
            // so we need to detect if the old file is there without this attribute, if it is then we delete it
            if (DetectLegacyPluginListFile())
                File.Delete(pluginListFile);

            if (detectChanges)
            {
                //first check if the cached hash is 0, if it is then we ne
                //do the check if they've changed
                RequiresRescanning = (CachedAssembliesHash != CurrentAssembliesHash) || CachedAssembliesHash == 0;
                //if they have changed, we need to write the new file
                if (RequiresRescanning)
                {
                    // if the hash has changed, clear out the persisted list no matter what, this will force
                    // rescanning of all plugin types including lazy ones.
                    // http://issues.umbraco.org/issue/U4-4789
                    File.Delete(pluginListFile);

                    WriteCachePluginsHash();
                }
            }
            else
            {
                // if the hash has changed, clear out the persisted list no matter what, this will force
                // rescanning of all plugin types including lazy ones.
                // http://issues.umbraco.org/issue/U4-4789
                File.Delete(pluginListFile);

                // always set to true if we're not detecting (generally only for testing)
                RequiresRescanning = true;
            }
        }

        /// <summary>
        /// Gets the current plugin manager.
        /// </summary>
        /// <remarks>
        /// <para>Ensures that no matter what, only one plugin manager is created, and thus proper caching always takes place.</para>
        /// <para>The setter is generally only used for unit tests + when creating the master plugin manager in CoreBootManager.</para>
        /// </remarks>
        public static PluginManager Current
        {
            get
            {
                return LazyInitializer.EnsureInitialized(ref _instance, ref _hasInstance, ref _instanceLocker, () =>
                {
                    var appctx = ApplicationContext.Current;
                    var cacheProvider = appctx == null 
                        ? new NullCacheProvider() 
                        : appctx.ApplicationCache.RuntimeCache;
                    ProfilingLogger profilingLogger;
                    if (appctx == null)
                    {
                        var logger = LoggerResolver.HasCurrent ? LoggerResolver.Current.Logger : new DebugDiagnosticsLogger();
                        var profiler = ProfilerResolver.HasCurrent ? ProfilerResolver.Current.Profiler : new LogProfiler(logger);
                        profilingLogger = new ProfilingLogger(logger, profiler);
                    }
                    else
                    {
                        profilingLogger = appctx.ProfilingLogger;
                    }
                    return new PluginManager(cacheProvider, profilingLogger);
                });
            }
            internal set
            {
                _hasInstance = true;
                _instance = value;
            }
        }

        #region Hash checking methods

        /// <summary>
        /// Gets a value indicating whether the assemblies in the /bin, app_code, global.asax, etc... have changed since they were last hashed.
        /// </summary>
        internal bool RequiresRescanning { get; }

        /// <summary>
        /// Gets the currently cached hash value of the scanned assemblies in the /bin folder.
        /// </summary>
        /// <value>The cached hash value, or 0 if no cache is found.</value>
        internal long CachedAssembliesHash
        {
            get
            {
                if (_cachedAssembliesHash != -1)
                    return _cachedAssembliesHash;

                var filePath = GetPluginHashFilePath();
                if (File.Exists(filePath) == false) return 0;

                var hash = File.ReadAllText(filePath, Encoding.UTF8);

                long val;
                if (long.TryParse(hash, out val) == false) return 0;

                _cachedAssembliesHash = val;
                return _cachedAssembliesHash;
            }
        }

        /// <summary>
        /// Gets the current assemblies hash based on creating a hash from the assemblies in the /bin folder.
        /// </summary>
        /// <value>The current hash.</value>
        internal long CurrentAssembliesHash
        {
            get
            {
                if (_currentAssembliesHash != -1)
                    return _currentAssembliesHash;

                _currentAssembliesHash = GetFileHash(
                    new List<Tuple<FileSystemInfo, bool>>
						{
							// add the bin folder and everything in it
							new Tuple<FileSystemInfo, bool>(new DirectoryInfo(IOHelper.MapPath(SystemDirectories.Bin)), false),
							// add the app code folder and everything in it
							new Tuple<FileSystemInfo, bool>(new DirectoryInfo(IOHelper.MapPath("~/App_Code")), false),
							// add the global.asax (the app domain also monitors this, if it changes will do a full restart)
							new Tuple<FileSystemInfo, bool>(new FileInfo(IOHelper.MapPath("~/global.asax")), false),
                            // add the trees.config - use the contents to create the has since this gets resaved on every app startup!
                            new Tuple<FileSystemInfo, bool>(new FileInfo(IOHelper.MapPath(SystemDirectories.Config + "/trees.config")), true)
						}, _logger
                    );

                return _currentAssembliesHash;
            }
        }

        /// <summary>
        /// Writes the assembly hash file.
        /// </summary>
        private void WriteCachePluginsHash()
        {
            var filePath = GetPluginHashFilePath();
            File.WriteAllText(filePath, CurrentAssembliesHash.ToString(), Encoding.UTF8);
        }

        /// <summary>
        /// Returns a unique hash for a combination of FileInfo objects.
        /// </summary>
        /// <param name="filesAndFolders">
        /// A collection of files and whether or not to use their file contents to determine the hash or the file's properties
        /// (true will make a hash based on it's contents)
        /// </param>
        /// <param name="logger">A profiling logger.</param>
        /// <returns>The hash.</returns>
        internal static long GetFileHash(IEnumerable<Tuple<FileSystemInfo, bool>> filesAndFolders, ProfilingLogger logger)
        {
            var ffA = filesAndFolders.ToArray();

            using (logger.TraceDuration<PluginManager>("Determining hash of code files on disk", "Hash determined"))
            {
                var hashCombiner = new HashCodeCombiner();

                // get the file info's to check
                var fileInfos = ffA.Where(x => x.Item2 == false).ToArray();
                var fileContents = ffA.Except(fileInfos);

                // add each unique folder/file to the hash
                foreach (var i in fileInfos.Select(x => x.Item1).DistinctBy(x => x.FullName))
                    hashCombiner.AddFileSystemItem(i);

                // add each unique file's contents to the hash
                foreach (var i in fileContents.Select(x => x.Item1)
                    .DistinctBy(x => x.FullName)
                    .Where(x => File.Exists(x.FullName)))
                {
                    var content = File.ReadAllText(i.FullName).Replace("\r\n", string.Empty).Replace("\n", string.Empty).Replace("\r", string.Empty);
                    hashCombiner.AddCaseInsensitiveString(content);
                }

                return ConvertPluginsHashFromHex(hashCombiner.GetCombinedHashCode());
            }
        }

        internal static long GetFileHash(IEnumerable<FileSystemInfo> filesAndFolders, ProfilingLogger logger)
        {
            using (logger.TraceDuration<PluginManager>("Determining hash of code files on disk", "Hash determined"))
            {
                var hashCombiner = new HashCodeCombiner();

                // add each unique folder/file to the hash
                foreach (var i in filesAndFolders.DistinctBy(x => x.FullName))
                    hashCombiner.AddFileSystemItem(i);

                return ConvertPluginsHashFromHex(hashCombiner.GetCombinedHashCode());
            }
        }

        /// <summary>
        /// Converts the hash value of current plugins to long from string
        /// </summary>
        /// <param name="val"></param>
        /// <returns></returns>
        internal static long ConvertPluginsHashFromHex(string val)
        {
            long outVal;
            return long.TryParse(val, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out outVal) ? outVal : 0;
        }

        /// <summary>
        /// Attempts to resolve the list of plugin + assemblies found in the runtime for the base type 'T' passed in.
        /// If the cache file doesn't exist, fails to load, is corrupt or the type 'T' element is not found then
        /// a false attempt is returned.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        internal Attempt<IEnumerable<string>> TryGetCachedPluginsFromFile<T>(TypeResolutionKind resolutionType)
        {
            var filePath = GetPluginListFilePath();
            if (File.Exists(filePath) == false)
                return Attempt<IEnumerable<string>>.Fail();

            try
            {
                // we will load the xml document, if the app context exist, we will load it from the cache (which is only around for 5 minutes)
                // while the app boots up, this should save some IO time on app startup when the app context is there (which is always unless in unit tests)
                var xml = _runtimeCache.GetCacheItem<XDocument>(CacheKey,
                    () => XDocument.Load(filePath),
                    new TimeSpan(0, 0, 5, 0));

                if (xml.Root == null)
                    return Attempt<IEnumerable<string>>.Fail();

                var typeElement = xml.Root.Elements()
                    .SingleOrDefault(x =>
                                     x.Name.LocalName == "baseType"
                                     && ((string)x.Attribute("type")) == typeof(T).FullName
                                     && ((string)x.Attribute("resolutionType")) == resolutionType.ToString());

                // return false but specify this exception type so we can detect it
                if (typeElement == null)
                    return Attempt<IEnumerable<string>>.Fail(new CachedPluginNotFoundInFileException());

                // return success
                return Attempt.Succeed(typeElement.Elements("add")
                        .Select(x => (string)x.Attribute("type")));
            }
            catch (Exception ex)
            {
                // if the file is corrupted, etc... return false
                return Attempt<IEnumerable<string>>.Fail(ex);
            }
        }

        /// <summary>
        /// Removes cache files and internal cache as well
        /// </summary>
        /// <remarks>
        /// Generally only used for resetting cache, for example during the install process
        /// </remarks>
        public void ClearPluginCache()
        {
            var path = GetPluginListFilePath();
            if (File.Exists(path))
                File.Delete(path);
            path = GetPluginHashFilePath();
            if (File.Exists(path))
                File.Delete(path);

            _runtimeCache.ClearCacheItem(CacheKey);
        }

        private string GetPluginListFilePath()
        {
            return Path.Combine(_tempFolder, $"umbraco-plugins.{NetworkHelper.FileSafeMachineName}.list");
        }

        private string GetPluginHashFilePath()
        {
            return Path.Combine(_tempFolder, $"umbraco-plugins.{NetworkHelper.FileSafeMachineName}.hash");
        }

        /// <summary>
        /// This will return true if the plugin list file is a legacy one
        /// </summary>
        /// <returns></returns>
        /// <remarks>
        /// This method exists purely due to an error in 4.11. We were writing the plugin list file without the
        /// type resolution kind which will have caused some problems. Now we detect this legacy file and if it is detected
        /// we remove it so it can be recreated properly.
        /// </remarks>
        internal bool DetectLegacyPluginListFile()
        {
            var filePath = GetPluginListFilePath();
            if (File.Exists(filePath) == false)
                return false;

            try
            {
                var xml = XDocument.Load(filePath);

                var typeElement = xml.Root?.Elements()
                    .FirstOrDefault(x => x.Name.LocalName == "baseType");

                //now check if the typeElement is missing the resolutionType attribute
                return typeElement != null && typeElement.Attributes().All(x => x.Name.LocalName != "resolutionType");
            }
            catch (Exception)
            {
                //if the file is corrupted, etc... return true so it is removed
                return true;
            }
        }

        /// <summary>
        /// Adds/Updates the type list for the base type 'T' in the cached file
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="typesFound"></param>
        ///<param name="resolutionType"> </param>
        ///<remarks>
        /// THIS METHOD IS NOT THREAD SAFE
        /// </remarks>
        /// <example>
        /// <![CDATA[
        /// <plugins>
        ///		<baseType type="Test.Testing.Tester">
        ///			<add type="My.Assembly.MyTester" assembly="My.Assembly" />
        ///			<add type="Your.Assembly.YourTester" assembly="Your.Assembly" />
        ///		</baseType>
        /// </plugins>
        /// ]]>
        /// </example>
        internal void UpdateCachedPluginsFile<T>(IEnumerable<Type> typesFound, TypeResolutionKind resolutionType)
        {
            var filePath = GetPluginListFilePath();
            XDocument xml;
            try
            {
                xml = XDocument.Load(filePath);
            }
            catch
            {
                // if there's an exception loading then this is somehow corrupt, we'll just replace it.
                File.Delete(filePath);
                // create the document and the root
                xml = new XDocument(new XElement("plugins"));
            }
            if (xml.Root == null)
            {
                // if for some reason there is no root, create it
                xml.Add(new XElement("plugins"));
            }
            // find the type 'T' element to add or update
            var typeElement = xml.Root.Elements()
                .SingleOrDefault(x =>
                                 x.Name.LocalName == "baseType"
                                 && ((string)x.Attribute("type")) == typeof(T).FullName
                                 && ((string)x.Attribute("resolutionType")) == resolutionType.ToString());

            if (typeElement == null)
            {
                // create the type element
                typeElement = new XElement("baseType",
                    new XAttribute("type", typeof(T).FullName),
                    new XAttribute("resolutionType", resolutionType.ToString()));
                // then add it to the root
                xml.Root.Add(typeElement);
            }


            // now we have the type element, we need to clear any previous types as children and add/update it with new ones
            typeElement.ReplaceNodes(typesFound.Select(x => new XElement("add", new XAttribute("type", x.AssemblyQualifiedName))));
            // save the xml file
            xml.Save(filePath);
        }

        #endregion

        /// <summary>
        /// Gets or sets which assemblies to scan when type finding, generally used for unit testing, if not explicitly set
        /// this will search all assemblies known to have plugins and exclude ones known to not have them.
        /// </summary>
        internal IEnumerable<Assembly> AssembliesToScan
        {
            get { return _assemblies ?? (_assemblies = TypeFinder.GetAssembliesWithKnownExclusions()); }
            set { _assemblies = value; }
        }

        #region Resolve Types

        private IEnumerable<Type> ResolveTypes<T>(
            Func<IEnumerable<Type>> finder,
            TypeResolutionKind resolutionType,
            bool cacheResult)
        {
            using (var readLock = new UpgradeableReadLock(Locker))
            {
                var typesFound = new List<Type>();

                using (_logger.DebugDuration<PluginManager>(
                    $"Starting resolution types of {typeof(T).FullName}",
                    $"Completed resolution of types of {typeof(T).FullName}", // cannot contain typesFound.Count as it's evaluated before the find!
                    50))
                {
                    //check if the TypeList already exists, if so return it, if not we'll create it
                    var typeList = _types.SingleOrDefault(x => x.IsTypeList<T>(resolutionType));

                    //need to put some logging here to try to figure out why this is happening: http://issues.umbraco.org/issue/U4-3505
                    if (cacheResult && typeList != null)
                    {
                        _logger.Logger.Debug<PluginManager>("Existing typeList found for {0} with resolution type {1}", () => typeof(T), () => resolutionType);
                    }

                    //if we're not caching the result then proceed, or if the type list doesn't exist then proceed
                    if (cacheResult == false || typeList == null)
                    {
                        //upgrade to a write lock since we're adding to the collection
                        readLock.UpgradeToWriteLock();

                        typeList = new TypeList<T>(resolutionType);

                        //we first need to look into our cache file (this has nothing to do with the 'cacheResult' parameter which caches in memory).
                        //if assemblies have not changed and the cache file actually exists, then proceed to try to lookup by the cache file.
                        if (RequiresRescanning == false && File.Exists(GetPluginListFilePath()))
                        {
                            var fileCacheResult = TryGetCachedPluginsFromFile<T>(resolutionType);

                            //here we need to identify if the CachedPluginNotFoundInFile was the exception, if it was then we need to re-scan
                            //in some cases the plugin will not have been scanned for on application startup, but the assemblies haven't changed
                            //so in this instance there will never be a result.
                            if (fileCacheResult.Exception is CachedPluginNotFoundInFileException)
                            {
                                _logger.Logger.Debug<PluginManager>("Tried to find typelist for type {0} and resolution {1} in file cache but the type was not found so loading types by assembly scan ", () => typeof(T), () => resolutionType);

                                //we don't have a cache for this so proceed to look them up by scanning
                                LoadViaScanningAndUpdateCacheFile<T>(typeList, resolutionType, finder);
                            }
                            else
                            {
                                if (fileCacheResult.Success)
                                {
                                    var successfullyLoadedFromCache = true;
                                    //we have a previous cache for this so we don't need to scan we just load what has been found in the file
                                    foreach (var t in fileCacheResult.Result)
                                    {
                                        try
                                        {
                                            //we use the build manager to ensure we get all types loaded, this is slightly slower than
                                            //Type.GetType but if the types in the assembly aren't loaded yet then we have problems with that.
                                            var type = BuildManager.GetType(t, true);
                                            typeList.AddType(type);
                                        }
                                        catch (Exception ex)
                                        {
                                            //if there are any exceptions loading types, we have to exist, this should never happen so
                                            //we will need to revert to scanning for types.
                                            successfullyLoadedFromCache = false;
                                            _logger.Logger.Error<PluginManager>("Could not load a cached plugin type: " + t + " now reverting to re-scanning assemblies for the base type: " + typeof(T).FullName, ex);
                                            break;
                                        }
                                    }
                                    if (successfullyLoadedFromCache == false)
                                    {
                                        //we need to manually load by scanning if loading from the file was not successful.
                                        LoadViaScanningAndUpdateCacheFile<T>(typeList, resolutionType, finder);
                                    }
                                    else
                                    {
                                        _logger.Logger.Debug<PluginManager>("Loaded plugin types {0} with resolution {1} from persisted cache", () => typeof(T), () => resolutionType);
                                    }
                                }
                            }
                        }
                        else
                        {
                            _logger.Logger.Debug<PluginManager>("Assembly changes detected, loading types {0} for resolution {1} by assembly scan", () => typeof(T), () => resolutionType);

                            //we don't have a cache for this so proceed to look them up by scanning
                            LoadViaScanningAndUpdateCacheFile<T>(typeList, resolutionType, finder);
                        }

                        //only add the cache if we are to cache the results
                        if (cacheResult)
                        {
                            //add the type list to the collection
                            var added = _types.Add(typeList);

                            _logger.Logger.Debug<PluginManager>("Caching of typelist for type {0} and resolution {1} was successful = {2}", () => typeof(T), () => resolutionType, () => added);

                        }
                    }
                    typesFound = typeList.GetTypes().ToList();
                }

                return typesFound;
            }
        }

        /// <summary>
        /// Invokes the finder which scans the assemblies for the types and then loads the result into the type finder,
        /// then updates the cached type xml file.
        /// </summary>
        /// <param name="typeList"></param>
        /// <param name="resolutionKind"> </param>
        /// <param name="finder"></param>
        /// <remarks>This method is not thread safe.</remarks>
        private void LoadViaScanningAndUpdateCacheFile<T>(TypeList typeList, TypeResolutionKind resolutionKind, Func<IEnumerable<Type>> finder)
        {
            // we don't have a cache for this so proceed to look them up by scanning
            foreach (var t in finder())
                typeList.AddType(t);

            UpdateCachedPluginsFile<T>(typeList.GetTypes(), resolutionKind);
        }

        /// <summary>
        /// Resolves specified types.
        /// </summary>
        /// <typeparam name="T">The type to find.</typeparam>
        /// <returns>The types.</returns>
        public IEnumerable<Type> ResolveTypes<T>(bool cacheResult = true, IEnumerable<Assembly> specificAssemblies = null)
        {
            return ResolveTypes<T>(
                () => TypeFinder.FindClassesOfType<T>(specificAssemblies ?? AssembliesToScan),
                TypeResolutionKind.FindAllTypes,
                cacheResult);
        }

        /// <summary>
        /// Resolves specified, attributed types.
        /// </summary>
        /// <typeparam name="T">The type to find.</typeparam>
        /// <typeparam name="TAttribute">The type of the attribute.</typeparam>
        /// <returns>The corresponding types.</returns>
        public IEnumerable<Type> ResolveTypesWithAttribute<T, TAttribute>(bool cacheResult = true, IEnumerable<Assembly> specificAssemblies = null)
            where TAttribute : Attribute
        {
            return ResolveTypes<T>(
                () => TypeFinder.FindClassesOfTypeWithAttribute<T, TAttribute>(specificAssemblies ?? AssembliesToScan),
                TypeResolutionKind.FindTypesWithAttribute,
                cacheResult);
        }

        /// <summary>
        /// Resolves attributed types.
        /// </summary>
        /// <typeparam name="TAttribute">The type of the attribute.</typeparam>
        /// <returns>The corresopnding types.</returns>
        public IEnumerable<Type> ResolveAttributedTypes<TAttribute>(bool cacheResult = true, IEnumerable<Assembly> specificAssemblies = null)
            where TAttribute : Attribute
        {
            return ResolveTypes<TAttribute>(
                () => TypeFinder.FindClassesWithAttribute<TAttribute>(specificAssemblies ?? AssembliesToScan),
                TypeResolutionKind.FindAttributedTypes,
                cacheResult);
        }

        #endregion

        #region Private

        /// <summary>
        /// Gets the list of types.
        /// </summary>
        /// <returns>The list of types.</returns>
        /// <remarks>For unit tests only.</remarks>
        internal HashSet<TypeList> GetTypeLists()
        {
            return _types;
        }

        /// <summary>
        /// The type of resolution being invoked
        /// </summary>
        internal enum TypeResolutionKind
        {
            FindAllTypes,
            FindAttributedTypes,
            FindTypesWithAttribute
        }

        internal abstract class TypeList
        {
            public abstract void AddType(Type t);
            public abstract bool IsTypeList<TLookup>(TypeResolutionKind resolutionType);
            public abstract IEnumerable<Type> GetTypes();
        }

        internal class TypeList<T> : TypeList
        {
            private readonly TypeResolutionKind _resolutionType;

            public TypeList(TypeResolutionKind resolutionType)
            {
                _resolutionType = resolutionType;
            }

            private readonly List<Type> _types = new List<Type>();

            public override void AddType(Type t)
            {
                //if the type is an attribute type we won't do the type check because typeof<T> is going to be the
                //attribute type whereas the 't' type is the object type found with the attribute.
                if (_resolutionType == TypeResolutionKind.FindAttributedTypes || t.IsType<T>())
                {
                    _types.Add(t);
                }
            }

            /// <summary>
            /// Returns true if the current TypeList is of the same lookup type
            /// </summary>
            /// <typeparam name="TLookup"></typeparam>
            /// <param name="resolutionType"></param>
            /// <returns></returns>
            public override bool IsTypeList<TLookup>(TypeResolutionKind resolutionType)
            {
                return _resolutionType == resolutionType && (typeof(T)) == typeof(TLookup);
            }

            public override IEnumerable<Type> GetTypes()
            {
                return _types;
            }
        }

        /// <summary>
        /// Represents the error that occurs when a plugin was not found in the cache plugin list with the specified
        /// TypeResolutionKind.
        /// </summary>
        internal class CachedPluginNotFoundInFileException : Exception
        { }

        #endregion
    }

    internal static class PluginManagerExtensions
    {
        /// <summary>
        /// Resolves property editors (based on the resolved Iparameter editors - this saves a scan).
        /// </summary>
        public static IEnumerable<Type> ResolvePropertyEditors(this PluginManager mgr)
        {
            //return all proeprty editor types found except for the base property editor type
            return mgr.ResolveTypes<IParameterEditor>()
                .Where(x => x.IsType<PropertyEditor>())
                .Except(new[] { typeof(PropertyEditor) });
        }

        /// <summary>
        /// Resolves parameter editors (which includes property editors)
        /// </summary>
        internal static IEnumerable<Type> ResolveParameterEditors(this PluginManager mgr)
        {
            //return all paramter editor types found except for the base property editor type
            return mgr.ResolveTypes<IParameterEditor>()
                .Except(new[] { typeof(ParameterEditor), typeof(PropertyEditor) });
        }

        /// <summary>
        /// Resolves IApplicationStartupHandler objects.
        /// </summary>
        internal static IEnumerable<Type> ResolveApplicationStartupHandlers(this PluginManager mgr)
        {
            return mgr.ResolveTypes<IApplicationEventHandler>();
        }

        /// <summary>
        /// Resolves ICacheRefresher objects.
        /// </summary>
        internal static IEnumerable<Type> ResolveCacheRefreshers(this PluginManager mgr)
        {
            return mgr.ResolveTypes<ICacheRefresher>();
        }

        /// <summary>
        /// Resolves IPackageAction objects.
        /// </summary>
        internal static IEnumerable<Type> ResolvePackageActions(this PluginManager mgr)
        {
            return mgr.ResolveTypes<IPackageAction>();
        }

        /// <summary>
        /// Resolves mapper types that have a MapperFor attribute defined.
        /// </summary>
        internal static IEnumerable<Type> ResolveAssignedMapperTypes(this PluginManager mgr)
        {
            return mgr.ResolveTypesWithAttribute<BaseMapper, MapperForAttribute>();
        }
    }
}