When using filters in the controller, if you encounter logic shared by multiple operations (such as authentication, logging, etc.), filters should be used first to keep the code tidy and reusable. 1. Filters are logical blocks that run before and after the action is executed, used to handle tasks across multiple operations; 2. Application filters are usually implemented by adding attributes to the controller or action method, such as [Authorize]; 3. Creating a custom filter requires a specific interface, such as IActionFilter, and can be checked before the action is executed; 4. Global filters can be applied to all requests through registration, and are suitable for anti-counterfeiting protection, website-wide HTTPS mandatory and other scenarios. By using filters reasonably, it can effectively reduce duplicate code and improve the maintainability of the application.

When you're working with filters in a controller—especially in frameworks like ASP.NET MVC or similar—you're essentially applying logic before or after an action runs. The main idea is to keep your code clean and reusable by separating concerns like authentication, logging, or validation from the actual action methods.

Here's how to actually use them without getting lost in abstraction.

What Are Filters and Why Use Them?

Filters are chunks of logic that run before or after a controller action. They help you handle tasks that apply across multiple actions, like checking user permissions, logging requests, or handling exceptions.

Instead of repeating code inside every action method, you attach a filter once and it runs automatically. Think of it like setting up a checkpoint: certain rules get enforced no matter which action is called.

Common uses:

• Authentication and authorization checks
• Logging or timing requests
• Handling errors consistently
• Caching responses

How to Apply Filters in Your Controller

Applying a filter is usually just a matter of adding an attribute to your controller class or a specific action method.

For example, in ASP.NET MVC:

 [Authorize]
public class AccountController : Controller
{
    public IActionResult Login()
    {
        return View();
    }
}

In this case, the [Authorize] filter ensures only authenticated users can access any action in this controller.

You can also apply it to a single method:

 public class BlogController: Controller
{
    [Authorize]
    public IActionResult Edit(int id)
    {
        return View();
    }

    public IActionResult Index()
    {
        return View();
    }
}

Now only the Edit action requires authorization, while Index remains public.

Creating Custom Filters (When Built-ins Aren't Enough)

Sometimes the built-in filters don't cut it. For example, maybe you want to check if a user has completed their profile before allowing them to post content.

To create a custom filter, you typically implement one of the base interfaces like IActionFilter , IAuthorizationFilter , or IResultFilter .

Here's a basic example of a custom action filter:

 public class RequireProfileCompleteAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        var httpContext = context.HttpContext;
        var user = httpContext.User;

        // Check if user's profile is complete
        if (!IsProfileComplete(user))
        {
            context.Result = new RedirectResult("/Profile/Complete");
        }

        base.OnActionExecuting(context);
    }

    private bool IsProfileComplete(ClaimsPrincipal user)
    {
        // Logic to check profile status
        return false; // Just as an example
    }
}

Then apply it like any other filter:

 [RequireProfileComplete]
public IActionResult PostArticle()
{
    return View();
}

This keeps your controller lean and makes the behavior reusable across different actions or controllers.

Registering Global Filters (Apply to All Actions)

If you want a filter to run on every request, you can register it globally instead of attaching it manually to each controller or action.

In ASP.NET Core, you do this in Startup.cs or Program.cs depending on the version:

 services.AddControllersWithViews(options =>
{
    options.Filters.Add(new AutoValidateAntiforgeryTokenAttribute());
});

Or for a custom global filter:

 services.AddControllersWithViews(options =>
{
    options.Filters.Add(typeof(MyGlobalFilterAttribute));
});

This is useful for things like anti-forgery protection, logging all requests, or enforcing HTTPS site-wide.

Using filters effectively helps you write cleaner, more maintained code. You don't need to sprinkle the same checks in every action—just define the rule once and let the framework enforce it.

And honestly, once you start using them regularly, you'll wonder how you ever managed without them.

Basically that's it.

The above is the detailed content of How do I use filters in a controller?. For more information, please follow other related articles on the PHP Chinese website!