Added profiling implementation

Src/Commons.InversionOfControl.Ninject/BoC.InversionOfControl.Ninject.csproj

@@ -18,15 +18,15 @@
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
+    <OutputPath>..\..\build\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
+    <OutputPath>..\..\build\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>

Src/Commons.InversionOfControl.Unity/BoC.InversionOfControl.Unity.nuspec

@@ -13,7 +13,7 @@
     <copyright>Copyright 2014</copyright>
     <tags>BoC,InversionOfControl,Unity</tags>
     <dependencies>
-      <dependency id="BoC" version="2.2.2" />
+      <dependency id="BoC" version="2.3.0" />
       <dependency id="Unity" version="3.5.1404" />
     </dependencies>
   </metadata>

Src/Commons.InversionOfControl.Unity/UnityDependencyResolver.cs

@@ -4,6 +4,7 @@
 using System.Configuration;
 using System.Linq;
 using BoC.Helpers;
+using BoC.Profiling;
 using Microsoft.Practices.Unity;
 using Microsoft.Practices.Unity.Configuration;
 
@@ -44,67 +45,79 @@ public void RegisterInstance<T>(T instance)
 
         public virtual void RegisterSingleton(Type from, Type to)
         {
-            _container.RegisterType(from, to, new ContainerControlledLifetimeManager());
+            using (Profiler.StartContext("UnityDependencyResolver.RegisterSingleton({0},{1})", from, to))
+                _container.RegisterType(from, to, new ContainerControlledLifetimeManager());
         }
 
         public void RegisterType<TFrom, TTo>(LifetimeScope scope = LifetimeScope.Transient) where TTo : TFrom
         {
-            _container.RegisterType<TFrom, TTo>(GetLifetimeManager(scope));
+            using (Profiler.StartContext("UnityDependencyResolver.RegisterSingleton<{0},{1}>({2})", typeof(TFrom), typeof(TTo), scope))
+                _container.RegisterType<TFrom, TTo>(GetLifetimeManager(scope));
         }
 
         public void RegisterFactory<TFrom>(Func<TFrom> factory)
         {
-            _container.RegisterType<TFrom>(new InjectionFactory(c => factory()));
+            using (Profiler.StartContext("UnityDependencyResolver.RegisterFactory<{0}>()", typeof(TFrom)))
+                _container.RegisterType<TFrom>(new InjectionFactory(c => factory()));
         }
 
         public IDependencyResolver CreateChildResolver()
         {
-            return new UnityDependencyResolver(_container.CreateChildContainer());
+            using (Profiler.StartContext("UnityDependencyResolver.CreateChildResolver()"))
+                return new UnityDependencyResolver(_container.CreateChildContainer());
         }
 
         public void RegisterFactory(Type from, Func<object> factory)
         {
-            _container.RegisterType(from, new InjectionFactory(c => factory()));
+            using (Profiler.StartContext("UnityDependencyResolver.RegisterFactory({0})", from))
+                _container.RegisterType(from, new InjectionFactory(c => factory()));
         }
 
         public virtual void RegisterType(Type from, Type to, LifetimeScope scope = LifetimeScope.Transient)
         {
             Check.Argument.IsNotNull(from, "from");
             Check.Argument.IsNotNull(to, "to");
 
-            _container.RegisterType(from, to, GetLifetimeManager(scope));
+            using (Profiler.StartContext("UnityDependencyResolver.RegisterType({0},{1},{2})", from, to,scope))
+                _container.RegisterType(from, to, GetLifetimeManager(scope));
         }
 
         public object Resolve(Type type)
         {
             Check.Argument.IsNotNull(type, "type");
-            if (_container.Configure<TypeTrackingExtension>().CanResolve(type))
+            using (Profiler.StartContext("UnityDependencyResolver.Resolve({0})", type))
             {
-                return _container.Resolve(type);
-            }
-            else
-            {
-                return null;
+                if (_container.Configure<TypeTrackingExtension>().CanResolve(type))
+                {
+                    return _container.Resolve(type);
+                }
+                else
+                {
+                    return null;
+                }
             }
         }
 
         public object Resolve(Type type, string name)
         {
             Check.Argument.IsNotNull(type, "type");
-            if (Container.Configure<TypeTrackingExtension>().CanResolve(type, name))
+            using (Profiler.StartContext("UnityDependencyResolver.Resolve({0},{1})", type, name))
             {
-                var result = _container.Resolve(type, name);
-                if (typeof(IEnumerable).IsAssignableFrom(type) && 
-                    ((result == null) || !((IEnumerable)result).Cast<Object>().Any()))
+                if (Container.Configure<TypeTrackingExtension>().CanResolve(type, name))
                 {
-                    result = this.ResolveAll(type);
+                    var result = _container.Resolve(type, name);
+                    if (typeof (IEnumerable).IsAssignableFrom(type) &&
+                        ((result == null) || !((IEnumerable) result).Cast<Object>().Any()))
+                    {
+                        result = this.ResolveAll(type);
+                    }
+
+                    return result;
+                }
+                else
+                {
+                    return null;
                 }
-
-                return result;
-            }
-            else
-            {
-                return null;
             }
         }
 
@@ -127,15 +140,17 @@ public IEnumerable ResolveAll(Type t)
             if (!CanResolve(t))
                 return Enumerable.Empty<object>();
 
-            return _container.ResolveAll(t);
+            using (Profiler.StartContext("UnityDependencyResolver.ResolveAll({0})", t))
+                return _container.ResolveAll(t);
         }
 
         public IEnumerable<T> ResolveAll<T>()
         {
             if (!CanResolve(typeof(T)))
                 return Enumerable.Empty<T>();
 
-            return _container.ResolveAll<T>();
+            using (Profiler.StartContext("UnityDependencyResolver.ResolveAll<{0}>()", typeof(T)))
+                return _container.ResolveAll<T>();
         }
 
         public bool IsRegistered<T>()
@@ -145,7 +160,8 @@ public bool IsRegistered<T>()
 
         public bool IsRegistered(Type type)
         {
-            return _container.Configure<TypeTrackingExtension>().IsRegistered(type);
+            using (Profiler.StartContext("UnityDependencyResolver.IsRegistered({0})", type))
+                return _container.Configure<TypeTrackingExtension>().IsRegistered(type);
         }
 
         /// <summary>
@@ -168,9 +184,12 @@ public bool CanResolve<T>()
         /// </returns>
         public bool CanResolve(Type type)
         {
-            if (isResolvableClass(type))
-                return true;
-            return IsRegistered(type);
+            using (Profiler.StartContext("UnityDependencyResolver.CanResolve({0})", type))
+            {
+                if (isResolvableClass(type))
+                    return true;
+                return IsRegistered(type);
+            }
         }
 
         private bool isResolvableClass(Type type)

Src/Commons.Persistence.Sitecore/BoC.Persistence.SitecoreGlass.csproj

@@ -127,6 +127,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="ContextDatabaseProvider.cs" />
+    <Compile Include="DefaultSetupTasks\EnableProfiling.cs" />
     <Compile Include="DefaultSetupTasks\RegisterConfigLoader.cs" />
     <Compile Include="GlassConfig\AppDomainHelperConfigLoader.cs" />
     <Compile Include="DefaultSetupTasks\RegisterValueProvider.cs" />
@@ -137,10 +138,12 @@
     <Compile Include="DefaultSetupTasks\AutoSitecoreRepositoryGenerator.cs" />
     <Compile Include="IDatabaseProvider.cs" />
     <Compile Include="IIndexNameProvider.cs" />
+    <Compile Include="DefaultSetupTasks\RegisterPerformanceProfilers.cs" />
     <Compile Include="Initialize\InitBoc.cs" />
     <Compile Include="DefaultSetupTasks\InitGlass.cs" />
     <Compile Include="ISitecoreServiceProvider.cs" />
     <Compile Include="Mvc\SitecoreValueProvider.cs" />
+    <Compile Include="Profiling\SitecorePerformanceProfiler.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SitecoreRepository.cs" />
     <Compile Include="SitecoreServiceProvider.cs" />

Src/Commons.Persistence.Sitecore/BoC.Persistence.SitecoreGlass.nuspec

@@ -14,8 +14,8 @@
     <copyright>Copyright 2014</copyright>
     <tags>BoC,Persistence,Glass,Mapper,ORM,Repository,Sitecore</tags>
     <dependencies>
-      <dependency id="BoC" version="2.2.0" />
-      <dependency id="BoC.Logging.Sitecore" version="2.0.1" />
+      <dependency id="BoC" version="2.3.0" />
+      <dependency id="BoC.Logging.Sitecore" version="2.2.0" />
       <dependency id="BoC.Glass.Mapper" version="1.0.3" />
       <dependency id="BoC.Glass.Mapper.Sc" version="1.0.3" />
       <dependency id="BoC.Glass.Mapper.Sc.Mvc-5" version="1.0.3" />

Src/Commons.Persistence.Sitecore/DefaultSetupTasks/EnableProfiling.cs

@@ -0,0 +1,13 @@
+using BoC.Profiling;
+using BoC.Tasks;
+
+namespace BoC.Persistence.SitecoreGlass.DefaultSetupTasks
+{
+    public class EnableProfiling: IBootstrapperTask
+    {
+        public void Execute()
+        {
+            Profiler.Enabled = global::Sitecore.Configuration.Settings.GetBoolSetting("BoC.Profiler.Enabled", false);
+        }
+    }
+}

Src/Commons.Persistence.Sitecore/DefaultSetupTasks/RegisterPerformanceProfilers.cs

@@ -0,0 +1,22 @@
+using BoC.InversionOfControl;
+using BoC.Persistence.SitecoreGlass.Profiling;
+using BoC.Profiling;
+
+namespace BoC.Persistence.SitecoreGlass.DefaultSetupTasks
+{
+
+    public class ContainerRegistrations: IContainerInitializer
+    {
+        private readonly IDependencyResolver _resolver;
+
+        public ContainerRegistrations(IDependencyResolver resolver)
+        {
+            _resolver = resolver;
+        }
+
+        public void Execute()
+        {
+            _resolver.RegisterSingleton<IPerformanceProfiler, SitecorePerformanceProfiler>();
+        }
+    }
+}

Src/Commons.Persistence.Sitecore/Profiling/SitecorePerformanceProfiler.cs

@@ -0,0 +1,18 @@
+using BoC.Profiling;
+
+namespace BoC.Persistence.SitecoreGlass.Profiling
+{
+    public class SitecorePerformanceProfiler: IPerformanceProfiler
+    {
+        public void BeginSession(string key)
+        {
+            Sitecore.Diagnostics.Profiler.StartOperation(key);
+        }
+
+        public void EndSession(string key)
+        {
+            Sitecore.Diagnostics.Profiler.EndOperation(key);
+        }
+
+    }
+}

Src/Commons.Persistence.Sitecore/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.2.0.0")]
-[assembly: AssemblyFileVersion("2.2.0.0")]
+[assembly: AssemblyVersion("2.3.0.0")]
+[assembly: AssemblyFileVersion("2.3.0.0")]