Sposób na wykluczenie filtrów działania w ASP.NET MVC?

Question

W ASP.NET MVC natknąłem się na kilka przypadków, w których chciałem zastosować filtr akcji dla każdej akcji z wyjątkiem jednej lub dwóch. Załóżmy na przykład, że masz AccountController. Każda akcja w nim wymaga zalogowania użytkownika, więc dodajesz [Autoryzuj] na poziomie kontrolera. Ale powiedz, że chcesz dołączyć stronę logowania do AccountController. Problem polega na tym, że użytkownicy wysłani na stronę logowania nie są autoryzowani, więc spowodowałoby to nieskończoną pętlę.

Oczywistą poprawką (inną niż przeniesienie działania Login do innego kontrolera) jest przeniesienie [Authorize] ze sterownika do wszystkich metod działania, z wyjątkiem Login. Cóż, to nie jest zabawne, szczególnie gdy masz dużo metod lub zapomnij dodać [Autoryzuj] do nowej metody.

Szyny to proste dzięki możliwości wykluczania filtrów. ASP.NET MVC nie pozwala. Postanowiłem więc umożliwić to i było to łatwiejsze niż myślałem.

/// <summary> 
/// This will disable any filters of the given type from being applied. This is useful when, say, all but on action need the Authorize filter. 
/// </summary> 
[AttributeUsage(AttributeTargets.Method|AttributeTargets.Class, AllowMultiple=true)] 
public class ExcludeFilterAttribute : ActionFilterAttribute 
{ 

    public ExcludeFilterAttribute(Type toExclude) 
    { 
     FilterToExclude = toExclude; 
    } 

    /// <summary> 
    /// The type of filter that will be ignored. 
    /// </summary> 
    public Type FilterToExclude 
    { 
     get; 
     private set; 
    } 
} 

/// <summary> 
/// A subclass of ControllerActionInvoker that implements the functionality of IgnoreFilterAttribute. To use this, just override Controller.CreateActionInvoker() and return an instance of this. 
/// </summary> 
public class ControllerActionInvokerWithExcludeFilter : ControllerActionInvoker 
{ 
    protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) 
    { 
     //base implementation does all the hard work. we just prune off the filters to ignore 
     var filterInfo = base.GetFilters(controllerContext, actionDescriptor);   
     foreach(var toExclude in filterInfo.ActionFilters.OfType<ExcludeFilterAttribute>().Select(f=>f.FilterToExclude).ToArray()) 
     { 
      RemoveWhere(filterInfo.ActionFilters, filter => toExclude.IsAssignableFrom(filter.GetType())); 
      RemoveWhere(filterInfo.AuthorizationFilters, filter => toExclude.IsAssignableFrom(filter.GetType())); 
      RemoveWhere(filterInfo.ExceptionFilters, filter => toExclude.IsAssignableFrom(filter.GetType())); 
      RemoveWhere(filterInfo.ResultFilters, filter => toExclude.IsAssignableFrom(filter.GetType())); 
     } 
     return filterInfo; 
    } 


    /// <summary> 
    /// Removes all elements from the list that satisfy the condition. Returns the list that was passed in (minus removed elements) for chaining. Ripped from one of my helper libraries (where it was a pretty extension method). 
    /// </summary> 
    private static IList<T> RemoveWhere<T>(IList<T> list, Predicate<T> predicate) 
    { 

     if (list == null || list.Count == 0) 
      return list; 
     //note: didn't use foreach because an exception will be thrown when you remove items during enumeration 
     for (var i = 0; i < list.Count; i++) 
     { 
      var item = list[i]; 
      if (predicate(item)) 
      { 
       list.RemoveAt(i); 
       i--; 
      } 
     } 
     return list; 
    } 
} 

/// <summary> 
/// An example of using the ExcludeFilterAttribute. In this case, Action1 and Action3 require authorization but not Action2. Notice the CreateActionInvoker() override. That's necessary for the attribute to work and is probably best to put in some base class. 
/// </summary> 
[Authorize] 
public class ExampleController : Controller 
{ 
    protected override IActionInvoker CreateActionInvoker() 
    { 
     return new ControllerActionInvokerWithExcludeFilter(); 
    } 

    public ActionResult Action1() 
    { 
     return View(); 
    } 

    [ExcludeFilter(typeof(AuthorizeAttribute))] 
    public ActionResult Action2() 
    { 
     return View(); 
    } 

    public ActionResult Action3() 
    { 
     return View(); 
    } 

} 

Przykład jest właśnie tutaj. Jak widać, było to całkiem proste i działa świetnie. Mam nadzieję, że przyda się każdemu?

Answer 1

Preferuję rozwiązanie opisane here. Chociaż nie jest to tak ogólne rozwiązanie jak twoje, uznałem to za nieco prostsze.

W moim przypadku szukałem sposobu na włączenie CompressionFilter we wszystkim poza kilkoma elementami. Więc stworzyłem pusty atrybut tak:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)] 
public sealed class DisableCompression : Attribute { } 

Następnie w głównym atrybutem, sprawdzić obecność atrybutu tak:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)] 
public class CompressionFilter : ActionFilterAttribute 
{ 
    public override void OnActionExecuting(ActionExecutingContext filterContext) 
    { 
     bool disabled = filterContext.ActionDescriptor.IsDefined(typeof(DisableCompression), true) || 
         filterContext.ActionDescriptor.ControllerDescriptor.IsDefined(typeof(DisableCompression), true); 
     if (disabled) 
      return; 

     // action filter logic here... 
    } 
} 

Choć strona I połączone z wspomina, że ​​jest to dla MVC 3, wydaje się również działać wystarczająco dobrze w MVC 1.

EDYCJA: pokazuje niektóre wykorzystanie tutaj w odpowiedzi na komentarze. Zanim wprowadziłem powyższe zmiany, wyglądało to dokładnie tak, z wyjątkiem braku atrybutu [DisableCompression] oznaczającego metodę, którą chciałem wykluczyć. Nie ma w tym nic wspólnego z refaktoryzacją.

[CompressionFilter] 
public abstract class BaseController : Controller 
{ 
} 

public class SomeController : BaseController 
{ 
    public ActionResult WantThisActionCompressed() 
    { 
     // code 
    } 

    [DisableCompression] 
    public ActionResult DontWantThisActionCompressed() 
    { 
     // code 
    } 
} 

Answer 2

Zakładam za lata temu, że atrybut [AllowAnnonymous] nie został dodany do ASP.NET MVC. Dzisiaj mogę mieć atrybut [Authorize] na moim kontrolerze, który stosuje się do wszystkich metod Akcji i po prostu po prostu nadpisuję to w Akcjach, które wymagają nieautoryzowanych użytkowników, dodając atrybuty [AllowAnonymous] do konkretnych działań.