ASP.Net Core 3 – pass parameters to actions

Passing parameters to actions is an essential part of building RESTful Web API. .Net Core offers multiple ways to pass parameters to methods, that represent your endpoints. Let’s see what they are.

Pass parameter as a part of an url

When passing a parameter in a url, you need to define a routing that would contain a parameter. Let’s have a look a the example:

 

This method returns a WeatherForecast for a single day in the future. DaysForward parameter represents how many days in advance weather forecast should be returned for. Notice that daysForward is a part of the routing, so a valid url to this endpoint will look like:

GET: weatherForecast/3

We can also use [FromRoute] attribute before variable type, but it will also work the same way by default.

Pass parameter in a query string

This is a vary common method for passing additional parameters, because it does not require for us to change routing, so it is also backward compatible. It’s important if we were to change an existing solution.

Let’s look at a different method, that would return a collection of weather worecasts with a sorting option.

In this example we pass on sortByTemperature parameter which is optional. Notice that we use [FromQuery] attribute to indicate, that it’s a variable taken from query string. A url to this endpoint would look like this:

GET: weatherForecast?sortByTemperature=true

You can put many prameters like this:

GET: weatherForecast?key1=value1&key2=value2&key3=value3

Remember, that url needs to be encoded properly to work right. If you were to pass a parameter like this:

http://www.michalbialecki.com/?name=Michał Białecki

It will need to be encoded into:

http://www.michalbialecki.com/?name=Micha%C5%82%20Bia%C5%82ecki

Pass parameters with headers

Passing parameters in a request headers is less popular, but also widely used. It doesn’t show in a url, so it’s less noticeable be the user. A common scenario for passing parameters in a header would be providing credentials or a parent request id to enable multi application tracking. Let’s have a look at this example:

In order to send a POST request, we would need to use some kind of a tool, I’ll use Postman:

Here you see that I specified headers and parentRequestId is one of them.

Pass parameters in a request body

Most common way to pass the data is to include it in a request body. We can add a header Content-Type with value application/json and inform the receiver how to interpret this body. Let’s have a look at our example:

We use [FromBody] attribute to indicate, that forecast will be taken from request body. In .Net Core 3 we don’t need and serialize to deserialize json body to WeatherForecast object, it will work automatically. To send POST request, let’s use Postman once again:

Have in mind, that size of the request body is limited by the server. It can be anywhere between 1MB to 2GB. In ASP.Net Core maximum request body size is around 28MB, but that can be changed. What if I would like to send bigger files than that, over 2GB? Then you should look into sending a content as a stream or sending it in chunks.

Pass parameters in a form

Sending content in a form is not very common, but it is the best solution if you want to upload a file. Let’s have a look at the example:

This method doesn’t really send a file, but it will successfully receive a file from the request. The interface IFormFile is used specifically for handling a file.

When sending a request we need to set Content-Type to application/x-www-form-urlencoded and it the Body part, we need to choose a file:

Let’s see what do we get when we debug this code:

And file is correctly read. Interesting fact is, that with IFormFile we get not only binarry data, but also a file type and name. So you might ask why I send a file name separately? This is because you might want to name file differently on the server, then the one you are sending.

Hope you enjoyed this post, you can have a look at the code posted here on my Github:

https://github.com/mikuam/TicketStore

One thought on “ASP.Net Core 3 – pass parameters to actions

  1. Very useful article Passing parameters to actions is an essential part of building RESTful Web API. .Net Core offers multiple ways to pass parameters to methods, that represent your endpoints.

Leave a Reply

Your email address will not be published. Required fields are marked *