i just want to get full querystring from url.
Request.QueryString
Request.ServerVariables["QUERY_STRING"]
Can i use any one of these?
which way is preferred?
Thanks
Request.ServerVariables["QUERY_STRING"] contains the entire query string, that is everything after the question mark but before the fragment identifier #
http://msdn.microsoft.com/en-us/library/ms525396(v=vs.90).aspx
Request.QueryString Contains a collection allowing you to get individual elements.
Using following syntax:
Request.QueryString(variable)[(index)|.Count]
This collection is generated from the ServerVariables collection. The values in this collection are automaticly UrlDecoded.
So if you call Request.QueryString.ToString(), it is inherently the same as Request.ServerVariables["QUERY_STRING"], but with UrlDecoding.
So you should use this as it is safer.
Request.QueryString(variable)[(index)|.Count]
http://msdn.microsoft.com/en-us/library/ms524784(v=vs.90).aspx
http://msdn.microsoft.com/en-us/library/ms524784(v=vs.90).aspx
The QueryString collection is a parsed version of the QUERY_STRING variable in the ServerVariables collection. It enables you to retrieve the QUERY_STRING variable by name. The value of Request.QueryString(parameter) is an array of all of the values of parameter that occur in QUERY_STRING. You can determine the number of values of a parameter by calling Request.QueryString(parameter).Count. If a variable does not have multiple data sets associated with it, the count is 1. If the variable is not found, the count is 0.
To reference a QueryString variable in one of multiple data sets, you specify a value for index. The index parameter can be any value between 1 and Request.QueryString(variable).Count. If you reference one of multiple QueryString variables without specifying a value for index, the data is returned as a comma-delimited string.
When you use parameters with Request.QueryString, the server parses the parameters sent to the request and returns the specified data. If your application requires unparsed QueryString data, you can retrieve it by calling Request.QueryString without any parameters.
If you call Request.QueryString["Whatever"] than UrlDecode is automatically executed. See does Request.Querystring automatically url decode a string? . So be careful with your spaces, %20, ampersands etc.
Regards,
Michael
Related
I'm working with some pre-existing code that uses an HttpGet endpoint to get all comments. It takes some default parameters and before each parameter it is decorated with a [FromQuery] attribute. I'm a little confused about why we need this here and what it really does for me.
There isn't much online all I found was this documentation:
(https://learn.microsoft.com/en-us/dotnet/api/microsoft.aspnetcore.mvc.fromqueryattribute?view=aspnetcore-2.2)
This doesn't answer my question though...
What is a query string?
How is it used in endpoints?
When is it that I don't need to specify this attribute? I don't see it being used very much.
[HttpGet]
[ProducesResponseType(typeof(FooResponse), 200),
public async Task<ActionResult<FooResponse>> GetAll([FromQuery]string sortColumn = "CommentId",
[FromQuery]SortDirections sortDirection = SortDirections.Asc,
[FromQuery]string filter = "",
[FromQuery]int page = 1,
[FromQuery]int pageSize = 10)
{
var data = await _mediator.Send(new GetAllComments(sortColumn, sortDirection, filter, page, pageSize));
.
.
.
return Ok(data);
}
I suspect that it has something to do with what is passed into the URL but I'm not quite sure...
The usage here is superfluous. The action would function the same without [FromQuery] being applied to all the params, as it only responds to GET requests.
What is a query string?
The query string is the portion of the URI after the ? character is applied. It constitutes a data portion of a URI versus a pure routing portion.
How is it used in endpoints?
The question here is a little tenuous, so it would be more appropriate to ask "How is it used in a request?" The answer to that it is a way to pass data along with a GET request to a particular URI. Unlike other HTTP methods, GET does not really allow a request "body". (Actually, the spec technically does allow this, but it's almost universally not implemented that way.)
When is it that I don't need to specify this attribute? I don't see it being used very much.
Again, a better question is "When do I actually need to specify this attribute?" The answer to that is basically when it's ambiguous where the data is coming from. This will almost invariably be with other HTTP methods such as POST. By default, data is expected to come from the request body there, and depending on the content type of that request body, the binding is expected to be either FromForm or FromBody, which will usually be the default for params there. (Which is the default depends on whether you're dealing with a traditional MVC-style controller or an API-style controller.) If you need to actually get a particular param from the query string instead of the body in such a scenario, then you would apply the [FromQuery] attribute to that particular param.
Since the action in your post is for GET requests only ([HttpGet]) the [FromQuery] isn't necessary - the parameters will automatically use the associated query string values.
For POST actions ([HttpPost]) this attribute specifies to grab the value from the query string as opposed to the data which was posted.
Query string is a part of the URL that comes after an ? and it provides a way to pass values as a list of key-value pairs, each pair separated by & characters. Say you have the following URL:
http://mywebsite.com/somePage?a=123&b=Hello&c=World
So the query string part int that URL corresponds to a=123&b=Hello&c=World, and the list of key-value pairs that were passed was:
a = 123
b = Hello
c = World
ASP.NET Core can bind values to variables in a lot of different ways, and one of them is by reading values from a query string and converting/assigning these values to the values of your API's methods. To specify that a parameter should come from the query string, you use the [FromQuery] attribute.
So - for instance - when you have [FromQuery]string sortColumn = "CommentId" you are basically telling it to read the sortColumn key from the query string and assign it to the sortColumn parameter of the GetAll() method, and if that "sortColumn" key is not present in the query string, it should be assigned the default "CommentId" value. It is similar to the other parameters.
So you could access that URL with something like that (you should use the correct URL to get to your GetAll method, which I can't tell with the code you have provided):
http://your-system-url-here/GetAll?page=2&pageSize=20
Which would assing the page parameter a value of 2 and the pageSize parameter a size of 20.
Trying to query the RETs database to only show CONDOs. There is a lookup field in the METADATA-LOOKUP_TYPE of TYPEOFPROP, but I'm unable to pull the value. Query below:
http://connectmls-rets.mredllc.com/rets/server/search?SearchType=Property&Class=ResidentialProperty&QueryType=DMQL2&Format=COMPACT&StandardNames=0&Query=(LP=300000%2B)&Count=1&Limit=2
Using system names, filter on TPC. You can then add "&select=tpc" to the querystring and add the filter ",(TPC=C)".
Since its a look up, you need to use "|" symbol in the query.
Check this example,
Perform a query:
http://retsgw.flexmls.com/rets2_1/Search?SearchType=Property&Class=A&QueryType=DMQL2&Query=(LIST_15=|OV61GOJ13C0)&Count=0&Format=COMPACT-DECODED&StandardNames=0&RestrictedIndicator=****&Limit=50
The response will contain the records you requested (limited to 50 due to the Limit argument given at the end). The COLUMNS line indicates the field names of the records returned and all DATA rows represent the records with field values in the same order as shown by the COLUMN row. If you’re only interested in receiving certain fields back, you can add a “&Select=” parameter to the end of the URL. For example, if you only want to retrieve back the KeyName field (noted as “LIST_1”) and the Listing Status field (noted as “LIST_15”), add “&Select=LIST_1,LIST_15” to the end of that URL. Note a few ‘LIST_1’ values for the next example.
For further reference, check this flex documentation
We are using Request.ServerVariables to read a specific header value added by a proxy in the request header.
We can get and read the searched value using
Request.ServerVariables.Get(myKey)
// or
Request.ServerVariables[myKey]
but we notice that when we loop over the keys with
foreach (string key in Request.ServerVariables.AllKeys)
...
we don't get the searched key !
Inside the documentation we can read :
The ServerVariables collection retrieves the values of predetermined
environment variables and request header information.
So is this correct to say that Request.ServerVariables.AllKeys does not contain all the keys and that we have to use the indexer or the get method to test if the key exists ?
The full list of variables can be found here. If you know the specific variables you're after, it would be more efficient to simply request these that enumerate the full collection anyway.
If you just debug in your web application, you will see the full list, and you can't add to this list in code (easily) as far as I know.
I thing you miss Name attribute of input element
for example
you con't get the value of bellow control using Request.ServerVariables.Get(myKey);
<input type='text' value='Indian' />
you use <input name ='country' type='text' value='Indian' /> and
Request.ServerVariables.Get('country');
I have a code example like this :
location.href = location.href + "/Edit?pID=" + hTable.getObj().ID; ; //aspx
parID = Request.QueryString["pID"]; //c#
it works, my question is - how ? what is the logic ?
thanks :)
The HttpRequest class represents the request made to the server and has various properties associated with it, such as QueryString.
The ASP.NET run-time parses a request to the server and populates this information for you.
Read HttpRequest Properties for a list of all the potential properties that get populated on you behalf by ASP.NET.
Note: not all properties will be populated, for instance if your request has no query string, then the QueryString will be null/empty. So you should check to see if what you expect to be in the query string is actually there before using it like this:
if (!String.IsNullOrEmpty(Request.QueryString["pID"]))
{
// Query string value is there so now use it
int thePID = Convert.ToInt32(Request.QueryString["pID"]);
}
A query string is an array of parameters sent to a web page.
This url: http://page.asp?x=1&y=hello
Request.QueryString[0] is the same as
Request.QueryString["x"] and holds a string value "1"
Request.QueryString[1] is the same as
Request.QueryString["y"] and holds a string value "hello"
The Request object is the entire request sent out to some server. This object comes with a QueryString dictionary that is everything after '?' in the URL.
Not sure exactly what you were looking for in an answer, but check out http://en.wikipedia.org/wiki/Query_string
Request.QueryString["pID"];
Here Request is a object that retrieves the values that the client browser passed to the server during an HTTP request and QueryString is a collection is used to retrieve the variable values in the HTTP query string.
READ MORE#
http://msdn.microsoft.com/en-us/library/ms524784(v=vs.90).aspx
The QueryString collection is used to retrieve the variable values in the HTTP query string.
The HTTP query string is specified by the values following the question mark (?), like this:
Link with a query string
The line above generates a variable named txt with the value "this is a query string test".
Query strings are also generated by form submission, or by a user typing a query into the address bar of the browser.
And see this sample : http://www.codeproject.com/Articles/5876/Passing-variables-between-pages-using-QueryString
refer this : http://www.dotnetperls.com/querystring
you can collect More details in google .
I have a web application using a SSRS 2010 service, and I'm having an issue getting back the valid values for a parameter. The parameter allows multiple values and is of type Text. In the report I create, I am getting available values by query, as opposed to 'specify values'. When I call GetItemParameters the ValidValues property is empty.
If my Report specifies values instead of getting values from query, then the ValidValues property is filled in completely.
I'm hoping someone knows a way to get that property filled out when getting from query, because I'd hate to have my report writers specifying hundreds of (often changing) values individually.
Thanks!
Your link ReportingService2010.GetItemParameters gives following information
If any parameters values are based on a query and you are interested
in returning the query-based parameters' valid values list, set
ForRendering to true. In addition, for query-based parameters, you
must pass in all of the credential information required to return the
query parameters.
Did you set ForRendering to true value as it is said in this link?