/// <summary>
/// Resolves class types inheriting from or implementing the specified type and marked with the specified attribute.
/// </summary>
/// <typeparam name="T">The type to inherit from or implement.</typeparam>
/// <typeparam name="TAttribute">The type of the attribute.</typeparam>
/// <param name="cache">Indicates whether to use cache for type resolution.</param>
/// <param name="specificAssemblies">A set of assemblies for type resolution.</param>
/// <returns>All class types inheriting from or implementing the specified type and marked with the specified attribute.</returns>
/// <remarks>Caching is disabled when using specific assemblies.</remarks>
public IEnumerable <Type> ResolveTypesWithAttribute <T, TAttribute>(bool cache = true, IEnumerable <Assembly> specificAssemblies = null)
where TAttribute : Attribute
{
// do not cache anything from specific assemblies
cache &= specificAssemblies == null;
// if not caching, or not IDiscoverable, directly resolve types
if (cache == false || typeof(IDiscoverable).IsAssignableFrom(typeof(T)) == false)
{
return(ResolveTypesInternal(
typeof(T), typeof(TAttribute),
() => TypeFinder.FindClassesOfTypeWithAttribute <T, TAttribute>(specificAssemblies ?? AssembliesToScan),
cache));
}
// if caching and IDiscoverable
// filter the cached discovered types (and cache the result)
var discovered = ResolveTypesInternal(
typeof(IDiscoverable), null,
() => TypeFinder.FindClassesOfType <IDiscoverable>(AssembliesToScan),
true);
return(ResolveTypesInternal(
typeof(T), typeof(TAttribute),
() => discovered
.Where(x => typeof(T).IsAssignableFrom(x))
.Where(x => x.GetCustomAttributes <TAttribute>(false).Any()),
true));
}
/// <summary>
/// Generic method to find the specified type and cache the result
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></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>
/// Generic method to find the specified type and cache the result
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
internal IEnumerable <Type> ResolveTypes <T>(bool cacheResult = true)
{
return(ResolveTypes <T>(
() => TypeFinder.FindClassesOfType <T>(AssembliesToScan),
TypeResolutionKind.FindAllTypes,
cacheResult));
}
/// <summary>
/// This is used when an IAction or IActionHandler is installed into the system
/// and needs to be loaded into memory.
/// </summary>
/// <remarks>
/// TODO: this shouldn't be needed... we should restart the app pool when a package is installed!
/// </remarks>
public static void ReRegisterActionsAndHandlers()
{
lock (Lock)
{
//TODO: Based on the above, this is a big hack as types should all be cleared on package install!
ActionsResolver.Reset();
ActionHandlers.Clear();
//TODO: Based on the above, this is a big hack as types should all be cleared on package install!
ActionsResolver.Current = new ActionsResolver(
() => TypeFinder.FindClassesOfType <IAction>(PluginManager.Current.AssembliesToScan));
RegisterIActionHandlers();
}
}
/// <summary>
/// This is used when an IAction or IActionHandler is installed into the system
/// and needs to be loaded into memory.
/// </summary>
/// <remarks>
/// TODO: this shouldn't be needed... we should restart the app pool when a package is installed!
/// </remarks>
public static void ReRegisterActionsAndHandlers()
{
lock (Lock)
{
using (Umbraco.Core.ObjectResolution.Resolution.DirtyBackdoorToConfiguration)
{
//TODO: Based on the above, this is a big hack as types should all be cleared on package install!
ActionsResolver.Reset(false); // and do NOT reset the whole resolution!
ActionHandlers.Clear();
//TODO: Based on the above, this is a big hack as types should all be cleared on package install!
ActionsResolver.Current = new ActionsResolver(
() => TypeFinder.FindClassesOfType <IAction>(PluginManager.Current.AssembliesToScan));
RegisterIActionHandlers();
}
}
}
/// <summary>
/// This is used when an IAction or IActionHandler is installed into the system
/// and needs to be loaded into memory.
/// </summary>
/// <remarks>
/// TODO: this shouldn't be needed... we should restart the app pool when a package is installed!
/// </remarks>
public static void ReRegisterActionsAndHandlers()
{
lock (Lock)
{
// NOTE use the DirtyBackdoor to change the resolution configuration EXCLUSIVELY
// ie do NOT do ANYTHING else while holding the backdoor, because while it is open
// the whole resolution system is locked => nothing can work properly => deadlocks
var newResolver = new ActionsResolver(
new ActivatorServiceProvider(), LoggerResolver.Current.Logger,
() => TypeFinder.FindClassesOfType <IAction>(PluginManager.Current.AssembliesToScan));
using (Umbraco.Core.ObjectResolution.Resolution.DirtyBackdoorToConfiguration)
{
ActionsResolver.Reset(false); // and do NOT reset the whole resolution!
ActionsResolver.Current = newResolver;
}
}
}
