¿Cómo debo pasar múltiples parámetros a un ASP.Net Web API GET?

Estoy usando la API web .Net MVC4 para (con suerte) implementar una API RESTful. Necesito pasar algunos parámetros al sistema y hacer que realice alguna acción, luego devolver una lista de objetos como resultado. Específicamente, paso dos fechas y devuelvo registros que se encuentran entre ellas. También estoy haciendo un seguimiento de los registros devueltos para que las llamadas posteriores no se vuelvan a procesar en el sistema.

He considerado algunos enfoques:

1. Serializar los parámetros en una sola cadena JSON y separarlos en la API. http://forums.asp.net/t/1807316.aspx/1

2. Pase los parámetros en la cadena de consulta.
   ¿Cuál es la mejor manera de pasar múltiples parámetros de consulta a una API relajante?

3. Definición de los parámetros en la ruta: api / controller / date1 / date2

4. Usando un POST que inherentemente me permite pasar un objeto con params.

5. Investigando ODATA ya que la API web (actualmente) lo admite. Todavía no he hecho mucho con esto, así que no estoy muy familiarizado con él.

Parece que las prácticas REST adecuadas indican cuándo se extraen los datos, debe usar un GET. Sin embargo, GET también debería ser nulipotente (no produce efectos secundarios), y me pregunto si mi implementación específica viola eso ya que marco registros en el sistema API, por lo tanto, estoy produciendo efectos secundarios.

También me llevó a la cuestión de admitir parámetros variables. Si la lista de parámetros de entrada cambia, sería tedioso tener que redefinir su ruta para la Opción 3 si eso sucede mucho. Y qué podría pasar si los parámetros se definen en tiempo de ejecución ...

En cualquier caso, para mi implementación específica, ¿qué opción (si hay alguna) parece mejor?

¿Qué significa esta marca de registro? Si esto se usa solo para fines de registro, usaría GET y deshabilitaría todo el almacenamiento en caché, ya que desea registrar cada consulta para estos recursos. Si el marcado de registros tiene otro propósito, POST es el camino a seguir. El usuario debe saber que sus acciones afectan el sistema y el método POST es una advertencia.

Creo que la forma más fácil es simplemente usar AttributeRouting.

Es obvio dentro de su controlador, ¿por qué querría esto en su WebApiConfigarchivo Global ?

Ejemplo:

    [Route("api/YOURCONTROLLER/{paramOne}/{paramTwo}")]
    public string Get(int paramOne, int paramTwo)
    {
        return "The [Route] with multiple params worked";
    }

Los {}nombres deben coincidir con sus parámetros.

Tan simple como eso, ahora tiene un separado GETque maneja múltiples parámetros en esta instancia.

Simplemente agregue una nueva ruta a las WebApiConfigentradas.

Por ejemplo, para llamar:

public IEnumerable<SampleObject> Get(int pageNumber, int pageSize) { ..

añadir:

config.Routes.MapHttpRoute(
    name: "GetPagedData",
    routeTemplate: "api/{controller}/{pageNumber}/{pageSize}"
);

Luego agregue los parámetros a la llamada HTTP:

GET //<service address>/Api/Data/2/10 

Solo tuve que implementar una API RESTfull donde necesito pasar parámetros. Lo hice pasando los parámetros en la cadena de consulta en el mismo estilo que se describe en el primer ejemplo de Mark "api / controller? Start = date1 & end = date2"

¿En el controlador usé un consejo de URL dividida en C #?

// uri: /api/courses
public IEnumerable<Course> Get()
{
    NameValueCollection nvc = HttpUtility.ParseQueryString(Request.RequestUri.Query);
    var system = nvc["System"];
    // BL comes here
    return _courses;
}

En mi caso, estaba llamando a WebApi a través de Ajax con el siguiente aspecto:

$.ajax({
        url: '/api/DbMetaData',
        type: 'GET',
        data: { system : 'My System',
                searchString: '123' },
        dataType: 'json',
        success: function (data) {
                  $.each(data, function (index, v) {
                  alert(index + ': ' + v.name);
                  });
         },
         statusCode: {
                  404: function () {
                       alert('Failed');
                       }
        }
   });

Espero que esto ayude...

Encontré una excelente solución en http://habrahabr.ru/post/164945/

public class ResourceQuery
{
   public string Param1 { get; set; }
   public int OptionalParam2 { get; set; }
}

public class SampleResourceController : ApiController
{
    public SampleResourceModel Get([FromUri] ResourceQuery query)
    {
        // action
    }
}

El uso de GET o POST se explica claramente por @LukLed . Con respecto a las formas en que puede pasar los parámetros, sugeriría ir con el segundo enfoque (tampoco sé mucho sobre ODATA ).

1. Serializar los parámetros en una sola cadena JSON y separarlos en la API. http://forums.asp.net/t/1807316.aspx/1

Esto no es fácil de usar ni SEO.

2. Pase los parámetros en la cadena de consulta. ¿Cuál es la mejor manera de pasar múltiples parámetros de consulta a una API relajante?

Este es el enfoque preferible habitual.

3.Definición de los parámetros en la ruta: api / controller / date1 / date2

Este definitivamente no es un buen enfoque. Esto hace sentir que alguien date2es un sub recurso de date1y ese no es el caso. Tanto el date1y date2son parámetros de consulta y viene en el mismo nivel.

En un caso simple, sugeriría un URI como este,

api/controller?start=date1&end=date2

Pero personalmente me gusta el siguiente patrón de URI, pero en este caso tenemos que escribir un código personalizado para mapear los parámetros.

api/controller/date1,date2

Utilice el enlace de parámetros como se describe completamente aquí: http://www.asp.net/web-api/overview/formats-and-model-binding/parameter-binding-in-aspnet-web-api

 [Route("api/controller/{one}/{two}")]
    public string Get(int One, int Two)
    {
        return "both params of the root link({one},{two}) and Get function parameters (one, two)  should be same ";
    }

Ambos parámetros del enlace raíz ({uno}, {dos}) y los parámetros de la función Obtener (uno, dos) deben ser iguales

Sé que esto es muy viejo, pero quería lo mismo recientemente y esto es lo que encontré ...

    public HttpResponseMessage Get([FromUri] string var, [FromUri] string test) {
        var retStr = new HttpResponseMessage(HttpStatusCode.OK);
        if (var.ToLower() == "getnew" && test.ToLower() == "test") {
            retStr.Content = new StringContent("Found Test", System.Text.Encoding.UTF8, "text/plain");
        } else {
            retStr.Content = new StringContent("Couldn't Find that test", System.Text.Encoding.UTF8, "text/plain");
        }

        return retStr;
    }

Así que ahora en su dirección / URI / ...

http (s): // myURL / api / myController /? var = getnew & test = test

Resultado: "Prueba encontrada"

http (s): // myURL / api / myController /? var = getnew & test = anything

Resultado: "No se pudo encontrar esa prueba"

Ahora puedes hacer esto simplemente usando

        public string Get(int id, int abc)
        {
            return "value: " + id + "  " + abc;
        }

esto devolverá: "valor: 5 10"

si lo llama con https: // yourdomain / api / yourcontroller? id = 5 & abc = 10

    public HttpResponseMessage Get(int id,string numb)
    {
        //this will differ according to your entity name
        using (MarketEntities entities = new MarketEntities())
        {
          var ent=  entities.Api_For_Test.FirstOrDefault(e => e.ID == id && e.IDNO.ToString()== numb);
            if (ent != null)
            {
                return Request.CreateResponse(HttpStatusCode.OK, ent);
            }
            else
            {
                return Request.CreateErrorResponse(HttpStatusCode.NotFound, "Applicant with ID " + id.ToString() + " not found in the system");
            }
        }
    }