Increase SEO Rank for Your ASP.NET Site with SEO Friendly URLs
To increase your site SEO rank, you should make SEO friendly URLs. In ASP.NET Web Forms applications, a URL is tied to a physical .aspx file. This default mapping between a URL and physical file makes it difficult for Web Forms applications to generate SEO friendly URLs. One option available to ASP.NET developers is to use URL routing features. Alternatively they can also use Friendly URLs – a feature that allows you to quickly and easily use SEO friendly URLs in Web Forms applications. This article discusses how.
For example, this URLs http://www.somewebsite/WebForm1/2014/03/10/1234 is more friendly URLs than this one http://somewebsite/WebForm1.aspx?postid=1
Installing Friendly Url via NuGet
In order to use ASP.NET FriendlyUrls you need to install the required assemblies using a NuGet package. So, open Visual Studio 2012 and create a blank ASP.NET Web Forms application. Then click on the Project > Manage NuGet Packages menu option. In the resulting dialog search for FriendlyUrls, you should see the Microsoft ASP.NET Friendly URLs entry listed as shown in the following figure.
Microsoft ASP.NET Friendly URLs
Once you install the necessary NuGet package you will find that a reference is added to the Microsoft.AspNet.FriendlyUrls assembly. Now you are ready to use FriendlyUrls in your application.
Enabling Friendly Urls
Next, open Global.asax file in Visual Studio and write the following code in its Application_Start event handler.
protected void Application_Start(object sender, EventArgs e)
{
RouteTable.Routes.EnableFriendlyUrls();
}The above code calls the EnableFriendlyUrls() method on the Routes collection. Calling the EnableFriendlyUrls() method enables FriendlyUrls for your application and you can use all the Web Form URLs without the .aspx extension. For example, instead of accessing a web form as /samplewebsite/WebForm1.aspx you can simply say /samplewebsite/WebForm1
Remember that EnableFriendlyUrls() is an extension method and you must import the following namespaces at the top of Global.asax.
using System.Web.Routing; using Microsoft.AspNet.FriendlyUrls;
Getting Information about FriendlyUrls
Inside the Web Form you may want to know the path information about a FriendlyUrl. You can easily obtain that information as shown below:
string path = Request.GetFriendlyUrlFileVirtualPath();
string ext = Request.GetFriendlyUrlFileExtension();
string friendlyurl = FriendlyUrl.Resolve("~/WebForm2.aspx");
string link = FriendlyUrl.Href("~/WebForm1", 2014, 03, 10, 1234);As you can see from the above code, several extension methods get added to the Request object. The GetFriendlyUrlFileVirtualPath() method returns the virtual path corresponding to the FriendlyUrl being accessed. For example, for a friendly URL http://somewebsite/WebForm1 it will return ~/WebForm1.aspx
The GetFriendlyUrlFileExtension() method returns the physical file extension of a FriendlyUrl. For web form files, it will be .aspx.
You can also generate FriendlyUrls via code using the Resolve() method of the FriendlyUrl class. The Resolve() method accepts a virtual path and resolves that path to the corresponding FriendlyUrl.
The Href() method of the FriendlyUrl class can be used to generate hyperlink URLs. It accepts the virtual path of the FriendlyUrl followed by URL segments (more on that later). For example, if you wish to generate a hyperlink that points to /somewebsite/WebForm1/2014/03/10/1234 then the first parameter will be ~/WebForm1 and URL segments will be 2014, 03,10 and 1234.
Accessing URL Segments in Code
FriendlyUrls features are not limited to generating extensionless URLs. You can also pass data to the underlying Web Form through URL segments. In the blog engine example we discussed earlier, the year, month and day of publication is passed to the Web Form along with the post ID. These pieces of information are passed as URL segments as shown below:
http://www.somewebsite/WebForm1/2014/03/10/1234
The URL segments that you pass along with a FriendlyUrl can be retrieved inside the Web Form code-behind file as shown below:
IList<string> segments = Request.GetFriendlyUrlSegments(); BlogPost post = new BlogPost(); post.Year = int.Parse(segments[0]); post.Month = int.Parse(segments[1]); post.Day = int.Parse(segments[2]); post.PostId = int.Parse(segments[3]);
As you can see, the code-behind uses the GetFriendlyUrlSegments() extension method on the Request object. The GetFriendlyUrlSegments() returns an IList of string. Once retrieved you can access and parse the individual segment and assign to a class named BlogPost. The BlogPost class is a simple class with four public properties, viz. Year, Month, Day and PostId.
public class BlogPost
{
public int Year { get; set; }
public int Month { get; set; }
public int Day { get; set; }
public int PostId { get; set; }
}FriendlyUrls and ValueProviders
It is also easy to use FriendlyUrls with data bound controls such as GridView and FormView. Consider, for example, that the Web Form that displays a blog post houses a FormView control to do so. The FormView control can use SelectMethod and ItemType properties to specify a method returning the data to be bound and type of the data being returned respectively.
<asp:FormView ID="FormView1" runat="server" ItemType="FriendlyUrlsDemo.BlogPost" SelectMethod="GetBlogPost"> <ItemTemplate> ... </ItemTemplate> </asp:FormView>
As you can, see the ItemType property points to the BlogPost class you created earlier and the SelectMethod property points to a public method named GetBlogPost(). The GetBlogPost() method is shown below:
public BlogPost GetBlogPost([FriendlyUrlSegments(0)]int year,
[FriendlyUrlSegments(1)]int month,
[FriendlyUrlSegments(2)]int day,
[FriendlyUrlSegments(3)]int postid)
{
//you may add some custom processing here
BlogPost post = new BlogPost();
post.Year = year;
post.Month = month;
post.Day = day;
post.PostId = postid;
return post;
}As you can see the GetBlogPost() method has four parameters, viz. year, month, day and postid. These parameter values will be passed through the URL segments as discussed earlier. You need to map the URL segments with the appropriate method parameters. You can do this using the [FriendlyUrlSegments] attribute. The [FriendlyUrlSegments] attribute is a value provider and is applied to various parameters of the GetBlogPost() method. It takes an index of the URL segment you wish to bind with a method parameter. In the above example, if you have URL like this:
http://www.somewebsite/WebForm1/2014/03/10/1234
Then year, month, day and postid parameters will be 2014, 03,10 and 1234 respectively. Although the above example simply constructs a BlogPost object based on the URL segment values you can add any custom processing here.
Cheap ASP.NET 4.5 Hosting Recommendation
- Build Your Website
Use ASPHostPortal.com‘s website building tools to get that special, customized look for your website. A nifty wizard will walk you through the process. - All-inclusive Prices Unbeatable Value
Other companies promise cheap hosting, but then charge extra for setup fees, higher renewal rates, or promotional services. With ASPHostPortal.com, the listed price is the number you’ll pay, and you can expect a fully loaded, comprehensive suite of web services. - Fast and Secure Server
Their powerful servers are especially optimized and ensure the best ASP.NET 4.5 performance. They have best data centers on three continent and unique account isolation for security. - Easy to Use and Manage
ASPHostPortal.com webspace explorer lets you manage your website files with a browser. A control panel lets you set up and control your server functions with ease.