如何在自定义属性中找到修饰的方法？

Question

I need to do some custom authorization based on specific methods in my controllers. Is it possible for a custom attribute to know which method is being called?

Given the following:

[CustomAttribute]
public ActionResult Index()
{
    //some stuff
}

Is it possible for [CustomAttribute] to know that Index that called specifically? The same would apply to any other method decorated with [CustomAttribute].

Answer 1

In MVC controller methods are called Actions.

You can figure out which action has been called from inside your attribute by having your attribute inherit from ActionFilterAttribute. You then override the OnActionExecuting method (or OnActionExecuted). The filterContext (ActionExecutingContext) argument has a property called ActionDescriptor. you can get the action name from the ActionName property.

var actionName = filterContext.ActionDescriptor.ActionName

Answer 2

I am not sure that I understand your question fully, but I will try to answer. The attributes are used to mark a method or a class. Imagine it as a tag. It is not an instance having behaviour and you cannot make decisions inside the attribute. You should use attribute annotations to make decisions in your methods and not the opposite.

Since you want to make custom authorization decisions, I would suggest using a custom Membership API provider . There, you could use the attributes of the current index method to make your custom decisions. I would use reflection to get the executing action or controller, using the next statements:

string actionName = this.ControllerContext.RouteData.Values["action"];
string controllerName = this.ControllerContext.RouteData.Values["controller"];

Then, using reflection you could also retrieve the info for the specific class and method and check the attributes decorating the respective objects. This MSDN post could explain how you could access the attributes of a specific method.

Hope I helped!

Answer 3

A custom attribute is a static piece of information attached to a code entity (property, method, field,). So, what you require is not possible.

The standard way of letting "someone" know that something is happening, is to use an event. Those can be static, if they concern the entire type and not just an instance.

First define an EventArgs class:

public class IndexCalledEventArgs : EventArgs
{
    public IndexCalledEventArgs(int index)
    {
        Index = index;
    }

    public int Index { get; private set; }
}

Your class whose index has to be observed defines the static event and fires it when the index is accessed:

public class MyClass
{
    public static event EventHandler<IndexCalledEventArgs> IndexCalled;

    public ActionResult Index()
    {
        int index;

        // Somehow get an index
        index = 7;
        OnIndexCalled(this, index);

        return new ActionResult { Index = index };
    }

    private static void OnIndexCalled(MyClass sender, int index)
    {
        var handler = IndexCalled;
        if (handler != null) {
            // Create the event args and fire the event.
            handler(sender, new IndexCalledEventArgs(index));
        }
    }
}

An object who wants to observe this event, attaches to it:

public class InteresedInIndexCalledEvent
{
    public InteresedInIndexCalledEvent()
    {
        MyClass.IndexCalled += MyClass_IndexCalled;
    }

    void MyClass_IndexCalled(object sender, IndexCalledEventArgs e)
    {
        Console.WriteLine("Index {0} was called", e.Index);
    }
}