In this article I will walk through a concept for URL Remapping in .Net 2.0

The need for url remapping can arise due to several reasons like
Generating SEO friendly urls
Hiding the actual page or other data from web users.
Control over each and every entry and exits for web requests.
Etc.
.Net 2.0 gives flexibility to define and remap urls in web.config file as well as generating your own Custom URL Remapper HTTP Module.
I will explain the first approach i.e remap urls in web.config in this post and will try to wrap up the second one in my next article with a pretty decent code sample for building Custom URL Remapper HTTP Module.
Remapping URL’s in web.config file.
To Map urls .Net provides a section named  urlMappings in web.config file where one can define the collection for their mapped urls.

<configuration>
<system.web>
 <urlMappings>
  <add url=”~/Home.aspx” mappedUrl=”~/Default.aspx”/>
 </urlMappings>
</system.web>
</configuration>

Here whenever the request for Home.aspx will come the .Net engine will search for  urlMappings section in web.config file and server the page that is mapped with it. In the above mention example it will server Default.aspx page.
Limitations: To have more control over the urls, regular expression cannot be used. So it is better to build our own  URL Remapper HTTP Module.
Live World Scenario:
In case of shopping cart with thousands of product categories and catalogs it is very important to make this page SEO Friendly. Though SEO includes several criteria depending on different robots basic idea of URL remains the same. So by using URL Remapping we can generate SEO friendly URLS that robots can easily search.
Like say for example we are having three products categories viz
CellPhones
Computers
DigitalCameras
We can map all the three categories to a single page that servers the purpose of displaying these products based on the product name
So we map all the three to Product.aspx page like shown in the below section.

<configuration>
<system.web>
 <urlMappings>
  <clear/>
  <add url="~/CellPhones.aspx" mappedUrl="~/Product.aspx"/>
  <add url="~/Computers.aspx" mappedUrl="~/Product.aspx"/>
  <add url="~/DigitalCameras.aspx" mappedUrl="~/Product.aspx"/>
</urlMappings>
</system.web>
</configuration>

Now whenever the request for  CellPhones.aspx,  Computers.aspx or DigitalCameras.aspx comes .Net engine will compile Product.aspx page and will server to the requesting client. In Product.aspx page we can extract the name and make calls to database to get all the products related to the given category.

To Download code sample Click Here

Modify Web Configuration file without restarting asp net worker process (aspnet_wp).

No one in the world can say that web.config file will remain intact after the deployment. Modifications have to happen to some or the other parameters of the web configuration file like one has to add or remove key value pairs from appsettings section etc…

So what?
As soon as the webs configuration file is saved the aspnet_wp worker process of that particular web application gets restarted and all the current sessions and data are lost.

This can cause tremendous issues to an organization whose application needs to be up for 24*7.

To recover from such kind of scenario Microsoft has already provided a great tweak to handle this.

Following are some steps that need to be followed.
Step 1) Make a separate configuration file lets say for example appsettings.config with the following xml data.

<?xml version="1.0"?>
<appSettings>
  <clear/>
  <add key="Name" value="Dhaval"/>
  <add key="Surname" value="Upadhyaya"/>
</appSettings>

Step 2) Now in the original web.config file make your appSettings section look like below

<appSettings configSource="appsettings.config">
</appSettings>

You are done.

 
Place a debug point on the Application_Start event in global.asax file and check that changing appsettings.config does not restart the worker process.

Choosing storage place for Images

In this article I have jotted down various pros and cons for choosing the best storage place for images used in our web based applications.

There are two basic approaches for storing the images that are used in our web application

1. File System
2. Database

Below are some comparisons between the two:

Ease: One can easily configure the path of an image from a directory on the web server containing images while from database one needs to create custom logic for reading Image data (eg .ashx handler for image)

Flexibility: It is always easy to store a new image file on the web server while in case of database new column needs to be created. 

Maintenance: Using simple file operations for storing the image on web server is very trivial task while in case of database one might need to create a complex query or business logic.

Caching: IIS can be easily configured to cache images stored in file system while images in database needs some further complex IIS configuration

Size: As the web directory in which our application is hosted can be easily scaled in terms of size for storing more images as a when needed while in database the size of database goes on increasing affecting the overall database performance.

Compatibility: Images are stored on file system with basic file operations while in case of database during migration process to some other database vendor their may be some Data Type compatibility problem

Performance: File operations are less costly in resource utilization while database operations are more costly in terms of resources.

How to create Scheduled Jobs in .net web applications.

Calling a function at predefined iteration of time has been one of the key requirements of web applications.
Example:
You want to automatically archive the data.
You want to automatically purge the data.
You want to automatically send the News Letters.
You want to take backup of the files or database etc.

Generally this type of functionality can be easily archived by creating and configuring scheduled jobs in SQL Server.

What if you are using the express edition of SQL Server?
You cannot take advantage of this feature because all the editions of SQL Server do not provide this functionality.

In this article I will explain how we can achieve this functionality using purely .Net framework class.

First of all let’s thanks System.Threading class. The main cream lies inside this class shipped in .Net Framework. Many of us usually do not use it but believe me its one of the most beautiful classes of the framework.

Anyways

Following are the steps which you need to perform:

Step 1) Create a class called Jobs.cs

namespace myScheduler
{
    public sealed class Jobs
    {
        public Jobs(){}

        public static void DailyJob(object state)
        {
           //Your dream goes here.
        }

        public static void HourlyJob(object state)
        {
            //Your dream goes here.
        }
    }
}

Jobs class includes the below two functions that will be called by our scheduler which we will create in the second step.
I have created two functions for this purpose.
DailyJob: Will be called daily by the scheduler.
HourlyJob: Will be called hourly by the scheduler.

Step 2) Create a class called Scheduler.cs

using System;
using System.Threading;

namespace myScheduler
{
    public sealed class Scheduler
    {
        public Scheduler() { }

        public void Scheduler_Start()
        {
            TimerCallback callbackDaily = new TimerCallback(Jobs.DailyJob);
            Timer dailyTimer = new Timer(callbackDaily, null, TimeSpan.Zero, TimeSpan.FromHours(24.0));

            TimerCallback callbackHourly = new TimerCallback(Jobs.HourlyJob);
            Timer hourlyTimer = new Timer(callbackHourly, null, TimeSpan.Zero, TimeSpan.FromHours(1.0));
        }
    }
}

Scheduler class contains the actual mechanism for running jobs created in Jobs class in Step one.

Timer: Mechanism for executing method at specified time intervals. This method has 5 overloads which we can use as per our needs. Some of its parameters are
TimerCallback: Represents the method that you want to actually callback on at a particular interval of time.
State: Any type of object you want to pass to your callback method.
Due Time: Amount of delay after which callback will be invoked. TimeSpan.Zero means immediately.
Period: Time period between invocations of callback function.

Step 3) Add Global.asax file to your web project. In Application_Start event instantiate Scheduler object and make a call to Scheduler_Start() method.

<%@ Application Language="C#" %>
<%@ Import Namespace="myScheduler" %>

<script RunAt="server">

    void Application_Start(object sender, EventArgs e)
    {
        // Code that runs on application startup
        Scheduler objmyScheduler = new Scheduler();
        objmyScheduler.Scheduler_Start();
    }

    void Application_End(object sender, EventArgs e)
    {
        //  Code that runs on application shutdown
    }

    void Application_Error(object sender, EventArgs e)
    {
        // Code that runs when an unhandled error occurs
    }

    void Session_Start(object sender, EventArgs e)
    {
        // Code that runs when a new session is started
    }

    void Session_End(object sender, EventArgs e)
    {
        // Code that runs when a session ends.
        // Note: The Session_End event is raised only when the sessionstate mode
        // is set to InProc in the Web.config file. If session mode is set to StateServer
        // or SQLServer, the event is not raised.

    }
      
</script>

You are done.

How it works?
Whenever the applications is first started the  Application_Start() in Global.asax is called and this calls Scheduler_Start() method which configures all the Jobs that we have created.

I have demonstrated a daily and hourly job in the above examples. In order to debug and test this code you need to wait for an Hour or a Day. Don’t panic I have done this intentionally. So in order to brush up your above learning’s prepare a job in Jobs.cs file that would be called every minute. Configure the callback and timer for your new job in Scheduler.cs file and enjoy the gist of scheduling.

Note: After running the project once do not forget to restart the IIS because Application_Start() wont be called every time you run your project. You know why?

How to Encrypt or Decrypt sections of Configuration file.

It is always a good practice to protect sensitive information in configuration files. One should always protect connectionStrings section from being easily readable; also some times it becomes necessary to encrypt appSettings section that may include some sensitive data. You know why…?

So in this Blog I will walkthrough the steps required for encryption\decryption of sections in configuration file.

.Net framework ships two providers for this purpose.
RsaProtectedConfigurationProvider and DpapiProtectedConfigurationProvider.
Here I will use RsaProtectedConfigurationProvider.

 
Step 1) First off all we will add provider to configuration section of web.config file that you want to play with. This provider is required for actual processing done while running commands depicted in step 3 and 4.

<configuration>
<configProtectedData defaultProvider="myProvider">
<providers>
 <clear/>
  <add name="myProvider"
  type="System.Configuration.RsaProtectedConfigurationProvider"
  keyContainerName="NetFrameworkConfigurationKey"/>
</providers>
</configProtectedData>
</configuration>

 RsaProtectedConfigurationProvider requires key container for encryption and decryption purpose. This container includes private\public keys that are required during encryption and decryption process by the attached provider.

NetFrameworkConfigurationKey : This is the default key container shipped by Microsoft. You can also create your own key container that includes private\public keys required for encryption\decryption. In order to avoid confusion I will depict these steps in my next article.

Note: As we are using default key container “NetFrameworkConfigurationKey” you can do away with the first step. This step will be added by machine.config file cause it includes declaration for both providers  (“RsaProtectedConfigurationProvider” and “DpapiProtectedConfigurationProvider”). But this will be helpful incase we are creating our own key container.

Step 2) After adding the provider in Step 1 go to the Visual Studio command prompt. Now In order to access “NetFrameworkConfigurationKey” key container your “ASPNET” account must have permission to access it. Run the below command to give access.

aspnet_regiis -pa “NetFrameworkConfigurationKey” “ASPNET”

Step 3) Run below command to encrypt connectionStrings section of your web.config file located in the virtual directory named “MyWebApplication”.

aspnet_regiis -pe connectionStrings -app /MyWebApplication

Step 4) Run below command to decrypt connectionStrings section of your web.config file located in the virtual directory named “MyWebApplication”.

aspnet_regiis -pd connectionStrings -app /MyWebApplication

Note: You can replace the “connectionStrings” section with the section name you want to encrypt\decrypt.
Eg: aspnet_regiis -pe appSettings -app /MyWebApplication
This will encrypt “appSettings” section of your web.config file located in the virtual directory named “MyWebApplication”.

To get more help about aspnet_regiis use the below command
aspnet_regiis help

Creating Custom Controls in ASP .Net

In this article I have simply demonstrated 2 code examples for creating Custom Web Controls.

Why Custom Controls?
To cater through the real world scenarios that may not be supplemented by inbuilt .Net controls, the need for Custom Control arises. Also their are several other reasons for creating custom control like reusability, centralized management over the control, ease of usage etc.

How to approach the requirement for creating Custom Controls?
If any of the inbuilt .Net control meets your requirement than you should always use these controls. If not than ask yourself a question

Would any of the existing control help me?

If yes than
Inherit from the existing control and add the new features to it and extend it further.
If No than
You need to build the control from scratch. In this case inherit from WebControl class.

How to create Custom Controls?

Their are two ways in which you can create a custom control.
1) You can inherit from existing .net web control to extend its features further. OR
2) You can directly inherit from WebControl class to create a web control from scratch.

Depending upon the approach you choose their will be several properties and methods for you to override. All of them cannot be explained here so I am explaining some important among them that I have used in my code samples.

AddAttributesToRender – Adds HTML or Style attributes for any of your HtmlTextWriterTag. You can also use HtmlTextWriter’s “AddAttribute” , “AddStyleAttribute” methods to achieve the same functionality. Make sure that you add this attributes before using “RenderBeginTag” method.

RenderContents – Outputs HTML content of Server Control to HtmlTextWriter object. So override this method to manage the HTML that your custom control renders to the browser.

TagKey – WebControl renders a span TAG by default on the cient browser. But to render any specific TAG you need to override this method.

Inheriting from the existing control
This example depicts the creation of a new web control named “myButton” that is derived from the Button class. It has all the features that a normal button control has. But for a twist I have added a simple feature that prompts for a message before submitting the page back to the server. I have added a new property called “AlertMessage” to quench this requirement.

using System;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace myControlLib
{
    public class myButton : Button
    {
        public myButton() { }
        private string _AlertMessage = "Are you sure to process this request!";
        public string AlertMessage
        {
            set { _AlertMessage = value; }
            get { return _AlertMessage; }
        }
        protected override void AddAttributesToRender(HtmlTextWriter writer)
        {
            writer.AddAttribute(HtmlTextWriterAttribute.Onclick, "return confirm('" + _AlertMessage + "')"); base.AddAttributesToRender(writer);
        }
    }
}

Registering the control on the web page

<%@ Register Assembly="myControlLib" Namespace="myControlLib" TagPrefix="myUcl" %>

Using the control

<myUcl:myButton ID="MyButton1" runat="server" Text="MyButton 1"  AlertMessage="Custom Message here!"/>

<myUcl:myButton ID="MyButton2" runat="server" Text="MyButton 2" />

Inheriting from the WebControl class
This example depicts the creation of a new web control named “myImage” that is directly derived from the WebControl class. This control renders a Picture, Name of the Picture and Description of the Picture. Description of the Picture is displayed when the mouse is moved over the picture.
For this I have created 3 additional properties for this.

ImageUrl – The url of the image to be displayed

ImageName – The name of the image.

ImageDescription – The description for the image.

using System;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace myControlLib
{
    public class myImage : WebControl
    {
        public myImage() { }

        private string _ImageUrl = "";
        public string ImageUrl
        {
            get { return _ImageUrl; }
            set { _ImageUrl = value; }
        }
        private string _ImageName = "";
        public string ImageName
        {
            get { return _ImageName; }
            set { _ImageName = value; }
        }
        private string _ImageDescription = "";
        public string ImageDescription
        {
            get { return _ImageDescription; }
            set { _ImageDescription = value; }
        }
        protected override void RenderContents(HtmlTextWriter writer)
        {
            writer.AddAttribute("onmousemove", "javascript:document.getElementById('" + this.UniqueID + "_divDescription').style.display='';");
            writer.AddAttribute("onmouseout", "javascript:document.getElementById('" + this.UniqueID + "_divDescription').style.display='none';");
            writer.AddAttribute(HtmlTextWriterAttribute.Src, _ImageUrl);
            writer.RenderBeginTag(HtmlTextWriterTag.Img);
            writer.RenderEndTag();
            writer.RenderBeginTag(HtmlTextWriterTag.Div);
            writer.Write("Name : " + _ImageName);
            writer.RenderEndTag();
            writer.AddStyleAttribute(HtmlTextWriterStyle.Display, "none");
            writer.AddAttribute(HtmlTextWriterAttribute.Id, this.UniqueID + "_divDescription");
            writer.RenderBeginTag(HtmlTextWriterTag.Div);
            writer.Write("Description : " + _ImageDescription);
            writer.RenderEndTag();
            base.RenderContents(writer);
        }
        protected override HtmlTextWriterTag TagKey
        {
            get
            {
                return HtmlTextWriterTag.Div;
            }
        }
    }
}

Registering the control on the web page

<%@ Register Assembly="myControlLib" Namespace="myControlLib" TagPrefix="myUcl" %>

Using the control

<myUcl:myImage ID="MyImage1" runat="server" ImageUrl="~/images/myImage1.jpg" ImageName="My Image Name"
ImageDescription="My Image Description........" />

Note: The above examples are the simplest controls that one can create. Remember that you can create more complex controls using the same approach. Choosing the best control that can serve the purpose of the requirement is our JOB and so make this decision very carefully.

How to make better appearance of your custom control in Visual Studio.

How to add custom control in Visual Studio Toolbox.

How to make better appearance of your custom control in Visual Studio.

In the previous article Creating Custom Controls in ASP .Net I have covered the technical approach for creating custom control.

Here I will explain how to improve the appearance of your custom control
Their are two ways in which this job can be done.
1) By decorating your control and control properties with some design time attributes.
2) By making your own control designer.

Decorating your control and control properties with some design time attributes:
.Net provides various design time attributes that can be applied on control or on property to take control over the design aspects of the control. You can do lots of things with this attributes let’s say:

One can choose the default event or default property for their controls.

One can assign the description to the property that is displayed in the last section of the property window when the property is selected.

One can categorize their additional properties in property window. This would be helpful when the property window is switched to “Categorized” mode.Etc…

Their are lots of such attributes with which you can playaround.
Some of them I have described below.

Attributes you can apply to your control class:

DefaultEvent – This attribute specifies the default event for your control. So when a control is double clicked, the event handler is automatically created for this event.

DefaultProperty – This attribute specifies the default property for your control. So when you open the property window for your control, this property will be focused by default.

ToolboxData – This attribute allows you to specify any tags that are added to the markup of your control whenever it is added to the page.

ToolboxItem – This attribute allows you to block the control from appearing in the toolbox.

TagPrefix – This attribute allows you to manage the html markup for the registration tag of your control.

Attributes you can apply to your control property:

Bindable – Displays a data binding dialog box for the property.

Browsable – This attribute allows you to block the property from appearing in Property window.

Category – This attribute allows you to group properties in a particular stencil. The property will appear under this category in the property window.

DefaultValue – This attribute allows you to give default value for the property.

Description – This attribute allows you to specify the description for the property. This description is displayed below in the property window when the property is selected.

Editor – This attribute allows you to specify the custom editor window for the property. Examples of custom editor are ImageUrlEditor, MailFileEditor,  MdbDataFileEditor,  UrlEditor etc…

EditorBrowsable – This attribute allow you to block a property from being display in the Intellisense.

Example Source Code

private string _ImageUrl = "";
[Category("My Custom Properties")]
[Description("Specify path of the image to be displayed.")]
[Editor("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
[DefaultValue("")]
[UrlProperty]
[Bindable(true)]
public string ImageUrl
{
    get { return _ImageUrl; }
    set { _ImageUrl = value; }
}

Making your own control designer:
Control Designer help to take control over the appearance of the control when they are drag dropped in the page. One can also create a smart tag that can help user to easily configure some properties of your control. Example: Some of the .Net controls like FormView, DetailsView, GridView have smart tags that help users to easily configure some important properties like Datasource, Templates etc. I will try to cover How to make smart tag controller in my next article.

Example Source Code

using System;
using System.Web.UI;
using System.Web.UI.Design;
using System.Web.UI.WebControls;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing;
using System.Drawing.Design;

[assembly: TagPrefix("myControlLib", "myUcl")]
namespace myControlLib
{
public class myImageDesigner : ControlDesigner
{
myImage objmyImage;
public override string GetDesignTimeHtml()
{
if (objmyImage.ImageUrl.Trim().Length == 0)
{
return "
<div style=\"background:yellow;width:100px;\"><center>Please set Image URL Property!</center>
<div>";
}
else
{
return base.GetDesignTimeHtml();
}
}
public override void Initialize(IComponent component)
{
objmyImage = (myImage)component;
base.Initialize(component);
return;
}
}

[Designer("myControlLib.myImageDesigner,myControlLib")]
[ToolboxBitmap(typeof(myImage), "myImageLogo.bmp")]
[ToolboxData(@"<{0}:myImage runat=""server"" ImageUrl="" "" ImageName="" "" ImageDescription="" "" />")]
public class myImage : WebControl
{
public myImage() { }

private string _ImageUrl = "";
[Category("My Custom Properties")]
[Description("Specify path of the image to be displayed.")]
[Editor("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
[DefaultValue("")]
[UrlProperty]
[Bindable(true)]
public string ImageUrl
{
get { return _ImageUrl; }
set { _ImageUrl = value; }
}

private string _ImageName = "";
[Category("My Custom Properties")]
[Description("Specify name of the image to be displayed.")]
public string ImageName
{
get { return _ImageName; }
set { _ImageName = value; }
}

private string _ImageDescription = "";
[Category("My Custom Properties")]
[Description("Specify description of the image to be displayed.")]
public string ImageDescription
{
get { return _ImageDescription; }
set { _ImageDescription = value; }
}

protected override void RenderContents(HtmlTextWriter writer)
{
writer.AddAttribute("onmousemove", "javascript:document.getElementById('" + this.UniqueID + "_divDescription').style.display='';");
writer.AddAttribute("onmouseout", "javascript:document.getElementById('" + this.UniqueID + "_divDescription').style.display='none';");
writer.AddAttribute(HtmlTextWriterAttribute.Src, _ImageUrl);
writer.RenderBeginTag(HtmlTextWriterTag.Img);
writer.RenderEndTag();
writer.RenderBeginTag(HtmlTextWriterTag.Div);
writer.Write("Name : " + _ImageName);
writer.RenderEndTag();
writer.AddStyleAttribute(HtmlTextWriterStyle.Display, "none");
writer.AddAttribute(HtmlTextWriterAttribute.Id, this.UniqueID + "_divDescription");
writer.RenderBeginTag(HtmlTextWriterTag.Div);
writer.Write("Description : " + _ImageDescription);
writer.RenderEndTag();
base.RenderContents(writer);
}

protected override HtmlTextWriterTag TagKey
{
get
{
return HtmlTextWriterTag.Div;
}
}
}
}

Note: Do not forget to add a .bmp image named (“myImageLogo.bmp”) to this project. This image would be displayed as the icon for your control in the toolbox. You can also create .bmp file using inbuilt .Net design tool. Just click on the added .bmp file to open this editor.
Your bmp should be 16×16 pixels in size.

To add custom control to your toolbox refere
How to add custom control in Visual Studio Toolbox.

How to add custom control in Visual Studio Toolbox.

In my previous article Creating Custom Controls in ASP .Net  we have seen the technical approach for creating custom control and  in How to make better appearance of your custom control in Visual Studio we have gone through the design aspects of custom control.

Now in this article I will explain how to add your custom control to your Toolbox.

Making Custom Control Class Library Project.

Step 1 – Create a class library project named myControlLib.

Step 2 – Add the following code to a new class named myImage. To download sample code files click here. After downloading add “myImage.cs” and “myImageLogo.bmp” file to your “myControlLib” project. Change the “Build Action” property of “myImageLogo.bmp” to Embedded Resource.

Step 3 – Compile the project.

Note: Above given steps are specific to the code sample that I have created. If you want to rename any of the file or change any other aspects than make sure that you also change the design time attributes of your control.

Example: [Designer ("myControlLib.myImageDesigner,myControlLib")] uses the namespace “myControlLib” that is directly related to the name of the class library project you make.

Adding custom control to toolbox.

Step 1 – Switch over to the web project in which you want to use the control.

Step 2 – In toolbox add your own tab or click on general tab.

Step 3 – Right click in the selected tab area and click Chose Items.

Step 4 – This will open Choose Toolbox Item screen. Click on Browse button and specify the path of dll you created in your myControlLib project.

Step 5 – Click Ok and you’re done. Your Custom control will be added to the toolbox as shown below.

Application Caching in .Net 2.0

What is Application Caching?
Application Caching is a technique in .Net 2.0 for caching different type of objects for faster access. As the name itself depicts, the Cache Object can be used from the entire application. A single cache object lies for the entire application and so can be used between various different user sessions and requests.

How Application Caching works and How to use it?
The main motive for Application Caching is to store cached Objects in memory for faster access. Expensive operation to obtain and persists data or information can lead to application failure or sluggishness at time of heavy traffic. Also the amount of time and resources involved in such operations may not be satisfactionary. So to improve upon the performance and the scalability of your application you can cache the expensive data for faster access.

You can use either Cache.Add() or Cache.Insert() methods for caching your data. The only difference between the two is, Cache.Add() method returns the object which you want to cache.
So let’s say if you want to use the object and cache it as well. You can do so in a single line of code with the help of Cache.Add().

Cache.Insert() methods has 4 different types of overloaded methods while Cache.Add() has only one.

Different Parameters used for the above methods:

Key
It is the name for the cached object by which it will be accessed. You can also use the key to remove the cached object from the memory. Following code will remove the cached object named “customerList” from the memory.

Cache.Remove("customerList");

Object to be cached
It is the object that you want to cache. This object will be stored in the memory for faster retrieval.

 
Dependency
It is the CacheDependency object that can be a file or cache key. So if the file or cache key is changed than the object in the cached will be invalidated and removed from the cache. This can be used to maintain the freshness of the data. This is an optional parameter. You can set it to null. Incase of multiple dependency conditions you can use AggregateCacheDependency object instead of CacheDependency.

 
Absolute Expiration Date
It is the time at which the object will be removed from the cache. To remove the object from cache after 10 minutes you can set this parameter to DateTime.Now.AddMinutes(10) as shown in the below code.

Cache.Insert("customerList", objDataSet,
new CacheDependency(Server.MapPath("~/App_Data/customerList.xml")),
DateTime.Now.AddMinutes(10), Cache.NoSlidingExpiration,
CacheItemPriority.Normal, null);

If you do not want the object to expire forcefully after some time than you may set this parameter to Cache.NoAbsoluteExpiration as shown in below code.

Cache.Insert("customerList", objDataSet,
new CacheDependency(Server.MapPath("~/App_Data/customerList.xml")),
Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration,
CacheItemPriority.Normal, null);

Time Span
It is the time span after which the object will be removed from the cache if it was not accessed. So lets say if you want to remove the object from cache if it has not been accessed since last 10 minutes than you can use the below code.

Cache.Insert("customerList", objDataSet,
new CacheDependency(Server.MapPath("~/App_Data/customerList.xml")),
Cache.NoAbsoluteExpiration,DateTime.Now.AddMinutes(10),
CacheItemPriority.Normal, null);

If you do not want the object to expire forcefully after some time it was last accessed than you may set this parameter to use Cache.NoSlidingExpiration  as shown in below code.

Cache.Insert("customerList", objDataSet,
new CacheDependency(Server.MapPath("~/App_Data/customerList.xml")),
Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration,
CacheItemPriority.Normal, null);

Note: If you are using this sliding expiration time parameter than Absolute Expiration Date parameter must be Cache.NoAbsoluteExpiration

Priority
It is the priority at which the objects will be purged from the memory incase if the memory runs low. Lower priority objects will be removed first.

Callback Method
It is the event handler that will run when the object is removed from the cache. If you do not want to use this parameter than you can set this to null.

 
To download Application caching code sample Click Here.

 
Note: To introduce sophisticated caching layer in your application you can always use Microsoft’s Enterprise Library – Caching Application Block.

Understanding Globalization and Localization in .NET

Now days as the audience for web applications has bursted from computers to pda’s, cell phones and many other gadgets, Globalization has become must for web application. Globalization allows your web application to be useful for different people in different parts of the world who speaks different languages.

Thanks to Microsoft .Net Globalization feature.

Using this feature one can easily build a web application available to dispersed audience throughout the world.

In this article I will walkthrough the steps that are essential for creating a multi cultured application. This example will include the use of Global and Local resource files that are heart for multi cultured web application.

ASP.Net supports two types of resources

Local Resource and Global Resource.

Both types of Resources are xml based resource files that can contain text translated into particular language

Local Resources:

Local resource is specific to particular webpage. All the resource files related to particular webpage must be placed in a special .Net folder named App_LocalResources. This folder must be in the same folder of the webpage that you want to localize. So App_LocalResources can be subfolder for any folder of your website.

Global Resources:

They are the resource files for the entire web application. They are not specific to any page. They can be accessed from the entire web application. Global resource files must be located in a special .Net folder named App_GlobalResources. App_GlobalResources must be at the root of the web application.

Steps to create local Resource file.

1) Switch to design view of the webpage for which you want to create the resource file.

2) Go to Tools menu and click Generate Local Resource.

3) As the result of step 2 .Net generates the .resx file.

Naming conventions that Resource files follow is as explained below:

<PageName>.aspx.<language>.resx

Example

myWebPage.aspx.resx: This is the default resource file of your page. If no culture matches than this resource file is used.

myWebPage.aspx.es.resx: For Neutral Spanish culture it may look like this.

myWebPage.aspx.es-MX.resx: For Specific Spanish Mexican culture it may look like this.

What do you mean by neutral and specific cultures? I leave this small exercise to readers.

Steps to create global Resource file.

1) Their are no specific utilities in .Net to generate Global resource files automatically. But you can create App_GlobalResources folder at root level and add a resource file manually Or you may copy the local resource file and change it at your will.

Ways in which you can Globalize or localize your application.

 
Implicit Localization

<asp:Label ID="lblLoadLocalResource" runat="server" 

Text="Local Resource" 

meta:resourcekey="lblLoadLocalResourceResource1">

</asp:Label>

Implicit Globalization

<asp:Label ID="lblLoadGlobalResource" runat="server" 

Text="<%$ Resources:Resource, commonHeader %>" 

ToolTip="<%$ Resources:Resource, commonHeader %>">

</asp:Label>

Programmatic Localization

lblLoadLocalResource.Text = GetLocalResourceObject
("lblLoadLocalResourceResource1.Text").ToString();

lblLoadLocalResource.ToolTip = GetLocalResourceObject
("lblLoadLocalResourceResource1.ToolTip").ToString();

Programmatic Globalization

lblLoadGlobalResource.Text = GetGlobalResourceObject
("Resource", "commonHeader").ToString();

lblLoadGlobalResource.ToolTip = GetGlobalResourceObject
("Resource", "commonHeader").ToString();

How to change the UI Culture?

Steps to check and configure the UI Culture of your webpage

1) To change it programmatically you need to override the InitializeCulture() of your web page.

protected override void InitializeCulture()
{
 UICulture = "en";
}

2) To change it implicitly from .aspx page Set

<%@ Page Language="C#" UICulture="en" %>

3)To change it globally from web.config file

<system.web>
 <globalization uiCulture="es"/>
</system.web>

Note: If you set UICulture=”auto” then .Net runtime will automatically detect the requesting browsers preferred language setting and will compile the related resource file for that culture. In this case you do not have to write a single piece of code for setting UICulture.

How to check this?

1) Open IE and go to Tools > internet Options

2) Click Languages tab.

3) This will open language Preference dialog box window.

4) Add the language by clicking the add button. Make sure to add the language for which you have configured the resource file of your web page.

5) Select the language that you have added and using Move Up button, bring it to the first topmost position in the language list.

6) Press Ok and again Ok to return.

Open your webpage in the browser and enjoy the taste of globalized web application.

I believe that few lines of code can speak thousand words and so I have prepared a small demo that includes both Globalization and Localization.

To download the entire source code Click Here.

Note: Globalizing the web application entirely, requires lots of other things like changing the Culture, formatting dates and currency and lot more. I will try to incorporate all this stuff in my next article.