route - web api rest c#

¿Cómo agregar métodos personalizados al controlador ASP.NET WebAPI?

Question

En el proyecto ASP.NET MVC WebAPI por defecto, hemos creado el siguiente controlador

 public class ValuesController : ApiController
    {
        // GET api/values
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "value2" };
        }

        // GET api/values/5
        public string Get(int id)
        {
            return "value";
        }

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

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

        // DELETE api/values/5
        public void Delete(int id)
        {
        }
}

¿Pero es posible agregar aquí algún método personalizado para que puedan admitir obtener / publicar también?

¡Gracias!

Answer 1

No estoy seguro de seguirlo ya que tiene GET y POST allí mismo en su código, pero en cualquier caso tiene otras opciones:

Opción 1

Primero, puede configurar sus Rutas personalizadas en la carpeta App_Start en el archivo WebApiConfig.cs . Esto es lo que normalmente uso:

    // GET /api/{resource}/{action}
    config.Routes.MapHttpRoute(
        name: "Web API RPC",
        routeTemplate: "{controller}/{action}",
        defaults: new { },
        constraints: new { action = @"[A-Za-z]+", httpMethod = new HttpMethodConstraint("GET") }
        );

    // GET|PUT|DELETE /api/{resource}/{id}/{code}
    config.Routes.MapHttpRoute(
        name: "Web API Resource",
        routeTemplate: "{controller}/{id}/{code}",
        defaults: new { code = RouteParameter.Optional },
        constraints: new { id = @"/d+" }
        );

    // GET /api/{resource}
    config.Routes.MapHttpRoute(
        name: "Web API Get All",
        routeTemplate: "{controller}",
        defaults: new { action = "Get" },
        constraints: new { httpMethod = new HttpMethodConstraint("GET") }
        );

    // PUT /api/{resource}
    config.Routes.MapHttpRoute(
        name: "Web API Update",
        routeTemplate: "{controller}",
        defaults: new { action = "Put" },
        constraints: new { httpMethod = new HttpMethodConstraint("PUT") }
        );

    // POST /api/{resource}
    config.Routes.MapHttpRoute(
        name: "Web API Post",
        routeTemplate: "{controller}",
        defaults: new { action = "Post" },
        constraints: new { httpMethod = new HttpMethodConstraint("POST") }
        );

    // POST /api/{resource}/{action}
    config.Routes.MapHttpRoute(
        name: "Web API RPC Post",
        routeTemplate: "{controller}/{action}",
        defaults: new { },
        constraints: new { action = @"[A-Za-z]+", httpMethod = new HttpMethodConstraint("POST") }
        );

Utilizo una combinación de puntos finales RESTful así como puntos finales RPC . Para algunos puristas, esto es motivo para una guerra santa. Para mí, uso una combinación de los dos porque es una combinación poderosa y no puedo encontrar ninguna razón sensata para no hacerlo.

opcion 2

Como han señalado los demás y mientras estoy haciendo más de estos días, use el enrutamiento de atributos:

    [HttpGet]
    [GET("SomeController/SomeUrlSegment/{someParameter}")]
    public int SomeUrlSegment(string someParameter)
    {
        //do stuff
    }

Necesitaba un paquete NuGet para el enrutamiento de atributos para hacer que esto funcionara (solo busque en NuGet "Enrutamiento de atributos"), pero creo que MVC 5 / WebAPI 2 lo tiene de forma nativa.

Espero que esto ayude.

Answer 2

Primero pon esta ruta a webapiconfig.cs

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

Ahora puedes agregar acciones a tus controladores de esta manera

 [HttpPost]
    public void Upload()
    {
           //Do some thing
    }

Decoré la acción de carga con el atributo httppost, lo que significa que esta acción solo acepta solicitudes de publicación, si desea que las acciones sean GET, puede eliminar el atributo o simplemente decorar su suite

Answer 3

Puede usar atributos como el RoutePrefix con el tipo Http.

[Route("ChangePassword")]
[HttpPost] // There are HttpGet, HttpPost, HttpPut, HttpDelete.
public async Task<IHttpActionResult> ChangePassword(ChangePasswordModel model)
{        
}

El tipo http lo asignará de nuevo a su método correcto en combinación con el nombre de la ruta.

Answer 4

Usted podría utilizar el enrutamiento de atributos:

[Route("customers/{customerId}/orders")]
public IEnumerable<Order> GetOrdersByCustomer(int customerId) { ... }

Algunos documentos para comenzar:

http://www.asp.net/web-api/overview/web-api-routing-and-actions/attribute-routing-in-web-api-2