Adding IFilterFactory

samples/MvcSample.Web/Filters/InspectResultPageAttribute.cs

@@ -1,28 +1,37 @@
 using System;
-using System.Threading.Tasks;
 using Microsoft.AspNet.Mvc;
-using Microsoft.AspNet.Mvc.Filters;
 using MvcSample.Web.Models;
 
 namespace MvcSample.Web.Filters
 {
-    public class InspectResultPageAttribute : ActionFilterAttribute
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
+    public class InspectResultPageAttribute : Attribute, IFilterFactory
     {
-        public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next)
+        public IFilter CreateInstance(IServiceProvider serviceProvider)
         {
-            var viewResult = context.Result as ViewResult;
+            return new InspectResultPageFilter();
+        }
 
-            if (viewResult != null)
+        private class InspectResultPageFilter : IResultFilter
+        {
+            public void OnResultExecuting(ResultExecutingContext context)
             {
-                var user = viewResult.ViewData.Model as User;
+                var viewResult = context.Result as ViewResult;
 
-                if (user != null)
+                if (viewResult != null)
                 {
-                    user.Name += "**" + user.Name + "**";
+                    var user = viewResult.ViewData.Model as User;
+
+                    if (user != null)
+                    {
+                        user.Name += "**" + user.Name + "**";
+                    }
                 }
             }
 
-            await next();
+            public void OnResultExecuted(ResultExecutedContext context)
+            {
+            }
         }
     }
 }

samples/MvcSample.Web/Filters/UserNameProvider.cs

@@ -4,8 +4,12 @@ namespace MvcSample.Web.Filters
 {
     public class UserNameProvider : IActionFilter
     {
-        private static readonly string[] _userNames = new[] { "Jon", "David", "Goliath" };
-        private static int _index;
+        private readonly UserNameService _nameService;
+
+        public UserNameProvider(UserNameService nameService)
+        {
+            _nameService = nameService;
+        }
 
         public void OnActionExecuting(ActionExecutingContext context)
         {
@@ -17,7 +21,7 @@ public void OnActionExecuting(ActionExecutingContext context)
 
             if (string.IsNullOrWhiteSpace(userName))
             {
-                context.ActionArguments["userName"] = _userNames[(_index++)%3];
+                context.ActionArguments["userName"] = _nameService.GetName();
             }
         }
 

samples/MvcSample.Web/Filters/UserNameService.cs

@@ -0,0 +1,15 @@
+using Microsoft.AspNet.Mvc;
+
+namespace MvcSample.Web.Filters
+{
+    public class UserNameService
+    {
+        private static readonly string[] _userNames = new[] { "Jon", "David", "Goliath" };
+        private static int _index;
+
+        public string GetName()
+        {
+            return _userNames[_index++ % 3];
+        }
+    }
+}

samples/MvcSample.Web/MvcSample.Web.kproj

@@ -50,6 +50,7 @@
     <Compile Include="Filters\InspectResultPageAttribute.cs" />
     <Compile Include="Filters\PassThroughAttribute.cs" />
     <Compile Include="Filters\UserNameProvider.cs" />
+    <Compile Include="Filters\UserNameService.cs" />
     <Compile Include="Home2Controller.cs" />
     <Compile Include="HomeController.cs" />
     <Compile Include="LinkController.cs" />

samples/MvcSample.Web/Startup.cs

@@ -2,6 +2,7 @@
 using Microsoft.AspNet.Abstractions;
 using Microsoft.AspNet.Mvc;
 using Microsoft.AspNet.Routing;
+using MvcSample.Web.Filters;
 
 namespace MvcSample.Web
 {
@@ -13,6 +14,7 @@ public void Configuration(IBuilder app)
             {
                 services.AddMvc();
                 services.AddSingleton<PassThroughAttribute, PassThroughAttribute>();
+                services.AddSingleton<UserNameService, UserNameService>();
             });
 
             app.UseMvc(routes =>

src/Microsoft.AspNet.Mvc.Core/Filters/DefaultFilterProvider.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics.Contracts;
 using Microsoft.AspNet.DependencyInjection;
+using Microsoft.AspNet.Mvc.Core;
 
 namespace Microsoft.AspNet.Mvc.Filters
 {
@@ -46,45 +47,23 @@ public virtual void ProvideFilter(FilterProviderContext context, FilterItem filt
 
             var filter = filterItem.Descriptor.Filter;
 
-            var serviceFilterSignature = filter as IServiceFilter;
-            if (serviceFilterSignature != null)
+            var filterFactory = filter as IFilterFactory;
+            if (filterFactory == null)
             {
-                var serviceFilter = ServiceProvider.GetService(serviceFilterSignature.ServiceType) as IFilter;
-
-                if (serviceFilter == null)
-                {
-                    throw new InvalidOperationException("Service filter must be of type IFilter");
-                }
-
-                filterItem.Filter = serviceFilter;
+                filterItem.Filter = filter;
             }
             else
             {
-                var typeFilterSignature = filter as ITypeFilter;
-                if (typeFilterSignature != null)
-                {
-                    if (typeFilterSignature.ImplementationType == null)
-                    {
-                        throw new InvalidOperationException("Type filter must provide a type to instantiate");
-                    }
+                filterItem.Filter = filterFactory.CreateInstance(ServiceProvider);
 
-                    if (!typeof (IFilter).IsAssignableFrom(typeFilterSignature.ImplementationType))
-                    {
-                        throw new InvalidOperationException("Type filter must implement IFilter");
-                    }
-
-                    var typeFilter = (IFilter)_typeActivator.CreateInstance(
-                        ServiceProvider,
-                        typeFilterSignature.ImplementationType,
-                        typeFilterSignature.Arguments);
-
-                    ApplyFilterToContainer(typeFilter, filter);
-                    filterItem.Filter = typeFilter;
-                }
-                else
+                if (filterItem.Filter == null)
                 {
-                    filterItem.Filter = filter;
+                    throw new InvalidOperationException(Resources.FormatTypeMethodMustReturnNotNullValue(
+                        "CreateInstance",
+                        typeof(IFilterFactory).Name));
                 }
+
+                ApplyFilterToContainer(filterItem.Filter, filterFactory);
             }
         }
 

src/Microsoft.AspNet.Mvc.Core/Filters/IFilterFactory.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Microsoft.AspNet.Mvc
+{
+    public interface IFilterFactory : IFilter
+    {
+        IFilter CreateInstance([NotNull] IServiceProvider serviceProvider);
+    }
+}

src/Microsoft.AspNet.Mvc.Core/Filters/ServiceFilterAttribute.cs

@@ -1,19 +1,35 @@
 using System;
 using System.Diagnostics;
+using Microsoft.AspNet.Mvc.Core;
 
 namespace Microsoft.AspNet.Mvc
 {
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
     [DebuggerDisplay("ServiceFilter: Type={ServiceType} Order={Order}")]
-    public class ServiceFilterAttribute : Attribute, IServiceFilter
+    public class ServiceFilterAttribute : Attribute, IFilterFactory, IOrderedFilter
     {
-        public ServiceFilterAttribute(Type type)
+        public ServiceFilterAttribute([NotNull] Type type)
         {
             ServiceType = type;
         }
 
         public Type ServiceType { get; private set; }
 
         public int Order { get; set; }
+
+        public IFilter CreateInstance([NotNull] IServiceProvider serviceProvider)
+        {
+            var service = serviceProvider.GetService(ServiceType);
+
+            var filter = service as IFilter;
+            if (filter == null)
+            {
+                throw new InvalidOperationException(Resources.FormatFilterFactoryAttribute_TypeMustImplementIFilter(
+                    typeof(ServiceFilterAttribute).Name,
+                    typeof(IFilter).Name));
+            }
+
+            return filter;
+        }
     }
 }

src/Microsoft.AspNet.Mvc.Core/Filters/TypeFilterAttribute.cs

@@ -1,13 +1,15 @@
 using System;
 using System.Diagnostics;
+using Microsoft.AspNet.DependencyInjection;
+using Microsoft.AspNet.Mvc.Core;
 
 namespace Microsoft.AspNet.Mvc
 {
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
     [DebuggerDisplay("TypeFilter: Type={ImplementationType} Order={Order}")]
-    public class TypeFilterAttribute : Attribute, ITypeFilter, IOrderedFilter
+    public class TypeFilterAttribute : Attribute, IFilterFactory, IOrderedFilter
     {
-        public TypeFilterAttribute(Type type)
+        public TypeFilterAttribute([NotNull] Type type)
         {
             ImplementationType = type;
         }
@@ -17,5 +19,21 @@ public TypeFilterAttribute(Type type)
         public Type ImplementationType { get; private set; }
 
         public int Order { get; set; }
+
+        public IFilter CreateInstance([NotNull] IServiceProvider serviceProvider)
+        {
+            var activator = serviceProvider.GetService<ITypeActivator>();
+            var obj = activator.CreateInstance(serviceProvider, ImplementationType, Arguments ?? new object[0]);
+
+            var filter = obj as IFilter;
+            if (filter == null)
+            {
+                throw new InvalidOperationException(Resources.FormatFilterFactoryAttribute_TypeMustImplementIFilter(
+                    typeof(TypeFilterAttribute).Name,
+                    typeof(IFilter).Name));
+            }
+
+            return filter;
+        }
     }
 }

src/Microsoft.AspNet.Mvc.Core/Microsoft.AspNet.Mvc.Core.kproj

@@ -103,8 +103,7 @@
     <Compile Include="Filters\IFilterContainer.cs" />
     <Compile Include="Filters\IOrderedFilter.cs" />
     <Compile Include="Filters\IResultFilter.cs" />
-    <Compile Include="Filters\IServiceFilter.cs" />
-    <Compile Include="Filters\ITypeFilter.cs" />
+    <Compile Include="Filters\IFilterFactory.cs" />
     <Compile Include="Filters\ResultExecutedContext.cs" />
     <Compile Include="Filters\ResultExecutingContext.cs" />
     <Compile Include="Filters\ResultExecutionDelegate.cs" />