A Complete URL Rewriting Solution for ASP.NET 2.0

by Gaidar Magdanurov

This article describes a complete solution for URL rewriting in ASP.NET 2.0. The solution uses regular expressions to specify rewriting rules and resolves possible difficulties with postback from pages accessed via virtual URLs.

Why use URL rewriting?
The two main reasons to incorporate URL rewriting capabilities into your ASP.NET applications are usability and maintainability.

Usability
It is well-known that users of web applications prefer short, neat URLs to monstrous addresses packed with difficult to comprehend query string parameters. From time to time, being able to remember and type in a concise URL is less time-consuming than adding the page to a browser's favorites only to access later. Again, when access to a browser's favorites is unavailable, it can be more convenient to type in the URL of a page on the browser address bar, without having to remember a few keywords and type them into a search engine in order to find the page.

Compare the following two addresses and decide which one you like more:

(1) http://www.somebloghost.com/Blogs/Posts.aspx?Year=2006&Month=12&Day=10
(2) http://www. somebloghost.com/Blogs/2006/12/10/

The first URL contains query string parameters to encode the date for which some blog engines should show available postings. The second URL contains this information in the address, giving the user a clear idea of what he or she is going to see. The second address also allows the user to hack the URL to see all postings available in December, simply by removing the text encoding the day '10': http://www.somehost.com/Blogs/2006/12/.

Maintainability
In large web applications, it is common for developers to move pages from one directory to another. Let us suppose that support information was initially available at http://www.somebloghost.com/Info/Copyright.aspx and http://www.somebloghost.com/Support/Contacts.aspx, but at a later date the developers moved the Copyright.aspx and Contacts.aspx pages to a new folder called Help. Users who have bookmarked the old URLs need to be redirected to the new location. This issue can be resolved by adding simple dummy pages containing calls to Response.Redirect(new location). However, what if there are hundreds of moved pages all over the application directory? The web project will soon contain too many useless pages that have the sole purpose of redirecting users to a new location.

Enter URL rewriting, which allows a developer to move pages between virtual directories just by editing a configuration file. In this way, the developer can separate the physical structure of the website from the logical structure available to users via URLs.

Native URL mapping in ASP.NET 2.0
ASP.NET 2.0 provides an out-of-the-box solution for mapping static URLs within a web application. It is possible to map old URLs to new ones in web.config without writing any lines of code. To use URL mapping, just create a new urlMappings section within the system.web section of your web.config file and add the required mappings (the path ~/ points to the root directory of the web application):






Thus, if a user types http://www.somebloghost.com/Support/Contacts.aspx, he can then see the page located at http://www.somebloghost.com/Help/Contacts.aspx, without even knowing the page had been moved.

This solution is fine if you have only two pages that have been moved to other locations, but it is completely unsuitable where there are dozens of re-located pages, or where a really neat URL needs to be created.

Another possible disadvantage of the native URL mapping technique is that if the page Contacts.aspx contains elements initiating postback to the server (which is most probable), then the user will be surprised that the URL http://www.somebloghost.com/Support/Contacts.aspx changes to http://www.somebloghost.com/Help/Contacts.aspx. This happens because the ASP.NET engine fills the action attribute of the form HTML tag with the actual path to a page. So the form renders like this:

action="http://www.simple-talk.com/Help/Contacts.aspx" id="formTest">

Thus, URL mapping available in ASP.NET 2.0 is almost always useless. It would be much better to be able to specify a set of similar URLs in one mapping rule. The best solution is to use Regular Expressions (for overview see Wikipedia and for implementation in .NET see MSDN), but an ASP.NET 2.0 mapping does not support regular expressions. We therefore need to develop a different solution to built-in URL mapping.

The URL rewriting module
The best way to implement a URL rewriting solution is to create reusable and easily configurable modules, so the obvious decision is to create an HTTP Module (for details on HTTP Modules see MSDN Magazine) and implement it as an individual assembly. To make this assembly as easy to use as possible, we need to implement the ability to configure the rewrite engine and specify rules in a web.config file.

During the development process we need to be able to turn the rewriting module on or off (for example if you have a bug that is difficult to catch, and which may have been caused by incorrect rewriting rules). There should, therefore, be an option in the rewriting module configuration section in web.config to turn the module on or off. So, a sample configuration section within web.config can go like this:


true





This means that all requests that run like: http://localhost/Web/2006/12/10/ should be internally redirected to the page Posts.aspx with query string parameters.

Please note that web.config is a well-formed XML file, and it is prohibited to use the symbol & in attribute value strings. In this case, you should use & instead in the destination attribute of the rule element.

To use the rewriteModule section in the web.config file, you need to register a section name and a section handler for this section. To do this, add a configSections section to web.config:

This means you may use the following section below the configSections section:



true






Another thing we have to bear in mind during the development of the rewriting module is that it should be possible to use 'virtual' URLs with query string parameters, as shown in the following: http://www.somebloghost.com/2006/12/10/?Sort=Desc&SortBy=Date. Thus we have to develop a solution that can detect parameters passed via query string and also via virtual URL in our web application.

So, let’s start by building a new Class Library. We need to add a reference to the System.Web assembly, as we want this library to be used within an ASP.NET application and we also want to implement some web-specific functions at the same time. If we want our module to be able to read web.config, we need to add a reference to the System.Configuration assembly.

Handling the configuration section
To be able to read the configuration settings specified in web.config, we have to create a class that implements the IConfigurationSectionHandler interface (see MSDN for details). This can be seen below:

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;using System.Web;
using System.Xml;
namespace RewriteModule
{
public class RewriteModuleSectionHandler : IConfigurationSectionHandler
{
private XmlNode _XmlSection;
private string _RewriteBase;
private bool _RewriteOn;
public XmlNode XmlSection
{
get { return _XmlSection; }
}
public string RewriteBase
{
get { return _RewriteBase; }
}
public bool RewriteOn
{
get { return _RewriteOn; }
}
public object Create(object parent,object configContext,System.Xml.XmlNodesection)
{
// set base path for rewriting module to application root
_RewriteBase = HttpContext.Current.Request.ApplicationPath + "/";
// process configuration section from web.config
try
{
_XmlSection = section;
_RewriteOn = Convert.ToBoolean(section.SelectSingleNod("rewriteOn").InnerText);
}
catch (Exception ex)
{
throw (new Exception("Error while processing RewriteModule configuration section.", ex));
}
return this;
}
}
}

The Class RewriteModuleSectionHandler will be initialized by calling the Create method with the rewriteModule section of web.config passed as XmlNode. The SelectSingleNode method of the XmlNode class is used to return values for module settings.

Using parameters from rewritten URL
When handling virtual URLS such as http://www. somebloghost.com/Blogs/gaidar/?Sort=Asc (that is, a virtual URL with query string parameters), it is important that you clearly distinguish parameters that were passed via a query string from parameters that were passed as virtual directories. Using the rewriting rules specified below:



you can use the following URL:

http://www. somebloghost.com/gaidar/?Folder=Blogs

and the result will be the same as if you used this URL:

http://www. somebloghost.com/Blogs/gaidar/

To resolve this issue, we have to create some kind of wrapper for 'virtual path parameters'. This could be a collection with a static method to access the current parameters set:

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections.Specialized;using System.Web;
namespace RewriteModule
{
public class RewriteContext
{
// returns actual RewriteContext instance for current request
public static RewriteContext Current
{
get
{
// Look for RewriteContext instance in current HttpContext. If there is no RewriteContextInfo item then this means that rewrite module is turned off
if(HttpContext.Current.Items.Contains("RewriteContextInfo")) return (RewriteContext)
HttpContext.Current.Items["RewriteContextInfo"]; else
return new RewriteContext(); } } public RewriteContext() { _Params = new NameValueCollection(); _InitialUrl = String.Empty; } public RewriteContext(NameValueCollection param, string url) { _InitialUrl = url; _Params = new NameValueCollection(param); } private NameValueCollection _Params; public NameValueCollection Params { get { return _Params; } set { _Params = value; } } private string _InitialUrl; public string InitialUrl { get { return _InitialUrl; } set { _InitialUrl = value; } } }}
You can see from the above that it is possible to access 'virtual path parameters' via the RewriteContext.Current collection and be sure that those parameters were specified in the URL as virtual directories or pages names, and not as query string parameters.

10 tips to go from a beginner to intermediate developer

#1: Learn another language
It doesn’t matter which language you learn, but learning another language (regardless of how many you already know) will make you a better developer. Even better is to learn one that is significantly different from what you already use on a regular basis. In other words, if you are a C# developer, learning VB.NET or Java will not help you as much as learning Ruby or Groovy.

And when I say “learn another language,” I mean really learn it. Learning a language consists of three realms of knowledge: the syntax, the built-in operators and libraries, and “how to use it.” The first two are easy; I think that an experienced developer can pick up enough of a language’s syntax to maintain code in 30 minutes to a few hours depending upon the language. The operators and libraries are just a matter of slowly accumulating knowledge and being willing to check reference materials until you memorize what you need to know. But it’s the third item — “how to use it” — that can only be learned over months of working with a language and that’s where the real magic happens. I suggest doing a project that is well suited for that language and doing it in that language’s style.

Truly learn another language, and I promise that your abilities as a developer will start to blossom.

#2: Learn advanced search techniques, tactics, and strategies
More and more, being a good developer is not just about your skill, but your skill at finding information. Simply put, modern languages and development frameworks are too large for most people to remember much of them. As a result, your ability to get work done is often dependent upon your ability to perform research. Unfortunately, knowing how to find accurate, high-quality information is more than just heading to TechRepublic for the answer or typing a few words into your search engine of choice.

“Techniques,” “tactics,” and “strategies” may sound like synonyms, but they are not. The techniques you need to learn are the advanced search systems of your favorite search engine; you need to learn things such as the Boolean operators, how to filter results (negative keywords, domain restrictions, etc.), what role word order plays, and more. So essentially, RTFM.

You should learn tactics such as knowing how to approach any particular search and knowing what you should you actually look for. Errors are easy — just look for the error code — but keyword selection on many searches is much more difficult.

With regard to strategies, you need to learn things such as what search engines to use (hint: general purpose search engines are not always the right answer), which sites to visit before going to a general purpose search engine, and even which message boards to post to for help.

#3: Help others
Teaching others is invariably one of the best ways to learn anything. It is understandable to think that you don’t have much to offer because you are relatively new to the development field. That’s nonsense. Remember, everything you know you learned from someone or somewhere; so try being the someone that another person learns from. Spend a few minutes a day trying to answer the questions on TechRepublic or another site as best you can. You can also learn a lot by reading other members’ answers.

#4: Be patient and keep practicing
Research shows that it takes “about ten years, or ten to twenty thousand hours of deliberate practice” to become an “expert.” That’s a lot of time. Furthermore, becoming an expert does not always mean doing the same task for 10 years; it often means doing a wide variety of tasks within a particular domain for 10 years. It will take a lot of time and energy to become an “expert”; working as a developer for a few years is not enough. Want to become a senior developer in your early 30s? Either start your education/training sooner or be willing to do a lot of work, reading, and practicing in your spare time. I started programming in high school, and I devoted a lot of off-hours to keeping up with the industry, learning new skills, and so on. As a result, I hit the intermediate and senior level developer positions significantly earlier in my career than most of my peers, which translates to an awful lot of money over time.

#5: Leave your dogmas at the door
Time for some brutal honesty: Beginner developers probably don’t know enough to state that there is One Best Way of doing something. It’s fine to respect the opinion of a friend or an authority figure, but until you are more experienced, don’t claim their opinions as your own. The simple fact is, if you don’t know enough to figure these things out on your own, what makes you think that you know which “expert” is right? I know this sounds really harsh, but please believe me; I have met far too many budding developers who had their careers or their growth set back years because they got hung up on some foolish piece of advice or followed some “expert” who really didn’t know what they were talking about. A great example of this is the abuse of object-oriented architecture. For example, many beginners read some information about OO, and suddenly the class diagrams to their simple applications look like the Eiffel Tower.

#6: Learn a few advanced ideas in-depth
Much of what goes into being an intermediate developer is having a few concepts that you are really good at working with in code. For me, it is multithreading/parallelism, regular expressions, and how to leverage dynamic languages (and the last two are fading as I get farther away from my Perl history). How did this happen? Multithreading and parallel processing came about because I read articles on it, thought it sounded interesting, and figured it out on my own; I keep writing apps that use those techniques. I had a job that used a ton of regular expressions in Perl. Also, I ended up writing my own e-commerce engine with a template processing engine and built-in database system; then I spent nearly two years working on it.

Find something that has you really hooked. It might be image manipulation or maybe database design or whatever. Even if you’re an entry-level developer over all, try to become an expert in at least one area of focus. This will get you into that intermediate level quite quickly, and once there, you will be halfway to expert.

#7: Learn the basic theories underlying your field
It’s one thing to write “Hello World,” but it’s another to understand how the words appear on the screen. By learning the “groundwork” that supports the work you do, you will become much better at it. Why? Because you will understand why things work the way they do, what might be wrong when things are broken, and so on. You will become better by learning what happens at a lower level than your work.

If you are a Web developer, read the HTTP RFC and the HTML spec. If you use a code generator, really look at the code it generates; if you use database tools, take a look at the underlying SQL it generates; and so on.

#8: Look at senior developers’ code
At your job, take a look at the code the senior developers are writing and ask how and why things were done a particular way. If you can, check out open source projects as well. Even if other developers don’t have the best coding habits, you’ll learn a lot about how code is written. Be careful not to pick up bad habits along the way. The idea here isn’t to just blindly imitate what other developers are doing; it’s to get an idea of what works and what makes sense and try to imitate it.

#9: Learn good habits
Nothing marks an inexperienced coder like stupid variable names, poor indentation habits, and other signs of being sloppy. All too often, a developer learned how to program without being taught the less interesting details such as code formatting — and it shows. Even though learning these things will not always make your code better or you a better developer, it will ensure that you are not viewed as an entry-level developer by your peers. Even if someone is a senior developer, when variables are named after their 97 cats or their functions are called “doSomething(),” they look like they do not know what they are doing, and it makes their code harder to maintain in the process.

#10: Have fun
Want to be stuck on the career treadmill? Hate your job. What it takes to move up in this business is not merely dogged determination to bring home an ever growing paycheck but an actual enjoyment of your work. If you do not like your work and you are a junior developer, what makes you think that being an intermediate or senior developer will be any better? Change jobs or change careers. On the other hand, if you love the work you are doing, great! I guarantee that you can become a better developer if you keep at it.

Source : http://blogs.techrepublic.com.com/programming-and-development/?p=1139&tag=nl.e055

What if I like my Desktop Messy?

Windows XP users are accustomed to having the balloon pop up that says” There are unused icons on your desktop”, right? But what if I like my desktop the way it is and don't want to be bothered with these messages anymore?

In that case, I bear good news, everyone! You can turn it off!

Here's how:

Right click on the desktop and choose “Properties”. In the next window click the desktop tab at the top and then the “Customize Desktop” button.

Under the “General” tab you'll see Desktop Cleanup towards the bottom of the window. Just uncheck the “Run Desktop Cleanup Wizard every 60 days” selection and click OK. No fuss, no muss, and your Windows XP experience just got a little less annoying!

Thanks : Andrew
http://www.worldstart.com/tips/tips.php/turn-off-desktop-cleanup-warning-xp

How can I make my blog load faster?

The speed at which your blog loads is critical to attracting more readers to your blog. If your blog takes a long time to load, many readers may leave your blog before they have the chance to read it. Here are a few tips and tricks that will help your blog load faster and attract more users:

Posts
Your blog's load time can be affected by the number of posts you display on your main page. You can easily edit the number of posts displayed of the main page from the Settings | Formatting tab. You can then select the number of posts you want to display on the main page. We recommend displaying 10 or fewer posts on the main page.

Third Party JavaScript and Links
For optimal blog load speed, we recommend using Google/Blogger widgets, JavaScipt and links. However, if you need to use third party JavaScipt and links, your blog will load much faster if you put all JavaScript at the bottom of your blog. If you have third party JavaScript and links in your sidebar, put them in at the bottom of the sidebar.

Google Help › Blogger Help › Publish and Archive › Posting & Editing › Fix a Problem › How can I make my blog load faster?

How can I make my blog load faster?The speed at which your blog loads is critical to attracting more readers to your blog. If your blog takes a long time to load, many readers may leave your blog before they have the chance to read it. Here are a few tips and tricks that will help your blog load faster and attract more users:

Posts
Your blog's load time can be affected by the number of posts you display on your main page. You can easily edit the number of posts displayed of the main page from the Settings | Formatting tab. You can then select the number of posts you want to display on the main page. We recommend displaying 10 or fewer posts on the main page.

Third Party JavaScript and Links
For optimal blog load speed, we recommend using Google/Blogger widgets, JavaScipt and links. However, if you need to use third party JavaScipt and links, your blog will load much faster if you put all JavaScript at the bottom of your blog. If you have third party JavaScript and links in your sidebar, put them in at the bottom of the sidebar.

Images and Media
The more images, videos and other multi-media you have on your blog the longer it will take to load. However, images and other multimedia are important to attracting users to your blog, so it is important to optimize the load speed of your images and media. Here are a few tips to increase the load speed of your media:

•Decrease the size of your images or use thumbnails that link to the full-size image.
•If you use third party images, consider uploading them to Picasa Web Albums via the Blogger post editor.
•If you have a large number of images to display, you can upload all your images (from a vacation or event) to a Picasa Web Album and link to the album in your post or sidebar.

Other suggestions
•If you've added any custom CSS to your blog, make sure you put it at the top of the page.
•The most important content of your blog that catches readers attention should load the quickest. To help you identify which items are taking the longest to load you can use Stopwatch. To use Stopwatch, enter your blog's URL into the text box and click "Start StopWatch". Stopwatch will then open your blog in a frame and will record the time it takes for everything on your blog to load, including images, videos, widgets, etc. Take note of the items that take the longest to load and modify them appropriately using our suggestions.

Source: http://help.blogger.com/bin/answer.py?answer=42394

Search Engine Optimization (SEO) and ASP.NET Developers

Search Engine Optimization (SEO) and ASP.NET Developers
In this article we're going to cover some basic concepts on what you can do in order to make your ASP.NET application as spider and search engine friendly as possible.


If you're developing for the Web then you should familiarize yourself with some Search Engine Optimization or SEO concepts. The idea here is to make your ASP.NET application as friendly as possible for spiders, and the specific spider we're talking about is Google.

In this article we're going to cover some basic concepts on what you can do in order to make your ASP.NET application as spider and search engine friendly as possible.

Postbacks

Your biggest gain in the search engine world is going to avoid the use of postbacks. For example, say you have content within an ASP panel. But in order to display that content you use a button and capture a click event in the code behind, then you change the property of the panel to visible=true once the button is clicked. This will not work with spiders since they don't "click buttons" so to speak. The way to write the page so the spider will work with it is to use a link, and then pass a parameter via a URL, this could be a link back to the page if you want, but then in the Page_Load event check for the parameters values to determine what panel or content to display in your page.

I can't understate the importance of eliminating postbacks when it comes to the Internet. Links are much better when dealing with spiders, avoid the postback, spiders simple can't do them.

Friendly URLs

Another thing to look into is the use of a URL rewriter in order to create spider friendly URLs. There are many examples on the Web for creating a URL rewriter. What a URL rewriter does is translate the parameters over to a directory like structure. For example, mypager.aspx?param1=1¶m2=2 becomes something like: /mypage/1/2/default.aspx. This will enhance the spiders efficiency in spidering your site and potentially increase the frequency of a spider doing a deep crawl through your site. You can read evidence of this fact via the Google FAQ:

"Your pages are dynamically generated. We're able to index dynamically generated pages. However, because our web crawler could overwhelm and crash sites that serve dynamic content, we limit the number of dynamic pages we index. In addition, our crawlers may suspect that a URL with many dynamic parameters might be the same page as another URL with different parameters. For that reason, we recommend using fewer parameters if possible. Typically, URLs with 1-2 parameters are more easily crawlable than those with many parameters. Also, you can help us find your dynamic URLs by submitting them to Google Sitemaps. "

There are plenty of resources on the Web for URL rewriting:

http://www.codeproject.com/aspnet/URLRewriter.asp
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnaspp/html/urlrewriting.asp
http://www.15seconds.com/Issue/030522.htm

Titles and Meta Tags
Another issue when generating dynamic pages, and using the same page but either posting back or linking back via a URL. Be sure to change the Title of the page and Meta description. If you do not do this then Google is going to "think" that it is the same page, and the results will not be displayed as high as you would like. It will definitely affect your search results. One way of tacking this is to convert both the title, and meta description tags to HTML controls and then change the inner text, or dynamically generate the text for the tags when displaying different content.

Here's a sample block of code for dynamically changing the title tag of your Web page:

First modify the page in order to make the title tag a control you can modify: