Resolving "Multiple actions were found that match the request" Error in ASP.NET Web API

Problem Background and Error Analysis

During ASP.NET Web API development, when a controller contains multiple identical HTTP methods (such as multiple GET methods), the <span style="font-family: monospace;">"Multiple actions were found that match the request"</span> error frequently occurs. This error stems from the default routing configuration's inability to distinguish between multiple action methods with the same HTTP verb.

Consider the following typical code scenario:

[HttpGet]
public HttpResponseMessage Summary(MyVm vm)
{
    return null;
}

[HttpGet]
public HttpResponseMessage FullDetails()
{
    return null;
}

Although these methods have different names, under the default routing configuration, Web API cannot correctly distinguish them based on the request URL, resulting in routing conflicts.

Limitations of Default Routing Configuration

The default routing configuration for ASP.NET Web API typically appears as follows:

routes.MapHttpRoute(
    name: "API Default",
    routeTemplate: "api/{controller}/{id}",
    defaults: new { id = RouteParameter.Optional });

This configuration only includes the controller name and an optional ID parameter, lacking explicit identification of action methods. When a request arrives, the routing system attempts to match all actions that comply with the HTTP method, and if multiple matches are found, it throws the aforementioned error.

Solution 1: Modify Route Template to Include Action Parameter

The most direct solution is to add an action parameter to the route template:

routes.MapHttpRoute(
    name: "API Default",
    routeTemplate: "api/{controller}/{action}/{id}",
    defaults: new { id = RouteParameter.Optional });

After modification, the request URL needs to explicitly specify the action method name, for example:

• <span style="font-family: monospace;">/api/MyController/Summary</span>
• <span style="font-family: monospace;">/api/MyController/FullDetails</span>

This method provides the clearest URL structure, facilitating understanding and maintenance.

Solution 2: Use Parameter Overloading Methods

Another elegant solution leverages method overloading characteristics:

public HttpResponseMessage Get()
{
    // Handle GET requests without parameters
    return null;
}

public HttpResponseMessage Get(MyVm vm)
{
    // Handle GET requests with parameters
    return null;
}

In this solution, Web API can distinguish between different methods based on whether the request contains parameters. For parameter passing, it is recommended to use URI parameters rather than the request body, as GET requests typically should not include request body content. If complex objects must be used, the <span style="font-family: monospace;">[FromBody]</span> attribute can be employed, but this does not align with HTTP best practices.

Solution 3: Configure Multiple Routing Strategies

Following the suggestions from reference materials, multiple routing rules can be configured to handle different scenarios:

config.MapHttpAttributeRoutes();

config.Routes.MapHttpRoute(
    name: "ControllerAndActionOnly",
    routeTemplate: "api/{controller}/{action}",
    defaults: new { },
    constraints: new { action = @"^[a-zA-Z]+([\s][a-zA-Z]+)*$" });

config.Routes.MapHttpRoute(
    name: "DefaultApi",
    routeTemplate: "api/{controller}/{id}",
    defaults: new { id = RouteParameter.Optional });

This configuration requires attention to routing order. The routing system attempts matches in the order of definition, so more specific routes should be placed first. The first route requires explicit specification of the action name, while the second route provides a traditional RESTful-style interface.

Best Practices and Recommendations

When selecting a solution, consider the specific requirements of the project:

1. If clear URL structure and explicit method invocation are needed, route configuration including action parameters is recommended
2. If maintaining RESTful style with similar method functionality is desired, parameter overloading is a better choice
3. For complex API requirements, multiple routing strategies offer maximum flexibility

Regardless of the chosen solution, ensure that the API design complies with HTTP standards and REST principles, providing clear and consistent interfaces for client usage.