Refactoring: application instance exposed in the action filter attribute

Author: VladimirDimov

src/JQDT.MVC/JQDataTableAttribute.cs

@@ -38,9 +38,10 @@ public override void OnActionExecuted(ActionExecutedContext filterContext)
         private void PerformOnActionExecuted(ActionExecutedContext filterContext)
         {
             var dataCollectionType = filterContext.Controller.ViewData.Model.GetType();
-            var applicationExecuteFunction = ExecuteFunctionProvider<ActionExecutedContext>.GetExecuteFunction(dataCollectionType, typeof(ApplicationMvc<>));
             var dependencyResolver = new DI.DependencyResolver();
-            var result = (ResultModel)applicationExecuteFunction(filterContext, dependencyResolver);
+            var applicationInitizlizationFunction = ExecuteFunctionProvider<ActionExecutedContext>.GetAppInicializationFunc(dataCollectionType, typeof(ApplicationMvc<>));
+            var mvcApplication = applicationInitizlizationFunction(filterContext, dependencyResolver);
+            var result = (ResultModel)mvcApplication.Execute();
 
             filterContext.Result = this.FormatResult(new
             {

src/JQDT.WebAPI/JQDataTableAttribute.cs

@@ -35,9 +35,10 @@ public override void OnActionExecuted(HttpActionExecutedContext actionExecutedCo
         private void PerformOnActionExecuted(HttpActionExecutedContext actionExecutedContext)
         {
             var modelType = ((System.Net.Http.ObjectContent)actionExecutedContext.Response.Content).ObjectType;
-            var applicationExecuteFunction = ExecuteFunctionProvider<HttpActionExecutedContext>.GetExecuteFunction(modelType, typeof(ApplicationWebApi<>));
+            var applicationInitizlizationFunction = ExecuteFunctionProvider<HttpActionExecutedContext>.GetAppInicializationFunc(modelType, typeof(ApplicationWebApi<>));
             var dependencyResolver = new DI.DependencyResolver();
-            var result = (ResultModel)applicationExecuteFunction(actionExecutedContext, dependencyResolver);
+            var webApiApplication = applicationInitizlizationFunction(actionExecutedContext, dependencyResolver);
+            var result = (ResultModel)webApiApplication.Execute();
             var formattedObjectResult = this.GetObjectResult(result);
             actionExecutedContext.Response.Content = new ObjectContent(typeof(object), formattedObjectResult, new JsonMediaTypeFormatter());
         }

src/JQDT/Application/ApplicationBase.cs

@@ -14,7 +14,7 @@
     /// The <see cref="ApplicationBase.Execute(System.Collections.Specialized.NameValueCollection, System.Linq.IQueryable{T})"/> should be called
     /// </summary>
     /// <typeparam name="T">Data Collection Generic Type</typeparam>
-    public abstract class ApplicationBase<T>
+    public abstract class ApplicationBase<T> : IApplicationBase
     {
         private readonly IDependencyResolver dependencyResolver;
 
@@ -28,9 +28,11 @@ public ApplicationBase(IDependencyResolver dependencyResolver)
         }
 
         /// <summary>
-        /// Application entry point method. Should be called from the ActionFilter.
+        /// Application entry point method. Executes all data processors.
         /// </summary>
-        /// <returns><see cref="ResultModel"/></returns>
+        /// <returns>
+        /// Processed data as <see cref="ResultModel" />
+        /// </returns>
         public ResultModel Execute()
         {
             ResultModel result = new ResultModel();

src/JQDT/Application/ExecuteFunctionProvider.cs

@@ -12,6 +12,7 @@
     public static class ExecuteFunctionProvider<TContext>
     {
         private static ConcurrentDictionary<Type, Func<TContext, DI.IDependencyResolver, object>> executionFunctionsCache = new ConcurrentDictionary<Type, Func<TContext, DI.IDependencyResolver, object>>();
+        private static ConcurrentDictionary<Type, Func<TContext, DI.IDependencyResolver, IApplicationBase>> appInitFunctionsCache = new ConcurrentDictionary<Type, Func<TContext, DI.IDependencyResolver, IApplicationBase>>();
 
         /// <summary>
         /// Gets the execute function.
@@ -42,5 +43,33 @@ public static class ExecuteFunctionProvider<TContext>
 
             return executeFunc;
         }
+
+        /// <summary>
+        /// Gets the application initialization function.
+        /// </summary>
+        /// <param name="dataCollectionType">Type of the data collection.</param>
+        /// <param name="appType">Type of the application.</param>
+        /// <returns><see cref="Func{T, TResult}"/> that return new <see cref="IApplicationBase"/> instance</returns>
+        public static Func<TContext, DI.IDependencyResolver, IApplicationBase> GetAppInicializationFunc(Type dataCollectionType, Type appType)
+        {
+            Func<TContext, DI.IDependencyResolver, IApplicationBase> executeFunc = null;
+
+            if (!appInitFunctionsCache.TryGetValue(dataCollectionType, out executeFunc))
+            {
+                Type[] typeArgs = { dataCollectionType.GenericTypeArguments.First() };
+                var genericAppType = appType.MakeGenericType(typeArgs);
+
+                var contextExpr = Expression.Parameter(typeof(TContext), "context");
+                var dependencyResolverExpr = Expression.Parameter(typeof(DI.IDependencyResolver));
+                var appConstructorInfo = genericAppType.GetConstructors().First();
+                var newAppExpr = Expression.New(appConstructorInfo, contextExpr, dependencyResolverExpr);
+                var lambda = Expression.Lambda(newAppExpr, contextExpr, dependencyResolverExpr);
+
+                executeFunc = (Func<TContext, DI.IDependencyResolver, IApplicationBase>)lambda.Compile();
+                executionFunctionsCache.TryAdd(dataCollectionType, executeFunc);
+            }
+
+            return executeFunc;
+        }
     }
 }

src/JQDT/Application/IApplicationBase.cs

@@ -0,0 +1,16 @@
+namespace JQDT.Application
+{
+    using JQDT.Models;
+
+    /// <summary>
+    /// Base interface for <see cref="ApplicationBase{T}"/>
+    /// </summary>
+    public interface IApplicationBase
+    {
+        /// <summary>
+        /// Application entry point method. Executes all data processors.
+        /// </summary>
+        /// <returns>Processed data as <see cref="ResultModel"/></returns>
+        ResultModel Execute();
+    }
+}

src/JQDT/JQDT.csproj

@@ -59,6 +59,7 @@
   <ItemGroup>
     <Compile Include="Application\ApplicationBase.cs" />
     <Compile Include="Application\ExecuteFunctionProvider.cs" />
+    <Compile Include="Application\IApplicationBase.cs" />
     <Compile Include="DataProcessing\ColumnsFilterDataProcessing\ColumnsFilterDataProcessor.cs" />
     <Compile Include="DataProcessing\Common\ConstantExpressionBuilder.cs" />
     <Compile Include="DataProcessing\Common\ContainsExpressionBuilder.cs" />