ASP.NET AcceptVerbs

last modified April 3, 2025

In this article, we explore the AcceptVerbs attribute in ASP.NET 8. This attribute provides flexible HTTP method routing for controller actions.

ASP.NET is a cross-platform framework for building modern web applications. AcceptVerbs allows multiple HTTP methods to be mapped to a single action.

Basic Definition

The AcceptVerbs attribute in ASP.NET specifies which HTTP methods can invoke a particular action method. It's more flexible than individual method attributes.

Unlike HttpGet or HttpPost, AcceptVerbs can accept multiple HTTP methods as parameters. This makes it useful for actions that handle several verb types.

AcceptVerbs is part of ASP.NET's routing system. It works with both convention and attribute routing. The attribute can be applied to controller action methods.

ASP.NET AcceptVerbs Example

The following example demonstrates a Web API controller using AcceptVerbs.

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();

var app = builder.Build();

app.MapControllers();
app.Run();

This sets up a basic ASP.NET application with controller support. The MapControllers method enables attribute routing for controllers.

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class TasksController : ControllerBase
{
    private static List<TaskItem> _tasks = new()
    {
        new TaskItem(1, "Buy groceries", false),
        new TaskItem(2, "Finish report", true),
        new TaskItem(3, "Call client", false)
    };

    [AcceptVerbs("GET", "HEAD")]
    public IActionResult GetAllTasks()
    {
        return Ok(_tasks);
    }

    [AcceptVerbs("GET", "HEAD", Route = "{id}")]
    public IActionResult GetTaskById(int id)
    {
        var task = _tasks.FirstOrDefault(t => t.Id == id);
        if (task == null) return NotFound();
        return Ok(task);
    }

    [AcceptVerbs("POST", "PUT")]
    public IActionResult CreateOrUpdateTask([FromBody] TaskItem task)
    {
        if (task.Id == 0) // New task
        {
            task.Id = _tasks.Max(t => t.Id) + 1;
            _tasks.Add(task);
            return CreatedAtAction(nameof(GetTaskById), 
                new { id = task.Id }, task);
        }
        
        var existing = _tasks.FirstOrDefault(t => t.Id == task.Id);
        if (existing == null) return NotFound();
        
        existing.Title = task.Title;
        existing.IsComplete = task.IsComplete;
        return NoContent();
    }

    [AcceptVerbs("DELETE", Route = "{id}")]
    public IActionResult DeleteTask(int id)
    {
        var task = _tasks.FirstOrDefault(t => t.Id == id);
        if (task == null) return NotFound();
        
        _tasks.Remove(task);
        return NoContent();
    }
}

public record TaskItem(int Id, string Title, bool IsComplete);

This controller demonstrates four different AcceptVerbs scenarios. The first method responds to both GET and HEAD requests for retrieving all tasks.

The second method also handles GET and HEAD requests but for a single task. The third method combines POST and PUT for create/update operations.

The fourth method uses DELETE for task removal. Each method returns appropriate HTTP status codes based on the operation result.

The example shows how AcceptVerbs can consolidate multiple HTTP methods into single action methods. This reduces code duplication while maintaining clarity.

Source

Microsoft ASP.NET Routing Documentation

In this article, we have explored the AcceptVerbs attribute in ASP.NET 8. This versatile feature provides flexible HTTP method routing for controller actions.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all ASP.NET tutorials.