Friday, January 30, 2009

State Management : A Step ahead series

State Management


The State or Cache Management is nothing but the way to storing the data in Client-Side and in Server-Side using preity small memory.
There are two major category of the above :

I. Server-Side State Management

Session State:

Its nothing but defined as a period of time shared between the web application and user. Every user has individual session. Items/Objects can be placed into the Session which would only define these object for that user. Session contains key variables which help to identify the related values. This can be thought of as a hash table. Each user would represent a different key node in the hash identifying unique values. The Session variables will be clear by the application which can clear it, as well as through the timeout property in the web config file. Usually the timeout is 20 minutes by default.

Session Variables are stored on the server, can hold any type of data including references, they are similar to global variables in a windows application and use HTTP cookies to store a key with which to locate user's session variables.

The collection of session variables is indexed by the name of the variable or by an integer index. Session variables are created by referring to the session variable by name. You do not have to declare a session variable or explicitly add it to the collection.

Lets get it cleared from following example:

Session[“firstName”] = “Gaurav” //User’s first name
Session[“lastName”] = “Arora” //User’s last name

// Clear the session variable
Session[“FirstName”] = null;

//Clear all Session variables
Session.Abandon();


InProc—Stores Session state in the same process as the ASP.NET process [aspnet_wp.exe].

StateServer—Stores Session state in a Windows NT process, which is distinct from the ASP.NET process[aspnet_state.exe].

SQLServer—Stores Session state in a SQL Server database.

Both in StateServer and SQLServer options, we need to ensure that the objects we cache are serializable as data storages are out-of-process systems. Both these options have impact on the application performance as data retrieval and saving operations take more time when compared to the InProc option. So based on our application requirement we should choose the option that best suits our requirement.


Note:
By default, ASP.NET session state is enabled for all ASP.NET applications.

ASP.NET application object


ASP.NET provides an object called Application object to store data that is accessible to all user requests. The life span of this object is tied to the application and it is re-created every time the application starts. Unlike ASP.NETSession object this object is accessible to all user requests. Since this storage is created and maintained in an application domain space, this should not be used for data storage in a web farm scenario. This option is very useful to store data like the application metadata (CONFIG files data) that can be loaded to the Application object during application start up and can be used during the life of the application without reloading it every time for each user request. But if there is a requirement to invalidate the cached data whenever there is any change to the CONFIG files while the application is running, this option should not be used as it doesn't provide any feature to expire the cached data. So in this case other options like the ASP.NET Cache object should be used, which is explained below.
Types of Cache –Dependencies


When anyone add an item to cache, he/she can define the dependency relationships that can force that item to be removed from the cache under specific activities of dependencies.

For example: If the cache is dependent on file and when the file data changes you want the cache object to be updated.

Following are the difference dependencies:
(a) File Dependency :
Allows invalidating a specific cache item when a disk based file or files change.

object errorData;
//Load errorData from errors.xml

CacheDependency fileDependency =
new CacheDependency(Server.MapPath("errors.xml"));
Cache.Insert("ERROR_INFO", errorData, fileDependency);


(b) Time based expiration :
Allows to invalidate a specific cache item depending on predefined time.

//Absolute Expiration

Cache.Insert("EMP_NAME", "Shubhabrata", null,
DateTime.Now.AddDays(1), Cache.NoSlidingExpiration);

//Sliding Expiration

Cache.Insert("EMP_NAME", "Shubhabrata", null,
Cache.NoAbsoluteExpiration, TimeSpan.FromSeconds(60));


(c) Key dependency :
Allows to invalidate a specific cache item depending when another cache item changes.

string[] relatedKeys = new string[1];
relatedKeys[0] = "EMP_NUM";
CacheDependency keyDependency = new CacheDependency(null, relatedKeys);
Cache["EMP_NUM"] = 5435;
Cache.Insert("EMP_NAME", "Shubhabrata", keyDependency);
Cache.Insert("EMP_ADDR", "Bhubaneswar", keyDependency);
Cache.Insert("EMP_SAL", "5555USD", keyDependency);


.NET remoting


You might be thinking how .NET remoting can be used for data caching? The same question came to my mind when I heard about it for the first time. As you know the .NET remoting singleton object shares the same instance with multiple clients so singleton objects can be used to store and share data between different client invocations. Since .NET remoting can be used outside the process and machine, this option is very useful when we want to cache data and share it across servers and users particularly in a web farm scenario. In this approach we can store the data as member variables of singleton remoting object and provide methods to read and save data. But while implementing this we need to ensure that the remoting object used as cache is not destroyed by the garbage collector. For that we will have to set the remoting cache object's lease period to infinite so that the lease period never times out. We can do that by overriding the InitializeLifetimeService method of MarshalByRefObject and return null from this method. But the only issue with this approach is performance. As the analysis says the performance is very poor in this approach when compared to other approaches. Anyway it is up to the application designers/developers to analyze different options and use the best one that suits the requirement.

Memory-mapped files


You all know what a memory-mapped file is. It is basically about mapping a file on disk to a specific range of addresses in the application's process address space. This option allows different processes to use the same data by increasing the application performance. As using memory-mapped file is not very popular among .NET developers, I would personally not suggest this approach as implementing this involves a lot of complexities and also .NET Framework doesn't support this. But if anyone is very much interested in using this approach then they will have to develop their own custom solution as per their own requirement.

Static variables


We use static variables for storing data or objects globally so that it can be accessed during the life of the application. Similarly, in ASP.NET we can use static objects for caching data and we can also provide methods to retrieve and save data to the cache. As static variables are stored in the process area, performance wise it is faster. But since it is very difficult to implement expiration policies and dependencies incase of static variables, I generally prefer ASP.NET cache object over this option. Another problem is that the custom static cache object has to be thread-safe which has to be implemented carefully.

Example:

public class CustomCache
{
//Synchronized to implement thread-safe

static Hashtable _myCache =
Hashtable.Synchronized(new Hashtable());

public static object GetData(object key)
{
return _myCache[key];
}

public static void SetData(object key, object val)
{
_myCache[key] = val;
}
}



II. Client-Side State Management

Cookies


Cookie is a very familiar term in web development environment. Cookie is a client-side storage that is sent to the server for each request and also received as response back from the server. Because of its size limitation (4096 bytes) it should be used for storing small amount of data. Expiration policies can be set for cookies to invalidate the items after a certain period of time. The following example shows how Cookie can be used in an ASP.NET application:

if (this.Request.Cookies["MY_NAME"] == null)
{
this.Response.Cookies.Add(new HttpCookie("MY_NAME",
"Shubhabrata Mohanty"));
}
else
{
this.Response.Write(this.Request.Cookies["MY_NAME"].Value);
}


ViewState


ASP.NET ViewState is a new concept. Here the data related to the pages and controls are stored in ViewState which retains the values across multiple requests to the server. If you remember correctly, in VB-ASP applications we used to store data across multiple requests using hidden fields. ViewState is actually implemented internally as hidden fields in ASP.NET but here the data is hashed to improve security as against hidden fields. To see how ViewState is implemented, you can view the source of the page in which ViewState is used in the Internet browser. ViewState should not be used to store large amounts of data as it is passed to the server for each request

protected void Page_Load(object sender, EventArgs e)
{
if (this.ViewState["MY_NAME"] == null)
{
this.ViewState["MY_NAME"] = "Shuby";
}

//txtName is a TextBox control

this.txtName.Text = this.ViewState["MY_NAME"].ToString();
}


Hidden fields


Hidden fields are very popular among VB-ASP web developers. Hidden field is similar to any other control in a page but the visible state of this control is always false. Like ViewState we should not use it for storing large amounts of data.
Note:Similarly hidden frames can be used to cache data in the client side. But please note that hidden frames are not supported by all Internet browsers.

<!--In ASP.NET-->
<asp:HiddenField ID="myHiddenField" Value="Shuby" runat="server" />

<!--In HTML-->
<input id="myHiddenField" type="hidden" value="Shuby" />

Query Strings



Query strings provide a simple but limited way of maintaining some state information.You can easily pass information from one page to another, But most browsers and client devices impose a 255-character limit on the length of the URL. In addition, the query values are exposed to the Internet via the URL so in some cases security may be an issue.

http://www.msdotnetheaven.com/?authorid=4

Example:

string authorid;
authorid=Request.Params[“authorid”];


Note: You can only use HTTP-Get method to post the web page, or you will never get the value from query strings.

Thursday, January 29, 2009

Build your website through DataBase using IronSpeed

Iron Speed : Provides facility to automatically generate asp.net web site directly from database.

Generate database and reporting applications for .NET in minutes. Quickly create visually stunning, feature-rich Web 2.0 applications that are easy to customize and ready to deploy.

Working :

Simply point to an existing database and let Iron Speed Designer build a sophisticated, database-driven application that's ready to deploy. In just minutes, Iron Speed Designer generates your application's ASPX pages, user interface code, data access logic and SQL statements. Say good-bye to hand-coding!

Refer : http://www.ironspeed.com/products


Features:
1. Sophisticated pages and reports
2. Visual Stunning web application
3. International Language Support
4. Application Security

Wednesday, January 28, 2009

Virtual Path Provider

Its the path providing facility to provide the virtual content to compiler. For example, a virtual path provider provides a means to supply content from locations other than the file system.

To attain the same following step(s) are required :

1. Create a VirtualPathProvider class, and implement all the required methods to handle files and folder requests.

2. Register the virtual path provider to let the ASP.NET hosting environment know where the content will be served from.

3. Create VirtualFile and VirtualDirectory objects to stream the content.
Visit : http://support.microsoft.com/kb/910441

Tuesday, January 27, 2009

XAML in .net : A Step Ahead Series

XAML : stands for eXtensible Application Markup Language and pronounced as zammel".

XAML combined with the next-gen Windows graphics kernel (code-named Avalon) is an all-in-one markup language for hypertext (HTML), vector graphics (SVG), animations (Flash,SMIL), print documents (PDF,XSL-FO), forms (XForms,XUL), and much more.

The best of both worlds: In the XAML world there's no longer a difference between a web application and a windows application. Windows is the browser kernel and Internet Explorer is just a shell.

The best of all worlds: A single programming model for media, documents and applications.

A typical XAML example:


<Window Text="Xul Challenge 2004">
<FlowPanel>
<SimpleText>Counter Sample</SimpleText>
<TextBox ID="ValueTextBox" HorizontalAlignment="Center" IsReadOnly="True"/>
<FlowPanel HorizontalAlignment="Center" Width="100%">
<Button Click="Dec">Dec (-)</Button>
<Button Click="Clear">Clear</Button>
<Button Click="Inc">Inc (+)</Button>
</FlowPanel>
</FlowPanel>
</Window>



<b>C# vs. XAML</b>

1. XAML-Example
<TextPanel
Background="BlanchedAlmond"
FontFamily="Comic sans MS"
FontSize="36pt"
HorizontalAlignment="Center">
Hello, world!
</TextPanel>

2. C#-Example

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

class HelloWorldApp : Application
{
static void Main()
{
HelloWorldApp app = new HelloWorldApp();
app.Run();
}

protected override void OnStartingUp( StartingUpCancelEventArgs args )
{
Window win = new Window();
TextPanel tp = new TextPanel();

tp.Background = Brushes.BlanchedAlmond;
tp.FontFamily = "Comic sans MS";
tp.FontSize = new FontSize( 36f, FontSizeType.Point);
tp.HorizontalAlignment = System.Windows.HorizontalAlignment.Center;
tp.TextRange.Text = "Hello, world";

win.Children.Add(tp);
win.Show();
}
}



For more details, please refer to:

1. http://msdn.microsoft.com/en-us/library/ms752059.aspx
2. http://xaml.sourceforge.net/talk/dotnet-dec-2004/slides.html

Sunday, January 25, 2009

State Management

The  State or Cache Management is nothing but the way to storing the data in Client-Side and in Server-Side using preity small memory.


There are two major category of the above :
I. Server-Side State Management

Session State: Its nothing but defined as a period of time shared between the web application and user. Every user has individual session. Items/Objects can be placed into the Session which would only define these object for that user. Session contains key variables which help to identify the related values. This can be thought of as a hash table. Each user would represent a different key node in the hash identifying unique values. The Session variables will be clear by the application which can clear it, as well as through the timeout property in the web config file. Usually the timeout is 20 minutes by default.

Session Variables are stored on the server, can hold any type of data including references, they are similar to global variables in a windows application and use HTTP cookies to store a key with which to locate user's session variables.

The collection of session variables is indexed by the name of the variable or by an integer index. Session variables are created by referring to the session variable by name. You do not have to declare a session variable or explicitly add it to the collection.

Lets get it cleared from following example:

Session[“firstName”] = “Gaurav” //User’s first name
Session[“lastName”] = “Arora” //User’s last name

// Clear the session variable 
Session[“FirstName”] = null; 

//Clear all Session variables 
Session.Abandon();  


InProc—Stores Session state in the same process as the ASP.NET process [aspnet_wp.exe].

StateServer—Stores Session state in a Windows NT process, which is distinct from the ASP.NET process[aspnet_state.exe].

SQLServer—Stores Session state in a SQL Server database.

Both in StateServer and SQLServer options, we need to ensure that the objects we cache are serializable as data storages are out-of-process systems. Both these options have impact on the application performance as data retrieval and saving operations take more time when compared to the InProc option. So based on our application requirement we should choose the option that best suits our requirement.


Note:
By default, ASP.NET session state is enabled for all ASP.NET applications.

ASP.NET application object

ASP.NET provides an object called Application object to store data that is accessible to all user requests. The life span of this object is tied to the application and it is re-created every time the application starts. Unlike ASP.NETSession object this object is accessible to all user requests. Since this storage is created and maintained in an application domain space, this should not be used for data storage in a web farm scenario. This option is very useful to store data like the application metadata (CONFIG files data) that can be loaded to the Application object during application start up and can be used during the life of the application without reloading it every time for each user request. But if there is a requirement to invalidate the cached data whenever there is any change to the CONFIG files while the application is running, this option should not be used as it doesn't provide any feature to expire the cached data. So in this case other options like the ASP.NET Cache object should be used, which is explained below.

Types of Cache –Dependencies

When anyone add an item to cache, he/she can define the dependency relationships that can force that item to be removed from the cache under specific activities of dependencies.

For example: If the cache is dependent on file and when the file data changes you want the cache object to be updated.

Following are the difference dependencies:

(a) File Dependency :Allows invalidating a specific cache item when a disk based file or files change.

object errorData;
 //Load errorData from errors.xml 

 CacheDependency fileDependency = 
     new CacheDependency(Server.MapPath("errors.xml")); 
 Cache.Insert("ERROR_INFO", errorData, fileDependency);


(b) Time based expiration :Allows to invalidate a specific cache item depending on predefined time.


//Absolute Expiration

Cache.Insert("EMP_NAME", "Shubhabrata", null, 
             DateTime.Now.AddDays(1), Cache.NoSlidingExpiration);

//Sliding Expiration

Cache.Insert("EMP_NAME", "Shubhabrata", null, 
             Cache.NoAbsoluteExpiration, TimeSpan.FromSeconds(60));


(c) Key dependency :Allows to invalidate a specific cache item depending when another cache item changes.

string[] relatedKeys = new string[1]; 
relatedKeys[0] = "EMP_NUM";
CacheDependency keyDependency = new CacheDependency(null, relatedKeys); 
Cache["EMP_NUM"] = 5435;
Cache.Insert("EMP_NAME", "Shubhabrata", keyDependency);
Cache.Insert("EMP_ADDR", "Bhubaneswar", keyDependency);
Cache.Insert("EMP_SAL", "5555USD", keyDependency);


.NET remoting
You might be thinking how .NET remoting can be used for data caching? The same question came to my mind when I heard about it for the first time. As you know the .NET remoting singleton object shares the same instance with multiple clients so singleton objects can be used to store and share data between different client invocations. Since .NET remoting can be used outside the process and machine, this option is very useful when we want to cache data and share it across servers and users particularly in a web farm scenario. In this approach we can store the data as member variables of singleton remoting object and provide methods to read and save data. But while implementing this we need to ensure that the remoting object used as cache is not destroyed by the garbage collector. For that we will have to set the remoting cache object's lease period to infinite so that the lease period never times out. We can do that by overriding the InitializeLifetimeService method of MarshalByRefObject and return null from this method. But the only issue with this approach is performance. As the analysis says the performance is very poor in this approach when compared to other approaches. Anyway it is up to the application designers/developers to analyze different options and use the best one that suits the requirement.

Memory-mapped files
You all know what a memory-mapped file is. It is basically about mapping a file on disk to a specific range of addresses in the application's process address space. This option allows different processes to use the same data by increasing the application performance. As using memory-mapped file is not very popular among .NET developers, I would personally not suggest this approach as implementing this involves a lot of complexities and also .NET Framework doesn't support this. But if anyone is very much interested in using this approach then they will have to develop their own custom solution as per their own requirement.

Static variables
We use static variables for storing data or objects globally so that it can be accessed during the life of the application. Similarly, in ASP.NET we can use static objects for caching data and we can also provide methods to retrieve and save data to the cache. As static variables are stored in the process area, performance wise it is faster. But since it is very difficult to implement expiration policies and dependencies incase of static variables, I generally prefer ASP.NET cache object over this option. Another problem is that the custom static cache object has to be thread-safe which has to be implemented carefully.

Example:
public class CustomCache
{
    //Synchronized to implement thread-safe

    static Hashtable _myCache = 
             Hashtable.Synchronized(new Hashtable());
    
    public static object GetData(object key)
    {
        return _myCache[key];
    }
    
    public static void SetData(object key, object val)
    {
        _myCache[key] = val;
    }
}



II. Client-Side State Management

Cookies
Cookie is a very familiar term in web development environment. Cookie is a client-side storage that is sent to the server for each request and also received as response back from the server. Because of its size limitation (4096 bytes) it should be used for storing small amount of data. Expiration policies can be set for cookies to invalidate the items after a certain period of time. 

The following example shows how Cookie can be used in an ASP.NET application:

if (this.Request.Cookies["MY_NAME"] == null) 
    this.Response.Cookies.Add(new HttpCookie("MY_NAME", 
                                       "Shubhabrata Mohanty")); 
else 
    this.Response.Write(this.Request.Cookies["MY_NAME"].Value); 
}


ViewState

ASP.NET ViewState is a new concept. Here the data related to the pages and controls are stored in ViewState which retains the values across multiple requests to the server. If you remember correctly, in VB-ASP applications we used to store data across multiple requests using hidden fields. ViewState is actually implemented internally as hidden fields in ASP.NET but here the data is hashed to improve security as against hidden fields. To see how ViewState is implemented, you can view the source of the page in which ViewState is used in the Internet browser. ViewState should not be used to store large amounts of data as it is passed to the server for each request

protected void Page_Load(object sender, EventArgs e) 

{
    if (this.ViewState["MY_NAME"] == null) 
    { 
        this.ViewState["MY_NAME"] = "Shuby";
    } 
    
    //txtName is a TextBox control 

    this.txtName.Text = this.ViewState["MY_NAME"].ToString(); 
}

Hidden fields

Hidden fields are very popular among VB-ASP web developers. Hidden field is similar to any other control in a page but the visible state of this control is always false. Like ViewState we should not use it for storing large amounts of data. 
Note:Similarly hidden frames can be used to cache data in the client side. But please note that hidden frames are not supported by all Internet browsers.

<!--In ASP.NET-->
<asp:hiddenfield id="myHiddenField" value="Shuby" runat="server" />
<!--In HTML-->
<input id="myHiddenField" type="hidden" value="Shuby">
</asp:hiddenfield>

Query Strings

Query strings provide a simple but limited way of maintaining some state information.You can easily pass information from one page to another, But most browsers and client devices impose a 255-character limit on the length of the URL. In addition, the query values are exposed to the Internet via the URL so in some cases security may be an issue. 

http://www.msdotnetheaven.com/?authorid=4

Example:
string authorid;
authorid=Request.Params[“authorid”];

Note: You can only use HTTP-Get method to post the web page, or you will never get the value from query strings.

Difference between cache, session and viewstate

Cache: Its nothing but a thought kind of memory. In respect to asp.net it’s the memory of the machine/server from where the source-code is running. It is the one way which allow to store complex data for reusability.
Now think a criteria where clients access an ASP.NET page, there are basically two ways to provide them with the information they need:
  • The ASP.NET page can either obtain information from server resources, such as  from data that has been persisted to a database, or
  • The ASP.NET page can obtain information from within the application.
Retrieving information from a resource outside the application will require more processing steps, and will therefore require more time and resources on the server than if the information can be obtained from within the application space.

Now, suppose the information’s which sent to browser’s have already been prepared then how faster the process of web-page.

The ASP.NET 3.5 Framework supports the following types of caching:
Page Output Caching :Page Output Caching caches an entire page.          

Partial Page Caching :Partial Page Caching enables you to get around this problem by enabling you to cache only particular regions of a page.

DataSource Caching:You use DataSource Caching with the different ASP.NET DataSource controls such as the SqlDataSource and ObjectDataSource controls. When you enable caching with a DataSource control, the DataSource control caches the data that it represents.
 
Data Caching :Finally, Data Caching is the fundamental caching mechanism. Behind the scenes, all the other types of caching use Data Caching. You can use Data Caching to cache arbitrary objects in memory. For example, you can use Data Caching to cache a DataSet across multiple pages in a web application.
 
Note: 
The Cache object can also have an expiration which would allow us to reinstitute data into the memory in intervals. Using the same example as above, we can make the cache expire every two hours, and repopulate the data. It would do this every 2 hours throughout the day, allowing the most up to date data to be fetched. Below is an example of how something can be put into the cache: 

Referenced from msdn 
 
public void AddItemToCache(Object sender, EventArgs e) 
    itemRemoved = false; 
    onRemove = new CacheItemRemovedCallback(this.RemovedCallback); 
    if (Cache["Key1"] == null) 
        Cache.Add("Key1", "Value 1", null, DateTime.Now.AddSeconds(60),TimeSpan.Zero, CacheItemPriority.High, onRemove); 
 
 
public void RemoveItemFromCache(Object sender, EventArgs e) 
    if(Cache["Key1"] != null) 
        Cache.Remove("Key1"); 
}
 
 
Session: Its nothing but defined as a period of time shared between the web application and user. Every user has individual session. Items/Objects can be placed into the Session which would only define these object for that user. Session contains key variables which help to identify the related values. This can be thought of as a hash table. Each user would represent a different key node in the hash identifying unique values. The Session variables will be clear by the application which can clear it, as well as through the timeout property in the web config file. Usually the timeout is 20 minutes by default.
 
Session Variables are stored on the server, can hold any type of data including references, they are similar to global variables in a windows application and use HTTP cookies to store a key with which to locate user's session variables.
 
The collection of session variables is indexed by the name of the variable or by an integer index. Session variables are created by referring to the session variable by name. You do not have to declare a session variable or explicitly add it to the collection.
 
Lets get it cleared from following example:
 
Session[“firstName”] = “Gaurav”    //User’s first name
Session[“lastName”] = “Arora”        //User’s last name
 
// Clear the session variable 
Session[“FirstName”] = null; 
 
//Clear all Session variables 
Session.Abandon();  
 
 
Note:By default, ASP.NET session state is enabled for all ASP.NET applications.
 
 
ViewState: Its nothing but it’s a hidden data which is kept by asp.net pages in “_VIEWSTATE” as hidden form field. They track the changes to a web site during post backs.
 
The ViewState of a page can be seen if you view the source code of the running page(Right Click --> View Source). It will be listed under the following tags:
Having a large ViewState will cause a page to download slowly from the users side. When a user clicks on a button and a post back occurs, all the view state information has to be posted back to the server which causes a slower request. Most times this is insignificant, but imagine a person using a dial up connection. If requests, and page loading is taking a couple of minutes, most likely the user will get frustrated, and leave.

Note:
  1. By default, View State is enabled for every control in the ASP.NET Framework.
  2. ViewState does not hold the controls, rather it holds the values of the form controls and their corresponding ID's that would otherwise be lost due to a post back because they do not post with the form.
  3. ViewState is not used to hold session data or to transmit data between pages.
  4. ViewState does not recreate the dynamically created controls of a page.
  5. It does not restore the values to the controls after a post back operation.

Friday, January 23, 2009

Capturing CTRL+Keys using JavaScript

This is the practical scenario where sometime one wants to disallow Ctl+keys combinitions on web-pages.

Following Code-snippet tells the whole story:


<html>
<head>
<script language="JavaScript">
function testCtrlKeys(e)
{
//Create an array for all possible keys
var arrCtrlKeys = new Array('a', 'n', 'c', 'x', 'v', 'j');
var key;
var isCtrl;

if(window.event)
{
key = window.event.keyCode; //Valid only for Internet Explorer
if(window.event.ctrlKey)
isCtrl = true;
else
isCtrl = false;
}

else
{
key = e.which; //this is other than IE
if(e.ctrlKey)
isCtrl = true;
else
isCtrl = false;
}


//if ctrl is pressed check if other key is in forbidenKeys array
if(isCtrl)
{
for(i=0; i<arrCtrlKeys .length; i++)
{
//case-insensitive comparation
if(arrCtrlKeys[i].toLowerCase() == String.fromCharCode(key).toLowerCase())
{
alert('You have pressed CTRL + '
+String.fromCharCode(key)
+'.');

return false;
}
}
}
return true;
}
</script>

</head>
<body>
<form method="">
<div>
<h3>Test Key Combinition [Ctrl+A, Ctrl+N, Ctrl+C, Ctrl+X, Ctrl+V,Ctrl+J]</h3>
<input type="text" name="mytext"
onKeyPress="return testCtrlKeys(event);"
onKeyDown="return testCtrlKeys(event);" />
</div>
</body>
</html>


Note:
1. Copy/paste above code in text file and save it as "nameddoc.html" and run it into Explorer
2. Check the magic of capturing javascript keys.

Capturing MouseEvents Using JavaScript

Capturing Mouse Events Using JavaScript :


Sometime there is a need to disable MouseEvents for specific task(s) in Web-Pages.

The following code-snippet shows how to achieve the same :


<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Capturing Mouse Events Using JavaScript</title>
</head>
<body>
<div>
<b> Testing with Link Button : </b>
<a href="javascript:void(null)"
onmousedown="return captureButton(event)" onmouseup="return preventOperation(event)"
onclick="return preventOperation(event)" ondblclick="return preventOperation(event)"
oncontextmenu="return preventOperation(event)"
>Click here with various mouse buttons to test</a>
</div>
<br/>
<div>
<b> Testing wuth Submit Button : </b>
<input name=btnG type=submit onmousedown="return captureButton(event)" onmouseup="return preventOperation(event)"
onclick="return preventOperation(event)" ondblclick="return preventOperation(event)"
oncontextmenu="return preventOperation(event)">
</div>
<br/>
<div>
<b> Testing with Input Text : </b>
<input name=btnG type=text onmousedown="return captureButton(event)" onmouseup="return preventOperation(event)"
onclick="return preventOperation(event)" ondblclick="return preventOperation(event)"
oncontextmenu="return preventOperation(event)">
</div>

<script language="Javascript">
function captureButton(event)
{
var button;
if (event.which == null)
button= (event.button < 2) ? "MOUSE BUTTON : LEFT" :
((event.button == 4) ? "MOUSE BUTTON : MIDDLE" : "MOUSE BUTTON : RIGHT");
else
button= (event.which < 2) ? "MOUSE BUTTON : LEFT" :
((event.which == 2) ? "MOUSE BUTTON : MIDDLE" : "MOUSE BUTTON : RIGHT");
alert(button);
preventOperation(event);
}
function preventOperation(event)
{
if (event.preventDefault)
event.preventDefault();
else
event.returnValue= false;
return false;
}
</script>

</body>
</html>



Copy paste above code in a text document and named it as MouseEvents.html
Now test the same.

Get MicroSoft SDK's under single roof

Now MicroSoft SDK's are available in a single page.

One can get download required SDK's from the page MicroSOft SDK's.

The are under heads :

1. Azure Services Platrform
2. Office
3. Windows Desktop
4. Devices
5. Games
6. Server Technologies
7. Others

If need any kind of assistant, please fell free to contact me.

Thursday, January 15, 2009

MCP/MCTS : Welcome Kit

Today I have got my Welcome kit for MCTS. I have successfully achieved the same with 96.4% marks.

I got this news from my wife Shuby Arora.

Want to share my joy with all of you.

Thursday, January 1, 2009

Writing CLR Stored Proc : Using Visual Studio

Overview & History


First of all let me say my thanks to
Mr. Joymon whose question inspired me to write this resource.

The present post is showing the another method to Write a CLR Proc apart from the method in my earlier post
Writting a CLR Stored Proc.

Step:Followings are the steps to start the above in Visual Studion



1. Start Visual Studio2005 or higher
2. Add new file from File -> New -> Project
3. Select Database Project [provide the name]
4. Create the project, it requires Database Reference [I used EmployeeDB here]
5. In Solution Explorer Right Click on the project name and Click Add
6. Select Stored Procedure
7. Add new File with name 'myTestStoredProcedure.cs'
8. The added file will look like :


using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;

public partial class StoredProcedures
{

[Microsoft.SqlServer.Server.SqlProcedure]
public static void myTestStoredProcedure()
{
//Right some code here

}
};



I am writing a code for following three Stored Proc:

1. myTestStoredProcedure - Simply prints a message
2. spGetRolesList - Display the rows from table
3. spGetEmployeeList - Display the rows from table for specific Age group.

The following code tells how to create a CLR stored proc with the use of Visual Studio:


/************************************************
* Topic : How to Create CLR Proc using VS
* Author : Gaurav Arora
* Reference : A Step Ahead Series - SQL2005
* Visit : http://msdotnetheaven.com
* **********************************************/

using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;


public partial class StoredProcedures
{
///
/// Prints a Message
///

[Microsoft.SqlServer.Server.SqlProcedure]
public static void myTestStoredProcedure()
{
//Simple proc
SqlPipe objSqlPipe = SqlContext.Pipe;
objSqlPipe.Send("Hi! I am simple CLR PROC");

}
///
/// Proc to Show Rows of [EmployeeDB]..[Roles] table
///

[Microsoft.SqlServer.Server.SqlProcedure]
public static void spGetRolesList()
{
//It returns rows from Roles table
SqlConnection conn = new SqlConnection();
conn.ConnectionString = "Context Connection=true";

SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = @"Select * from [dbo].[Roles] Order By HireDate";
conn.Open();

SqlDataReader sqldr = cmd.ExecuteReader();
SqlContext.Pipe.Send(sqldr);

sqldr.Close();
conn.Close();


}
///
/// It shows rows from Employee table on basis of supplied age
///
/// a specified age
[Microsoft.SqlServer.Server.SqlProcedure]
public static void spGetEmployeeList(Int32 intAge)
{

//It returns rows from Employee table on basis of supplied age
SqlConnection conn = new SqlConnection();
conn.ConnectionString = "Context Connection=true";


SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
conn.Open();
cmd.CommandText = "Select * from [dbo].[Employees] Where Age >=@intAge Order By Age";

SqlParameter paramAge = new SqlParameter();
paramAge.Value = intAge;
paramAge.Direction = ParameterDirection.Input;
paramAge.DbType = DbType.Int32;
paramAge.ParameterName = "@intAge";

cmd.Parameters.Add(paramAge);

SqlDataReader sqldr = cmd.ExecuteReader();
SqlContext.Pipe.Send(sqldr);

sqldr.Close();
conn.Close();

}
};


Build and Deploy the assembly :



1. Press ctrl+shift+B or Select Build option Under Build
2. If project successfully Build, now its time to deploy the assembly in SQLServer Directory.
3. Right click on Project name in SOlution Explorer
4. Click on Deploy.
5. Check the Status Bar for further.
6. If It deployed successfully, you can check the CLR proc from Server Explorer
7. Expand EmployeeDB node.
8. Expand Assemblynode [ you can find 'AStepAheadProcVisual' CLR Assembly]

Executing CLR Stored Proc :



Using Server Explorer of VS

1. Expand the AStepAheadProcVisual node
2. Here you can see a class file and Assembly.info file including three procs.
3. Right click on anyone Stored Proc [option availale :Open, Execute, Step Into Stored Procedure ].
(a) Open : Directs to a specific proc.
(b) Execute : Executes the selected proc and result is available in OutPut window.
(c) Step Into Stored Procedure : It debugs the application following selected proc.


Using SQLServer Management Studio

1. Open your SQLServer Management Studio[if not opened earlier]
2. Type following code in Query Window



Use [EmployeeDB]
Go

DECLARE @Role int
SET @Role = 28
Exec [dbo].[spGetEmployeeList] @Role
Go



3. The above code will display the EmployeeList with Employees having age 28Yrs or more.
4. In same manner execute other procs



Use [EmployeeDB]
Go

Exec [dbo].[myTestStoredProcedure]
Go

Exec [dbo].[spGetRolesList]
Go

DECLARE @Role int
SET @Role = 28
Exec [dbo].[spGetEmployeeList] @Role
Go



Scripts of Databases:



Followings are the scripts of Table(s) used in given example:



USE [master]
GO
/****** Object: Database [EmployeeDB] Script Date: 01/01/2009 23:04:12 ******/
IF NOT EXISTS (SELECT name FROM sys.databases WHERE name = N'EmployeeDB')
BEGIN
DROP DATABASE [EmployeeDB]
CREATE DATABASE [EmployeeDB]
END

USE [EmployeeDB]
GO
/****** Object: Table [dbo].[employees] Script Date: 01/01/2009 23:05:24 ******/
IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[employees]') AND type in (N'U'))
BEGIN
DROP TABLE [dbo].[employees]

CREATE TABLE [dbo].[employees](
[id] [nvarchar](4) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,
[firstname] [nvarchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL DEFAULT ('First Name'),
[lastname] [nvarchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL DEFAULT ('Last Name'),
[age] [nvarchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL DEFAULT ('19'),
PRIMARY KEY CLUSTERED
(
[id] ASC
)WITH (IGNORE_DUP_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
END

GO

IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[Roles]') AND type in (N'U'))
BEGIN
DROP TABLE [dbo].[Roles]
CREATE TABLE [dbo].[Roles](
[Id] [int] IDENTITY(1,1) NOT NULL,
[Role] [nvarchar](300) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,
[IsRetiree] [bit] NOT NULL,
[HireDate] [datetime] NOT NULL,
CONSTRAINT [PK_Roles] PRIMARY KEY CLUSTERED
(
[Id] ASC
)WITH (IGNORE_DUP_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
END

GO



IMPORTANT NOTE:


1. If get error : Execution of user code in the .NET Framework is disabled. Enable "clr enabled" configuration option.
, While executing the above using SQLSERVER2005/2008, run following code in Query analyzer:



sp_configure 'clr enabled', 1
go
reconfigure
go



2. You can also Debug the Produced code within VS: by starting Debugging from DEBUG MENU


Hope the represented article is worthful for you.