This course will be retired on June 1, 2025.
Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
If a controller action method has parameters, Web API must provide values for those parameters using a process known as "parameter binding".
Follow Along
To follow along committing your changes to this course, you'll need to fork the aspnet-fitness-frog-spa repo. Then you can clone, commit, and push your changes to your fork like this:
git clone <your-fork>
cd aspnet-fitness-frog-spa
git checkout tags/v2.4 -b exploring-parameter-binding
JSON POST Data
If you're following along, here's the message body data for making a POST request against the API:
{
"date": "1/1/2017",
"activityId": 1,
"duration": 4.5,
"intensity": 1,
"exclude": false,
"notes": null
}
Advanced Parameter Binding Options
For more information about the advanced parameter binding options available in Web API—including type converters, model binders, value providers, and custom parameter binding rules—see this resource:
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
After Web API has selected
a controller to handle a request,
0:00
it then calls an action
method on that controller.
0:04
If the action method has parameters,
Web API must provide values for
0:07
those parameters using
a process knows as binding.
0:11
Our Get method that returns a collection
of entries doesn't define any parameters.
0:15
So web API can just directly call that
method without having to do any binding.
0:22
But the call that Get method
that returns a single entry,
0:31
a value must be provided for
the ID parameter.
0:34
Our current implementations for
the Post, Put and
0:37
Delete action methods don't define
any parameters, but they should.
0:41
The post method should define
an entry parameter of type entry.
0:46
Representing the resource to create.
0:52
And the Put method should define
an ID parameter of type int.
0:56
Specifying the id of
the resource to update, and
1:00
an Entry parameter of type entry,
representing the resource to update.
1:03
And the Delete method should define
an id parameter of type int,
1:11
specifying the id of
the resource to delete.
1:15
So how does Web API provide binding
values for these parameters?
1:19
By default, simply types get their
values from the route data or
1:24
query string parameters and complex types
get their values from the message body,
1:28
using immediate type formatter.
1:33
Let's set break points in the Delete and
Post methods.
1:35
And use Postman to see Web API's
parameter binding in action.
1:40
First, let's make a request
to delete an entry.
1:51
Select DELET in the list of HTTP methods,
1:54
Provide the URL, http://localhost; and
2:01
then your port number,
for me that's 51487.
2:07
Remember, your port number
is probably different,
2:14
then /api/entries/1, and
click the Send button.
2:19
Here we are at our break
point in Visual Studio.
2:30
If we hover over the id parameter,
we can see that its value is 1.
2:33
The ID parameter is of type int,
which is a simple type.
2:38
In this context, simple types include
the .net primitive types like int,
2:42
bool, double, to name a few.
2:47
Plus timespan, daytime,
guid, decimal, and string.
2:50
Plus any type of a type converter
that can convert from a string.
2:55
Type converters are special classes
that contain logic to convert strings to
3:00
the type that they're associated with.
3:04
For more information about type
converters see the teacher's notes.
3:06
So because the id parameter is a simple
type, It was populated from the URI,
3:15
specifically, in this case,
the route data for the request.
3:22
If we review our configured default route,
3:35
we'll see that we provided the route
template api/controller/id.
3:39
A request URI without the protocol and
3:47
host name was api/entries/1.
3:52
The first segment matched
the API literal parse segment.
3:57
The second segment entires, match
the controller route parameter segment,
4:02
and 1 match the ID route
parameter segment.
4:07
Our ID method parameter match
the name of the ID route parameter.
4:11
So, Web API binded the route parameter
value of 1 to the method parameter.
4:16
Let's start the application again and
switch the Postman.
4:21
Let's make a request to post an entry.
4:33
I'll open a new tab and
select Post in the list of HTTP methods.
4:37
And provide the URL
http://localhost: my port number,
4:44
51487/api/entries.
4:53
When making a POST request,
we need to provide a message body.
4:58
Click on the Body tab, select raw and
5:02
JSON(application/json).
5:06
Then click into the field
right below that and
5:10
provide the following JSON formatted data.
5:13
A set of curly braces,
a pair of quotes and
5:16
the field name date, followed by a colon,
followed by another pair of quotes.
5:21
And inside of that, the date 1/1/2017.
5:27
Add a comma on the end and another
set of quotes and the property name,
5:33
activityId, followed by a colon and
the number 1.
5:38
Another comma, another set of quotes,
and the property name,
5:42
duration, followed by a colon and
the value 4.5.
5:47
Another comma, set of quotes,
and a property name, intensity,
5:53
followed by a colon and
the number 1, followed by a comma
5:59
and the property name exclude,
another colon.
6:06
This time Boolean value false comma,
notes for
6:10
the property name and null for the value.
6:15
If you're following along,
6:20
you can find a copy of this JSON
data in the teachers notes.
6:21
Then click the Send button.
6:25
Here we are at our break
point in Visual Studio.
6:30
If we hover over the entry parameter,
6:33
we can see that our JSON formatted data
has flowed into the object properties.
6:36
The Entry parameter is of type
entry which is a complex type.
6:42
In this context, a complex type is a class
that defines one or more properties.
6:47
Typically, these classes are an
application's data models, or entities.
6:52
The entry parameter is the complex type,
so
7:00
it was populated from the message
body using a media type formatter.
7:03
In this case specifically,
because we specified a media type of
7:08
applications/JSON, web API used
the JSON media type formatter
7:11
to deserialize the JSON formatted data
to an instance of the entry class.
7:16
Remember that the JSON media
type formatter internally
7:23
uses the JSON.Net framework.
7:26
So Json.NET was actually responsible for
deserializing the provided JSON data.
7:29
It's also possible to override
the default parameter binding behavior
7:40
using the from URI, and
from body attributes.
7:45
For instance,
7:48
you could decorate a complex method
parameter with the FromUri attribute to
7:49
force Web API to populate the complex
types property values from the URI.
7:54
Or vice versa.
8:04
You could decorate a simple method
parameter with the front body attribute to
8:06
force Web API to populate the simple
parameter value from the message body.
8:10
We're okay with the default
parameter binding behavior, so
8:22
let's remove these attributes.
8:26
There are also an number of advanced
parameter binding options that when used
8:35
allow you to customize
the binding process.
8:39
For information about custom
TypeConverters, model binders, and
8:42
more, see the teacher's notes.
8:46
Our Fitness Frog API is really
starting to take shape.
8:49
In the next section,
we'll wrap up work in our API.
8:52
See you after the break.
8:55
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up