Amol Thengane's Technical blog

Data Caching using Enterprise Library

2014-10-31T15:58:00.001+05:30

Introduction

Caching is one of most important factors if we think about application performance. Most applications need a caching implementation to improve performance. The Caching Application Block provides a flexible and extensible caching framework with a set of APIs that can be used at any layer of an application. It supports in-memory, database, or isolated storage for storing cached data. We can use it in web applications as well as Windows applications. Implementing caching using the Caching Application Block improves the performance of applications as well as reduces development time and cost. This application block provides all kinds of functions like adding, removing, and managing the expiration of cache. In this article, I have explained how we can use the Caching Application Block of Enterprise Library 4.1 in an ASP.NET Web application. But as I said earlier, the Caching Application Block is very generic and can be used in different applications without changing a single line of code. In other words, we can say the Enterprise Library Caching Application Block provides a ready to use caching framework. Hope this article will help all of you. Please provide your valuable suggestions and feedback to improve my article.

Where can the Caching Application Block be used?

The Enterprise Library Caching Application Block is a ready to use caching framework that can be used in various applications like:

ASP.NET Web applications
Windows Forms
Console
Windows Service
Enterprise Services
Web Service

This caching application block has in-built features like inserting an item into cache, remove from cache, cache expiration settings, etc. This is extensible as well as per your requirement.

Installing Enterprise Library 4.1

First of all, we need to install Enterprise Library before we start working with any of the application blocks. As of now, the latest version of Enterprise Library is 4.1. This article is based on the same version. You can download and install Enterprise Library easily from Enterprise Library 4.1-October 2008.
Microsoft Enterprise Library is a collection of reusable application blocks designed to assist software developers with common enterprise development challenges. This release includes caching, cryptography, data access, exception handling, logging, policy injection, security, validation, and unity.

Using Enterprise Library Configuration Manager

Enterprise Library's API is based on an XML configuration. The application configuration file contains all related information regarding application blocks. As this is an XML configuration, we can do all kinds of manual changes in the file but it’s quite difficult to remember all the configuration and properties. Microsoft provides the Enterprise configuration UI console to configure the application block using a UI.
After installing Enterprise Library 4.1, you can find the Enterprise Library Configuration Manager in the Bin directory of your installed location. In my case, it is in "C:\Program Files (x86)\Microsoft Enterprise Library 4.1 - October 2008\Bin". Run EntLibConfig.exe. Or you can go to Start > Select Program Files > Microsoft Patterns and Practices > Enterprise Library >Enterprise Library Configuration. The following screen will appear:

Configure Caching Application Block

Now click on File > Open application. Select the "web.config" of your ASP.NET web application.

By default, Enterprise Library configuration has a Data Access Application Block setting added. We can easily remove any configuration settings by using right click > Remove.
Now we can add a "Caching Application Block" using right click on Root > New > Caching Application Block.

A new configuration section "Caching Application Block" will be automatically added with the configuration File.

Save the configuration in Configuration Manager. Now open the web application and check the web.config file for changes. You will find the below Config section has been added in the web.config file after adding the Caching Application Block using the Enterprise Application Manager.

Using the Caching Application Block

Adding Reference

As the caching application block is a predefined set of code and is defined in a framework, we need to add some reference to our application. These are Microsoft.Practices.EnterpriseLibrary.Caching.dll and Microsoft.Practices.EnterpriseLibrary.common.dll. These two are sufficient for using the Caching Application Block.

After adding a reference, we have to add a namespace for using the Caching Application Block. These are:

using Microsoft.Practices.EnterpriseLibrary.Caching;
using Microsoft.Practices.EnterpriseLibrary.Common;

This is all about adding references and namespaces. Now let’s have a look at how we can do all kinds of caching operations like insert data into cache, remove from cache, display data from cache, cache expiration, etc.

Before doing any kind of caching operation, we need to initialize the CacheManager object.

Initialize Cache Manager

ICacheManager is the main interface between our application and the Caching Application Block. To create an instance of a CacheManager object, the application uses the CacheFactory class, which in turn uses the CacheManagerFactory class. The CacheManagerFactory class creates all the internal classes needed to implement a CacheManager object.

Insert Item to Cache

Now we have an instance of CacheManager. The CacheManager provides an Add() method to add a new CacheItem to the cache. By default, it takes two arguments: String Key and Object Value.
Below is a sample code snippet to show how to add a CacheItem to the cache:

Remove Item from Cache

Removing an item from cache is very easy to implement. CacheManager provides a Remove() method to remove a CacheItem from cache. This method has no overloaded method and takes only a single argument Key. If the key exists, the CacheItem will be removed automatically from CacheItems, otherwise this method will do nothing.

Retrieve Item From Cache

After adding an element into a cache, the next thing we need to do is to retrieve the cache element from the cache collection. But when retrieving the cache element, we have to make sure we are type casting the object in proper type. For example, if we have stored a DataSet as an object in cache, during retrieval, we have to make sure we are doing the same type casting.

Remove All Items From Cache

We can remove all items from cache using the Flush() method of CacheManager.

Caching Expiration

Microsoft Caching Application Block provides great use of the caching expiration functionality. For that, we need to add the namespace below:

using Microsoft.Practices.EnterpriseLibrary.Caching.Expirations;

Adding the namespace will provide us the below classes to implement the expiration of caching using the Application Block.

AbsoluteTime
ExtendedFormat
ExtendedFormatTime
FileDependency
NeverExpired
SlidingTime

AbsoluteTime

Absolute time defines the lifetime of a cache item by specifying the absolute time for an item to expire from the cache item collection. Absolute expirations are specified in full-time format (hh:mm:ss). The object will expire from the cache at the specified time:

ExtendedFormat and ExtendFormatTime are quite similar with AbsoluteTime configuration. I am not going into details on these two. Let us start with FileDependency.

FileDependency

File-based dependency invalidates a particular cache item when a file(s) on the disk changes. This is quite helpful when we want to update cache data if there are some changes in files or database.

NeverExpired

If we set the caching expiring policy as never expire, then data will be stored in the cache collection unless and until we use CacheManager.Remove() to remove the cache item. When we use the CacheManager.Add() method with only a key and value argument, the cache object is set to never expire mode.

Sliding

Sliding resets the time for the item in the cache to expire on each request. This is useful when an item in the cache is to be kept alive as long as requests for that item are coming in from various clients. This means the item expires after the specified time has elapsed from when the item was last accessed. The default time is 2 minutes.

IS and AS operators in C#.NET

2013-02-13T13:22:00.000+05:30

The below excerpt is from the book: Applied Microsoft .Net Framework Programming by Jeffrey Richter. If you are a C# programmer and you are not aware of is and as operators in C#, then reading the following extract would be very useful.

C# offers another way to cast using the is operator. The is operator checks whether an object is compatible with a given type, and the result of the evaluation is a Boolean: true or false. The is operator will never throw an exception. The following code demonstrates:

System.Object o = new System.Object();

System.Boolean b1 = (o is System.Object); // b1 is true.

System.Boolean b2 = (o is Employee); // b2 is false.

If the object reference is null, the is operator always returns false because there is no object available to check its type. The is operator is typically used as follows:

if (o is Employee)

{

Employee e = (Employee) o;

// Use e within the ‘if’ statement.

}

In this code, the CLR is actually checking the object’s type twice: the is operator first checks to see if o is compatible with the Employee type. If it is, then inside the if statement, the CLR again verifies that o refers to an Employee when performing the cast. Because this programming paradigm is quite common, C# offers a way to simplify this code and improve its performance by providing an as operator:

Employee e = o as Employee;

if (e != null)

{

// Use e within the ‘if’ statement.

}

In this code, the CLR checks if o is compatible with the Employee type, and if it is, as returns a non−null pointer to the same object. If o is not compatible with the Employee type, then the as operator returns null. Notice that the as operator causes the CLR to verify an object’s type just once. The if statement simply checks whether or not e is null—this check can be performed much more efficiently than verifying an object’s type.

The as operator works just like casting except the as operator will never throw an exception. Instead, if the object can’t be cast, the result is null. You’ll want to check to see whether the resulting reference is null, or attempting to use the resulting reference will cause a System.NullReferenceException exception to be thrown. The following code demonstrates:

System.Object o = new System.Object(); // Creates a new Object object

Employee e = o as Employee; // Casts o to an Employee

// The cast above fails: no exception is thrown, but e is set to null.

e.ToString(); // Accessing e throws a NullReferenceException.

Dynamically binding property at Design-Time in WPF

2012-01-17T17:33:00.003+05:30

Binding WPF property dynamically to controls at Design-Time is a good feature provided in WPF. With this feature we can test the control binding without running the application.

Implemention is not a big deal. It is very easy to implement.

I will demonstrate implementation of this feature with an example.

Example:-

Create a new WPF application. Add new project named as "ViewModelBase". Add a class file named as "StudentBase.cs". Add basic properties of Student such as Name, Address, City, State, Country. Refer below image.

Add new project to solution named as "DesignTimeViewModel". Add a class file in that named as "Student.cs". Inherit "StudentBase" to this class. Refer image below...

Add a default constructor to this newly added class. Write a method which sets all the properties of the base class. Call this method from default contructor as shown in above image.

Now, go to the WPF project which was added initially. Double click on Window.Xaml page. Design a page as shown below.

Add binding property to the text box controls shown as selected in the image below. Use respective property such as Name, Address etc for binding to the textbox controls.

After setting binding property to the controls still you will not able to see property value set in derived class in textbox control.

After doing all the above stuff, we required to add one xaml tag in Window section on the Window.xaml page refer a selected tag in the below image.

Now, you will be able to see all the respective properties values set in derived class are dynamically bind to all textbox controls.

Note:- If you are still unable to see property values set in dervied class in textboxes as shown in above image then you must required to build the whole application. If you still face an issue then please le me know.

Detecting browser close event in Javascript

2011-04-30T11:04:00.001+05:30

Below code is applicable for IE and Mozilla.

///Javascript starts here

var keyCd, altKy, mouseBtn, ctlKy, shiftKy;
Browser = navigator.appName
Net = Browser.indexOf("Netscape")
Micro = Browser.indexOf("Microsoft")
Netscape = false
IE = false
if (Net >= 0) {
    window.captureEvents(Event.MOUSEDOWN)
    window.onmousedown = HandleClose
    Netscape = true
}
if (Micro >= 0) {
    IE = true
}
function getKeyCode(event) {
    if (IE == true) {
        keyCd = event.keyCode;
        altKy = event.altKey;
        ctlKy = event.ctlKey;
        shiftKy = event.shiftKey;
    }
    if (Netscape == true) {
        if (event.which == null)
            keyCd = event.keyCode;
        else
            keyCd = event.which;
        altKy = event.altKey;
        ctlKy = event.ctrlKey;
        shiftKy = event.shiftKey;
    }
    if (keyCd == 13) {
        document.getElementById("ctl00_BtnLogout").disabled = true;
    }
}
function getMouseButton(event) {
    if (IE == true) {
        mouseBtn = event.button;
    }
    if (Netscape == true) {
        if (event.which == null)
            mouseBtn = event.button;
        else
            mouseBtn = event.which;

    }
}
function HandleClose(e) {
    if (IE == true) {
        //Browser Closes through ALT + F4 buttons
        if (event.altKey == true && event.keyCode == 0) {
            PageMethods.DeleteSession();
        }
        //Browser Closes through Browser Close (X) button
        Xwidth = window.document.body.offsetWidth - window.event.clientX
        YHeight = window.event.clientY
        if (Xwidth <= 30 && YHeight < 0) {
            PageMethods.DeleteSession();
        }
        //Browser Closes through CTRL + F4 and CTRL + W buttons
        if (event.ctrlKey == true && event.keyCode == 0) {
            PageMethods.DeleteSession();
        }
        //Browser Closes through ALT + SPACE + C buttons
        if (keyCd == 32 && altKy == true) {
            PageMethods.DeleteSession();
        }
        //Browser Closes through Mouse right Click in Task bar
        if (mouseBtn == null && keyCd == null) {
            if (window.event.clientX > 1000) {
                PageMethods.DeleteSession();
            }
        }
    }
    else if (Netscape == true) {
        //Browser Closes through ALT + F4 buttons
        if (altKy == true && keyCd == 115) {
            PageMethods.DeleteSession();
            alert('Hi1');
        }

        //Browser Closes through CTRL + F4 and CTRL + W buttons
        if (ctlKy == true && (keyCd == 87 || keyCd == 115)) {
            PageMethods.DeleteSession();
            alert('Hi2');
        }
        //Browser Closes through ALT + SPACE + C buttons
        if (altKy == true && keyCd == 18) {
            PageMethods.DeleteSession();
            alert('Hi3');
        }

        //Browser Closes through Mouse right Click in Task bar
        if (mouseBtn == null && keyCd == null) {
            PageMethods.DeleteSession();
            alert(e.X);
        }
    }
}

///Javascript ends here

///Html or Asp.net code starts here

<body onbeforeunload="HandleClose(event)" onKeyDown="return getKeyCode(event)" onMouseDown= "getMouseButton(event)">
///Your code here
</body>

///Html or Asp.net code ends here