¿Cómo leer valores de la cadena de consulta con ASP.NET Core?

Estoy creando una API RESTful usando ASP.NET Core MVC y quiero usar parámetros de cadena de consulta para especificar el filtrado y la paginación en un recurso que devuelve una colección.

En ese caso, necesito leer los valores pasados ​​en la cadena de consulta para filtrar y seleccionar los resultados para devolver.

Ya descubrí que dentro de la Getacción del controlador , el acceso HttpContext.Request.Querydevuelve uno IQueryCollection.

El problema es que no sé cómo se usa para recuperar los valores. En verdad, pensé que la forma de hacerlo era usando, por ejemplo

string page = HttpContext.Request.Query["page"]

El problema es que HttpContext.Request.Query["page"]no devuelve una cadena, sino a StringValues.

De todos modos, ¿cómo se usa uno IQueryCollectionpara leer realmente los valores de la cadena de consulta?

Puede usar [FromQuery]para vincular un modelo particular a la cadena de consulta:

https://docs.microsoft.com/en-us/aspnet/core/mvc/models/model-binding

p.ej

[HttpGet()]
public IActionResult Get([FromQuery(Name = "page")] string page)
{...}

Puede usar el método ToString en el IQueryCollectionque devolverá el valor deseado si pagese especifica un único parámetro:

string page = HttpContext.Request.Query["page"].ToString();

si hay varios valores como ?page=1&page=2entonces, el resultado de la llamada ToString será1,2

Pero como sugirió @ mike-g en su respuesta, sería mejor usar el enlace de modelo y no acceder directamente al HttpContext.Request.Queryobjeto.

ASP.NET Core se unirá de forma automática form values, route valuesy query stringspor su nombre. Esto significa que simplemente puede hacer esto:

[HttpGet()]
public IActionResult Get(int page)
{ ... }

MVC intentará vincular los datos de la solicitud a los parámetros de acción por nombre ... a continuación hay una lista de las fuentes de datos en el orden en que el enlace del modelo los revisa

1. Form values: Estos son valores de formulario que van en la solicitud HTTP utilizando el método POST. (incluidas las solicitudes jQuery POST).

2. Route values: El conjunto de valores de ruta proporcionados por Enrutamiento

3. Query strings: La parte de la cadena de consulta del URI.

Fuente: Cómo funciona el enlace de modelos

Para su información, también puede combinar los enfoques automático y explícito:

[HttpGet()]
public IActionResult Get(int page
     , [FromQuery(Name = "page-size")] int pageSize)
{ ... }

Simplemente puede crear un objeto como este:

public class SomeQuery
{
    public string SomeParameter { get; set; }
    public int? SomeParameter2 { get; set; }
}

Y luego en el controlador solo haz algo así:

[HttpGet]
public IActionResult FindSomething([FromQuery] SomeQuery query)
{
    // Your implementation goes here..
}

Aún mejor, puede crear un modelo API a partir de:

[HttpGet]
public IActionResult GetSomething([FromRoute] int someId, [FromQuery] SomeQuery query)

a:

[HttpGet]
public IActionResult GetSomething(ApiModel model)

public class ApiModel
{
    [FromRoute]
    public int SomeId { get; set; }
    [FromQuery]
    public string SomeParameter { get; set; }
    [FromQuery]
    public int? SomeParameter2 { get; set; }
}

Aquí hay una muestra de código que he usado (con una vista de .NET Core):

@{
    Microsoft.Extensions.Primitives.StringValues queryVal;

    if (Context.Request.Query.TryGetValue("yourKey", out queryVal) &&
        queryVal.FirstOrDefault() == "yourValue")
    {
    }
}

StringValueses una matriz de cadenas . Puede obtener su valor de cadena proporcionando un índice, por ejemplo HttpContext.Request.Query["page"][0].

IQueryCollectiontiene un TryGetValue()valor que devuelve un valor con la clave dada. Entonces, si tuviera un parámetro de consulta llamado someInt, podría usarlo así:

var queryString = httpContext.Request.Query;
StringValues someInt;
queryString.TryGetValue("someInt", out someInt);
var daRealInt = int.Parse(someInt);

Tenga en cuenta que a menos que tenga varios parámetros del mismo nombre, el StringValuestipo no es un problema.

en .net core si desea acceder a la cadena de consulta en nuestra vista, úsela como

@Context.Request.Query["yourKey"]

si estamos en una ubicación donde @Context no está disponible, podemos inyectarlo como

@inject Microsoft.AspNetCore.Http.IHttpContextAccessor HttpContextAccessor
@if (HttpContextAccessor.HttpContext.Request.Query.Keys.Contains("yourKey"))
{
      <text>do something </text>
}

también para galletas

HttpContextAccessor.HttpContext.Request.Cookies["DeniedActions"]

Tengo una mejor solución para este problema,

• request es miembro de la clase abstracta ControllerBase
• GetSearchParams () es un método de extensión creado en la siguiente clase de ayuda.

var searchparams = await Request.GetSearchParams();

He creado una clase estática con pocos métodos de extensión.

public static class HttpRequestExtension
{
  public static async Task<SearchParams> GetSearchParams(this HttpRequest request)
        {
            var parameters = await request.TupledParameters();

            try
            {
                for (var i = 0; i < parameters.Count; i++)
                {
                    if (parameters[i].Item1 == "_count" && parameters[i].Item2 == "0")
                    {
                        parameters[i] = new Tuple<string, string>("_summary", "count");
                    }
                }
                var searchCommand = SearchParams.FromUriParamList(parameters);
                return searchCommand;
            }
            catch (FormatException formatException)
            {
                throw new FhirException(formatException.Message, OperationOutcome.IssueType.Invalid, OperationOutcome.IssueSeverity.Fatal, HttpStatusCode.BadRequest);
            }
        }



public static async Task<List<Tuple<string, string>>> TupledParameters(this HttpRequest request)
{
        var list = new List<Tuple<string, string>>();


        var query = request.Query;
        foreach (var pair in query)
        {
            list.Add(new Tuple<string, string>(pair.Key, pair.Value));
        }

        if (!request.HasFormContentType)
        {
            return list;
        }
        var getContent = await request.ReadFormAsync();

        if (getContent == null)
        {
            return list;
        }
        foreach (var key in getContent.Keys)
        {
            if (!getContent.TryGetValue(key, out StringValues values))
            {
                continue;
            }
            foreach (var value in values)
            {
                list.Add(new Tuple<string, string>(key, value));
            }
        }
        return list;
    }
}

De esta manera puede acceder fácilmente a todos sus parámetros de búsqueda. Espero que esto ayude a muchos desarrolladores :)

Algunos de los comentarios mencionan esto también, pero asp net core hace todo este trabajo por usted.

Si tiene una cadena de consulta que coincide con el nombre, estará disponible en el controlador.

https: // myapi / some-endpoint / 123? someQueryString = YayThisWorks

[HttpPost]
[Route("some-endpoint/{someValue}")]
public IActionResult SomeEndpointMethod(int someValue, string someQueryString)
    {
        Debug.WriteLine(someValue);
        Debug.WriteLine(someQueryString);
        return Ok();
    }

Ouputs:

123

YayThisWorks