ASP.NET QueryString Usage
You want to see how to use the QueryString collection in the ASP.NET web development framework. Almost all examples show one way of using this NameValueCollection, but there are faster and more logical ways. This short information sheet has some examples and tips with QueryString, using the C# programming language.
=== QueryString benchmark (ASP.NET) === There are different ways of accessing the query string. Some ways are faster than others. Method A: 0.45 s Notes: This method loops through the QueryString. Method B: 2.80 s Notes: This method looks up values with the indexer.
Using QueryString
Here we see an .aspx Web Forms page that executes when the user accesses Default.aspx. The code here is the code-behind part, Default.aspx.cs, and it is written in the C# programming language. To test the above code, run the page in the web browser on the ASP.NET development server. It will be completely blank. Try adding the string "?param=dotnet" at the end of the URL.
~~~ QueryString example (C#) ~~~
using System;
using System.Web.UI;
public partial class _Default : Page
{
protected void Page_Load(object sender, EventArgs e)
{
string v = Request.QueryString["param"];
if (v != null)
{
Response.Write("param is ");
Response.Write(v);
}
}
}
Testing two query string parameters
Here we see how you can test two query string URL parameters. Another common requirement is to test two different query strings. You may have to use either one or both at once. The next example here has some inefficiencies, but it works well otherwise.
using System;
using System.Web.UI;
public partial class _Default : Page
{
protected void Page_Load(object sender, EventArgs e)
{
string v = Request.QueryString["param"];
if (v != null)
{
Response.Write("param is ");
Response.Write(v);
}
string x = Request.QueryString["id"];
if (x != null)
{
Response.Write(" id detected");
}
}
}Testing the code. Try the above example code by typing, at the end of the URL in Internet Explorer or Firefox, this string:
?param=first&id=true
Understanding the query string. The above string specifies that the "param" query is equal to "first", while the "id" param is equal to "true". Always be careful with the "id" query string, as Google's spiders may avoid it.
Advanced example
The Request.QueryString collection is a NameValueCollection internally. QueryString is implemented as a property getter for an internal NameValueCollection.
About the QueryString collection. NameValueCollection is a specialized collection that has a somewhat unusual implementation. MSDN describes it as a "collection of associated String keys and String values that can be accessed either with the key or with the index."
Testing the QueryString collection. My testing indicates that using the index to access a value in NameValueCollection is far faster than using the ["string"] syntax.
using System;
using System.Web.UI;
using System.Collections.Specialized;
public partial class _Default : Page
{
protected void Page_Load(object sender, EventArgs e)
{
// 1
// Get collection
NameValueCollection n = Request.QueryString;
// 2
// See if any query string exists
if (n.HasKeys())
{
// 3
// Get first key and value
string k = n.GetKey(0);
string v = n.Get(0);
// 4
// Test different keys
if (k == "param")
{
Response.Write("param is " + v);
}
if (k == "id")
{
Response.Write("id is " + v);
}
}
}
}Overview of the example code. In step one, this code gets a reference to the QueryString collection. In high-performance code, you want to avoid excessive property lookups.
Next steps in the code. In step two, we use the HasKeys() method on QueryString. This is very useful for telling whether there are any query string keys available on the URL. In step four, we do two lookups on the NameValueCollection to get the very first key and the very first value. Because we only access the first key and value, this code doesn't work for more than one key value pair.
Reviewing NameValueCollection
This article is really more about NameValueCollection than QueryString, as QueryString is simply an instance of NameValueCollection. You can find more detailed information about this collection on this site.
See NameValueCollection Usage.
Optimizations
Here I benchmarked the query string code examples. The benchmark simply reads the very first query string key/value pair from the URL. My requirement was to accept only the first query string on a page.
=== A. Uses HasKeys(), GetKey(), and Get() ===
using System;
using System.Web;
using System.Web.UI;
using System.Collections.Specialized;
public partial class _Default : Page
{
protected void Page_Load(object sender, EventArgs e)
{
HttpRequest q = Request;
NameValueCollection n = q.QueryString;
if (n.HasKeys())
{
string k = n.GetKey(0);
if (k == "one")
{
string v = n.Get(0);
}
if (k == "two")
{
string v = n.Get(0);
}
}
}
}
=== Uses QueryString["key"] syntax ===
using System;
using System.Web;
using System.Web.UI;
using System.Collections.Specialized;
public partial class _Default : Page
{
protected void Page_Load(object sender, EventArgs e)
{
HttpRequest q = Request;
string v = q.QueryString["one"];
if (v != null)
{
}
v = q.QueryString["two"];
if (v != null)
{
}
}
}Discussion the benchmark results. What we see is that when you only need to access the first query string key/value pair, using HasKeys(), Get(), and GetKey() is lots faster than the QueryString["string"] approach.
=== Benchmark: No query string === Method A: 0.08 s Method B: 1.75 s === Benchmark: Matching query string === Method A: 0.45 s Method B: 2.80 s === Benchmark: No matching query string === Method A: 0.46 s Method B: 1.73 s
Is QueryString filled lazily?
No. I found that by the time your HttpRequest is being used, the QueryString collection has already been initialized with all the query key/value pairs. I looked at the locals in the Visual Studio debugger to find this. Therefore, the analysis in this article is correct and the faster method shown is really considerably faster than the naive approach.
See Visual Studio Debugging Tutorial.
Notes
When you use QueryString in Global.asax or another "hot" path in your code, it pays to optimize the logic. When your website runs the code several times each second, you need it to be as fast as possible.
Reviewing NameValueCollection. My research into NameValueCollection, which was helped by my use of Red Gate's Reflector, led to this interesting optimization. It could prove helpful to the high-volume, important ASP.NET sites.
Summary
Here we saw two examples of Request.QueryString, using the same code pattern that most ASP.NET tutorials use. However, we also noted how you can use other methods on QueryString to gain a substantial performance increase.