Issue title: Web api - conventional routing instead of attribute routing
 Issue body: At the moment the Web Api project template contains a ValuesController which uses the following attribute for routing - [Route("api/[controller]")]. For prototyping purposes, I was trying to get rid of this attribute route and replace it with a MapRoute call in Startup.cs without much luck. The following code does match the first "Get" action, but not the others. 

```
routes.MapRoute(
    name: "default",
    template: "api/{controller}/{action}",
    defaults: new { action = "Get" });
```

Any help would be highly appreciated. Thanks!
 Comments: 
 Comment 0: There's no reason why you can't use traditional routing (`MapRoute`) instead of attribute routing for an API. 

We really strongly recommend using attribute routing for APIs because it gives you fine grained control over your URL surface. You also can run into scaling problems if you write many routes using `MapRoute` to try and accomplish the same thing.

================

You should take a look at https://docs.microsoft.com/en-us/aspnet/core/mvc/controllers/routing if you haven't already. If that doesn't answer your questions then please provide more information about what you're trying to do and we can try to help.
 Comment 1: @rynowak, thanks for getting back to me on this. Yes, I have found the documentation and I have been reading up on this yet, I was not able to come up with a `MapRoute` statement which could replace the `[Route("api/[controller]")]` attribute route. I was thinking that I might have to use `MapGet` but I could not get that to work. Any code samples would be highly appreciated.

Let me try to give you some context as I might be approaching the issue in the wrong way. I am working on an ASP.NET Core application (targeting .NET Framework) that leverages areas and will be used by separate teams. The scope of the team that is using the application is in the URL (ex: /team1/Area/Home/Index, /team2/Area/Home/Index). I have a settings file which defines which area is available for which team and based on that setting file I was thinking of explicitly setting up the routes of my application using `MapRoute` instead of writing validation code and redirect to a 404 in case an area is not available to a particular team.

The other option that I have been exploring which is mentioned in the documentation that you have linked above is to:
- Use an attribute route for all Web Apis - `[Route("api/[area]/[controller]")]`
- Use the application model to update/add a routing attribute for each team based on the settings file

Thanks again for your guidance!
 Comment 2: There isn't really a way to use `MapRoute(...)` to say the same thing as `[Route("api/[controller]")]` and `MapRoute("api/{controller}/{action}")` when we're talking about routing. There really isn't an equivalency here, they are made of different stuff.


`[Route("api/[controller]")]` is token substitution, the name of the controller (let's say `ProductsController` is the class name) gets substituted in to make `"api/Products"`. Additionally, any attribute routes that appear of on the action methods get **appended**. 

So when you write:
```
[Route("api/[controller]")]
public class ProductsController : Controller
{
    [HttpGet("{id}")]
    public IActionResult GetProduct(int id) { }
}
```

There's an entry created in the attribute routing tree that links `api/Products/{id}` back to your `ProductsController.GetProduct` method.

-----------------

One the other hand conventional routing is a totally different mechanism. When you do define a route like `MapRoute("api/{controller}/{action}/{id?}")` you've defined a pattern for matching URL paths. So a URL path like `api/Products/GetProduct/7` will be matched and then we'll look up the route data `{ controller = Products, action = GetProduct }` in a table and find your `ProductsController.GetProduct`.


Now what will happen if you want to write a route that's specific to a given controller or action? you can do this with defaults.
```
MapRoute("api/Products/{id?}", defaults: new { controller = "Products", action = "GetProduct"})
```

You've create a route now that will always and only match the `ProductsController.GetProduct` method. When this pattern matches, the same set of route values are produced by both of these examples.

However -- this still isn't the same as `[Route("api/[controller]")]` because you have to create a route for each action. This leads to the scalability problem I pointed out in my original answer.

------

If your needs are as simple as disabling a few areas, then I think the simplest thing to do would be to build your application using attribute routing, and then use application model to **remove** the controllers that you don't want to work at startup time based on configuration.
 Comment 3: @rynowak, thanks for your guidance. Will go with the attribute route + application model option.
 Comment 4: @lszomoru Will below code work for you by "https://localhost:44387/api/values/getbyid/1"?
Rourting
```
            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
                routes.MapRoute(
                    name: "api",
                    template: "api/{controller=Values}/{action=GetAll}/{id?}");
            });
```
ValuesController
 ```
   //[Route("api/[controller]")]
    public class ValuesController : Controller
    {
        // GET: api/values
        //[HttpGet]
        public IEnumerable<string> GetAll()
        {
            return new string[] { "value1", "value2" };
        }
        // GET api/values/5
        //[HttpGet("{id}")]
        public string GetById(int id)
        {
            return "value";
        }

        //// POST api/values
        //[HttpPost]
        //public void Post([FromBody]string value)
        //{
        //}

        //// PUT api/values/5
        //[HttpPut("{id}")]
        //public void Put(int id, [FromBody]string value)
        //{
        //}

        //// DELETE api/values/5
        //[HttpDelete("{id}")]
        //public void Delete(int id)
        //{
        //}
    }
```
**Note, remove all of the Attribute route.**


{'source': 'GithubIssues', 'repo_name_with_owner': 'aspnet/Routing', 'issue_id': 206499865, 'repo_stars': 273.0}