Required query string parameter in ASP.NET Core

Question

Using ASP.NET Core 1.1 with VS2015 (sdk 1.0.0-preview2-003131), I have the following controller:

public class QueryParameters
{
    public int A { get; set;          


        

Answer 1

Use model validation. You can define a ViewModel and use DataAnnotations to mark property A as [Required]. Then in your action just check if ModelState.IsValid. You can also easily do this using an action filter as shown in this article: https://msdn.microsoft.com/en-us/magazine/mt767699.aspx

Answer 2

Let the framework do the work for you. Here is one solution, as it appears there are a number of ways to accomplish the same thing in ASP.NET Core. But this is what works for me and is quite simple. It seems to be a combination of some of the answers already given.

public class QueryParameters
{
    [Required]
    public int A { get; set; }

    public int B { get; set; }
}

[Route("api/[controller]")]
public class ValuesController : Controller
{
    // GET api/values
    // [HttpGet] isn't needed as it is the default method, but ok to leave in
    // QueryParameters is injected here, the framework takes what is in your query string and does its best to match any parameters the action is looking for. In the case of QueryParameters, you have A and B properties, so those get matched up with the a and b query string parameters
    public IEnumerable<string> Get(QueryParameters parameters)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(); // or whatever you want to do
        }

        return new [] { parameters.a.ToString(), parameters.b.ToString() };
    }        
}

Answer 3

You can consider using the model binding feature of the framework

According to documentation here: Customize model binding behavior with attributes

MVC contains several attributes that you can use to direct its default model binding behavior to a different source. For example, you can specify whether binding is required for a property, or if it should never happen at all by using the [BindRequired] or [BindNever] attributes.

So I suggest you add a BindRequiredAttribute to the model property.

public class QueryParameters
{
    [BindRequired]
    public int A { get; set; }
    public int B { get; set; }
}

From there the framework should be able to handle the binding and updating model state so that you can check the state of the model in the action

[Route("api/[controller]")]
public class ValuesController : Controller
{
    // GET api/values
    [HttpGet]
    public IActionResult Get([FromQuery]QueryParameters parameters)
    {    
        if (ModelState.IsValid)
        {
            return Ok(new [] { parameters.A.ToString(), parameters.B.ToString() });
        }
        return BadRequest();
    }        
}

The other option would be to create a custom model binder that would fault the action if the required query string is not present.

Reference: Custom Model Binding

Answer 4

Use attribute routing and list each required parameter in the function's HttpGet attribute.

[Route("api/[controller]")]
public class ValuesController : Controller
{
    [HttpGet("{A}")]
    public IEnumerable<string> Get(int A, int B)
    {
       return new [] { A.ToString(), B.ToString() };
    }
}

This will require e.g /5 and allow /5?B=6 query url parameters.

Answer 5

In ASP.NET Core 2.1 and above you can use top level parameters validation. You can put attributes on parameters

    [HttpGet]
    public IActionResult GetDices([Required, Range(1, 6)]int number)
    {
        if (ModelState.IsValid)
        {
            return Ok(_diceRepo.GetDices(number));
        }
        return BadRequest("Something went wrong");
    }

More about this https://andrewlock.net/coming-in-asp-net-core-2-1-top-level-mvc-parameter-validation/