I have the following route definition in my webapi project. I have problem one of the parameter is not passed. eg;
when i call /Controller/Action/param2/startdate/enddate the value i passed for param2 is taken for param1 and vice versa.The problem is, the RoutingModule can not detect that the provided route value is for param2 not param1
It works if i use querystring in the url but doesn't want to use querystring. Appreciate your help.
Is there any way to achieve what i expect?
config.Routes.MapHttpRoute(
name: "RetrieveHistory",
routeTemplate: "{controller}/{action}/{param1}/{param2}/{startDate}/{endDate}",
defaults: new
{
controller = "Vend",
action = "RetrieveUtrnHistory",
param1 = RouteParameter.Optional,
param2 = RouteParameter.Optional,
starDate = RouteParameter.Optional,
endDate = RouteParameter.Optional
});
Thanks
To solve your problem you must take into account this things:
you can register more than one route. The first registered route that can handle an URL, will handle it.
you can use something apart from slash / as separator, to make parts of a route distinguishable
you can use parameter constraints, usually regular expressions, to make it easier to discover if a parameter is of one or other kind
you can specify default values for your parameters, and, if you do so, the action method must have default values for them (unless MVC, that only requires them to be nullable or of reference type)
As you didn't tell how your URL looks like I'll show you my own examples.
Let's suppose that you have a TestController Web API Controller class with an action like this:
// GET api/Test/TestAction/ ...
[HttpGet]
public object TestAction(int param1, DateTime startDate, DateTime endDate,
int? param2 = null)
{
return new
{
param1 = param1,
param2 = param2,
startDate = startDate,
endDate = endDate
}.ToString();
}
NOTE: with the default routes a Web API controller's method named GetXxx is available to HTTP GET, a method named PostXxx is available to HTTP POST and so on. However, once you include Controller and Action in the URL template, you must use the [HttpXxx] attributes to make your method available to the required HTTP method.
Optional parameter(s) in the middle
In this first example, I suppose that both param1, and param2 are integer numbers, and stardDate and endDate are dates:
http://myhost/api/Mycontroller/Myaction/12/22/2014-12-01/2014-12-31
http://myhost/api/Mycontroller/Myaction/22/2014-12-01/2014-12-31
If you want the first URL to match parameters like these:
param1 = 12; param2 = 22; startDate = 2014-12-01; endData = 2014-12-31
and the second like these:
param1 = 12; param2 = null; startDate = 2014-12-01; endData = 2014-12-31
You need to register two routes, one that will match each possible URL structure, i.e.
// for the 1st
routeTemplate: "api/{controller}/{action}/{param1}/{param2}/{startDate}/{endDate}"
// for the 2nd
routeTemplate: "api/{controller}/{action}/{param1}/{startDate}/{endDate}"
Note that, in this case, both routes are mutually exclusive, i.e. a single URL can match only one of the routes, so you can register them in any other.
However, you must notice that the second URL doesn't define a value for param2, and the TestAction method requires it. This wouldn't work: you must include a default value for this parameter, both in the controler's method and in the route registration:
action parameter int? param2 = null (C# requires optional parameter to be the last ones).
the route must include the default: defaults: new { param2 = RouteParameter.Optional }
This is the way to solve the optional parameter in the middle problem. In general, you'll need to define several routes, depending on how many optional parameters there are, and declare this parameters, with default values, in the Web API action method.
NOTE: as I wrote above, in MVC you don't need to specify a default value in the method parameter for this to work
Parameter constraints
Specifying constrains for a route parameter has two consequences:
There's a warranty that the parameter value has the expected format
Most importantly, the route will only handle the URL if the format is the expected one. So this helps you make your URL more selective, thus making it more flexible.
You simply need to add a constraint parameter on the route registration, like this:
config.Routes.MapHttpRoute(
name: "Multiparam2",
routeTemplate: "api/{controller}/{action}/{param1}/{param2}/{startDate}/{endDate}",
constraints: new
{
startDate = #"20\d\d-[0-1]?\d-[0-3]?\d", // regex
endDate = #"20\d\d-[0-1]?\d-[0-3]?\d" // regex
},
defaults: new object { }
);
Note that it's necessary to specify a defaults parameter, even if it's empty.
NOTE: the constraints in this case are a regex that only matches dates in the year 20XX, the month expressed as a single digit, or as 0x or 1x, and the date as a single digit or 0x, 1x, 2x or 3x, separated by dashes. So this regex will match 2012-1-1 or 2015-12-30, but not 1920-12-30. You should adapt the regex to your needs.
Optional parameters at the end
By this time I've explained how to support optional parameters, and how to specify formats (constraints) for them, to match a route template.
The usual way to define optional parameters is to do it at the end of the URL template, and, in this case, if there are missing params in a route, they must be all at the end of the route. (Compare this with optional in the middle: they require different routes).
In this example, if you want to make optional the param2, and the startDate and endDate, you must define them in the route registration, and set default parameter values in the action method.
The final code would look like this:
[HttpGet]
public object TestAction(int param1, int? param2 = null, DateTime? startDate = null,
DateTime? endDate = null)
{
return new
{
param1 = param1,
param2 = param2,
startDate = startDate,
endDate = endDate
}.ToString();
}
config.Routes.MapHttpRoute(
name: "Multiparam1",
routeTemplate: "api/{controller}/{action}/{param1}/{startDate}/{endDate}",
constraints: new
{
startDate = #"20\d\d-[0-1]?\d-[0-3]?\d",
endDate = #"20\d\d-[0-1]?\d-[0-3]?\d"
},
defaults: new
{
param2 = RouteParameter.Optional,
startDate = RouteParameter.Optional,
endDate = RouteParameter.Optional
}
);
config.Routes.MapHttpRoute(
name: "Multiparam2",
routeTemplate: "api/{controller}/{action}/{param1}/{param2}/{startDate}/{endDate}",
constraints: new
{
startDate = #"(20\d\d-[0-1]?\d-[0-3]?\d)?",
endDate = #"(20\d\d-[0-1]?\d-[0-3]?\d)?"
},
defaults: new
{
startDate = RouteParameter.Optional,
endDate = RouteParameter.Optional
}
);
Note, that, in this case:
the routes could be mismatched, so they must be registered in the right order, as shown. If you registered first the Multiparam2 route, it would erroneously handle an URL like this: http://localhost:1179/api/test/testaction/1/2014-12-12/2015-1-1, with param1=1; param2="2014-12-12"; startDate="2015-1-1". (You could avoid this with an additional constraint on param2 that only accepts numbers, like param2=#"\d+")
the action must have default values for startDate and endDate.
Conclusions
You can handle default parameters in different positions by carefully:
registering routes in the right order
define default parameters in the route, and also default values in the controller's action
use constraints
If you plan carefully how your routes look like, you can get what you need with a few routes and optional parameters.
JotaBe answer was nice and complete. Just you have to consider if parameters are optional you have to write routeTemplate with the order from lowest parameters to highest.
Just like :
// for the 1st
routeTemplate: "api/{controller}/{action}/{param1}/{startDate}/{endDate}"
// for the 2nd
routeTemplate: "api/{controller}/{action}/{param1}/{param2}/{startDate}/{endDate}"
Related
What is the actual difference between these two routes ?
&
These two routes are the same?
//Route 1.
routes.MapRoute("SampleRounteOne" , "{controller}/{action}/{id}" , new {id = UrlParamter.Optional})
//Route 2.
routes.MapRoute("SampleRounteTwo" , "{controller}/{action}/{id}" , new {id = ""})
Theoretically speaking:
In Route1 you have a parameter which is declared as UrlParameter.Optional, which, for instance, is optional.
In Route2 your parameter is default set to "", which is an empty string.
Practically speaking:
On Route1, your parameter will be of Nullable so the default value is null when you're passing it to the controller.
So you will have this kind of implementation:
public void MyController(string? id)
{
//dowork
}
On Route2, your parameter will be Non-Nullable type, which, for default, will be valued to "" on your controller, an empty string.
Your controller will look like this in this situation:
public void MyController(string id = "")
{
//dowork
}
No! These two routes are not the same.
//Route1
route.MapRoute("Route1" , "{controller}/{action}/{id}" , new { id = UrlParameter.Optional});
The same thing can also be acomplished by setting the id to be an empty string: { id : ""}
for example:
//Route 2.
routes.MapRoute("Route2" , "{controller}/{action}/{id}" , new {id = ""})
This seems a lot short/breif, so why not we use this ?
What is the difference?
First thing:
you asking that : These two routes are the same?
No! these two routes are not same.
Now Come to the point!
What is the actual difference between these two routes?
When we type URL parameters values are parsed out of the URL and put into a dictionary?
Now When we use UrlParameter.Optional as a default value and no value is supplied in the URL, Routing does'nt even add an entry to the dictionary. If the default value is set to an empty string, the route value dictionary will contain a value with the key "id" and the value as an empty string. In some cases, this distincition is important it lets you know the difference between the id not being specified, and it being specified but left empty.
I'm receiving the following error that my default route parameters are null. I've used this same code on a Controller Action that didn't have any parameters in the URL and it worked fine. I know that my custom route is being called but I don't understand why startIndex and pageSize are showing up null in the action.
Error:
The parameters dictionary contains a null entry for parameter 'startIndex' of non-nullable type 'System.Int32' for method 'System.Web.Mvc.ActionResult ViewVcByStatus(System.String, Int32, Int32)' in 'AEO.WorkOrder.WebUI.Controllers.VendorComplianceController'. An optional parameter must be a reference type, a nullable type, or be declared as an optional parameter.
Parameter name: parameters
Controller:
public ActionResult ViewVcByStatus(string status, int startIndex, int pageSize) { ... }
Route:
routes.MapRoute("ViewVcByStatus", "ViewVcByStatus/{status}",
new
{
controller = "VendorCompliance",
action = "ViewVcByStatus",
startIndex = 0,
pageSize = WebConfigurationManager.AppSettings["PageSize"],
});
Link:
<a href="VendorCompliance/ViewVcByStatus?status=PROCESSED">
Also tried this link which produces the same error:
<a href="VendorCompliance/ViewVcByStatus/PROCESSED">
Try this.
public ActionResult ViewVcByStatus(string status, int? pageSize, int?startIndex)
{
return View();
}
Route.config
routes.MapRoute(
name: "ViewVcByStatus",
url: "ViewVcByStatus/{status}",
defaults: new { controller = "VendorCompliance", action = "ViewVcByStatus", startIndex = UrlParameter.Optional, pageSize = UrlParameter.Optional });
optional parameters should be declared optional in routeconfig and mark them int? in your action method, This will do the work for you. Hope this helps.This solution will work with your url pattern in your question "http://localhost:53290/VendorCompliance/ViewVcByStatus?status=PROCESSED".
Send the startIndex and pageSize with the link(I hardcoded it, use parameters instead), your actionresult is expecting all parameters that the link needs to provide, and the MapRoute will probably fall through to default Route because it can´t match it with any other route matching the one parameter you provided
<a href="VendorCompliance/ViewVcByStatus?status=PROCESSED&startIndex=0&pageSize=0">
I'm having problems with my Web.API routing. I have the following two routes:
config.Routes.MapHttpRoute(
name: "MethodOne",
routeTemplate: "api/{controller}/{action}/{id}/{type}",
defaults: new { id = RouteParameter.Optional, type = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "MethodTwo",
routeTemplate: "api/{controller}/{action}/{directory}/{report}",
defaults: new { directory = RouteParameter.Optional, report = RouteParameter.Optional }
);
And in my controller these two methods:
[HttpGet]
[ActionName("methodone")]
public string MethodOne(string id, string type)
{
return string.Empty;
}
[HttpGet]
[ActionName("methodtwo")]
public string MethodTwo(string directory, string report)
{
return string.Empty;
}
These two seemingly cannot live side by side. If I comment out the MethodOne route in WebApiConfig, the MethodTwo route works. Commenting MethodTwo route allows MethodOne to work. Leaving both uncommented, MethodOne works, but not MethodTwo.
I was hoping to use one route for both of these then it seems they would have to have the same parameter names. Who writes methods with generic parameter names? Bad. I really don't want my methods to have the same parameter names (like p1, p2, p3), so I thought I could create a route just for the new method. But even this doesn't seem to work.
I really miss the WebGet(UriTemplate="") from WCF rest.
I have one controller that has many methods, some with 1, 2, 3 or even more parameters. I can't believe I cant use meaningful parameter names with the MapHttpRoute approach.
I could comment that stuff out entirely and use WebGet() … but before I got there I wanted to see if I'm missing something.
The reason you are seeing this problem is because your first route will match both requests. The id and type token in the URL will match both requests because when the route is being run, it will try parse the URL and match each segment against your URL.
So your first route will happily match both requests as follows.
~/methodone/1/mytype => action = methodone, id = 1, and type = mytype
~/methodtwo/directory/report => action = methodtwo, id = directory, and type = report
To work around this, you should use route like
config.Routes.MapHttpRoute(
name: "MethodOne",
routeTemplate: "api/{controller}/methodone/{id}/{type}",
defaults: new { id = RouteParameter.Optional, type = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "MethodTwo",
routeTemplate: "api/{controller}/methodtwo/{directory}/{report}",
defaults: new { directory = RouteParameter.Optional, report = RouteParameter.Optional }
);
Even if you use WebGet, you might need to do something similarly to disambiguous those two methods I believe.
You can choose to pass the parameters in the query string like /MethodTwo?directory=a&report=b, but if you'd rather they show up in the path, this looks like a good candidate for attribute-based routing. Filip has a great post about it here:
http://www.strathweb.com/2012/05/attribute-based-routing-in-asp-net-web-api/
From http://www.asp.net/web-api/overview/web-api-routing-and-actions/routing-and-action-selection
You can also provide constraints, which restrict how a URI segment can
match a placeholder:
constraints: new { id = #"\d+" } // Only matches if "id" is one or
more digits.
Adding this constraint to "MethodOne" (api/{controller}/{action}/{id}/{type}) would mean that numbers it only matches if {id} is a number otherwise it would match "MethodTwo" ("api/{controller}/{action}/{directory}/{report}").
I have the following route: {param1}/{param2}/{param3} and I want to bind it to action which doesn't have param1 parameter (it doesn't matter for it). If I just don't define param1 parameter in the action method, route won't be chosen by ASP.NET MVC. So now I have to define param1 parameter in the action and just don't use it.
Is there any way to ignore some route values to not have to define them in action methods?
Why don't you reorder your parameters so that it goes:
routes.MapRoute(
//// Route name
"myNewRoute",
//// URL with parameters
"{param2}/{param3}/{param1}",
//// Parameter defaults
new { controller = "MyController", action = "MyActionName", param2 = string.Empty, param3 = string.Empty, param1 = string.Empty });
Now if you supply only the first two parameters, it takes param2 and param3. param1 defaults to string.empty.
If you supply all three parameters, then param1, param2, and param3 will all have values.
A second approach would be to use a 2 MapRoutes. Note that I added "Custom" to the route here, to ensure that the routing engine can differentiate between this route and routes that take three parameters and should go to the default asp mvc route.
I also placed Route1 before Route2 so the routing engine, if it sees 2 parameters, would prefer this route over Route2. if you supply 3 parameters, the route will prefer Route2 over Route1 or the default mvc route.
routes.MapRoute(
//// Route name
"Route1",
//// URL with parameters
"Custom/{param2}/{param3}",
//// Parameter defaults
new { controller = "MyController", action = "MyActionName", param2 = string.Empty, param3 = string.Empty });
routes.MapRoute(
//// Route name
"Route2",
//// URL with parameters
"Custom/{param1}/{param2}/{param3}",
//// Parameter defaults
new { controller = "MyController", action = "MyActionName", param2 = string.Empty, param3 = string.Empty, param1 = string.Empty });
I have the following route
routes.MapRoute(
"Segnalazioni_CercaSegnalazioni",
"Segnalazioni/CercaSegnalazioni/{flag}",
new { controller = "Segnalazioni", action = "CercaSegnalazioni", flag = 7 }
);
that maps to the following methon of the class SegnalazioniController:
public ActionResult CercaSegnalazioni(int flag)
{
ViewData["collezioneSegnalazioni"] = Models.Segnalazioni.Recupera(flag);
System.Xml.Linq.XElement x = (System.Xml.Linq.XElement)ViewData["collezioneSegnalazioni"];
return View("Index");
}
How come the link http://localhost:1387/Segnalazioni/CercaSegnalazioni/1 gives me the error
The parameters dictionary contains a null entry for parameter 'flag' of non-nullable type 'System.Int32' for method 'System.Web.Mvc.ActionResult CercaSegnalazioni(Int32)' in 'RecuperoPagatiMvc.Controllers.SegnalazioniController'. To make a parameter optional its type should be either a reference type or a Nullable type.
Nome parametro: parameters
Post all your routes. It sounds like your URL is being handled by a different route than this one. Remember, the order you list your routes does matter. Therefore, if you have another route BEFORE this one that this URL can map to, it will.
MvcContrib contains route debugger. Use it and you'll see which route is called for this url. Here are some instructions how to enable it