diff --git a/src/Umbraco.Core/ActionsResolver.cs b/src/Umbraco.Core/ActionsResolver.cs index 50c9fbe9a1..ff34f62c60 100644 --- a/src/Umbraco.Core/ActionsResolver.cs +++ b/src/Umbraco.Core/ActionsResolver.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; using System.Linq; using System.Reflection; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; using umbraco.interfaces; @@ -12,13 +13,14 @@ namespace Umbraco.Core /// internal sealed class ActionsResolver : LazyManyObjectsResolverBase { - - /// - /// Constructor - /// - /// - internal ActionsResolver(Func> packageActions) - : base(packageActions) + /// + /// Constructor + /// + /// + /// + /// + internal ActionsResolver(IServiceProvider serviceProvider, ILogger logger, Func> packageActions) + : base(serviceProvider, logger, packageActions) { } @@ -55,7 +57,7 @@ namespace Umbraco.Core var instance = type.GetProperty("Instance", BindingFlags.Public | BindingFlags.Static); //if the singletone initializer is not found, try simply creating an instance of the IAction if it supports public constructors if (instance == null) - typeInstance = PluginManager.Current.CreateInstance(type); + typeInstance = ServiceProvider.GetService(type) as IAction; else typeInstance = instance.GetValue(null, null) as IAction; diff --git a/src/Umbraco.Core/ActivatorHelper.cs b/src/Umbraco.Core/ActivatorHelper.cs index 88ec01ae35..90a21f7386 100644 --- a/src/Umbraco.Core/ActivatorHelper.cs +++ b/src/Umbraco.Core/ActivatorHelper.cs @@ -1,8 +1,6 @@ -using System; - namespace Umbraco.Core { - /// + /// /// Helper methods for Activation /// internal static class ActivatorHelper @@ -14,7 +12,9 @@ namespace Umbraco.Core /// public static T CreateInstance() where T : class, new() { - return Activator.CreateInstance(typeof(T)) as T; + return new ActivatorServiceProvider().GetService(typeof (T)) as T; } + + } } \ No newline at end of file diff --git a/src/Umbraco.Core/ActivatorServiceProvider.cs b/src/Umbraco.Core/ActivatorServiceProvider.cs new file mode 100644 index 0000000000..550a4a3ca8 --- /dev/null +++ b/src/Umbraco.Core/ActivatorServiceProvider.cs @@ -0,0 +1,12 @@ +using System; + +namespace Umbraco.Core +{ + internal class ActivatorServiceProvider : IServiceProvider + { + public object GetService(Type serviceType) + { + return Activator.CreateInstance(serviceType); + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/CacheRefreshersResolver.cs b/src/Umbraco.Core/CacheRefreshersResolver.cs index e8df98fc1b..4047a06b62 100644 --- a/src/Umbraco.Core/CacheRefreshersResolver.cs +++ b/src/Umbraco.Core/CacheRefreshersResolver.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; using umbraco.interfaces; @@ -12,13 +13,14 @@ namespace Umbraco.Core /// internal sealed class CacheRefreshersResolver : LegacyTransientObjectsResolver { - - /// - /// Constructor - /// - /// - internal CacheRefreshersResolver(Func> refreshers) - : base(refreshers) + /// + /// Constructor + /// + /// + /// + /// + internal CacheRefreshersResolver(IServiceProvider serviceProvider, ILogger logger, Func> refreshers) + : base(serviceProvider, logger, refreshers) { } diff --git a/src/Umbraco.Core/CoreBootManager.cs b/src/Umbraco.Core/CoreBootManager.cs index 70f3d3e5eb..4aeee2881d 100644 --- a/src/Umbraco.Core/CoreBootManager.cs +++ b/src/Umbraco.Core/CoreBootManager.cs @@ -41,15 +41,22 @@ namespace Umbraco.Core private bool _isInitialized = false; private bool _isStarted = false; private bool _isComplete = false; + private readonly IServiceProvider _serviceProvider = new ActivatorServiceProvider(); private readonly UmbracoApplicationBase _umbracoApplication; protected ApplicationContext ApplicationContext { get; set; } protected CacheHelper ApplicationCache { get; set; } + protected PluginManager PluginManager { get; private set; } protected UmbracoApplicationBase UmbracoApplication { get { return _umbracoApplication; } } + protected IServiceProvider ServiceProvider + { + get { return _serviceProvider; } + } + public CoreBootManager(UmbracoApplicationBase umbracoApplication) { if (umbracoApplication == null) throw new ArgumentNullException("umbracoApplication"); @@ -70,6 +77,11 @@ namespace Umbraco.Core CreateApplicationCache(); + //create and set the plugin manager (I'd much prefer to not use this singleton anymore but many things are using it unfortunately and + // the way that it is setup, there must only ever be one per app so without IoC it would be hard to make this not a singleton) + PluginManager = new PluginManager(ServiceProvider, ApplicationCache.RuntimeCache, _profilingLogger); + PluginManager.Current = PluginManager; + //Create the legacy prop-eds mapping LegacyPropertyEditorIdToAliasConverter.CreateMappingsForCoreEditors(); LegacyParameterEditorAliasConverter.CreateMappingsForCoreEditors(); @@ -195,7 +207,9 @@ namespace Umbraco.Core //ApplicationStartupHandler.RegisterHandlers(); //... and set the special flag to let us resolve before frozen resolution ApplicationEventsResolver.Current = new ApplicationEventsResolver( - PluginManager.Current.ResolveApplicationStartupHandlers()) + ServiceProvider, + LoggerResolver.Current.Logger, + PluginManager.ResolveApplicationStartupHandlers()) { CanResolveBeforeFrozen = true }; @@ -284,11 +298,12 @@ namespace Umbraco.Core /// protected virtual void InitializeResolvers() { - PropertyEditorResolver.Current = new PropertyEditorResolver(() => PluginManager.Current.ResolvePropertyEditors()); - ParameterEditorResolver.Current = new ParameterEditorResolver(() => PluginManager.Current.ResolveParameterEditors()); + PropertyEditorResolver.Current = new PropertyEditorResolver(ServiceProvider, LoggerResolver.Current.Logger, () => PluginManager.ResolvePropertyEditors()); + ParameterEditorResolver.Current = new ParameterEditorResolver(ServiceProvider, LoggerResolver.Current.Logger, () => PluginManager.ResolveParameterEditors()); //setup the validators resolver with our predefined validators - ValidatorsResolver.Current = new ValidatorsResolver(new[] + ValidatorsResolver.Current = new ValidatorsResolver( + ServiceProvider, LoggerResolver.Current.Logger, new[] { new Lazy(() => typeof (RequiredManifestValueValidator)), new Lazy(() => typeof (RegexValidator)), @@ -308,7 +323,8 @@ namespace Umbraco.Core new DefaultServerMessenger()); MappingResolver.Current = new MappingResolver( - () => PluginManager.Current.ResolveAssignedMapperTypes()); + ServiceProvider, LoggerResolver.Current.Logger, + () => PluginManager.ResolveAssignedMapperTypes()); @@ -316,31 +332,39 @@ namespace Umbraco.Core // new RepositoryFactory(ApplicationCache)); CacheRefreshersResolver.Current = new CacheRefreshersResolver( - () => PluginManager.Current.ResolveCacheRefreshers()); + ServiceProvider, LoggerResolver.Current.Logger, + () => PluginManager.ResolveCacheRefreshers()); DataTypesResolver.Current = new DataTypesResolver( - () => PluginManager.Current.ResolveDataTypes()); + ServiceProvider, LoggerResolver.Current.Logger, + () => PluginManager.ResolveDataTypes()); MacroFieldEditorsResolver.Current = new MacroFieldEditorsResolver( - () => PluginManager.Current.ResolveMacroRenderings()); + ServiceProvider, LoggerResolver.Current.Logger, + () => PluginManager.ResolveMacroRenderings()); PackageActionsResolver.Current = new PackageActionsResolver( - () => PluginManager.Current.ResolvePackageActions()); + ServiceProvider, LoggerResolver.Current.Logger, + () => PluginManager.ResolvePackageActions()); ActionsResolver.Current = new ActionsResolver( - () => PluginManager.Current.ResolveActions()); + ServiceProvider, LoggerResolver.Current.Logger, + () => PluginManager.ResolveActions()); //the database migration objects MigrationResolver.Current = new MigrationResolver( - () => PluginManager.Current.ResolveTypes()); + ServiceProvider, LoggerResolver.Current.Logger, + () => PluginManager.ResolveTypes()); // todo: remove once we drop IPropertyEditorValueConverter support. PropertyEditorValueConvertersResolver.Current = new PropertyEditorValueConvertersResolver( - PluginManager.Current.ResolvePropertyEditorValueConverters()); + ServiceProvider, LoggerResolver.Current.Logger, + PluginManager.ResolvePropertyEditorValueConverters()); // need to filter out the ones we dont want!! PropertyValueConvertersResolver.Current = new PropertyValueConvertersResolver( - PluginManager.Current.ResolveTypes()); + ServiceProvider, LoggerResolver.Current.Logger, + PluginManager.ResolveTypes()); // use the new DefaultShortStringHelper ShortStringHelperResolver.Current = new ShortStringHelperResolver( @@ -348,6 +372,7 @@ namespace Umbraco.Core new DefaultShortStringHelper().WithDefaultConfig()); UrlSegmentProviderResolver.Current = new UrlSegmentProviderResolver( + ServiceProvider, LoggerResolver.Current.Logger, typeof(DefaultUrlSegmentProvider)); // by default, no factory is activated diff --git a/src/Umbraco.Core/DataTypesResolver.cs b/src/Umbraco.Core/DataTypesResolver.cs index 76061b252d..cf4074fc7e 100644 --- a/src/Umbraco.Core/DataTypesResolver.cs +++ b/src/Umbraco.Core/DataTypesResolver.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; using umbraco.interfaces; @@ -11,12 +12,14 @@ namespace Umbraco.Core [Obsolete("IDataType is obsolete and is no longer used, it will be removed from the codebase in future versions")] internal sealed class DataTypesResolver : LegacyTransientObjectsResolver { - /// - /// Constructor - /// - /// - internal DataTypesResolver(Func> dataTypes) - : base(dataTypes) + /// + /// Constructor + /// + /// + /// + /// + internal DataTypesResolver(IServiceProvider serviceProvider, ILogger logger, Func> dataTypes) + : base(serviceProvider, logger, dataTypes) { } diff --git a/src/Umbraco.Core/Macros/MacroFieldEditorsResolver.cs b/src/Umbraco.Core/Macros/MacroFieldEditorsResolver.cs index eb0366eb93..1788932c8f 100644 --- a/src/Umbraco.Core/Macros/MacroFieldEditorsResolver.cs +++ b/src/Umbraco.Core/Macros/MacroFieldEditorsResolver.cs @@ -4,6 +4,7 @@ using System.Linq; using System.Web; using System.Web.UI; using System.Linq; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; using umbraco.interfaces; @@ -18,13 +19,14 @@ namespace Umbraco.Core.Macros /// internal sealed class MacroFieldEditorsResolver : LazyManyObjectsResolverBase { - - /// - /// Constructor - /// - /// - internal MacroFieldEditorsResolver(Func> macroEditors) - : base(macroEditors, ObjectLifetimeScope.Transient) + /// + /// Constructor + /// + /// + /// + /// + internal MacroFieldEditorsResolver(IServiceProvider serviceProvider, ILogger logger, Func> macroEditors) + : base(serviceProvider, logger, macroEditors, ObjectLifetimeScope.Transient) { } /// @@ -70,10 +72,10 @@ namespace Umbraco.Core.Macros internal Control GetMacroRenderControlByType(PersistableMacroProperty prop, string uniqueId) { var m = MacroControlTypes.FindLast(macroGuiCcontrol => macroGuiCcontrol.ToString() == string.Format("{0}.{1}", prop.AssemblyName, prop.TypeName)); - var instance = PluginManager.Current.CreateInstance(m); + var instance = ServiceProvider.GetService(m) as IMacroGuiRendering; if (instance != null) { - if (!string.IsNullOrEmpty(prop.Value)) + if (string.IsNullOrEmpty(prop.Value) == false) { instance.Value = HttpUtility.HtmlDecode(prop.Value); } diff --git a/src/Umbraco.Core/Macros/XsltExtensionsResolver.cs b/src/Umbraco.Core/Macros/XsltExtensionsResolver.cs index 7927ee5745..0c754c9d3f 100644 --- a/src/Umbraco.Core/Macros/XsltExtensionsResolver.cs +++ b/src/Umbraco.Core/Macros/XsltExtensionsResolver.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; namespace Umbraco.Core.Macros @@ -9,13 +10,14 @@ namespace Umbraco.Core.Macros /// internal sealed class XsltExtensionsResolver : LazyManyObjectsResolverBase { - /// - /// Constructor - /// - /// - internal XsltExtensionsResolver(Func> packageActions) - : base(packageActions, ObjectLifetimeScope.Application) + /// Constructor + /// + /// + /// + /// + internal XsltExtensionsResolver(IServiceProvider serviceProvider, ILogger logger, Func> packageActions) + : base(serviceProvider, logger, packageActions, ObjectLifetimeScope.Application) { } diff --git a/src/Umbraco.Core/ObjectResolution/ApplicationEventsResolver.cs b/src/Umbraco.Core/ObjectResolution/ApplicationEventsResolver.cs index a31598bfc8..1b55a89a9c 100644 --- a/src/Umbraco.Core/ObjectResolution/ApplicationEventsResolver.cs +++ b/src/Umbraco.Core/ObjectResolution/ApplicationEventsResolver.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; using System.Linq; using System.Threading; +using Umbraco.Core.Logging; using umbraco.interfaces; namespace Umbraco.Core.ObjectResolution @@ -18,11 +19,13 @@ namespace Umbraco.Core.ObjectResolution private readonly LegacyStartupHandlerResolver _legacyResolver; /// - /// Constructor - /// - /// - internal ApplicationEventsResolver(IEnumerable applicationEventHandlers) - : base(applicationEventHandlers) + /// Constructor + /// + /// + /// + /// + internal ApplicationEventsResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable applicationEventHandlers) + : base(serviceProvider, logger, applicationEventHandlers) { //create the legacy resolver and only include the legacy types _legacyResolver = new LegacyStartupHandlerResolver( diff --git a/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs b/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs index 6aa3cce51c..2851a70e15 100644 --- a/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs +++ b/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs @@ -1,8 +1,9 @@ using System; using System.Collections.Generic; +using System.ComponentModel; using System.Linq; -using System.Threading; using System.Web; +using Umbraco.Core.Logging; namespace Umbraco.Core.ObjectResolution { @@ -15,98 +16,133 @@ namespace Umbraco.Core.ObjectResolution /// This is a special case resolver for when types get lazily resolved in order to resolve the actual types. This is useful /// for when there is some processing overhead (i.e. Type finding in assemblies) to return the Types used to instantiate the instances. /// In some these cases we don't want to have to type-find during application startup, only when we need to resolve the instances. - /// Important notes about this resolver: it does not support Insert or Remove and therefore does not support any ordering unless + /// Important notes about this resolver: it does not support Insert or Remove and therefore does not support any ordering unless /// the types are marked with the WeightedPluginAttribute. - /// + /// public abstract class LazyManyObjectsResolverBase : ManyObjectsResolverBase - where TResolved : class + where TResolved : class where TResolver : ResolverBase - { - #region Constructors + { + #region Constructors /// - /// Initializes a new instance of the class with an empty list of objects, - /// with creation of objects based on an HttpRequest lifetime scope. + /// Initializes a new instance of the class with an empty list of objects, + /// and an optional lifetime scope. /// + /// + /// /// The lifetime scope of instantiated objects, default is per Application. /// If is per HttpRequest then there must be a current HttpContext. /// is per HttpRequest but the current HttpContext is null. + protected LazyManyObjectsResolverBase(IServiceProvider serviceProvider, ILogger logger, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) + : base(serviceProvider, logger, scope) + { + Initialize(); + } + + [EditorBrowsable(EditorBrowsableState.Never)] + [Obsolete("Use ctor specifying IServiceProvider instead")] protected LazyManyObjectsResolverBase(ObjectLifetimeScope scope = ObjectLifetimeScope.Application) : base(scope) { Initialize(); } - /// - /// Initializes a new instance of the class with an empty list of objects, - /// with creation of objects based on an HttpRequest lifetime scope. - /// - /// The HttpContextBase corresponding to the HttpRequest. - /// is null. + [EditorBrowsable(EditorBrowsableState.Never)] + [Obsolete("Use ctor specifying IServiceProvider instead")] protected LazyManyObjectsResolverBase(HttpContextBase httpContext) : base(httpContext) { Initialize(); } - /// - /// Initializes a new instance of the class with an initial list - /// If is per HttpRequest then there must be a current HttpContext. - /// is per HttpRequest but the current HttpContext is null. - /// + protected LazyManyObjectsResolverBase(IServiceProvider serviceProvider, ILogger logger, IEnumerable> lazyTypeList, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) + : this(serviceProvider, logger, scope) + { + AddTypes(lazyTypeList); + } + + [EditorBrowsable(EditorBrowsableState.Never)] + [Obsolete("Use ctor specifying IServiceProvider instead")] protected LazyManyObjectsResolverBase(IEnumerable> lazyTypeList, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) - : this(scope) - { - AddTypes(lazyTypeList); - } + : this(new ActivatorServiceProvider(), LoggerResolver.Current.Logger, lazyTypeList, scope) + { + } + + protected LazyManyObjectsResolverBase(IServiceProvider serviceProvider, ILogger logger, Func> typeListProducerList, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) + : this(serviceProvider, logger, scope) + { + _typeListProducerList.Add(typeListProducerList); + } + + [EditorBrowsable(EditorBrowsableState.Never)] + [Obsolete("Use ctor specifying IServiceProvider instead")] + protected LazyManyObjectsResolverBase(Func> typeListProducerList, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) + : this(new ActivatorServiceProvider(), LoggerResolver.Current.Logger, typeListProducerList, scope) + { + } + + protected LazyManyObjectsResolverBase(IServiceProvider serviceProvider, ILogger logger, HttpContextBase httpContext, IEnumerable> lazyTypeList) + : this(serviceProvider, logger, httpContext) + { + AddTypes(lazyTypeList); + } + + [EditorBrowsable(EditorBrowsableState.Never)] + [Obsolete("Use ctor specifying IServiceProvider instead")] + protected LazyManyObjectsResolverBase(HttpContextBase httpContext, IEnumerable> lazyTypeList) + : this(new ActivatorServiceProvider(), LoggerResolver.Current.Logger, httpContext, lazyTypeList) + { + } + + protected LazyManyObjectsResolverBase(IServiceProvider serviceProvider, ILogger logger, HttpContextBase httpContext, Func> typeListProducerList) + : this(serviceProvider, logger, httpContext) + { + _typeListProducerList.Add(typeListProducerList); + } + + [EditorBrowsable(EditorBrowsableState.Never)] + [Obsolete("Use ctor specifying IServiceProvider instead")] + protected LazyManyObjectsResolverBase(HttpContextBase httpContext, Func> typeListProducerList) + : this(new ActivatorServiceProvider(), LoggerResolver.Current.Logger, httpContext, typeListProducerList) + { + } + + #endregion + + private readonly List> _lazyTypeList = new List>(); + private readonly List>> _typeListProducerList = new List>>(); + private readonly List _excludedTypesList = new List(); + private Lazy> _resolvedTypes; /// - /// Initializes a new instance of the class with an initial list - /// of functions producing types, and an optional lifetime scope. + /// Initializes a new instance of the class with an empty list of objects, + /// with creation of objects based on an HttpRequest lifetime scope. /// - /// The list of functions producing types. + /// + /// + /// The HttpContextBase corresponding to the HttpRequest. + /// is null. + protected LazyManyObjectsResolverBase(IServiceProvider serviceProvider, ILogger logger, HttpContextBase httpContext) + : base(serviceProvider, logger, httpContext) + { + } + + /// + /// Initializes a new instance of the class with an initial list of object types, + /// and an optional lifetime scope. + /// + /// + /// + /// The list of object types. /// The lifetime scope of instantiated objects, default is per Application. /// If is per HttpRequest then there must be a current HttpContext. /// is per HttpRequest but the current HttpContext is null. - protected LazyManyObjectsResolverBase(Func> typeListProducerList, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) - : this(scope) - { - _typeListProducerList.Add(typeListProducerList); - } + protected LazyManyObjectsResolverBase(IServiceProvider serviceProvider, ILogger logger, IEnumerable value, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) + : base(serviceProvider, logger, value, scope) + { + } - /// - /// Initializes a new instance of the class with an initial list of - /// lazy object types, with creation of objects based on an HttpRequest lifetime scope. - /// - /// The HttpContextBase corresponding to the HttpRequest. - /// The list of lazy object types. - /// is null. - protected LazyManyObjectsResolverBase(HttpContextBase httpContext, IEnumerable> lazyTypeList) - : this(httpContext) - { - AddTypes(lazyTypeList); - } - - /// - /// Initializes a new instance of the class with an initial list of - /// functions producing types, with creation of objects based on an HttpRequest lifetime scope. - /// - /// The HttpContextBase corresponding to the HttpRequest. - /// The list of functions producing types. - /// is null. - protected LazyManyObjectsResolverBase(HttpContextBase httpContext, Func> typeListProducerList) - : this(httpContext) - { - _typeListProducerList.Add(typeListProducerList); - } - - #endregion - - private readonly List> _lazyTypeList = new List>(); - private readonly List>> _typeListProducerList = new List>>(); - private readonly List _excludedTypesList = new List(); - private Lazy> _resolvedTypes = null; - private void Initialize() { _resolvedTypes = new Lazy>(() => @@ -129,23 +165,23 @@ namespace Umbraco.Core.ObjectResolution }); } - /// - /// Gets a value indicating whether the resolver has resolved types to create instances from. - /// + /// + /// Gets a value indicating whether the resolver has resolved types to create instances from. + /// /// To be used in unit tests. - public bool HasResolvedTypes - { - get { return _resolvedTypes.IsValueCreated; } - } + public bool HasResolvedTypes + { + get { return _resolvedTypes.IsValueCreated; } + } /// /// Gets the list of types to create instances from. /// /// When called, will get the types from the lazy list. protected override IEnumerable InstanceTypes - { - get { return _resolvedTypes.Value; } - } + { + get { return _resolvedTypes.Value; } + } /// /// Ensures that type is valid and not a duplicate @@ -154,15 +190,15 @@ namespace Umbraco.Core.ObjectResolution /// /// private void AddValidAndNoDuplicate(List list, Type type) - { + { EnsureCorrectType(type); if (list.Contains(type)) - { + { throw new InvalidOperationException(string.Format( "Type {0} is already in the collection of types.", type.FullName)); } list.Add(type); - } + } #region Types collection manipulation @@ -179,86 +215,86 @@ namespace Umbraco.Core.ObjectResolution /// /// Lazily adds types from lazy types. - /// + /// /// The lazy types, to add. - protected void AddTypes(IEnumerable> types) - { - EnsureSupportsAdd(); + protected void AddTypes(IEnumerable> types) + { + EnsureSupportsAdd(); using (Resolution.Configuration) using (GetWriteLock()) - { - foreach (var t in types) - { - _lazyTypeList.Add(t); - } - } - } + { + foreach (var t in types) + { + _lazyTypeList.Add(t); + } + } + } - /// + /// /// Lazily adds types from a function producing types. - /// + /// /// The functions producing types, to add. public void AddTypeListDelegate(Func> typeListProducer) - { + { EnsureSupportsAdd(); using (Resolution.Configuration) using (GetWriteLock()) - { + { _typeListProducerList.Add(typeListProducer); - } - } + } + } - /// + /// /// Lazily adds a type from a lazy type. - /// + /// /// The lazy type, to add. - public void AddType(Lazy value) - { + public void AddType(Lazy value) + { EnsureSupportsAdd(); using (Resolution.Configuration) using (GetWriteLock()) - { - _lazyTypeList.Add(value); - } - } + { + _lazyTypeList.Add(value); + } + } - /// + /// /// Lazily adds a type from an actual type. - /// + /// /// The actual type, to add. /// The type is converted to a lazy type. - public override void AddType(Type value) - { - AddType(new Lazy(() => value)); - } + public override void AddType(Type value) + { + AddType(new Lazy(() => value)); + } - /// - /// Clears all lazy types - /// - public override void Clear() - { - EnsureSupportsClear(); + /// + /// Clears all lazy types + /// + public override void Clear() + { + EnsureSupportsClear(); using (Resolution.Configuration) using (GetWriteLock()) - { - _lazyTypeList.Clear(); - } - } + { + _lazyTypeList.Clear(); + } + } #endregion #region Types collection manipulation support - /// + /// /// Gets a false value indicating that the resolver does NOT support inserting types. - /// - protected override bool SupportsInsert - { - get { return false; } + /// + protected override bool SupportsInsert + { + get { return false; } } #endregion diff --git a/src/Umbraco.Core/ObjectResolution/LegacyTransientObjectsResolver.cs b/src/Umbraco.Core/ObjectResolution/LegacyTransientObjectsResolver.cs index 9362ed54fe..62ce20cbbb 100644 --- a/src/Umbraco.Core/ObjectResolution/LegacyTransientObjectsResolver.cs +++ b/src/Umbraco.Core/ObjectResolution/LegacyTransientObjectsResolver.cs @@ -1,8 +1,8 @@ using System; using System.Collections.Concurrent; using System.Collections.Generic; -using System.Linq; using System.Threading; +using Umbraco.Core.Logging; namespace Umbraco.Core.ObjectResolution { @@ -22,21 +22,23 @@ namespace Umbraco.Core.ObjectResolution where TResolver : ResolverBase { private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(); - private ConcurrentDictionary _id2type; + private ConcurrentDictionary _id2Type; #region Constructors - - /// - /// Initializes a new instance of the class with an initial list of object types. - /// - /// A function returning the list of object types. - /// - /// We are creating Transient instances (new instances each time) because this is how the legacy code worked and - /// I don't want to muck anything up by changing them to application based instances. - /// TODO: However, it would make much more sense to do this and would speed up the application plus this would make the GetById method much easier. - /// - protected LegacyTransientObjectsResolver(Func> value) - : base(value, ObjectLifetimeScope.Transient) // new objects every time + + /// + /// Initializes a new instance of the class with an initial list of object types. + /// + /// + /// + /// A function returning the list of object types. + /// + /// We are creating Transient instances (new instances each time) because this is how the legacy code worked and + /// I don't want to muck anything up by changing them to application based instances. + /// TODO: However, it would make much more sense to do this and would speed up the application plus this would make the GetById method much easier. + /// + protected LegacyTransientObjectsResolver(IServiceProvider serviceProvider, ILogger logger, Func> value) + : base(serviceProvider, logger, value, ObjectLifetimeScope.Transient) // new objects every time { } #endregion @@ -55,9 +57,9 @@ namespace Umbraco.Core.ObjectResolution public TResolved GetById(Guid id) { EnsureIsInitialized(); - return !_id2type.ContainsKey(id) + return _id2Type.ContainsKey(id) == false ? null - : PluginManager.Current.CreateInstance(_id2type[id]); + : ServiceProvider.GetService(_id2Type[id]) as TResolved; } /// @@ -72,14 +74,14 @@ namespace Umbraco.Core.ObjectResolution { using (var l = new UpgradeableReadLock(_lock)) { - if (_id2type == null) + if (_id2Type == null) { l.UpgradeToWriteLock(); - _id2type = new ConcurrentDictionary(); + _id2Type = new ConcurrentDictionary(); foreach (var value in Values) { - _id2type.TryAdd(GetUniqueIdentifier(value), value.GetType()); + _id2Type.TryAdd(GetUniqueIdentifier(value), value.GetType()); } } } diff --git a/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs b/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs index 95ff923c58..dc889975a2 100644 --- a/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs +++ b/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs @@ -1,8 +1,10 @@ using System; using System.Collections.Generic; +using System.ComponentModel; using System.Linq; using System.Threading; using System.Web; +using Umbraco.Core.Logging; namespace Umbraco.Core.ObjectResolution { @@ -15,75 +17,111 @@ namespace Umbraco.Core.ObjectResolution where TResolved : class where TResolver : ResolverBase { - private Lazy> _applicationInstances = null; + private Lazy> _applicationInstances; private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(); private readonly string _httpContextKey; private readonly List _instanceTypes = new List(); - private IEnumerable _sortedValues = null; + private IEnumerable _sortedValues; private int _defaultPluginWeight = 10; #region Constructors - - /// - /// Initializes a new instance of the class with an empty list of objects, + + /// + /// Initializes a new instance of the class with an empty list of objects, /// and an optional lifetime scope. - /// - /// The lifetime scope of instantiated objects, default is per Application. - /// If is per HttpRequest then there must be a current HttpContext. - /// is per HttpRequest but the current HttpContext is null. + /// + /// + /// + /// The lifetime scope of instantiated objects, default is per Application. + /// If is per HttpRequest then there must be a current HttpContext. + /// is per HttpRequest but the current HttpContext is null. + protected ManyObjectsResolverBase(IServiceProvider serviceProvider, ILogger logger, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) + { + if (serviceProvider == null) throw new ArgumentNullException("serviceProvider"); + if (logger == null) throw new ArgumentNullException("logger"); + CanResolveBeforeFrozen = false; + if (scope == ObjectLifetimeScope.HttpRequest) + { + if (HttpContext.Current == null) + throw new InvalidOperationException("Use alternative constructor accepting a HttpContextBase object in order to set the lifetime scope to HttpRequest when HttpContext.Current is null"); + + CurrentHttpContext = new HttpContextWrapper(HttpContext.Current); + } + + ServiceProvider = serviceProvider; + Logger = logger; + LifetimeScope = scope; + if (scope == ObjectLifetimeScope.HttpRequest) + _httpContextKey = GetType().FullName; + _instanceTypes = new List(); + + InitializeAppInstances(); + } + + [EditorBrowsable(EditorBrowsableState.Never)] + [Obsolete("Use ctor specifying IServiceProvider instead")] protected ManyObjectsResolverBase(ObjectLifetimeScope scope = ObjectLifetimeScope.Application) + : this(new ActivatorServiceProvider(), LoggerResolver.Current.Logger, scope) { - CanResolveBeforeFrozen = false; - if (scope == ObjectLifetimeScope.HttpRequest) - { - if (HttpContext.Current == null) - throw new InvalidOperationException("Use alternative constructor accepting a HttpContextBase object in order to set the lifetime scope to HttpRequest when HttpContext.Current is null"); - - CurrentHttpContext = new HttpContextWrapper(HttpContext.Current); - } - - LifetimeScope = scope; - if (scope == ObjectLifetimeScope.HttpRequest) - _httpContextKey = this.GetType().FullName; - _instanceTypes = new List(); - - InitializeAppInstances(); + } - /// - /// Initializes a new instance of the class with an empty list of objects, - /// with creation of objects based on an HttpRequest lifetime scope. - /// - /// The HttpContextBase corresponding to the HttpRequest. - /// is null. - protected ManyObjectsResolverBase(HttpContextBase httpContext) + /// + /// Initializes a new instance of the class with an empty list of objects, + /// with creation of objects based on an HttpRequest lifetime scope. + /// + /// + /// + /// The HttpContextBase corresponding to the HttpRequest. + /// is null. + protected ManyObjectsResolverBase(IServiceProvider serviceProvider, ILogger logger, HttpContextBase httpContext) { - CanResolveBeforeFrozen = false; - if (httpContext == null) - throw new ArgumentNullException("httpContext"); + if (serviceProvider == null) throw new ArgumentNullException("serviceProvider"); + if (httpContext == null) throw new ArgumentNullException("httpContext"); + CanResolveBeforeFrozen = false; + Logger = logger; LifetimeScope = ObjectLifetimeScope.HttpRequest; - _httpContextKey = this.GetType().FullName; - CurrentHttpContext = httpContext; + _httpContextKey = GetType().FullName; + ServiceProvider = serviceProvider; + CurrentHttpContext = httpContext; _instanceTypes = new List(); InitializeAppInstances(); } - /// - /// Initializes a new instance of the class with an initial list of object types, + [EditorBrowsable(EditorBrowsableState.Never)] + [Obsolete("Use ctor specifying IServiceProvider instead")] + protected ManyObjectsResolverBase(HttpContextBase httpContext) + : this(new ActivatorServiceProvider(), LoggerResolver.Current.Logger, httpContext) + { + + } + + /// + /// Initializes a new instance of the class with an initial list of object types, /// and an optional lifetime scope. - /// - /// The list of object types. - /// The lifetime scope of instantiated objects, default is per Application. - /// If is per HttpRequest then there must be a current HttpContext. - /// is per HttpRequest but the current HttpContext is null. - protected ManyObjectsResolverBase(IEnumerable value, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) - : this(scope) + /// + /// + /// + /// The list of object types. + /// The lifetime scope of instantiated objects, default is per Application. + /// If is per HttpRequest then there must be a current HttpContext. + /// is per HttpRequest but the current HttpContext is null. + protected ManyObjectsResolverBase(IServiceProvider serviceProvider, ILogger logger, IEnumerable value, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) + : this(serviceProvider, logger, scope) { _instanceTypes = value.ToList(); } + [EditorBrowsable(EditorBrowsableState.Never)] + [Obsolete("Use ctor specifying IServiceProvider instead")] + protected ManyObjectsResolverBase(IEnumerable value, ObjectLifetimeScope scope = ObjectLifetimeScope.Application) + : this(new ActivatorServiceProvider(), LoggerResolver.Current.Logger, value, scope) + { + + } + /// /// Initializes a new instance of the class with an initial list of objects, /// with creation of objects based on an HttpRequest lifetime scope. @@ -91,8 +129,9 @@ namespace Umbraco.Core.ObjectResolution /// The HttpContextBase corresponding to the HttpRequest. /// The list of object types. /// is null. - protected ManyObjectsResolverBase(HttpContextBase httpContext, IEnumerable value) - : this(httpContext) + [Obsolete("Use ctor specifying IServiceProvider instead")] + protected ManyObjectsResolverBase(HttpContextBase httpContext, IEnumerable value) + : this(new ActivatorServiceProvider(), LoggerResolver.Current.Logger, httpContext) { _instanceTypes = value.ToList(); } @@ -123,7 +162,14 @@ namespace Umbraco.Core.ObjectResolution /// If not null, then LifetimeScope will be ObjectLifetimeScope.HttpRequest. protected HttpContextBase CurrentHttpContext { get; private set; } - /// + /// + /// Returns the service provider used to instantiate objects + /// + public IServiceProvider ServiceProvider { get; private set; } + + public ILogger Logger { get; private set; } + + /// /// Gets or sets the lifetime scope of resolved objects. /// protected ObjectLifetimeScope LifetimeScope { get; private set; } @@ -214,7 +260,7 @@ namespace Umbraco.Core.ObjectResolution /// A list of objects of type . protected virtual IEnumerable CreateInstances() { - return PluginManager.Current.CreateInstances(InstanceTypes); + return ServiceProvider.CreateInstances(InstanceTypes, Logger); } #region Types collection manipulation @@ -423,7 +469,7 @@ namespace Umbraco.Core.ObjectResolution { EnsureCorrectType(existingType); EnsureCorrectType(value); - if (!_instanceTypes.Contains(existingType)) + if (_instanceTypes.Contains(existingType) == false) { throw new InvalidOperationException(string.Format( "Type {0} is not in the collection of types.", existingType.FullName)); @@ -514,9 +560,9 @@ namespace Umbraco.Core.ObjectResolution /// the type is not a valid type for the resolver. protected virtual void EnsureCorrectType(Type value) { - if (!TypeHelper.IsTypeAssignableFrom(value)) + if (TypeHelper.IsTypeAssignableFrom(value) == false) throw new InvalidOperationException(string.Format( - "Type {0} is not an acceptable type for resolver {1}.", value.FullName, this.GetType().FullName)); + "Type {0} is not an acceptable type for resolver {1}.", value.FullName, GetType().FullName)); } #endregion @@ -529,7 +575,7 @@ namespace Umbraco.Core.ObjectResolution /// The resolver does not support removing types. protected void EnsureSupportsRemove() { - if (!SupportsRemove) + if (SupportsRemove == false) throw new InvalidOperationException("This resolver does not support removing types"); } @@ -538,7 +584,7 @@ namespace Umbraco.Core.ObjectResolution /// /// The resolver does not support clearing types. protected void EnsureSupportsClear() { - if (!SupportsClear) + if (SupportsClear == false) throw new InvalidOperationException("This resolver does not support clearing types"); } @@ -548,7 +594,7 @@ namespace Umbraco.Core.ObjectResolution /// The resolver does not support adding types. protected void EnsureSupportsAdd() { - if (!SupportsAdd) + if (SupportsAdd == false) throw new InvalidOperationException("This resolver does not support adding new types"); } @@ -558,7 +604,7 @@ namespace Umbraco.Core.ObjectResolution /// The resolver does not support inserting types. protected void EnsureSupportsInsert() { - if (!SupportsInsert) + if (SupportsInsert == false) throw new InvalidOperationException("This resolver does not support inserting new types"); } diff --git a/src/Umbraco.Core/PackageActionsResolver.cs b/src/Umbraco.Core/PackageActionsResolver.cs index 551bf8cfa7..717262d100 100644 --- a/src/Umbraco.Core/PackageActionsResolver.cs +++ b/src/Umbraco.Core/PackageActionsResolver.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; using umbraco.interfaces; @@ -10,13 +11,14 @@ namespace Umbraco.Core /// internal sealed class PackageActionsResolver : LazyManyObjectsResolverBase { - - /// - /// Constructor - /// - /// - internal PackageActionsResolver(Func> packageActions) - : base(packageActions) + /// + /// Constructor + /// + /// + /// + /// + internal PackageActionsResolver(IServiceProvider serviceProvider, ILogger logger, Func> packageActions) + : base(serviceProvider, logger, packageActions) { } diff --git a/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs b/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs index 007ddbd014..ea44964219 100644 --- a/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs +++ b/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs @@ -12,9 +12,11 @@ namespace Umbraco.Core.Persistence.Mappers /// /// Constructor accepting a list of BaseMapper types that are attributed with the MapperFor attribute /// + /// + /// /// - public MappingResolver(Func> assignedMapperTypes) - : base(assignedMapperTypes) + public MappingResolver(IServiceProvider serviceProvider, ILogger logger, Func> assignedMapperTypes) + : base(serviceProvider, logger, assignedMapperTypes) { } diff --git a/src/Umbraco.Core/Persistence/Migrations/MigrationResolver.cs b/src/Umbraco.Core/Persistence/Migrations/MigrationResolver.cs index 3d28e99c56..69391c7485 100644 --- a/src/Umbraco.Core/Persistence/Migrations/MigrationResolver.cs +++ b/src/Umbraco.Core/Persistence/Migrations/MigrationResolver.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; namespace Umbraco.Core.Persistence.Migrations @@ -9,16 +10,17 @@ namespace Umbraco.Core.Persistence.Migrations /// internal class MigrationResolver : LazyManyObjectsResolverBase { - - /// - /// Constructor - /// - /// - /// - /// Use transient objects as we don't want these as singletons and take up memory that is not required - /// - public MigrationResolver(Func> migrations) - : base(migrations, ObjectLifetimeScope.Transient) + /// + /// Constructor + /// + /// + /// + /// + /// + /// Use transient objects as we don't want these as singletons and take up memory that is not required + /// + public MigrationResolver(IServiceProvider serviceProvider, ILogger logger, Func> migrations) + : base(serviceProvider, logger, migrations, ObjectLifetimeScope.Transient) { } diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IStylesheetRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IStylesheetRepository.cs index 81bbcac98e..1b2bcbe3eb 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IStylesheetRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IStylesheetRepository.cs @@ -5,16 +5,6 @@ namespace Umbraco.Core.Persistence.Repositories { public interface IStylesheetRepository : IRepository { - /// - /// Gets a list of all that exist at the relative path specified. - /// - /// - /// If null or not specified, will return the stylesheets at the root path relative to the IFileSystem - /// - /// - IEnumerable GetStylesheetsAtPath(string rootPath = null); - - bool ValidateStylesheet(Stylesheet stylesheet); } } \ No newline at end of file diff --git a/src/Umbraco.Core/PluginManager.cs b/src/Umbraco.Core/PluginManager.cs index 12484889d5..102f0ee88f 100644 --- a/src/Umbraco.Core/PluginManager.cs +++ b/src/Umbraco.Core/PluginManager.cs @@ -15,7 +15,9 @@ using Umbraco.Core.Models; using Umbraco.Core.Persistence.Mappers; using Umbraco.Core.Persistence.Migrations; using Umbraco.Core.Persistence.SqlSyntax; +using Umbraco.Core.Profiling; using Umbraco.Core.PropertyEditors; +using Umbraco.Core.Cache; using umbraco.interfaces; using File = System.IO.File; @@ -36,34 +38,27 @@ namespace Umbraco.Core /// public class PluginManager { - private readonly ApplicationContext _appContext; - private const string CacheKey = "umbraco-plugins.list"; - /// /// Creates a new PluginManager with an ApplicationContext instance which ensures that the plugin xml /// file is cached temporarily until app startup completes. /// - /// + /// /// - internal PluginManager(ApplicationContext appContext, bool detectChanges = true) - : this(detectChanges) + /// + /// + internal PluginManager(IServiceProvider serviceProvider, IRuntimeCacheProvider runtimeCache, ProfilingLogger logger, bool detectChanges = true) { - if (appContext == null) throw new ArgumentNullException("appContext"); - _appContext = appContext; - } + if (serviceProvider == null) throw new ArgumentNullException("serviceProvider"); + if (runtimeCache == null) throw new ArgumentNullException("runtimeCache"); + if (logger == null) throw new ArgumentNullException("logger"); + + _serviceProvider = serviceProvider; + _runtimeCache = runtimeCache; + _logger = logger; - /// - /// Creates a new PluginManager - /// - /// - /// If true will detect changes in the /bin folder, app_code, etc... and therefor load plugins from the - /// cached plugins file if one is found. If false will never use the cache file for plugins - /// - internal PluginManager(bool detectChanges = true) - { _tempFolder = IOHelper.MapPath("~/App_Data/TEMP/PluginCache"); //create the folder if it doesn't exist - if (!Directory.Exists(_tempFolder)) + if (Directory.Exists(_tempFolder) == false) { Directory.CreateDirectory(_tempFolder); } @@ -104,14 +99,18 @@ namespace Umbraco.Core //always set to true if we're not detecting (generally only for testing) RequiresRescanning = true; } - } + private readonly IServiceProvider _serviceProvider; + private readonly IRuntimeCacheProvider _runtimeCache; + private readonly ProfilingLogger _logger; + private const string CacheKey = "umbraco-plugins.list"; static PluginManager _resolver; - static readonly ReaderWriterLockSlim Lock = new ReaderWriterLockSlim(); private readonly string _tempFolder; private long _cachedAssembliesHash = -1; private long _currentAssembliesHash = -1; + private static bool _initialized = false; + private static object _singletonLock = new object(); /// /// We will ensure that no matter what, only one of these is created, this is to ensure that caching always takes place @@ -123,19 +122,28 @@ namespace Umbraco.Core { get { - using (var l = new UpgradeableReadLock(Lock)) + return LazyInitializer.EnsureInitialized(ref _resolver, ref _initialized, ref _singletonLock, () => { - if (_resolver == null) + if (ApplicationContext.Current == null) { - l.UpgradeToWriteLock(); - _resolver = ApplicationContext.Current == null - ? new PluginManager() - : new PluginManager(ApplicationContext.Current); + var logger = LoggerResolver.HasCurrent ? LoggerResolver.Current.Logger : new DebugDiagnosticsLogger(); + var profiler = ProfilerResolver.HasCurrent ? ProfilerResolver.Current.Profiler : new LogProfiler(logger); + return new PluginManager( + new ActivatorServiceProvider(), + new NullCacheProvider(), + new ProfilingLogger(logger, profiler)); } - return _resolver; - } + return new PluginManager( + new ActivatorServiceProvider(), + ApplicationContext.Current.ApplicationCache.RuntimeCache, + ApplicationContext.Current.ProfilingLogger); + }); + } + set + { + _initialized = true; + _resolver = value; } - set { _resolver = value; } } #region Hash checking methods @@ -196,7 +204,7 @@ namespace Umbraco.Core //add the trees.config - use the contents to create the has since this gets resaved on every app startup! new Tuple(new FileInfo(IOHelper.MapPath(SystemDirectories.Config + "/trees.config")), true) - }, _appContext.ProfilingLogger + }, _logger ); return _currentAssembliesHash; } @@ -297,18 +305,9 @@ namespace Umbraco.Core { //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) - XDocument xml; - if (_appContext != null) - { - xml = _appContext.ApplicationCache.GetCacheItem(CacheKey, - new TimeSpan(0, 0, 5, 0), - () => XDocument.Load(filePath)); - } - else - { - xml = XDocument.Load(filePath); - } - + var xml = _runtimeCache.GetCacheItem(CacheKey, + () => XDocument.Load(filePath), + new TimeSpan(0, 0, 5, 0)); if (xml.Root == null) return Attempt>.Fail(); @@ -349,10 +348,7 @@ namespace Umbraco.Core if (File.Exists(path)) File.Delete(path); - if (_appContext != null) - { - _appContext.ApplicationCache.ClearCacheItem(CacheKey); - } + _runtimeCache.ClearCacheItem(CacheKey); } private string GetPluginListFilePath() @@ -606,35 +602,7 @@ namespace Umbraco.Core /// internal IEnumerable CreateInstances(IEnumerable types, bool throwException = false) { - //Have removed logging because it doesn't really need to be logged since the time taken is generally 0ms. - //we want to know if it fails ever, not how long it took if it is only 0. - - var typesAsArray = types.ToArray(); - //using (_appContext.ProfilingLogger.DebugDuration( - // String.Format("Starting instantiation of {0} objects of type {1}", typesAsArray.Length, typeof(T).FullName), - // String.Format("Completed instantiation of {0} objects of type {1}", typesAsArray.Length, typeof(T).FullName))) - //{ - var instances = new List(); - foreach (var t in typesAsArray) - { - try - { - var typeInstance = (T)Activator.CreateInstance(t); - instances.Add(typeInstance); - } - catch (Exception ex) - { - - _appContext.ProfilingLogger.Logger.Error(String.Format("Error creating type {0}", t.FullName), ex); - - if (throwException) - { - throw ex; - } - } - } - return instances; - //} + return _serviceProvider.CreateInstances(types, _logger.Logger, throwException); } /// @@ -659,7 +627,7 @@ namespace Umbraco.Core { var typesFound = new List(); - using (_appContext.ProfilingLogger.TraceDuration( + using (_logger.TraceDuration( String.Format("Starting resolution types of {0}", typeof(T).FullName), String.Format("Completed resolution of types of {0}, found {1}", typeof(T).FullName, typesFound.Count))) { @@ -669,7 +637,7 @@ namespace Umbraco.Core //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) { - _appContext.ProfilingLogger.Logger.Debug("Existing typeList found for {0} with resolution type {1}", () => typeof(T), () => resolutionType); + _logger.Logger.Debug("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 @@ -691,7 +659,7 @@ namespace Umbraco.Core //so in this instance there will never be a result. if (fileCacheResult.Exception != null && fileCacheResult.Exception is CachedPluginNotFoundInFileException) { - _appContext.ProfilingLogger.Logger.Debug("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); + _logger.Logger.Debug("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(typeList, resolutionType, finder); @@ -716,7 +684,7 @@ namespace Umbraco.Core //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; - _appContext.ProfilingLogger.Logger.Error("Could not load a cached plugin type: " + t + " now reverting to re-scanning assemblies for the base type: " + typeof(T).FullName, ex); + _logger.Logger.Error("Could not load a cached plugin type: " + t + " now reverting to re-scanning assemblies for the base type: " + typeof(T).FullName, ex); break; } } @@ -727,14 +695,14 @@ namespace Umbraco.Core } else { - _appContext.ProfilingLogger.Logger.Debug("Loaded plugin types {0} with resolution {1} from persisted cache", () => typeof(T), () => resolutionType); + _logger.Logger.Debug("Loaded plugin types {0} with resolution {1} from persisted cache", () => typeof(T), () => resolutionType); } } } } else { - _appContext.ProfilingLogger.Logger.Debug("Assembly changes detected, loading types {0} for resolution {1} by assembly scan", () => typeof(T), () => resolutionType); + _logger.Logger.Debug("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(typeList, resolutionType, finder); @@ -746,7 +714,7 @@ namespace Umbraco.Core //add the type list to the collection var added = _types.Add(typeList); - _appContext.ProfilingLogger.Logger.Debug("Caching of typelist for type {0} and resolution {1} was successful = {2}", () => typeof(T), () => resolutionType, () => added); + _logger.Logger.Debug("Caching of typelist for type {0} and resolution {1} was successful = {2}", () => typeof(T), () => resolutionType, () => added); } } diff --git a/src/Umbraco.Core/PropertyEditors/ParameterEditorResolver.cs b/src/Umbraco.Core/PropertyEditors/ParameterEditorResolver.cs index ef01b3a891..3c8d04fcf0 100644 --- a/src/Umbraco.Core/PropertyEditors/ParameterEditorResolver.cs +++ b/src/Umbraco.Core/PropertyEditors/ParameterEditorResolver.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using Umbraco.Core.Logging; using Umbraco.Core.Manifest; using Umbraco.Core.ObjectResolution; @@ -15,8 +16,8 @@ namespace Umbraco.Core.PropertyEditors /// internal class ParameterEditorResolver : LazyManyObjectsResolverBase { - public ParameterEditorResolver(Func> typeListProducerList) - : base(typeListProducerList, ObjectLifetimeScope.Application) + public ParameterEditorResolver(IServiceProvider serviceProvider, ILogger logger, Func> typeListProducerList) + : base(serviceProvider, logger, typeListProducerList, ObjectLifetimeScope.Application) { } diff --git a/src/Umbraco.Core/PropertyEditors/PropertyEditorResolver.cs b/src/Umbraco.Core/PropertyEditors/PropertyEditorResolver.cs index 441d7fde2c..fa2d4da594 100644 --- a/src/Umbraco.Core/PropertyEditors/PropertyEditorResolver.cs +++ b/src/Umbraco.Core/PropertyEditors/PropertyEditorResolver.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using Umbraco.Core.Logging; using Umbraco.Core.Manifest; using Umbraco.Core.ObjectResolution; @@ -14,6 +15,12 @@ namespace Umbraco.Core.PropertyEditors /// public class PropertyEditorResolver : LazyManyObjectsResolverBase { + public PropertyEditorResolver(IServiceProvider serviceProvider, ILogger logger, Func> typeListProducerList) + : base(serviceProvider, logger, typeListProducerList, ObjectLifetimeScope.Application) + { + } + + [Obsolete("Use the ctor specifying a PluginManager instead")] public PropertyEditorResolver(Func> typeListProducerList) : base(typeListProducerList, ObjectLifetimeScope.Application) { diff --git a/src/Umbraco.Core/PropertyEditors/PropertyEditorValueConvertersResolver.cs b/src/Umbraco.Core/PropertyEditors/PropertyEditorValueConvertersResolver.cs index f6c40a3323..c81f243a32 100644 --- a/src/Umbraco.Core/PropertyEditors/PropertyEditorValueConvertersResolver.cs +++ b/src/Umbraco.Core/PropertyEditors/PropertyEditorValueConvertersResolver.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; namespace Umbraco.Core.PropertyEditors @@ -13,20 +14,24 @@ namespace Umbraco.Core.PropertyEditors /// Initializes a new instance of the class with /// an initial list of converter types. /// + /// + /// /// The list of converter types /// The resolver is created by the WebBootManager and thus the constructor remains internal. - internal PropertyEditorValueConvertersResolver(IEnumerable converters) - : base(converters) + internal PropertyEditorValueConvertersResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable converters) + : base(serviceProvider, logger, converters) { } /// /// Initializes a new instance of the class with /// an initial list of converter types. /// + /// + /// /// The list of converter types /// The resolver is created by the WebBootManager and thus the constructor remains internal. - internal PropertyEditorValueConvertersResolver(params Type[] converters) - : base(converters) + internal PropertyEditorValueConvertersResolver(IServiceProvider serviceProvider, ILogger logger, params Type[] converters) + : base(serviceProvider, logger, converters) { } /// diff --git a/src/Umbraco.Core/PropertyEditors/PropertyValueConvertersResolver.cs b/src/Umbraco.Core/PropertyEditors/PropertyValueConvertersResolver.cs index 295fdb4b09..622ed2661f 100644 --- a/src/Umbraco.Core/PropertyEditors/PropertyValueConvertersResolver.cs +++ b/src/Umbraco.Core/PropertyEditors/PropertyValueConvertersResolver.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; using System.Linq; using System.Threading; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; namespace Umbraco.Core.PropertyEditors @@ -15,20 +16,24 @@ namespace Umbraco.Core.PropertyEditors /// Initializes a new instance of the class with /// an initial list of converter types. /// + /// + /// /// The list of converter types /// The resolver is created by the WebBootManager and thus the constructor remains internal. - internal PropertyValueConvertersResolver(IEnumerable converters) - : base(converters) + internal PropertyValueConvertersResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable converters) + : base(serviceProvider, logger, converters) { } /// /// Initializes a new instance of the class with /// an initial list of converter types. /// + /// + /// /// The list of converter types /// The resolver is created by the WebBootManager and thus the constructor remains internal. - internal PropertyValueConvertersResolver(params Type[] converters) - : base(converters) + internal PropertyValueConvertersResolver(IServiceProvider serviceProvider, ILogger logger, params Type[] converters) + : base(serviceProvider, logger, converters) { } /// diff --git a/src/Umbraco.Core/PropertyEditors/ValidatorsResolver.cs b/src/Umbraco.Core/PropertyEditors/ValidatorsResolver.cs index 6fcbe112f7..547271a941 100644 --- a/src/Umbraco.Core/PropertyEditors/ValidatorsResolver.cs +++ b/src/Umbraco.Core/PropertyEditors/ValidatorsResolver.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; namespace Umbraco.Core.PropertyEditors @@ -9,9 +10,9 @@ namespace Umbraco.Core.PropertyEditors /// A resolver to resolve all registered validators /// internal class ValidatorsResolver : LazyManyObjectsResolverBase - { - public ValidatorsResolver(IEnumerable> lazyTypeList) - : base(lazyTypeList, ObjectLifetimeScope.Application) + { + public ValidatorsResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable> lazyTypeList) + : base(serviceProvider, logger, lazyTypeList, ObjectLifetimeScope.Application) { } diff --git a/src/Umbraco.Core/ServiceProviderExtensions.cs b/src/Umbraco.Core/ServiceProviderExtensions.cs new file mode 100644 index 0000000000..335396ede6 --- /dev/null +++ b/src/Umbraco.Core/ServiceProviderExtensions.cs @@ -0,0 +1,45 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Umbraco.Core.Logging; + +namespace Umbraco.Core +{ + internal static class ServiceProviderExtensions + { + /// + /// Used to create instances of the specified type based on the resolved/cached plugin types + /// + /// + /// + /// + /// + /// set to true if an exception is to be thrown if there is an error during instantiation + /// + public static IEnumerable CreateInstances(this IServiceProvider serviceProvider, IEnumerable types, ILogger logger, bool throwException = false) + { + var typesAsArray = types.ToArray(); + + var instances = new List(); + foreach (var t in typesAsArray) + { + try + { + var typeInstance = (T) serviceProvider.GetService(t); + instances.Add(typeInstance); + } + catch (Exception ex) + { + + logger.Error(String.Format("Error creating type {0}", t.FullName), ex); + + if (throwException) + { + throw; + } + } + } + return instances; + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Services/FileService.cs b/src/Umbraco.Core/Services/FileService.cs index 438287bd56..258539b4c2 100644 --- a/src/Umbraco.Core/Services/FileService.cs +++ b/src/Umbraco.Core/Services/FileService.cs @@ -67,21 +67,6 @@ namespace Umbraco.Core.Services } } - /// - /// Gets a list of all that exist at the relative path specified. - /// - /// - /// If null or not specified, will return the stylesheets at the root path relative to the IFileSystem - /// - /// - public IEnumerable GetStylesheetsAtPath(string rootPath = null) - { - using (var repository = _repositoryFactory.CreateStylesheetRepository(_fileUowProvider.GetUnitOfWork(), _dataUowProvider.GetUnitOfWork())) - { - return repository.GetStylesheetsAtPath(rootPath); - } - } - /// /// Gets a object by its name /// diff --git a/src/Umbraco.Core/Services/IFileService.cs b/src/Umbraco.Core/Services/IFileService.cs index 83ff3e5736..484226ae78 100644 --- a/src/Umbraco.Core/Services/IFileService.cs +++ b/src/Umbraco.Core/Services/IFileService.cs @@ -26,15 +26,6 @@ namespace Umbraco.Core.Services /// /// An enumerable list of objects IEnumerable GetStylesheets(params string[] names); - - /// - /// Gets a list of all that exist at the relative path specified. - /// - /// - /// If null or not specified, will return the stylesheets at the root path relative to the IFileSystem - /// - /// - IEnumerable GetStylesheetsAtPath(string rootPath = null); /// /// Gets a object by its name diff --git a/src/Umbraco.Core/Strings/UrlSegmentProviderResolver.cs b/src/Umbraco.Core/Strings/UrlSegmentProviderResolver.cs index f545cd8b86..745694e178 100644 --- a/src/Umbraco.Core/Strings/UrlSegmentProviderResolver.cs +++ b/src/Umbraco.Core/Strings/UrlSegmentProviderResolver.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; namespace Umbraco.Core.Strings @@ -12,19 +13,23 @@ namespace Umbraco.Core.Strings /// /// Initializes a new instance of the class with an initial list of provider types. /// + /// + /// /// The list of provider types. /// The resolver is created by the WebBootManager and thus the constructor remains internal. - internal UrlSegmentProviderResolver(IEnumerable providerTypes) - : base(providerTypes) + internal UrlSegmentProviderResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable providerTypes) + : base(serviceProvider, logger, providerTypes) { } /// /// Initializes a new instance of the class with an initial list of provider types. /// + /// + /// /// The list of provider types. /// The resolver is created by the WebBootManager and thus the constructor remains internal. - internal UrlSegmentProviderResolver(params Type[] providerTypes) - : base(providerTypes) + internal UrlSegmentProviderResolver(IServiceProvider serviceProvider, ILogger logger, params Type[] providerTypes) + : base(serviceProvider, logger, providerTypes) { } /// diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj index acf6743a7c..2d36719441 100644 --- a/src/Umbraco.Core/Umbraco.Core.csproj +++ b/src/Umbraco.Core/Umbraco.Core.csproj @@ -133,6 +133,7 @@ Properties\SolutionInfo.cs + @@ -314,6 +315,7 @@ + diff --git a/src/Umbraco.Tests/BootManagers/CoreBootManagerTests.cs b/src/Umbraco.Tests/BootManagers/CoreBootManagerTests.cs index a21e15dc38..381f3889b5 100644 --- a/src/Umbraco.Tests/BootManagers/CoreBootManagerTests.cs +++ b/src/Umbraco.Tests/BootManagers/CoreBootManagerTests.cs @@ -3,9 +3,11 @@ using System.Collections.Generic; using System.Linq; using System.Text; using System.Web; +using Moq; using NUnit.Framework; using Umbraco.Core; using Umbraco.Core.Configuration; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Tests.TestHelpers; @@ -63,7 +65,9 @@ namespace Umbraco.Tests.BootManagers protected override void InitializeApplicationEventsResolver() { //create an empty resolver so we can add our own custom ones (don't type find) - ApplicationEventsResolver.Current = new ApplicationEventsResolver(new Type[] + ApplicationEventsResolver.Current = new ApplicationEventsResolver( + new ActivatorServiceProvider(), Mock.Of(), + new Type[] { typeof(LegacyStartupHandler), typeof(TestApplicationEventHandler) diff --git a/src/Umbraco.Tests/CodeFirst/TypeInheritanceTest.cs b/src/Umbraco.Tests/CodeFirst/TypeInheritanceTest.cs index b4854ed6f9..e48e13a385 100644 --- a/src/Umbraco.Tests/CodeFirst/TypeInheritanceTest.cs +++ b/src/Umbraco.Tests/CodeFirst/TypeInheritanceTest.cs @@ -1,9 +1,13 @@ using System; using System.Collections.Generic; using System.Linq; +using Moq; using NUnit.Framework; using Umbraco.Core; +using Umbraco.Core.Cache; +using Umbraco.Core.Logging; using Umbraco.Core.Models; +using Umbraco.Core.Profiling; using Umbraco.Tests.CodeFirst.Attributes; using Umbraco.Tests.CodeFirst.Definitions; using Umbraco.Tests.CodeFirst.TestModels.Composition; @@ -13,17 +17,25 @@ namespace Umbraco.Tests.CodeFirst [TestFixture] public class TypeInheritanceTest { + private PluginManager _pluginManager; + [SetUp] public void Initialize() { - //this ensures its reset - PluginManager.Current = new PluginManager(false); + var logger = new ProfilingLogger(Mock.Of(), Mock.Of()); - //for testing, we'll specify which assemblies are scanned for the PluginTypeResolver - PluginManager.Current.AssembliesToScan = new[] - { - typeof (ContentTypeBase).Assembly - }; + //this ensures its reset + _pluginManager = new PluginManager(new ActivatorServiceProvider(), new NullCacheProvider(), + logger, + false) + { + AssembliesToScan = new[] + { + typeof (ContentTypeBase).Assembly + } + }; + + } [Test] @@ -69,18 +81,13 @@ namespace Umbraco.Tests.CodeFirst [Test] public void Ensure_Only_One_Type_List_Created() { - var foundTypes = PluginManager.Current.ResolveContentTypeBaseTypes(); + var foundTypes = _pluginManager.ResolveContentTypeBaseTypes(); Assert.That(foundTypes.Count(), Is.EqualTo(15)); Assert.AreEqual(1, - PluginManager.Current.GetTypeLists() + _pluginManager.GetTypeLists() .Count(x => x.IsTypeList(PluginManager.TypeResolutionKind.FindAllTypes))); } - [TearDown] - public void TearDown() - { - PluginManager.Current = null; - } } } \ No newline at end of file diff --git a/src/Umbraco.Tests/DistributedCache/DistributedCacheTests.cs b/src/Umbraco.Tests/DistributedCache/DistributedCacheTests.cs index c714cd0a2e..f3942a1716 100644 --- a/src/Umbraco.Tests/DistributedCache/DistributedCacheTests.cs +++ b/src/Umbraco.Tests/DistributedCache/DistributedCacheTests.cs @@ -1,9 +1,13 @@ using System; using System.Collections.Generic; using System.Linq; +using Moq; using NUnit.Framework; using Umbraco.Core; +using Umbraco.Core.Cache; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; +using Umbraco.Core.Profiling; using Umbraco.Core.Sync; using umbraco.interfaces; @@ -22,7 +26,8 @@ namespace Umbraco.Tests.DistributedCache new TestServerRegistrar()); ServerMessengerResolver.Current = new ServerMessengerResolver( new TestServerMessenger()); - CacheRefreshersResolver.Current = new CacheRefreshersResolver(() => new[] { typeof(TestCacheRefresher) }); + CacheRefreshersResolver.Current = new CacheRefreshersResolver( + new ActivatorServiceProvider(), Mock.Of(), () => new[] { typeof(TestCacheRefresher) }); Resolution.Freeze(); } diff --git a/src/Umbraco.Tests/LibraryTests.cs b/src/Umbraco.Tests/LibraryTests.cs index 129b520b2f..dca6215d90 100644 --- a/src/Umbraco.Tests/LibraryTests.cs +++ b/src/Umbraco.Tests/LibraryTests.cs @@ -4,6 +4,7 @@ using System.IO; using System.Linq; using System.Text; using NUnit.Framework; +using Umbraco.Core; using Umbraco.Core.Models; using Umbraco.Core.Configuration; using Umbraco.Core.Models.PublishedContent; @@ -27,7 +28,7 @@ namespace Umbraco.Tests public override void Initialize() { // required so we can access property.Value - PropertyValueConvertersResolver.Current = new PropertyValueConvertersResolver(); + PropertyValueConvertersResolver.Current = new PropertyValueConvertersResolver(new ActivatorServiceProvider(), Logger); base.Initialize(); diff --git a/src/Umbraco.Tests/Macros/MacroEngineFactoryTests.cs b/src/Umbraco.Tests/Macros/MacroEngineFactoryTests.cs index 48f1d01825..da91cd13b5 100644 --- a/src/Umbraco.Tests/Macros/MacroEngineFactoryTests.cs +++ b/src/Umbraco.Tests/Macros/MacroEngineFactoryTests.cs @@ -1,9 +1,13 @@ using System; using System.Collections.Generic; using System.Linq; +using Moq; using NUnit.Framework; using umbraco.cms.businesslogic.macro; using Umbraco.Core; +using Umbraco.Core.Cache; +using Umbraco.Core.Logging; +using Umbraco.Core.Profiling; using umbraco.interfaces; namespace Umbraco.Tests.Macros @@ -14,14 +18,20 @@ namespace Umbraco.Tests.Macros [SetUp] public void Initialize() { + var logger = new ProfilingLogger(Mock.Of(), Mock.Of()); + //this ensures its reset - PluginManager.Current = new PluginManager(false); + PluginManager.Current = new PluginManager(new ActivatorServiceProvider(), new NullCacheProvider(), + logger, + false) + { + AssembliesToScan = new[] + { + this.GetType().Assembly + } + }; //for testing, we'll specify which assemblies are scanned for the PluginTypeResolver - PluginManager.Current.AssembliesToScan = new[] - { - this.GetType().Assembly - }; } [TearDown] diff --git a/src/Umbraco.Tests/MediaFactoryTests.cs b/src/Umbraco.Tests/MediaFactoryTests.cs index c17eb330f3..3dc43d3da3 100644 --- a/src/Umbraco.Tests/MediaFactoryTests.cs +++ b/src/Umbraco.Tests/MediaFactoryTests.cs @@ -1,10 +1,14 @@ using System; using System.Collections.Generic; using System.Linq; +using Moq; using NUnit.Framework; using Umbraco.Core; using umbraco.BusinessLogic; using umbraco.cms.businesslogic.media; +using Umbraco.Core.Cache; +using Umbraco.Core.Logging; +using Umbraco.Core.Profiling; namespace Umbraco.Tests { @@ -14,14 +18,19 @@ namespace Umbraco.Tests [SetUp] public void Initialize() { + var logger = new ProfilingLogger(Mock.Of(), Mock.Of()); //this ensures its reset - PluginManager.Current = new PluginManager(false); + PluginManager.Current = new PluginManager(new ActivatorServiceProvider(), new NullCacheProvider(), + logger, + false) + { + AssembliesToScan = new[] + { + this.GetType().Assembly + } + }; //for testing, we'll specify which assemblies are scanned for the PluginTypeResolver - PluginManager.Current.AssembliesToScan = new[] - { - this.GetType().Assembly - }; } [TearDown] diff --git a/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs b/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs index b7859c5326..a3e6aca822 100644 --- a/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs +++ b/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs @@ -19,7 +19,9 @@ namespace Umbraco.Tests.Migrations [SetUp] public void Initialize() { - MigrationResolver.Current = new MigrationResolver(() => new List + MigrationResolver.Current = new MigrationResolver( + new ActivatorServiceProvider(), Mock.Of(), + () => new List { typeof (AlterUserTableMigrationStub), typeof(Dummy), diff --git a/src/Umbraco.Tests/Migrations/TargetVersionSixthMigrationsTest.cs b/src/Umbraco.Tests/Migrations/TargetVersionSixthMigrationsTest.cs index a3b72cade6..1697110b5d 100644 --- a/src/Umbraco.Tests/Migrations/TargetVersionSixthMigrationsTest.cs +++ b/src/Umbraco.Tests/Migrations/TargetVersionSixthMigrationsTest.cs @@ -32,7 +32,9 @@ namespace Umbraco.Tests.Migrations Path = TestHelper.CurrentAssemblyDirectory; AppDomain.CurrentDomain.SetData("DataDirectory", Path); - MigrationResolver.Current = new MigrationResolver(() => new List + MigrationResolver.Current = new MigrationResolver( + new ActivatorServiceProvider(), ProfilingLogger.Logger, + () => new List { typeof (Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero.RemoveUmbracoAppConstraints), typeof (DeleteAppTables), diff --git a/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs b/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs index afa0158677..ea99b01c32 100644 --- a/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs +++ b/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs @@ -30,7 +30,9 @@ namespace Umbraco.Tests.Migrations.Upgrades Path = TestHelper.CurrentAssemblyDirectory; AppDomain.CurrentDomain.SetData("DataDirectory", Path); - MigrationResolver.Current = new MigrationResolver(() => new List + MigrationResolver.Current = new MigrationResolver( + new ActivatorServiceProvider(), Mock.Of(), + () => new List { typeof (Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero.RemoveUmbracoAppConstraints), typeof (DeleteAppTables), diff --git a/src/Umbraco.Tests/Models/ContentXmlTest.cs b/src/Umbraco.Tests/Models/ContentXmlTest.cs index ac7bae8ce2..f1a42c20b6 100644 --- a/src/Umbraco.Tests/Models/ContentXmlTest.cs +++ b/src/Umbraco.Tests/Models/ContentXmlTest.cs @@ -21,7 +21,10 @@ namespace Umbraco.Tests.Models protected override void FreezeResolution() { - UrlSegmentProviderResolver.Current = new UrlSegmentProviderResolver(typeof(DefaultUrlSegmentProvider)); + UrlSegmentProviderResolver.Current = new UrlSegmentProviderResolver( + new ActivatorServiceProvider(), + Logger, + typeof(DefaultUrlSegmentProvider)); base.FreezeResolution(); } diff --git a/src/Umbraco.Tests/Models/MediaXmlTest.cs b/src/Umbraco.Tests/Models/MediaXmlTest.cs index cc82f7ce88..a5db651115 100644 --- a/src/Umbraco.Tests/Models/MediaXmlTest.cs +++ b/src/Umbraco.Tests/Models/MediaXmlTest.cs @@ -24,7 +24,10 @@ namespace Umbraco.Tests.Models protected override void FreezeResolution() { - UrlSegmentProviderResolver.Current = new UrlSegmentProviderResolver(typeof(DefaultUrlSegmentProvider)); + UrlSegmentProviderResolver.Current = new UrlSegmentProviderResolver( + new ActivatorServiceProvider(), + Logger, + typeof(DefaultUrlSegmentProvider)); base.FreezeResolution(); } diff --git a/src/Umbraco.Tests/Mvc/SurfaceControllerTests.cs b/src/Umbraco.Tests/Mvc/SurfaceControllerTests.cs index f4b2cc5119..b4fd390ac4 100644 --- a/src/Umbraco.Tests/Mvc/SurfaceControllerTests.cs +++ b/src/Umbraco.Tests/Mvc/SurfaceControllerTests.cs @@ -28,7 +28,7 @@ namespace Umbraco.Tests.Mvc appCtx, true); - var ctrl = new TestSurfaceController(Mock.Of(), umbCtx); + var ctrl = new TestSurfaceController(umbCtx); var result = ctrl.Index(); @@ -46,7 +46,7 @@ namespace Umbraco.Tests.Mvc appCtx, true); - var ctrl = new TestSurfaceController(Mock.Of(), umbCtx); + var ctrl = new TestSurfaceController(umbCtx); Assert.IsNotNull(ctrl.UmbracoContext); } @@ -62,7 +62,7 @@ namespace Umbraco.Tests.Mvc appCtx, true); - var ctrl = new TestSurfaceController(Mock.Of(), umbCtx); + var ctrl = new TestSurfaceController(umbCtx); Assert.IsNotNull(ctrl.Umbraco); } @@ -107,7 +107,7 @@ namespace Umbraco.Tests.Mvc using (var uTest = new DisposableUmbracoTest(appCtx)) { - var ctrl = new TestSurfaceController(Mock.Of(), uTest.UmbracoContext); + var ctrl = new TestSurfaceController(uTest.UmbracoContext); var result = ctrl.GetContent(2) as PublishedContentResult; Assert.IsNotNull(result); @@ -117,8 +117,8 @@ namespace Umbraco.Tests.Mvc public class TestSurfaceController : SurfaceController { - public TestSurfaceController(ILogger logger, UmbracoContext umbracoContext) - : base(logger, umbracoContext) + public TestSurfaceController(UmbracoContext umbracoContext) + : base(umbracoContext) { } diff --git a/src/Umbraco.Tests/Plugins/PluginManagerTests.cs b/src/Umbraco.Tests/Plugins/PluginManagerTests.cs index 342e337a57..959fbad11c 100644 --- a/src/Umbraco.Tests/Plugins/PluginManagerTests.cs +++ b/src/Umbraco.Tests/Plugins/PluginManagerTests.cs @@ -11,6 +11,7 @@ using umbraco; using umbraco.businesslogic; using umbraco.cms.businesslogic; using Umbraco.Core; +using Umbraco.Core.Cache; using Umbraco.Core.IO; using Umbraco.Core.Logging; using Umbraco.Core.Profiling; @@ -28,16 +29,17 @@ namespace Umbraco.Tests.Plugins [TestFixture] public class PluginManagerTests { - + private PluginManager _manager; [SetUp] public void Initialize() { //this ensures its reset - PluginManager.Current = new PluginManager(false); + _manager = new PluginManager(new ActivatorServiceProvider(), new NullCacheProvider(), + new ProfilingLogger(Mock.Of(), Mock.Of())); //for testing, we'll specify which assemblies are scanned for the PluginTypeResolver //TODO: Should probably update this so it only searches this assembly and add custom types to be found - PluginManager.Current.AssembliesToScan = new[] + _manager.AssembliesToScan = new[] { this.GetType().Assembly, typeof(ApplicationStartupHandler).Assembly, @@ -62,7 +64,7 @@ namespace Umbraco.Tests.Plugins [TearDown] public void TearDown() { - PluginManager.Current = null; + _manager = null; } private DirectoryInfo PrepareFolder() @@ -158,7 +160,7 @@ namespace Umbraco.Tests.Plugins public void Detect_Legacy_Plugin_File_List() { var tempFolder = IOHelper.MapPath("~/App_Data/TEMP/PluginCache"); - var manager = new PluginManager(false); + var filePath= Path.Combine(tempFolder, string.Format("umbraco-plugins.{0}.list", NetworkHelper.FileSafeMachineName)); File.WriteAllText(filePath, @" @@ -168,7 +170,7 @@ namespace Umbraco.Tests.Plugins "); - Assert.IsTrue(manager.DetectLegacyPluginListFile()); + Assert.IsTrue(_manager.DetectLegacyPluginListFile()); File.Delete(filePath); @@ -180,7 +182,7 @@ namespace Umbraco.Tests.Plugins "); - Assert.IsFalse(manager.DetectLegacyPluginListFile()); + Assert.IsFalse(_manager.DetectLegacyPluginListFile()); } [Test] @@ -188,12 +190,11 @@ namespace Umbraco.Tests.Plugins { var types = new[] { typeof(PluginManager), typeof(PluginManagerTests), typeof(UmbracoContext) }; - var manager = new PluginManager(false); //yes this is silly, none of these types inherit from string, but this is just to test the xml file format - manager.UpdateCachedPluginsFile(types, PluginManager.TypeResolutionKind.FindAllTypes); + _manager.UpdateCachedPluginsFile(types, PluginManager.TypeResolutionKind.FindAllTypes); - var plugins = manager.TryGetCachedPluginsFromFile(PluginManager.TypeResolutionKind.FindAllTypes); - var diffType = manager.TryGetCachedPluginsFromFile(PluginManager.TypeResolutionKind.FindAttributedTypes); + var plugins = _manager.TryGetCachedPluginsFromFile(PluginManager.TypeResolutionKind.FindAllTypes); + var diffType = _manager.TryGetCachedPluginsFromFile(PluginManager.TypeResolutionKind.FindAttributedTypes); Assert.IsTrue(plugins.Success); //this will be false since there is no cache of that type resolution kind @@ -256,80 +257,80 @@ namespace Umbraco.Tests.Plugins [Test] public void Ensure_Only_One_Type_List_Created() { - var foundTypes1 = PluginManager.Current.ResolveFindMeTypes(); - var foundTypes2 = PluginManager.Current.ResolveFindMeTypes(); + var foundTypes1 = _manager.ResolveFindMeTypes(); + var foundTypes2 = _manager.ResolveFindMeTypes(); Assert.AreEqual(1, - PluginManager.Current.GetTypeLists() + _manager.GetTypeLists() .Count(x => x.IsTypeList(PluginManager.TypeResolutionKind.FindAllTypes))); } [Test] public void Resolves_Assigned_Mappers() { - var foundTypes1 = PluginManager.Current.ResolveAssignedMapperTypes(); + var foundTypes1 = _manager.ResolveAssignedMapperTypes(); Assert.AreEqual(23, foundTypes1.Count()); } [Test] public void Resolves_Types() { - var foundTypes1 = PluginManager.Current.ResolveFindMeTypes(); + var foundTypes1 = _manager.ResolveFindMeTypes(); Assert.AreEqual(2, foundTypes1.Count()); } [Test] public void Resolves_Attributed_Trees() { - var trees = PluginManager.Current.ResolveAttributedTrees(); + var trees = _manager.ResolveAttributedTrees(); Assert.AreEqual(19, trees.Count()); } [Test] public void Resolves_Actions() { - var actions = PluginManager.Current.ResolveActions(); + var actions = _manager.ResolveActions(); Assert.AreEqual(36, actions.Count()); } [Test] public void Resolves_Trees() { - var trees = PluginManager.Current.ResolveTrees(); + var trees = _manager.ResolveTrees(); Assert.AreEqual(39, trees.Count()); } [Test] public void Resolves_Applications() { - var apps = PluginManager.Current.ResolveApplications(); + var apps = _manager.ResolveApplications(); Assert.AreEqual(7, apps.Count()); } [Test] public void Resolves_DataTypes() { - var types = PluginManager.Current.ResolveDataTypes(); + var types = _manager.ResolveDataTypes(); Assert.AreEqual(35, types.Count()); } [Test] public void Resolves_RazorDataTypeModels() { - var types = PluginManager.Current.ResolveRazorDataTypeModels(); + var types = _manager.ResolveRazorDataTypeModels(); Assert.AreEqual(2, types.Count()); } [Test] public void Resolves_RestExtensions() { - var types = PluginManager.Current.ResolveRestExtensions(); + var types = _manager.ResolveRestExtensions(); Assert.AreEqual(3, types.Count()); } [Test] public void Resolves_XsltExtensions() { - var types = PluginManager.Current.ResolveXsltExtensions(); + var types = _manager.ResolveXsltExtensions(); Assert.AreEqual(3, types.Count()); } diff --git a/src/Umbraco.Tests/PublishedContent/PublishedContentMoreTests.cs b/src/Umbraco.Tests/PublishedContent/PublishedContentMoreTests.cs index d320c5f844..7c74d093ba 100644 --- a/src/Umbraco.Tests/PublishedContent/PublishedContentMoreTests.cs +++ b/src/Umbraco.Tests/PublishedContent/PublishedContentMoreTests.cs @@ -3,6 +3,7 @@ using System.Collections.ObjectModel; using System.Web.Routing; using NUnit.Framework; using Umbraco.Core; +using Umbraco.Core.Cache; using Umbraco.Core.Models; using Umbraco.Core.Models.PublishedContent; using Umbraco.Core.ObjectResolution; @@ -31,7 +32,7 @@ namespace Umbraco.Tests.PublishedContent // this is so the model factory looks into the test assembly _pluginManager = PluginManager.Current; - PluginManager.Current = new PluginManager(false) + PluginManager.Current = new PluginManager(new ActivatorServiceProvider(), new NullCacheProvider(), ProfilingLogger, false) { AssembliesToScan = _pluginManager.AssembliesToScan .Union(new[] { typeof (PublishedContentMoreTests).Assembly}) @@ -43,7 +44,7 @@ namespace Umbraco.Tests.PublishedContent protected override void FreezeResolution() { PropertyValueConvertersResolver.Current = - new PropertyValueConvertersResolver(); + new PropertyValueConvertersResolver(new ActivatorServiceProvider(), Logger); var types = PluginManager.Current.ResolveTypes(); PublishedContentModelFactoryResolver.Current = new PublishedContentModelFactoryResolver(new PublishedContentModelFactory(types)); diff --git a/src/Umbraco.Tests/PublishedContent/PublishedContentTestBase.cs b/src/Umbraco.Tests/PublishedContent/PublishedContentTestBase.cs index 478335af15..789d9f7218 100644 --- a/src/Umbraco.Tests/PublishedContent/PublishedContentTestBase.cs +++ b/src/Umbraco.Tests/PublishedContent/PublishedContentTestBase.cs @@ -41,6 +41,7 @@ namespace Umbraco.Tests.PublishedContent { if (PropertyValueConvertersResolver.HasCurrent == false) PropertyValueConvertersResolver.Current = new PropertyValueConvertersResolver( + new ActivatorServiceProvider(), Logger, new[] { typeof(DatePickerValueConverter), diff --git a/src/Umbraco.Tests/PublishedContent/PublishedContentTests.cs b/src/Umbraco.Tests/PublishedContent/PublishedContentTests.cs index 343d9359e8..a61dd793b2 100644 --- a/src/Umbraco.Tests/PublishedContent/PublishedContentTests.cs +++ b/src/Umbraco.Tests/PublishedContent/PublishedContentTests.cs @@ -30,7 +30,7 @@ namespace Umbraco.Tests.PublishedContent // this is so the model factory looks into the test assembly _pluginManager = PluginManager.Current; - PluginManager.Current = new PluginManager(false) + PluginManager.Current = new PluginManager(new ActivatorServiceProvider(), CacheHelper.RuntimeCache, ProfilingLogger, false) { AssembliesToScan = _pluginManager.AssembliesToScan .Union(new[] { typeof(PublishedContentTests).Assembly }) diff --git a/src/Umbraco.Tests/Resolvers/ActionsResolverTests.cs b/src/Umbraco.Tests/Resolvers/ActionsResolverTests.cs index 0e57d49154..08049c5480 100644 --- a/src/Umbraco.Tests/Resolvers/ActionsResolverTests.cs +++ b/src/Umbraco.Tests/Resolvers/ActionsResolverTests.cs @@ -1,7 +1,11 @@ using System.Linq; +using Moq; using NUnit.Framework; using Umbraco.Core; +using Umbraco.Core.Cache; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; +using Umbraco.Core.Profiling; using Umbraco.Tests.TestHelpers; using umbraco.BasePages; using umbraco.interfaces; @@ -9,28 +13,13 @@ using umbraco.interfaces; namespace Umbraco.Tests.Resolvers { [TestFixture] - public class ActionsResolverTests - { - [SetUp] - public void Initialize() - { - ActionsResolver.Reset(); - - // this ensures it's reset - PluginManager.Current = new PluginManager(false); - - // for testing, we'll specify which assemblies are scanned for the PluginTypeResolver - PluginManager.Current.AssembliesToScan = new[] - { - this.GetType().Assembly // this assembly only - }; - } - + public class ActionsResolverTests : ResolverBaseTest + { + [TearDown] public void TearDown() { ActionsResolver.Reset(); - PluginManager.Current = null; } // NOTE @@ -42,7 +31,8 @@ namespace Umbraco.Tests.Resolvers public void FindAllActions() { ActionsResolver.Current = new ActionsResolver( - () => PluginManager.Current.ResolveActions()); + new ActivatorServiceProvider(), ProfilingLogger.Logger, + () => PluginManager.ResolveActions()); Resolution.Freeze(); diff --git a/src/Umbraco.Tests/Resolvers/MacroFieldEditorsResolverTests.cs b/src/Umbraco.Tests/Resolvers/MacroFieldEditorsResolverTests.cs index 8f373993c2..b1dfc4c58e 100644 --- a/src/Umbraco.Tests/Resolvers/MacroFieldEditorsResolverTests.cs +++ b/src/Umbraco.Tests/Resolvers/MacroFieldEditorsResolverTests.cs @@ -10,29 +10,13 @@ using umbraco.interfaces; namespace Umbraco.Tests.Resolvers { [TestFixture] - public class MacroFieldEditorsResolverTests + public class MacroFieldEditorsResolverTests : ResolverBaseTest { - [SetUp] - public void Initialize() - { - MacroFieldEditorsResolver.Reset(); - - - // this ensures it's reset - PluginManager.Current = new PluginManager(false); - - // for testing, we'll specify which assemblies are scanned for the PluginTypeResolver - PluginManager.Current.AssembliesToScan = new[] - { - this.GetType().Assembly - }; - } - + [TearDown] public void TearDown() { MacroFieldEditorsResolver.Reset(); - PluginManager.Current = null; } // NOTE @@ -43,7 +27,8 @@ namespace Umbraco.Tests.Resolvers public void FindAllTypes() { MacroFieldEditorsResolver.Current = new MacroFieldEditorsResolver( - () => PluginManager.Current.ResolveMacroRenderings()); + new ActivatorServiceProvider(), ProfilingLogger.Logger, + () => PluginManager.ResolveMacroRenderings()); Resolution.Freeze(); diff --git a/src/Umbraco.Tests/Resolvers/PackageActionsResolverTests.cs b/src/Umbraco.Tests/Resolvers/PackageActionsResolverTests.cs index c034852434..8026f0bd99 100644 --- a/src/Umbraco.Tests/Resolvers/PackageActionsResolverTests.cs +++ b/src/Umbraco.Tests/Resolvers/PackageActionsResolverTests.cs @@ -9,30 +9,14 @@ using umbraco.interfaces; namespace Umbraco.Tests.Resolvers { - [TestFixture] - public class PackageActionsResolverTests - { - [SetUp] - public void Initialize() - { - - PackageActionsResolver.Reset(); - - // ensures it's reset - PluginManager.Current = new PluginManager(false); - - // for testing, we'll specify which assemblies are scanned for the PluginTypeResolver - PluginManager.Current.AssembliesToScan = new[] - { - this.GetType().Assembly // this assembly only - }; - } + [TestFixture] + public class PackageActionsResolverTests : ResolverBaseTest + { [TearDown] public void TearDown() { PackageActionsResolver.Reset(); - PluginManager.Current = null; } // NOTE @@ -43,7 +27,8 @@ namespace Umbraco.Tests.Resolvers public void FindAllPackageActions() { PackageActionsResolver.Current = new PackageActionsResolver( - () => PluginManager.Current.ResolvePackageActions()); + new ActivatorServiceProvider(), ProfilingLogger.Logger, + () => PluginManager.ResolvePackageActions()); Resolution.Freeze(); diff --git a/src/Umbraco.Tests/Resolvers/ResolverBaseTest.cs b/src/Umbraco.Tests/Resolvers/ResolverBaseTest.cs new file mode 100644 index 0000000000..b5fa17f235 --- /dev/null +++ b/src/Umbraco.Tests/Resolvers/ResolverBaseTest.cs @@ -0,0 +1,44 @@ +using System.Collections.Generic; +using System.Reflection; +using Moq; +using NUnit.Framework; +using Umbraco.Core; +using Umbraco.Core.Cache; +using Umbraco.Core.Logging; +using Umbraco.Core.Profiling; + +namespace Umbraco.Tests.Resolvers +{ + public abstract class ResolverBaseTest + { + protected PluginManager PluginManager { get; private set; } + protected ProfilingLogger ProfilingLogger { get; private set; } + + [SetUp] + public void Initialize() + { + + PackageActionsResolver.Reset(); + + ProfilingLogger = new ProfilingLogger(Mock.Of(), Mock.Of()); + + PluginManager = new PluginManager(new ActivatorServiceProvider(), new NullCacheProvider(), + ProfilingLogger, + false) + { + AssembliesToScan = AssembliesToScan + }; + } + + protected virtual IEnumerable AssembliesToScan + { + get + { + return new[] + { + this.GetType().Assembly // this assembly only + }; + } + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Tests/Resolvers/XsltExtensionsResolverTests.cs b/src/Umbraco.Tests/Resolvers/XsltExtensionsResolverTests.cs index c6de3564cc..84bb735578 100644 --- a/src/Umbraco.Tests/Resolvers/XsltExtensionsResolverTests.cs +++ b/src/Umbraco.Tests/Resolvers/XsltExtensionsResolverTests.cs @@ -1,8 +1,12 @@ using System.Linq; +using Moq; using NUnit.Framework; using Umbraco.Core; +using Umbraco.Core.Cache; +using Umbraco.Core.Logging; using Umbraco.Core.Macros; using Umbraco.Core.ObjectResolution; +using Umbraco.Core.Profiling; using Umbraco.Web; using Umbraco.Web.Macros; using umbraco; @@ -10,28 +14,12 @@ using umbraco; namespace Umbraco.Tests.Resolvers { [TestFixture] - public class XsltExtensionsResolverTests + public class XsltExtensionsResolverTests : ResolverBaseTest { - [SetUp] - public void Initialize() - { - ActionsResolver.Reset(); - - // this ensures it's reset - PluginManager.Current = new PluginManager(false); - - // for testing, we'll specify which assemblies are scanned for the PluginTypeResolver - PluginManager.Current.AssembliesToScan = new[] - { - this.GetType().Assembly // this assembly only - }; - } - [TearDown] public void TearDown() { ActionsResolver.Reset(); - PluginManager.Current = null; } // NOTE @@ -43,7 +31,8 @@ namespace Umbraco.Tests.Resolvers public void Find_All_Extensions() { XsltExtensionsResolver.Current = new XsltExtensionsResolver( - () => PluginManager.Current.ResolveXsltExtensions()); + new ActivatorServiceProvider(),ProfilingLogger.Logger, + () => PluginManager.ResolveXsltExtensions()); Resolution.Freeze(); diff --git a/src/Umbraco.Tests/Routing/RenderRouteHandlerTests.cs b/src/Umbraco.Tests/Routing/RenderRouteHandlerTests.cs index 39137ff964..9744f189aa 100644 --- a/src/Umbraco.Tests/Routing/RenderRouteHandlerTests.cs +++ b/src/Umbraco.Tests/Routing/RenderRouteHandlerTests.cs @@ -40,8 +40,10 @@ namespace Umbraco.Tests.Routing DefaultRenderMvcControllerResolver.Current = new DefaultRenderMvcControllerResolver(typeof(RenderMvcController)); SurfaceControllerResolver.Current = new SurfaceControllerResolver( + new ActivatorServiceProvider(), Logger, PluginManager.Current.ResolveSurfaceControllers()); UmbracoApiControllerResolver.Current = new UmbracoApiControllerResolver( + new ActivatorServiceProvider(), Logger, PluginManager.Current.ResolveUmbracoApiControllers()); ShortStringHelperResolver.Current = new ShortStringHelperResolver(new LegacyShortStringHelper()); @@ -158,7 +160,7 @@ namespace Umbraco.Tests.Routing /// public class CustomDocumentController : RenderMvcController { - public CustomDocumentController(ILogger logger, UmbracoContext umbracoContext) : base(logger, umbracoContext) + public CustomDocumentController(UmbracoContext umbracoContext) : base(umbracoContext) { } diff --git a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs index 283fbcfdce..8a5702b8ed 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs @@ -201,16 +201,19 @@ namespace Umbraco.Tests.TestHelpers protected override void FreezeResolution() { PropertyEditorResolver.Current = new PropertyEditorResolver( + new ActivatorServiceProvider(), Logger, () => PluginManager.Current.ResolvePropertyEditors()); DataTypesResolver.Current = new DataTypesResolver( + new ActivatorServiceProvider(), Logger, () => PluginManager.Current.ResolveDataTypes()); MappingResolver.Current = new MappingResolver( + new ActivatorServiceProvider(), Logger, () => PluginManager.Current.ResolveAssignedMapperTypes()); if (PropertyValueConvertersResolver.HasCurrent == false) - PropertyValueConvertersResolver.Current = new PropertyValueConvertersResolver(); + PropertyValueConvertersResolver.Current = new PropertyValueConvertersResolver(new ActivatorServiceProvider(), Logger); if (PublishedContentModelFactoryResolver.HasCurrent == false) PublishedContentModelFactoryResolver.Current = new PublishedContentModelFactoryResolver(); diff --git a/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs b/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs index b1bb7b6a77..63f65adeba 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs @@ -42,20 +42,19 @@ namespace Umbraco.Tests.TestHelpers { base.Initialize(); - using (DisposableTimer.TraceDuration("init", "init")) - { - TestHelper.InitializeContentDirectories(); + TestHelper.InitializeContentDirectories(); - InitializeLegacyMappingsForCoreEditors(); + SetupCacheHelper(); - SetupPluginManager(); + InitializeLegacyMappingsForCoreEditors(); - SetupApplicationContext(); + SetupPluginManager(); - InitializeMappers(); + SetupApplicationContext(); - FreezeResolution(); - } + InitializeMappers(); + + FreezeResolution(); } @@ -64,19 +63,16 @@ namespace Umbraco.Tests.TestHelpers { base.TearDown(); - using (DisposableTimer.TraceDuration("teardown")) - { - LoggerResolver.Reset(); - //reset settings - SettingsForTests.Reset(); - UmbracoContext.Current = null; - TestHelper.CleanContentDirectories(); - TestHelper.CleanUmbracoSettingsConfig(); - //reset the app context, this should reset most things that require resetting like ALL resolvers - ObjectExtensions.DisposeIfDisposable(ApplicationContext.Current); - ApplicationContext.Current = null; - ResetPluginManager(); - } + LoggerResolver.Reset(); + //reset settings + SettingsForTests.Reset(); + UmbracoContext.Current = null; + TestHelper.CleanContentDirectories(); + TestHelper.CleanUmbracoSettingsConfig(); + //reset the app context, this should reset most things that require resetting like ALL resolvers + ObjectExtensions.DisposeIfDisposable(ApplicationContext.Current); + ApplicationContext.Current = null; + ResetPluginManager(); } @@ -142,13 +138,16 @@ namespace Umbraco.Tests.TestHelpers } } + protected virtual void SetupCacheHelper() + { + CacheHelper = CacheHelper.CreateDisabledCacheHelper(); + } + /// /// Inheritors can override this if they wish to create a custom application context /// protected virtual void SetupApplicationContext() { - //disable cache - var cacheHelper = CacheHelper.CreateDisabledCacheHelper(); var sqlSyntax = new SqlCeSyntaxProvider(); var repoFactory = new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), Logger, sqlSyntax, SettingsForTests.GenerateMockSettings()); @@ -158,8 +157,8 @@ namespace Umbraco.Tests.TestHelpers new DatabaseContext(new DefaultDatabaseFactory(Core.Configuration.GlobalSettings.UmbracoConnectionName, Logger), Logger, sqlSyntax, "System.Data.SqlServerCe.4.0"), //assign the service context - new ServiceContext(repoFactory, new PetaPocoUnitOfWorkProvider(Logger), new FileUnitOfWorkProvider(), new PublishingStrategy(), cacheHelper, Logger), - cacheHelper, + new ServiceContext(repoFactory, new PetaPocoUnitOfWorkProvider(Logger), new FileUnitOfWorkProvider(), new PublishingStrategy(), CacheHelper, Logger), + CacheHelper, ProfilingLogger) { IsReady = true @@ -173,19 +172,23 @@ namespace Umbraco.Tests.TestHelpers { if (PluginManager.Current == null || PluginManagerResetRequired) { - PluginManager.Current = new PluginManager(false); - PluginManager.Current.AssembliesToScan = new[] + PluginManager.Current = new PluginManager( + new ActivatorServiceProvider(), + CacheHelper.RuntimeCache, ProfilingLogger, false) { - Assembly.Load("Umbraco.Core"), - Assembly.Load("umbraco"), - Assembly.Load("Umbraco.Tests"), - Assembly.Load("businesslogic"), - Assembly.Load("cms"), - Assembly.Load("controls"), - Assembly.Load("umbraco.editorControls"), - Assembly.Load("umbraco.MacroEngines"), - Assembly.Load("umbraco.providers"), - Assembly.Load("Umbraco.Web.UI"), + AssembliesToScan = new[] + { + Assembly.Load("Umbraco.Core"), + Assembly.Load("umbraco"), + Assembly.Load("Umbraco.Tests"), + Assembly.Load("businesslogic"), + Assembly.Load("cms"), + Assembly.Load("controls"), + Assembly.Load("umbraco.editorControls"), + Assembly.Load("umbraco.MacroEngines"), + Assembly.Load("umbraco.providers"), + Assembly.Load("Umbraco.Web.UI"), + } }; } } @@ -208,5 +211,6 @@ namespace Umbraco.Tests.TestHelpers get { return ProfilingLogger.Logger; } } protected ProfilingLogger ProfilingLogger { get; private set; } + protected CacheHelper CacheHelper { get; private set; } } } \ No newline at end of file diff --git a/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs b/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs index 4cc1b80eb3..b77b915ac7 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs @@ -1,8 +1,12 @@ -using NUnit.Framework; +using Moq; +using NUnit.Framework; using Umbraco.Core; +using Umbraco.Core.Cache; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; using Umbraco.Core.Persistence.Mappers; using Umbraco.Core.Persistence.SqlSyntax; +using Umbraco.Core.Profiling; namespace Umbraco.Tests.TestHelpers { @@ -12,9 +16,13 @@ namespace Umbraco.Tests.TestHelpers [SetUp] public virtual void Initialize() { + var logger = new ProfilingLogger(Mock.Of(), Mock.Of()); SqlSyntaxContext.SqlSyntaxProvider = new SqlCeSyntaxProvider(); - PluginManager.Current = new PluginManager(false); + PluginManager.Current = new PluginManager(new ActivatorServiceProvider(), new NullCacheProvider(), + logger, + false); MappingResolver.Current = new MappingResolver( + new ActivatorServiceProvider(), logger.Logger, () => PluginManager.Current.ResolveAssignedMapperTypes()); Resolution.Freeze(); diff --git a/src/Umbraco.Tests/Umbraco.Tests.csproj b/src/Umbraco.Tests/Umbraco.Tests.csproj index b9fdc56bc2..2526b68705 100644 --- a/src/Umbraco.Tests/Umbraco.Tests.csproj +++ b/src/Umbraco.Tests/Umbraco.Tests.csproj @@ -168,6 +168,7 @@ + diff --git a/src/Umbraco.Web/Editors/StylesheetController.cs b/src/Umbraco.Web/Editors/StylesheetController.cs index d40f6f2290..38318541a4 100644 --- a/src/Umbraco.Web/Editors/StylesheetController.cs +++ b/src/Umbraco.Web/Editors/StylesheetController.cs @@ -28,7 +28,7 @@ namespace Umbraco.Web.Editors { public IEnumerable GetAll() { - return Services.FileService.GetStylesheetsAtPath() + return Services.FileService.GetStylesheets() .Select(x => new Stylesheet() { Name = x.Alias, diff --git a/src/Umbraco.Web/Install/Controllers/InstallApiController.cs b/src/Umbraco.Web/Install/Controllers/InstallApiController.cs index 2ab1fd97ad..cc0851262d 100644 --- a/src/Umbraco.Web/Install/Controllers/InstallApiController.cs +++ b/src/Umbraco.Web/Install/Controllers/InstallApiController.cs @@ -257,7 +257,7 @@ namespace Umbraco.Web.Install.Controllers internal InstallSetupResult ExecuteStep(InstallSetupStep step, JToken instruction) { - using (DisposableTimer.TraceDuration("Executing installation step: " + step.Name, "Step completed")) + using (ApplicationContext.ProfilingLogger.TraceDuration("Executing installation step: " + step.Name, "Step completed")) { var model = instruction == null ? null : instruction.ToObject(step.StepType); var genericStepType = typeof(InstallSetupStep<>); diff --git a/src/Umbraco.Web/Media/ImageUrlProviderResolver.cs b/src/Umbraco.Web/Media/ImageUrlProviderResolver.cs index d11036919b..c52d937d8f 100644 --- a/src/Umbraco.Web/Media/ImageUrlProviderResolver.cs +++ b/src/Umbraco.Web/Media/ImageUrlProviderResolver.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using Umbraco.Core.Logging; using Umbraco.Core.Media; using Umbraco.Core.ObjectResolution; using Umbraco.Web.Media.ImageUrlProviders; @@ -9,12 +10,15 @@ namespace Umbraco.Web.Media { internal sealed class ImageUrlProviderResolver : ManyObjectsResolverBase { - internal ImageUrlProviderResolver(IEnumerable value) : base(value) { } + internal ImageUrlProviderResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable value) + : base(serviceProvider, logger, value) + { + } public IImageUrlProvider GetProvider(string provider) { - return string.IsNullOrEmpty(provider) ? - Values.First(v => v.Name.Equals(ImageUrlProvider.DefaultName, StringComparison.InvariantCultureIgnoreCase)) : + return string.IsNullOrEmpty(provider) ? + Values.First(v => v.Name.Equals(ImageUrlProvider.DefaultName, StringComparison.InvariantCultureIgnoreCase)) : Values.First(v => v.Name.Equals(provider, StringComparison.InvariantCultureIgnoreCase)); } } diff --git a/src/Umbraco.Web/Media/ThumbnailProviders/ThumbnailProvidersResolver.cs b/src/Umbraco.Web/Media/ThumbnailProviders/ThumbnailProvidersResolver.cs index 10e019111b..a27bbe7f8e 100644 --- a/src/Umbraco.Web/Media/ThumbnailProviders/ThumbnailProvidersResolver.cs +++ b/src/Umbraco.Web/Media/ThumbnailProviders/ThumbnailProvidersResolver.cs @@ -4,6 +4,7 @@ using System.Linq; using System.Text; using System.Web; using Umbraco.Core; +using Umbraco.Core.Logging; using Umbraco.Core.Media; using Umbraco.Core.ObjectResolution; using umbraco.BusinessLogic; @@ -13,14 +14,14 @@ namespace Umbraco.Web.Media.ThumbnailProviders { internal sealed class ThumbnailProvidersResolver : ManyObjectsResolverBase { - - - /// - /// Constructor - /// - /// - internal ThumbnailProvidersResolver(IEnumerable providers) - : base(providers) + /// + /// Constructor + /// + /// + /// + /// + internal ThumbnailProvidersResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable providers) + : base(serviceProvider, logger, providers) { } diff --git a/src/Umbraco.Web/Mvc/FilteredControllerFactoriesResolver.cs b/src/Umbraco.Web/Mvc/FilteredControllerFactoriesResolver.cs index e4fadf7c4b..140c7738fa 100644 --- a/src/Umbraco.Web/Mvc/FilteredControllerFactoriesResolver.cs +++ b/src/Umbraco.Web/Mvc/FilteredControllerFactoriesResolver.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; namespace Umbraco.Web.Mvc @@ -9,12 +10,14 @@ namespace Umbraco.Web.Mvc /// public sealed class FilteredControllerFactoriesResolver : ManyObjectsResolverBase { - /// - /// Constructor - /// - /// - internal FilteredControllerFactoriesResolver(IEnumerable factories) - : base(factories) + /// + /// Constructor + /// + /// + /// + /// + internal FilteredControllerFactoriesResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable factories) + : base(serviceProvider, logger, factories) { } diff --git a/src/Umbraco.Web/Mvc/PluginController.cs b/src/Umbraco.Web/Mvc/PluginController.cs index d4aae1e08c..66111875f5 100644 --- a/src/Umbraco.Web/Mvc/PluginController.cs +++ b/src/Umbraco.Web/Mvc/PluginController.cs @@ -8,101 +8,104 @@ using Umbraco.Web.WebApi; namespace Umbraco.Web.Mvc { - /// - /// A base class for all plugin controllers to inherit from - /// - public abstract class PluginController : Controller - { - /// - /// stores the metadata about plugin controllers - /// - private static readonly ConcurrentDictionary MetadataStorage = new ConcurrentDictionary(); + /// + /// A base class for all plugin controllers to inherit from + /// + public abstract class PluginController : Controller + { + /// + /// stores the metadata about plugin controllers + /// + private static readonly ConcurrentDictionary MetadataStorage = new ConcurrentDictionary(); - - protected PluginController(ILogger logger, UmbracoContext umbracoContext) + /// + /// Default constructor + /// + /// + protected PluginController(UmbracoContext umbracoContext) { - if (logger == null) throw new ArgumentNullException("logger"); if (umbracoContext == null) throw new ArgumentNullException("umbracoContext"); - Logger = logger; UmbracoContext = umbracoContext; InstanceId = Guid.NewGuid(); Umbraco = new UmbracoHelper(umbracoContext); } - /// - /// Default constructor - /// - /// - protected PluginController(UmbracoContext umbracoContext) - : this(LoggerResolver.Current.Logger, umbracoContext) - { - } + /// + /// Useful for debugging + /// + internal Guid InstanceId { get; private set; } - /// - /// Useful for debugging - /// - internal Guid InstanceId { get; private set; } - - /// - /// Returns an UmbracoHelper object - /// - public UmbracoHelper Umbraco { get; private set; } + /// + /// Returns an UmbracoHelper object + /// + public UmbracoHelper Umbraco { get; private set; } /// /// Returns an ILogger /// - public ILogger Logger { get; private set; } + public ILogger Logger + { + get { return ProfilingLogger.Logger; } + } - /// - /// Returns the current UmbracoContext - /// - public UmbracoContext UmbracoContext { get; private set; } + /// + /// Returns a ProfilingLogger + /// + public ProfilingLogger ProfilingLogger + { + get { return UmbracoContext.Application.ProfilingLogger; } + } - /// - /// Returns the current ApplicationContext - /// - public ApplicationContext ApplicationContext - { - get { return UmbracoContext.Application; } - } + /// + /// Returns the current UmbracoContext + /// + public UmbracoContext UmbracoContext { get; private set; } - /// - /// Returns a ServiceContext - /// - public ServiceContext Services - { - get { return ApplicationContext.Services; } - } + /// + /// Returns the current ApplicationContext + /// + public ApplicationContext ApplicationContext + { + get { return UmbracoContext.Application; } + } - /// - /// Returns a DatabaseContext - /// - public DatabaseContext DatabaseContext - { - get { return ApplicationContext.DatabaseContext; } - } + /// + /// Returns a ServiceContext + /// + public ServiceContext Services + { + get { return ApplicationContext.Services; } + } - /// - /// Returns the metadata for this instance - /// - internal PluginControllerMetadata Metadata - { - get { return GetMetadata(this.GetType()); } - } + /// + /// Returns a DatabaseContext + /// + public DatabaseContext DatabaseContext + { + get { return ApplicationContext.DatabaseContext; } + } - /// - /// Returns the metadata for a PluginController - /// - /// - /// - internal static PluginControllerMetadata GetMetadata(Type type) - { - - return MetadataStorage.GetOrAdd(type, type1 => - { + /// + /// Returns the metadata for this instance + /// + internal PluginControllerMetadata Metadata + { + get { return GetMetadata(this.GetType()); } + } + + /// + /// Returns the metadata for a PluginController + /// + /// + /// + internal static PluginControllerMetadata GetMetadata(Type type) + { + + return MetadataStorage.GetOrAdd(type, type1 => + { var pluginAttribute = type.GetCustomAttribute(false); //check if any inherited class of this type contains the IsBackOffice attribute - var backOfficeAttribute = type.GetCustomAttribute(true); + var backOfficeAttribute = type.GetCustomAttribute(true); var meta = new PluginControllerMetadata() { @@ -116,8 +119,8 @@ namespace Umbraco.Web.Mvc MetadataStorage.TryAdd(type, meta); return meta; - }); + }); - } - } + } + } } \ No newline at end of file diff --git a/src/Umbraco.Web/Mvc/RenderMvcController.cs b/src/Umbraco.Web/Mvc/RenderMvcController.cs index 8b2658dc84..da3a5d107f 100644 --- a/src/Umbraco.Web/Mvc/RenderMvcController.cs +++ b/src/Umbraco.Web/Mvc/RenderMvcController.cs @@ -25,12 +25,6 @@ namespace Umbraco.Web.Mvc ActionInvoker = new RenderActionInvoker(); } - public RenderMvcController(ILogger logger, UmbracoContext umbracoContext) - : base(logger, umbracoContext) - { - - } - public RenderMvcController(UmbracoContext umbracoContext) : base(umbracoContext) { diff --git a/src/Umbraco.Web/Mvc/SurfaceController.cs b/src/Umbraco.Web/Mvc/SurfaceController.cs index 3dbd49a716..5304821131 100644 --- a/src/Umbraco.Web/Mvc/SurfaceController.cs +++ b/src/Umbraco.Web/Mvc/SurfaceController.cs @@ -17,17 +17,6 @@ namespace Umbraco.Web.Mvc [MergeParentContextViewData] public abstract class SurfaceController : PluginController { - /// - /// Default constructor - /// - /// - /// - protected SurfaceController(ILogger logger, UmbracoContext umbracoContext) - : base(logger, umbracoContext) - { - _membershipHelper = new MembershipHelper(umbracoContext); - } - /// /// Default constructor /// @@ -106,7 +95,7 @@ namespace Umbraco.Web.Mvc /// protected UmbracoPageResult CurrentUmbracoPage() { - return new UmbracoPageResult(); + return new UmbracoPageResult(ApplicationContext.ProfilingLogger); } /// diff --git a/src/Umbraco.Web/Mvc/SurfaceControllerResolver.cs b/src/Umbraco.Web/Mvc/SurfaceControllerResolver.cs index c3e6b92375..69683261bc 100644 --- a/src/Umbraco.Web/Mvc/SurfaceControllerResolver.cs +++ b/src/Umbraco.Web/Mvc/SurfaceControllerResolver.cs @@ -8,8 +8,8 @@ namespace Umbraco.Web.Mvc { internal sealed class SurfaceControllerResolver : ManyObjectsResolverBase { - public SurfaceControllerResolver(IEnumerable surfaceControllers) - : base(surfaceControllers) + public SurfaceControllerResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable surfaceControllers) + : base(serviceProvider, logger, surfaceControllers) { } diff --git a/src/Umbraco.Web/Mvc/UmbracoController.cs b/src/Umbraco.Web/Mvc/UmbracoController.cs index c1dabe4477..413680522d 100644 --- a/src/Umbraco.Web/Mvc/UmbracoController.cs +++ b/src/Umbraco.Web/Mvc/UmbracoController.cs @@ -12,17 +12,10 @@ namespace Umbraco.Web.Mvc /// public abstract class UmbracoController : Controller { - protected UmbracoController(ILogger logger, UmbracoContext umbracoContext) - { - if (logger == null) throw new ArgumentNullException("logger"); - if (umbracoContext == null) throw new ArgumentNullException("umbracoContext"); - Logger = logger; - UmbracoContext = umbracoContext; - } - protected UmbracoController(UmbracoContext umbracoContext) - : this(LoggerResolver.Current.Logger, umbracoContext) - { + { + if (umbracoContext == null) throw new ArgumentNullException("umbracoContext"); + UmbracoContext = umbracoContext; } protected UmbracoController() @@ -44,7 +37,18 @@ namespace Umbraco.Web.Mvc /// /// Returns an ILogger /// - public ILogger Logger { get; private set; } + public ILogger Logger + { + get { return ProfilingLogger.Logger; } + } + + /// + /// Returns a ProfilingLogger + /// + public ProfilingLogger ProfilingLogger + { + get { return UmbracoContext.Application.ProfilingLogger; } + } /// /// Returns the current UmbracoContext diff --git a/src/Umbraco.Web/Mvc/UmbracoPageResult.cs b/src/Umbraco.Web/Mvc/UmbracoPageResult.cs index ac981d1512..1c12e7e498 100644 --- a/src/Umbraco.Web/Mvc/UmbracoPageResult.cs +++ b/src/Umbraco.Web/Mvc/UmbracoPageResult.cs @@ -4,6 +4,8 @@ using System.Web; using System.Web.Mvc; using System.Web.Routing; using Umbraco.Core; +using Umbraco.Core.Logging; +using Umbraco.Core.Profiling; namespace Umbraco.Web.Mvc { @@ -12,7 +14,21 @@ namespace Umbraco.Web.Mvc /// public class UmbracoPageResult : ActionResult { - public override void ExecuteResult(ControllerContext context) + private readonly ProfilingLogger _profilingLogger; + + public UmbracoPageResult(ProfilingLogger profilingLogger) + { + _profilingLogger = profilingLogger; + } + + [Obsolete("Use the ctor specifying all depenendencies instead")] + public UmbracoPageResult() + : this(new ProfilingLogger(LoggerResolver.Current.Logger, ProfilerResolver.Current.Profiler)) + { + + } + + public override void ExecuteResult(ControllerContext context) { ResetRouteData(context.RouteData); @@ -52,9 +68,9 @@ namespace Umbraco.Web.Mvc /// /// Executes the controller action /// - private static void ExecuteControllerAction(ControllerContext context, IController controller) + private void ExecuteControllerAction(ControllerContext context, IController controller) { - using (DisposableTimer.TraceDuration("Executing Umbraco RouteDefinition controller", "Finished")) + using (_profilingLogger.TraceDuration("Executing Umbraco RouteDefinition controller", "Finished")) { controller.Execute(context.RequestContext); } @@ -75,7 +91,7 @@ namespace Umbraco.Web.Mvc /// private static void ValidateRouteData(RouteData routeData) { - if (!routeData.DataTokens.ContainsKey("umbraco-route-def")) + if (routeData.DataTokens.ContainsKey("umbraco-route-def") == false) { throw new InvalidOperationException("Can only use " + typeof(UmbracoPageResult).Name + " in the context of an Http POST when using a SurfaceController form"); diff --git a/src/Umbraco.Web/Routing/ContentFinderResolver.cs b/src/Umbraco.Web/Routing/ContentFinderResolver.cs index 78dcbda899..b069f86315 100644 --- a/src/Umbraco.Web/Routing/ContentFinderResolver.cs +++ b/src/Umbraco.Web/Routing/ContentFinderResolver.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; namespace Umbraco.Web.Routing @@ -9,22 +10,26 @@ namespace Umbraco.Web.Routing /// public sealed class ContentFinderResolver : ManyObjectsResolverBase { - /// - /// Initializes a new instance of the class with an initial list of finder types. - /// - /// The list of finder types - /// The resolver is created by the WebBootManager and thus the constructor remains internal. - internal ContentFinderResolver(IEnumerable finders) - : base(finders) + /// + /// Initializes a new instance of the class with an initial list of finder types. + /// + /// + /// + /// The list of finder types + /// The resolver is created by the WebBootManager and thus the constructor remains internal. + internal ContentFinderResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable finders) + : base(serviceProvider, logger, finders) { } - /// - /// Initializes a new instance of the class with an initial list of finder types. - /// - /// The list of finder types - /// The resolver is created by the WebBootManager and thus the constructor remains internal. - internal ContentFinderResolver(params Type[] finders) - : base(finders) + /// + /// Initializes a new instance of the class with an initial list of finder types. + /// + /// + /// The list of finder types + /// + /// The resolver is created by the WebBootManager and thus the constructor remains internal. + internal ContentFinderResolver(IServiceProvider serviceProvider, ILogger logger, params Type[] finders) + : base(serviceProvider, logger, finders) { } /// diff --git a/src/Umbraco.Web/Routing/UrlProviderResolver.cs b/src/Umbraco.Web/Routing/UrlProviderResolver.cs index 0cd0346cd9..505e3ff52a 100644 --- a/src/Umbraco.Web/Routing/UrlProviderResolver.cs +++ b/src/Umbraco.Web/Routing/UrlProviderResolver.cs @@ -2,8 +2,8 @@ using System.Collections.Generic; using System.Linq; using System.Text; - -using Umbraco.Core.ObjectResolution; +using Umbraco.Core.Logging; +using Umbraco.Core.ObjectResolution; namespace Umbraco.Web.Routing { @@ -15,19 +15,23 @@ namespace Umbraco.Web.Routing /// /// Initializes a new instance of the class with an initial list of provider types. /// + /// /// The list of provider types. + /// /// The resolver is created by the WebBootManager and thus the constructor remains internal. - internal UrlProviderResolver(IEnumerable providerTypes) - : base(providerTypes) + internal UrlProviderResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable providerTypes) + : base(serviceProvider, logger, providerTypes) { } /// /// Initializes a new instance of the class with an initial list of provider types. /// + /// /// The list of provider types. + /// /// The resolver is created by the WebBootManager and thus the constructor remains internal. - internal UrlProviderResolver(params Type[] providerTypes) - : base(providerTypes) + internal UrlProviderResolver(IServiceProvider serviceProvider, ILogger logger, params Type[] providerTypes) + : base(serviceProvider, logger, providerTypes) { } /// diff --git a/src/Umbraco.Web/Standalone/StandaloneBootManager.cs b/src/Umbraco.Web/Standalone/StandaloneBootManager.cs index 2e8d23dd1d..b06135d522 100644 --- a/src/Umbraco.Web/Standalone/StandaloneBootManager.cs +++ b/src/Umbraco.Web/Standalone/StandaloneBootManager.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Linq; using System.Text; using Umbraco.Core; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; using Umbraco.Web.PublishedCache; using Umbraco.Web.Routing; @@ -61,11 +62,12 @@ namespace Umbraco.Web.Standalone PublishedCachesResolver.Current = new PublishedCachesResolver(caches); - UrlProviderResolver.Current = new UrlProviderResolver(typeof (DefaultUrlProvider)); + UrlProviderResolver.Current = new UrlProviderResolver(ServiceProvider, LoggerResolver.Current.Logger, typeof(DefaultUrlProvider)); SiteDomainHelperResolver.Current = new SiteDomainHelperResolver(new SiteDomainHelper()); ContentLastChanceFinderResolver.Current = new ContentLastChanceFinderResolver(); ContentFinderResolver.Current = new ContentFinderResolver( + ServiceProvider, LoggerResolver.Current.Logger, typeof (ContentFinderByPageIdQuery), typeof (ContentFinderByNiceUrl), typeof (ContentFinderByIdPath), diff --git a/src/Umbraco.Web/UI/Controls/UmbracoControl.cs b/src/Umbraco.Web/UI/Controls/UmbracoControl.cs index eb1546525a..4d8bd4ce69 100644 --- a/src/Umbraco.Web/UI/Controls/UmbracoControl.cs +++ b/src/Umbraco.Web/UI/Controls/UmbracoControl.cs @@ -17,21 +17,13 @@ namespace Umbraco.Web.UI.Controls public abstract class UmbracoControl : Control { - protected UmbracoControl(UmbracoContext umbracoContext) - : this(LoggerResolver.Current.Logger, umbracoContext) - { - } - /// /// Default constructor /// - /// /// - protected UmbracoControl(ILogger logger, UmbracoContext umbracoContext) + protected UmbracoControl(UmbracoContext umbracoContext) { - if (logger == null) throw new ArgumentNullException("logger"); if (umbracoContext == null) throw new ArgumentNullException("umbracoContext"); - Logger = logger; UmbracoContext = umbracoContext; Umbraco = new UmbracoHelper(umbracoContext); } @@ -49,7 +41,22 @@ namespace Umbraco.Web.UI.Controls /// public UmbracoHelper Umbraco { get; private set; } - public ILogger Logger { get; private set; } + /// + /// Returns an ILogger + /// + public ILogger Logger + { + get { return ProfilingLogger.Logger; } + } + + /// + /// Returns a ProfilingLogger + /// + public ProfilingLogger ProfilingLogger + { + get { return UmbracoContext.Application.ProfilingLogger; } + } + public UmbracoContext UmbracoContext { get; private set; } protected ApplicationContext ApplicationContext diff --git a/src/Umbraco.Web/UI/Controls/UmbracoUserControl.cs b/src/Umbraco.Web/UI/Controls/UmbracoUserControl.cs index d6cb44338b..b60c519dd4 100644 --- a/src/Umbraco.Web/UI/Controls/UmbracoUserControl.cs +++ b/src/Umbraco.Web/UI/Controls/UmbracoUserControl.cs @@ -16,21 +16,13 @@ namespace Umbraco.Web.UI.Controls /// public abstract class UmbracoUserControl : UserControl { - protected UmbracoUserControl(UmbracoContext umbracoContext) - : this(LoggerResolver.Current.Logger, umbracoContext) - { - } - /// /// Default constructor /// - /// /// - protected UmbracoUserControl(ILogger logger, UmbracoContext umbracoContext) + protected UmbracoUserControl(UmbracoContext umbracoContext) { - if (logger == null) throw new ArgumentNullException("logger"); if (umbracoContext == null) throw new ArgumentNullException("umbracoContext"); - Logger = logger; UmbracoContext = umbracoContext; InstanceId = Guid.NewGuid(); Umbraco = new UmbracoHelper(umbracoContext); @@ -73,7 +65,21 @@ namespace Umbraco.Web.UI.Controls get { return UmbracoContext.Security; } } - public ILogger Logger { get; private set; } + /// + /// Returns an ILogger + /// + public ILogger Logger + { + get { return ProfilingLogger.Logger; } + } + + /// + /// Returns a ProfilingLogger + /// + public ProfilingLogger ProfilingLogger + { + get { return UmbracoContext.Application.ProfilingLogger; } + } /// /// Returns the current UmbracoContext diff --git a/src/Umbraco.Web/UI/Pages/BasePage.cs b/src/Umbraco.Web/UI/Pages/BasePage.cs index 0119cd7fdb..b9eec4982b 100644 --- a/src/Umbraco.Web/UI/Pages/BasePage.cs +++ b/src/Umbraco.Web/UI/Pages/BasePage.cs @@ -9,6 +9,7 @@ using Umbraco.Core; using Umbraco.Core.Configuration; using Umbraco.Core.IO; using Umbraco.Core.Logging; +using Umbraco.Core.Profiling; using Umbraco.Core.Services; using Umbraco.Web.Security; using umbraco.BusinessLogic; @@ -28,8 +29,6 @@ namespace Umbraco.Web.UI.Pages private ClientTools _clientTools; - - //We won't expose this... people should be using the DatabaseContext for custom queries if they need them. @@ -42,12 +41,25 @@ namespace Umbraco.Web.UI.Pages // get { return global::umbraco.BusinessLogic.Application.SqlHelper; } //} - private ILogger _logger; + /// + /// Returns an ILogger + /// public ILogger Logger { - get { return _logger ?? (_logger = LoggerResolver.Current.Logger); } + get { return ProfilingLogger.Logger; } } + /// + /// Returns a ProfilingLogger + /// + public ProfilingLogger ProfilingLogger + { + get { return _logger ?? (_logger = new ProfilingLogger(LoggerResolver.Current.Logger, ProfilerResolver.Current.Profiler)); } + } + + private ProfilingLogger _logger; + + private UrlHelper _url; /// /// Returns a UrlHelper diff --git a/src/Umbraco.Web/WebApi/UmbracoApiController.cs b/src/Umbraco.Web/WebApi/UmbracoApiController.cs index 05e390816d..9b1a37f4f7 100644 --- a/src/Umbraco.Web/WebApi/UmbracoApiController.cs +++ b/src/Umbraco.Web/WebApi/UmbracoApiController.cs @@ -22,23 +22,15 @@ namespace Umbraco.Web.WebApi } - protected UmbracoApiController(ILogger logger, UmbracoContext umbracoContext) + protected UmbracoApiController(UmbracoContext umbracoContext) { - if (logger == null) throw new ArgumentNullException("logger"); if (umbracoContext == null) throw new ArgumentNullException("umbracoContext"); UmbracoContext = umbracoContext; InstanceId = Guid.NewGuid(); Umbraco = new UmbracoHelper(umbracoContext); - Logger = logger; _membershipHelper = new MembershipHelper(UmbracoContext); } - protected UmbracoApiController(UmbracoContext umbracoContext) - : this(LoggerResolver.Current.Logger, umbracoContext) - { - - } - private readonly MembershipHelper _membershipHelper; /// @@ -50,7 +42,21 @@ namespace Umbraco.Web.WebApi return Request.TryGetHttpContext(); } - public ILogger Logger { get; private set; } + /// + /// Returns an ILogger + /// + public ILogger Logger + { + get { return ProfilingLogger.Logger; } + } + + /// + /// Returns a ProfilingLogger + /// + public ProfilingLogger ProfilingLogger + { + get { return UmbracoContext.Application.ProfilingLogger; } + } /// /// Returns the current ApplicationContext diff --git a/src/Umbraco.Web/WebApi/UmbracoApiControllerResolver.cs b/src/Umbraco.Web/WebApi/UmbracoApiControllerResolver.cs index 1d4d48d4f6..cea26b8de7 100644 --- a/src/Umbraco.Web/WebApi/UmbracoApiControllerResolver.cs +++ b/src/Umbraco.Web/WebApi/UmbracoApiControllerResolver.cs @@ -1,13 +1,14 @@ using System; using System.Collections.Generic; +using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; namespace Umbraco.Web.WebApi { internal sealed class UmbracoApiControllerResolver : ManyObjectsResolverBase { - public UmbracoApiControllerResolver(IEnumerable apiControllers) - : base(apiControllers) + public UmbracoApiControllerResolver(IServiceProvider serviceProvider, ILogger logger, IEnumerable apiControllers) + : base(serviceProvider, logger, apiControllers) { } diff --git a/src/Umbraco.Web/WebBootManager.cs b/src/Umbraco.Web/WebBootManager.cs index 5d7874758f..4a7b78c683 100644 --- a/src/Umbraco.Web/WebBootManager.cs +++ b/src/Umbraco.Web/WebBootManager.cs @@ -315,7 +315,7 @@ namespace Umbraco.Web { base.InitializeResolvers(); - XsltExtensionsResolver.Current = new XsltExtensionsResolver(() => PluginManager.Current.ResolveXsltExtensions()); + XsltExtensionsResolver.Current = new XsltExtensionsResolver(ServiceProvider, LoggerResolver.Current.Logger, () => PluginManager.Current.ResolveXsltExtensions()); //set the default RenderMvcController DefaultRenderMvcControllerResolver.Current = new DefaultRenderMvcControllerResolver(typeof(RenderMvcController)); @@ -343,9 +343,11 @@ namespace Umbraco.Web })); SurfaceControllerResolver.Current = new SurfaceControllerResolver( + ServiceProvider, LoggerResolver.Current.Logger, PluginManager.Current.ResolveSurfaceControllers()); UmbracoApiControllerResolver.Current = new UmbracoApiControllerResolver( + ServiceProvider, LoggerResolver.Current.Logger, PluginManager.Current.ResolveUmbracoApiControllers()); // both TinyMceValueConverter (in Core) and RteMacroRenderingValueConverter (in Web) will be @@ -366,6 +368,7 @@ namespace Umbraco.Web new NamespaceHttpControllerSelector(GlobalConfiguration.Configuration)); FilteredControllerFactoriesResolver.Current = new FilteredControllerFactoriesResolver( + ServiceProvider, LoggerResolver.Current.Logger, // add all known factories, devs can then modify this list on application // startup either by binding to events or in their own global.asax new[] @@ -374,6 +377,7 @@ namespace Umbraco.Web }); UrlProviderResolver.Current = new UrlProviderResolver( + ServiceProvider, LoggerResolver.Current.Logger, //typeof(AliasUrlProvider), // not enabled by default typeof(DefaultUrlProvider), typeof(CustomRouteUrlProvider) @@ -388,6 +392,7 @@ namespace Umbraco.Web new ContentLastChanceFinderByNotFoundHandlers()); ContentFinderResolver.Current = new ContentFinderResolver( + ServiceProvider, LoggerResolver.Current.Logger, // all built-in finders in the correct order, devs can then modify this list // on application startup via an application event handler. typeof(ContentFinderByPageIdQuery), @@ -411,9 +416,11 @@ namespace Umbraco.Web PublishedCache.XmlPublishedCache.PublishedContentCache.UnitTesting = _isForTesting; ThumbnailProvidersResolver.Current = new ThumbnailProvidersResolver( + ServiceProvider, LoggerResolver.Current.Logger, PluginManager.Current.ResolveThumbnailProviders()); ImageUrlProviderResolver.Current = new ImageUrlProviderResolver( + ServiceProvider, LoggerResolver.Current.Logger, PluginManager.Current.ResolveImageUrlProviders()); CultureDictionaryFactoryResolver.Current = new CultureDictionaryFactoryResolver( diff --git a/src/Umbraco.Web/WebServices/UmbracoHttpHandler.cs b/src/Umbraco.Web/WebServices/UmbracoHttpHandler.cs index 964606dbd9..d50f28b350 100644 --- a/src/Umbraco.Web/WebServices/UmbracoHttpHandler.cs +++ b/src/Umbraco.Web/WebServices/UmbracoHttpHandler.cs @@ -21,16 +21,8 @@ namespace Umbraco.Web.WebServices } protected UmbracoHttpHandler(UmbracoContext umbracoContext) - : this(LoggerResolver.Current.Logger, umbracoContext) { - } - - - protected UmbracoHttpHandler(ILogger logger, UmbracoContext umbracoContext) - { - if (logger == null) throw new ArgumentNullException("logger"); if (umbracoContext == null) throw new ArgumentNullException("umbracoContext"); - Logger = logger; UmbracoContext = umbracoContext; Umbraco = new UmbracoHelper(umbracoContext); } @@ -43,7 +35,21 @@ namespace Umbraco.Web.WebServices get { return UmbracoContext.Application; } } - public ILogger Logger { get; private set; } + /// + /// Returns an ILogger + /// + public ILogger Logger + { + get { return ProfilingLogger.Logger; } + } + + /// + /// Returns a ProfilingLogger + /// + public ProfilingLogger ProfilingLogger + { + get { return UmbracoContext.Application.ProfilingLogger; } + } /// /// Returns the current UmbracoContext diff --git a/src/Umbraco.Web/WebServices/UmbracoWebService.cs b/src/Umbraco.Web/WebServices/UmbracoWebService.cs index 42743f6911..e92e85de1e 100644 --- a/src/Umbraco.Web/WebServices/UmbracoWebService.cs +++ b/src/Umbraco.Web/WebServices/UmbracoWebService.cs @@ -22,15 +22,8 @@ namespace Umbraco.Web.WebServices } protected UmbracoWebService(UmbracoContext umbracoContext) - : this(LoggerResolver.Current.Logger, umbracoContext) { - } - - protected UmbracoWebService(ILogger logger, UmbracoContext umbracoContext) - { - if (logger == null) throw new ArgumentNullException("logger"); if (umbracoContext == null) throw new ArgumentNullException("umbracoContext"); - Logger = logger; UmbracoContext = umbracoContext; Umbraco = new UmbracoHelper(umbracoContext); } @@ -43,7 +36,21 @@ namespace Umbraco.Web.WebServices get { return UmbracoContext.Application; } } - public ILogger Logger { get; private set; } + /// + /// Returns an ILogger + /// + public ILogger Logger + { + get { return ProfilingLogger.Logger; } + } + + /// + /// Returns a ProfilingLogger + /// + public ProfilingLogger ProfilingLogger + { + get { return UmbracoContext.Application.ProfilingLogger; } + } /// /// Returns the current UmbracoContext diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/loadStylesheets.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/loadStylesheets.cs index d51c8ddc95..7cd2bf9d90 100644 --- a/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/loadStylesheets.cs +++ b/src/Umbraco.Web/umbraco.presentation/umbraco/Trees/loadStylesheets.cs @@ -62,7 +62,7 @@ namespace umbraco public override void Render(ref XmlTree tree) { - foreach (var sheet in Services.FileService.GetStylesheetsAtPath()) + foreach (var sheet in Services.FileService.GetStylesheets()) { var xNode = XmlTreeNode.Create(this); xNode.NodeID = sheet.Alias; diff --git a/src/umbraco.cms/Actions/Action.cs b/src/umbraco.cms/Actions/Action.cs index 075cd84436..d3bea5941e 100644 --- a/src/umbraco.cms/Actions/Action.cs +++ b/src/umbraco.cms/Actions/Action.cs @@ -42,15 +42,15 @@ namespace umbraco.BusinessLogic.Actions ReRegisterActionsAndHandlers(); } - /// - /// This is used when an IAction or IActionHandler is installed into the system - /// and needs to be loaded into memory. - /// - /// - /// TODO: this shouldn't be needed... we should restart the app pool when a package is installed! - /// - public static void ReRegisterActionsAndHandlers() - { + /// + /// This is used when an IAction or IActionHandler is installed into the system + /// and needs to be loaded into memory. + /// + /// + /// TODO: this shouldn't be needed... we should restart the app pool when a package is installed! + /// + public static void ReRegisterActionsAndHandlers() + { lock (Lock) { // NOTE use the DirtyBackdoor to change the resolution configuration EXCLUSIVELY @@ -58,6 +58,7 @@ namespace umbraco.BusinessLogic.Actions // the whole resolution system is locked => nothing can work properly => deadlocks var newResolver = new ActionsResolver( + new ActivatorServiceProvider(), LoggerResolver.Current.Logger, () => TypeFinder.FindClassesOfType(PluginManager.Current.AssembliesToScan)); using (Umbraco.Core.ObjectResolution.Resolution.DirtyBackdoorToConfiguration) @@ -67,7 +68,7 @@ namespace umbraco.BusinessLogic.Actions } } - } + } /// /// Jacascript for the contextmenu @@ -86,10 +87,10 @@ namespace umbraco.BusinessLogic.Actions /// public static List GetJavaScriptFileReferences() { - return ActionsResolver.Current.Actions - .Where(x => !string.IsNullOrWhiteSpace(x.JsSource)) - .Select(x => x.JsSource).ToList(); - //return ActionJsReference; + return ActionsResolver.Current.Actions + .Where(x => !string.IsNullOrWhiteSpace(x.JsSource)) + .Select(x => x.JsSource).ToList(); + //return ActionJsReference; } /// @@ -106,7 +107,7 @@ namespace umbraco.BusinessLogic.Actions { string _actionJsList = ""; - foreach (IAction action in ActionsResolver.Current.Actions) + foreach (IAction action in ActionsResolver.Current.Actions) { // Adding try/catch so this rutine doesn't fail if one of the actions fail // Add to language JsList @@ -124,7 +125,7 @@ namespace umbraco.BusinessLogic.Actions } catch (Exception ee) { - LogHelper.Error("Error registrering action to javascript", ee); + LogHelper.Error("Error registrering action to javascript", ee); } } @@ -143,10 +144,10 @@ namespace umbraco.BusinessLogic.Actions /// /// /// An arraylist containing all javascript variables for the contextmenu in the tree - [Obsolete("Use ActionsResolver.Current.Actions instead")] + [Obsolete("Use ActionsResolver.Current.Actions instead")] public static ArrayList GetAll() { - return new ArrayList(ActionsResolver.Current.Actions.ToList()); + return new ArrayList(ActionsResolver.Current.Actions.ToList()); } /// @@ -160,7 +161,7 @@ namespace umbraco.BusinessLogic.Actions List list = new List(); foreach (char c in actions.ToCharArray()) { - IAction action = ActionsResolver.Current.Actions.ToList().Find( + IAction action = ActionsResolver.Current.Actions.ToList().Find( delegate(IAction a) { return a.Letter == c; @@ -188,7 +189,7 @@ namespace umbraco.BusinessLogic.Actions /// public static List GetPermissionAssignable() { - return ActionsResolver.Current.Actions.ToList().FindAll( + return ActionsResolver.Current.Actions.ToList().FindAll( delegate(IAction a) { return (a.CanBePermissionAssigned);