Attributi MVC su controller e azioni

Question

C'è un modo per aggiungere un attributo a livello di controller ma non su un'azione specifica. Ad esempio, supponiamo di avere 10 azioni nel mio controller e solo una di quelle azioni non richiede un attributo specifico che ho creato.

 
[MyAttribute] 
public class MyController : Controller 
{ 
    public ActionResult Action1() {} 
    public ActionResult Action2() {} 

    [Remove_MyAttribute] 
    public ActionResult Action3() {} 
} 

ho potuto potenzialmente spostare questo azione in un altro controller (ma non lo simile) oppure avrei potuto applicare il MyAttribute a tutte le azioni tranne dal Action3 ma solo pensato se c'è un modo più semplice?

Answer 1

Johannes ha fornito la soluzione corretta ed ecco come l'ho codificato ... spero che aiuti gli altri.

 
[MyFilter("MyAction")] 
public class HomeController : Controller 
{ 
    public ActionResult Action1... 
    public ActionResult Action2... 
    public ActionResult MyAction... 
} 

public class CompressFilter : ActionFilterAttribute 
{ 
    private IList _ExcludeActions = null; 

    public CompressFilter() 
    { 
     _ExcludeActions = new List(); 
    } 

    public CompressFilter(string excludeActions) 
    { 
     _ExcludeActions = new List(excludeActions.Split(',')); 
    } 

    public override void OnActionExecuting(ActionExecutingContext filterContext) 
    { 
     HttpRequestBase request = filterContext.HttpContext.Request; 

     string currentActionName = (string)filterContext.RouteData.Values["action"]; 

     if (_ExcludeActions.Contains(currentActionName)) 
      return; 

     ... 
    } 

Answer 2

Si potrebbe escludere un'azione specifica per passarlo al principale attributo:

[MyAttribute(Exclude="Action3")] 

EDIT

Il mio esempio era dalla testa (come si può vedere il seguente è VB.NET, forse è lì che è andata male), questo è come ho implementato:

<Models.MyAttribute(Exclude:="Action3")> _ 
Public Class MyController 
Inherits System.Web.Mvc.Controller 

End Class 

Answer 3

Devi eseguire l'override/estendo l'attributo di default e aggiungi un con personalizzato strutturatore per consentire l'esclusione. Oppure puoi creare il tuo attributo personalizzato per l'esclusione (nel tuo esempio è [Remove_MyAttribute]).

Answer 4

Lo schema usuale per ciò che si sta cercando di fare è di avere e di attribuire con un parametro booleano che indica se l'attributo viene applicato o meno.

Es:

[ComVisible] which is equivalent with [ComVisible(true)] 

or 

[ComVisible(false)] 

inf vostro caso si avrebbe:

[MyAttribute] // defaults to true 

and 

[MyAttribute(false)] for applying the attribute on excluded members 

Answer 5

So che la mia risposta è un po 'tardi (quasi quattro anni) per il gioco, ma mi sono imbattuto in questa domanda e volevo condividere una soluzione che ho ideato che mi permettesse di fare più o meno quello che la domanda originale voleva fare, nel caso in cui aiutasse qualcun altro in futuro.

La soluzione comprende un piccolo gioiello chiamato AttributeUsage, che ci consente di specificare un attributo sul controller (e anche su qualsiasi controller di base! Essi "si sovrappongono" fino a dove viene attivato solo l'attributo più granulare: cioè, passano da meno specifici (controllori di base) a più specifici (controllori derivati), a più specifici (metodi di azione).

Ecco come:

[AttributeUsage(AttributeTargets.Class|AttributeTargets.Method, Inherited=true, AllowMultiple=false)] 
public class MyCustomFilterAttribute : ActionFilterAttribute 
{ 

    private MyCustomFilterMode _Mode = MyCustomFilterMode.Respect;  // this is the default, so don't always have to specify 

    public MyCustomFilterAttribute() 
    { 
    } 
    public MyCustomFilterAttribute(MyCustomFilterMode mode) 
    { 
     _Mode = mode; 
    } 

    public override void OnActionExecuting(ActionExecutingContext filterContext) 
    { 
     if (_Mode == MyCustomFilterMode.Ignore) 
     { 
      return; 
     } 

     // Otherwise, respect the attribute and work your magic here! 
     // 
     // 
     // 
    } 

} 

public enum MyCustomFilterMode 
{ 
    Ignore = 0, 
    Respect = 1 
} 

(ti ho sentito come attributi, così ho messo alcuni attributi per l'attributo Questo è davvero ciò che rende il lavoro magia qui in cima: permettendo loro di ereditare/a cascata, ma consentendo solo uno di loro da eseguire)

Ecco come viene utilizzato oggi:.

[MyCustomFilter] 
public class MyBaseController : Controller 
{ 
    // I am the application's base controller with the filter, 
    // so any derived controllers will ALSO get the filter (unless they override/Ignore) 
} 

public class HomeController : MyBaseController 
{ 
    // Since I derive from MyBaseController, 
    // all of my action methods will also get the filter, 
    // unless they specify otherwise! 

    public ActionResult FilteredAction1... 
    public ActionResult FilteredAction2... 

    [MyCustomFilter(Ignore)] 
    public ActionResult MyIgnoredAction... // I am ignoring the filter! 

} 

[MyCustomFilter(Ignore)] 
public class SomeSpecialCaseController : MyBaseController 
{ 
    // Even though I also derive from MyBaseController, I can choose 
    // to "opt out" and indicate for everything to be ignored 

    public ActionResult IgnoredAction1... 
    public ActionResult IgnoredAction2... 

    // Whoops! I guess I do need the filter on just one little method here: 
    [MyCustomFilter] 
    public ActionResult FilteredAction1... 

} 

Spero che questo compila, mi strappai da qualche codice simile e ha fatto un po 'di s earch-and-replace su di esso in modo che potrebbe non essere perfetto.