Tech Geek- Amit Kumar Shinde

Folder structure for a .NET application

noreply@blogger.com (Amit Kumar Shinde) — Fri, 30 Mar 2012 04:52:00 +0000

I usually stick to the same base folder structure for my .NET applications. This one works well for both my open source projects and enterprise projects at work:

Branch name (usually ‘trunk’)	This root folder contains the solution file.
Application	All the projects of the application goes here. Each project in it’s own subfolder.
Build	I keep all build related stuff here, like: The signing key for the application A C# project holding the main MSBuild script file and any custom MSBuild tasks
Common	Usually not much here, except always a SolutionInfo.cs file.
Documentation	All developer-related documents of the project are kept here. This way a developer can easily get the latest version of a document without leaving Visual Studio. If the project contains auto-generated documentation (for instance using Sandcastle), these generator-projects are kept here as well.
Installers	All installer projects are kept here (Setup projects, WIX projects). Each project in it’s own subfolder.
Lib	This folder contains all the external assemblies used by the project. All Visual Studio projects reference the needed dll’s directly from this folder.
Tests	Contains all test projects, usually divided in unit tests, integration tests and test helpers. Each project in it’s own subfolder.

Note that the above is the physical folder structure. I always make sure that the version control has the excact same folder structure. Never try to build this folder structure from within Visual Studio. Instead build it by hand and add it to source control by hand.

In the main Visual Studio solution file however, I alter the structure slightly by putting the contents of the Application folder directly in the solution root, and mimic the rest of the folders using solution folders:

Solution root
- All projects of the Application folder
- Build
- Common
- Documentation
- Installers
- Lib
- Tests

Now, with everything being nicely structured, it’s time to do some coding.

What is volatile keyword in C#

noreply@blogger.com (Amit Kumar Shinde) — Fri, 30 Mar 2012 03:28:00 +0000

volatile

The keyword volatile means that a field can be modified in the program by thinks along the lines of say the operating system, hardware or even a thread executing concurrently. General syntax of volatile is:


volatile declaration

where:

declaration is of a field.

Key Points:

Whenever a volatile is requested, the system returns the current value at the time of the request. All assignments are written to the object immediately.

Common usage of the volatile modifier is when a particular field is accessed by many threads without using the lock statement to serialize access. So in essence the volatile modifier guarantees that a thread will retrieve the most recent value written by another thread (even if it was modified by the previous instruction from you call).

You are not allowed to use volatile on just any time. The following is a list of types you can implement this modifier on:

Any reference type.
Any pointer type in a unsafe context
sbyte, byte, short, ushort, int, uint, char, float, bool.
An enum type with an enum base type of the following: byte, sbyte, short, ushort, int, uint.

Example:


public volatile int iAge;

C# How To Encode or Decode a String to Base64 UTF-8

noreply@blogger.com (Amit Kumar Shinde) — Thu, 29 Mar 2012 07:32:00 +0000

This example uses the .NET Framework 4 Encoding Class to Base64 Encode and Decode a supplied sting in your C# Application. The example syntax can be used in any ASP.Net or Win32 program.In addition to the UTF-8 example I've supplied below, the framework also supports methods for encoding/decoding ASCIIEncoding, UnicodeEncoding, UTF32Encoding, UTF7Encoding and UTF8Encoding.

Assumptions: Your project contains these 3 controls (Label1, TextBox1, Button1)

protected void Button1_Click(object sender, EventArgs e)
{
Label1.Text = EncodeTo64UTF8(TextBox1.Text.ToString());
}

C# Base64 Encoding Method:

///

/// This method creates a Base64 encoded string from an input
/// parameter string.
///

/// The String containing the characters
/// to be encoded.
/// The Base64 encoded string.
public static string EncodeTo64UTF8(string m_enc)
{
    byte[] toEncodeAsBytes =
    System.Text.Encoding.UTF8.GetBytes(m_enc);
    string returnValue =
    System.Convert.ToBase64String(toEncodeAsBytes);
    return returnValue;
}

C# Base64 Decoding Method:

///

/// This method will Decode a Base64 string.
///

/// The String containing the characters
/// to be decoded.
/// A String containing the results of decoding the
/// specified sequence of bytes.
public static string DecodeFrom64(string m_enc)
{
    byte[] encodedDataAsBytes =
    System.Convert.FromBase64String(m_enc);
    string returnValue =
    System.Text.Encoding.UTF8.GetString(encodedDataAsBytes);
    return returnValue;
}

Reference: http://msdn.microsoft.com/en-us/library/system.text.encoding.aspx

What is New in ASP.NET 4.0, Visual Studio 2010 IDE

noreply@blogger.com (Amit Kumar Shinde) — Fri, 23 Mar 2012 15:30:00 +0000

Introduction

This article is an introduction to some of the new features in ASP.NET 4.0 and Visual Studio 2010 IDE.

Code Snippets

Code snippets are pre-developed code templates which can save time spent on thinking about the syntax. There are already a lot of built-in code snippets in VS2005 and VS2008. However, those are only available for the code-behind. Code snippets in VS2010 are introduced for JScript, HTML, and ASP.NET markup as well. In the screenshots below, we can see different snippet context menus for JScript and HTML.
Inside the script tag, it would be

And inside the HTML:

New Profiles

We have seen different development profiles in previous versions of .NET. Like VB, C#, Web Development, and General Development. We select a profile based on our priorities. These are selected after the first installation of Visual Studio or from the Import Export option.

In VS2010, two more profiles are introduced and both support HTML developers. Those are:

Web Development
Web Development (Code Optimized)

The Web Development profile hides the client objects and events bar on top in HTML mode.

In Code Optimized, you will find the HTML editor without code, and the designer tabs. So, it provides a more bigger area on the screen to play with HTML.

You can choose a profile after installation of Visual Studio on first use. You can also change the existing working profile from the Tools > Import & Export Settings > Reset all settings option. You will have to open and close Visual Studio if it does not show the changes in the IDE.

Generate From Usage

In previous versions of ASP.NET, Microsoft introduced code refactoring to generate methods and identifiers from existing code. In ASP.NET 4.0, there is a new concept of Generate From Usage - generates properties, methods, classes, and other types based on existing code.
Write some code, select it and right click on the left most character, and you will get options to change it to a property or method etc. This option is shown only if you do not define an identifier. For example, in the following example intellisense, it will not show the options to extract a property if you right click on the variable i.

Multi-Targeting

In VS2008, it is possible to create a project in version 2.0 or 3.0, rather than developing in default 3.5. Also, there is an option to change a developed project's target framework version.
The same option is available in VS2010, but with one improvement. In the previous versions, if you create a project in framework 2.0, intellisense will still show you the types and members of 3.5 version as well, so there are more chances of error if you cannot identify the member of the chosen framework. But in VS2010, the intellisense will show you options for the appropriate framework only.

Multi-Monitor

Visual Studio 2010 provides us facility to move windows of the IDE outside of the Visual Studio IDE and place them on the desktop area. It also supports having different IDE windows on multiple monitors. If we close Visual Studio and open it again, we will find all the windows on the same places where we finished them last time.

Code Navigation in Class Files

Code Navigation

A new Navigate To option gives us facility to search a term in a file more quickly. It searches the text as you type, but it works for class files only, i.e., it doesn't work for HTML or code-behind files. In the following example, it shows the function name as I type it in the Navigate To window; on selection of any, it will navigate to the function definition.

View Call Hierarchy

This featrure helps to see the use of a function and its properties. For example, if you right click on a function name, it will show you the hierarchical list of function usage.

If you click View Call Hierarchy, it will show you a window with the details of the function calls:

On selection of the function call in the hierarchy window, it will show the details of the parameters and the location of the function call.

Code Identifier Highlighting

On selection of an identifier, the IDE will highlight the places for you where it is utilized. For example, I selected variable i and it highlights the different places it is used.

Intellisense Improvements

In VS2008, on selecting properties for an object, intellisense will show you the properties based on the alphabetical order as you type.
In VS2010, it shows you the properties based on groups. For example, if you type text for a text box, it will show you the members based on the word text, like Text, TextChanged, TextMode. It also supports Pascal case intellisense. For example, if you type TC, it will navigate to the TextChanged member.

In the picture below, you can see the ClientIDMode property in version 4, and if we change its target version from project properties, it will not show this attribute for the textbox.

EnablePersistedSelection

On selecting a row in controls like DataList or GridView, if we move to another page index, it selects the same numbered row on the newly selected page, although we selected it only on the first page.
To avoid this, ASP.NET 4.0 has introduced a new property for these controls, called EnablePersistedSelection. If you set it to true, it will not select the same numbered row on other pages, and on navigation to the original page, for example, the first page, it will show the initially selected row as selected.

Web.Config Transformation

Normally, we set some values in web.config for the development environment, and then we change those values manually at the time of deployment or testing.
For example, if we have a connection string or any key value combination in the web.config file, and we want to replace those at the time of project publishing or deployment, then we can use the new web.config transformation. It is an automatic way to perform this operation.
Web.config settings can be overridden by other config files like web.release.config, web.debug.config etc., at the time of debug, release. These values are not overridden in the original web.config but in the published web.config.
With the help of transformation, we can replace, remove, or delete a node, and for a node itself, we can remove or set attributes. For example:

Create a config file from Configuration Manager > New:
Name it TransformWebConfig. Select Release from the Copy settings from option:
This will create TransformWebConfig.config.
Right click on web.config and select the Add config transfroms option. Open the web.config and add a test key and the value to be changed.
Collapse | Copy Code
```
<appSettings> 
  <add key="KeyOne" value="A value"/> 
</appSettings>
```

Open TransformWebConfig.config and add the following line to it:

Collapse | Copy Code

<appSettings> 
  <add key="KeyOne" 
    value="TestOnConfigurationConfig" 
    xdt:Transform="Replace"
    xdt:Locator="Match(key)" /> 
</appSettings>

Set the xdt:Transform attribute to Replace.

Right click on the project and select Create Package. VS will get the values from the TransformWebConfig.config file, and it will change the value in the published web.config file for us.

On successful build, go to the obj folder and check the web.config file under the TransformWebConfig folder; you will see the value TestOnConfigurationConfig for the key KeyOne.

URL Routing

Nowadays, we see that website URLs are more SEO specific and do not show any descriptive information. For example, rather than showing a URL like: http://mywebsite.com/userprofiles.aspx?userid=1, developers would prefer to show the URL as: http://mywebsite.com/mydetails.
URL mapping in ASP.NET 2.0 provides us an option to achieve this functionality up to some extent. We can mention exact URLs to navigate and URLs to show to the user. But in the case of postback, this option starts showing the actual URL in the browser.
URL routing was introduced in ASP.NET 3.5. Developers had to create different route handler classes depending on the number of URL routings for a website. The postback issue was solved with this URL routing option.
In ASP.NET 4.0, you do not need to define separate handler classes for each routing. There is a built-in helper function MapPageRoute which helps you to implement routing more quickly. These routes are registered on Application_Start. For example, in this example, in global.asax, the SetRouting method sets routing, the first parameter is the router's friendly name, the second parameter is to check for the URL pattern to match, and the third is the ASPX page where this functionality would be implemented for the users.
Global.asax would be:

Collapse | Copy Code

protected void Application_Start(object sender, EventArgs e) 
{ 
    SetRouting(System.Web.Routing.RouteTable.Routes); 
} 
private void SetRouting(System.Web.Routing.RouteCollection routeCollection) 
{ 
    routeCollection.MapPageRoute("RouteFriendlyName", 
        "MyWebsite/RequestParameterName",
        "~/Book.aspx"); 
    // you can add other page routes with different names and combinations here }

Now, Book.aspx would use the following code to proceed further:

Collapse | Copy Code

string Parameter = Page.RouteData.Values["RequestParameterName"].ToString(); 

if (Parameter=="Chemistry"){....} 
else if (Parameter=="Physics"){....}

Now, if we navigate to localhost/MyWebsite/Chemistry, it will go to the first if condition.

Add Reference Dialog

In previous versions of Visual Studio, on opening the Add Reference dialog box, it will take some time to load .NET assembly files initially till the time it loads all the references from the GAC. In VS2010, on opening Add Reference, it opens the Projects tab by default.

If you click on the .NET or COM tab by mistake, you still have an option of canceling it before it loads all the assemblies. So, the VS IDE does not freeze like before.

Compressing Session Values

ASP.NET session out-of-process state values are saved in a database or on the server. These are saved in a serialized format. Bigger session values consume more resources to be sent to the server. Now, those can be compressed with a new built-in property compressionEnabled. This attribute for the sessionState element can be mentioned in the web.config, like this:

Collapse | Copy Code

<sessionState
  mode="SQLServer" 
  stateConnectionString="connectionstring goes here" 
  compressionEnabled="true"/>

This option would be available for out-of-process sessions.

Improvements in C# 4.0

C# in .NET Framework 4.0 has some more things to offer. These are:

Dynamic lookup
Named
Optional parameters

Dynamic Lookup

There is a new static type named dynamic. We can use it as object of any type. If there is any error on its usage, we would get it on runtime only. For example:

dynamic integerValue = 1; 
dynamic stringValue = " a string"; 
dynamic Result = integerValue + stringValue;

Output of this would be: 1 a string.
But, if you change the last line to:

dynamic Result = integerValue & stringValue;

You will not get any compilation error, but the following error on runtime:

Operator '&' cannot be applied to operands of type 'int' and 'string'

Optional Parameters

To implement optional parameters, we used to create overloaded functions before ASP.NET 4, but now, optional parameters are no more a restriction in C#. Like VB, optional parameters must be mentioned last. For example:

public void FunctionOptionalParam(string Name, int Age, string Country = "")

and we can call them without mentioning the value for the optional parameter.

FunctionOptionalParam("My Full Name",20);

Named Parameters

Named parameters allow you to ignore the parameter order and mention parameters with names in a different order. For example:

public void FunctionNamedParam(int x, int y , int z)

On function call, it would be:

FunctionNamedParam(x:1, z:3, y:2);

Although we are sending a value for the parameter z before its order in the function declaration, but these would be equal to x=1, y=2, z=3.

Meta Tags

The HtmlMeta class can be used to add HTML meta tags dynamically. HTMLMeta's Name, Content properties can be used to add any meta tag name and its values dynamically on runtime.
In ASP.NET 4.0, the Page class has two more properties: MetaDescription and MetaKeywords. These can be used to add meta values in HTML on runtime for the description and keyword elements. These can be mentioned as page attributes in HTML, or in this way:

Page.MetaDescription = "this is meta description";
Page.MetaKeywords = "this is a meta keyword";

If we see the HTML generated for this, it would be:

<head>
<meta name="description" content="this is meta description " />
<meta name="keywords" content="this is a meta keyword" />
</head>

Generating Client IDs

Client IDs for web controls are generated dynamically based on their parent controls. So if we use a textbox inside a web user control in a WebForm, we have to see what ID is generated for it and use it in the client script accordingly.
Sometimes, these are dynamic, or in the case of changing the user control name, it changes the ID for the child control as well. In ASP.NET 4.0, this problem is solved by the ClientIDMode attribute for the page. It has the following possible values: AutoID, Static, Predictable, and Inherit.

AutoID: It is the default setting for a webpage, and works like in the previous versions of ASP.NET.
Static: It sets the static IDs for the web control, so we do not have to worry about the parent control ID and so on if we are referencing it in JavaScript. For example, a TextBox inside a user control and one outside it with ClientIDMode set to Static:
Collapse | Copy Code
```
<asp:TextBox ID="textbox1" 
     runat="server" clientIDMode="Static"></asp:TextBox> 

<uc1:WebUserControl ID="WebUserControl1" runat="server" />
```
And this user control is the container for TextBox2:
Collapse | Copy Code
```
<asp:TextBox ID="TextBox2" 
   ClientIDMode="Static" runat="server"></asp:TextBox>
```
This code will generate the following HTML:
Collapse | Copy Code
```
<input name="ctl00$MainContent$textbox1" 
  type="text" id="textbox1" /> 
<input name="ctl00$MainContent$WebUserControl1$TextBox2" 
  type="text" id="TextBox2" />
```
If we remove the ClientIDMode set to static, the output would be like this:
Collapse | Copy Code
```
<input name="ctl00$MainContent$textbox1" 
  type="text" id="MainContent_textbox1" />
```
It will generate the ID for TextBox as it does in previous versions of ASP.NET.
Predictable: If we use Predictable as ClientIDMode for web controls inside a GridView or ListView, then it will concatenate the GridView ID with the control ID and the value of the column mentioned in the ClientIDRowSuffiex attribute:
Collapse | Copy Code
```
Gridview ID ="GridView1"
ClientIDMode="Predictable"
ClientIDRowSuffix="ItemID"
```
If there is a Label in the GridView template column having the ID Label1 and it is bound with the ItemID column, it will generate an ID, GridView1_Label1_200.
If we use the ClientIDMode value of Predictable for web controls outside databound controls:
```
<asp:TextBox ID="TextBox1" runat="server" 
  ClientIDMode="Predictable"></asp:TextBox>

<asp:Panel ID="panel1" runat="server">

<asp:TextBox ID="TextBox2" runat="server" 
  ClientIDMode="Predictable"></asp:TextBox> 

</asp:Panel>
```
You can see the output of the web controls in the panel and outside the panel.
```
<input name="ctl00$MainContent$TextBox1" 
  type="text" id="MainContent_TextBox1" />

<div id="MainContent_panel1">

<input name="ctl00$MainContent$TextBox1" 
  type="text" id="MainContent_TextBox1" />

</div>
```
It will generate the ID for all the web controls concatenated with the ID of the content panel of the child page.
Inherit: Web controls, by default, inherit from the parent container ID. Controls can override this attribute of the parent as well if we set a different value for ClientModeID.

Permanent Redirect

In a situation where we want to redirect users to a newly developed page if current page is obsolete, we can use Response.Redirect to shift the page to a new page. But in this case, search engines keep the old information of the page in their indexes for search. Also, if a user navigates to this page, he would be redirected to this page and then to a new page with the help of Response.Redriect.
But in ASP.NET 4.0, a new command Response.RedirectPermanent can be used to change the header information for the page on the server. So, if a user goes for a page, he is directly redirected to new page and it saves a double trip for him.
Similarly, search engines, on re-indexing of that website and page, finds the updated header and updates the information in their index and shows the updated information on search.

New Browser Definitions

During the last few years of ASP.NET 3.5, a few browsers have been introduced including Google Chrome and those which support Blackberry SmartPhones as well. ASP.NET 4.0's HTTPBrowserCapabilities class is updated with the support for new browsers.

Publishing a Project

In VS2010, if you click the Properties link in Solution Explorer, you will find three new tabs:

Package/Publish
Deploy SQL
Silverlight Applications

I will discuss about the first two options.

Package/Publish

Package, Publish options provide you settings for the publish and package commands. The configuration option for Debug, Release provides options to set these values on compilation and build like in previous versions.
If the hosting server does not have SQL Express, or if you do not want to include those in the published files, then select Exclude files from the App_Data folder. If you select the option Create a web package as a ZIP file, it will create a zip file to be deployed. Otherwise, it would be an unzipped folder by default.
The default package folder is created under the obj folder of the application. It is not be shown by default in the Solution Explorer until you select the Show all files option. We can also set the web application name on the server and the destination server physical path as well.

Deploy SQL

The Deploy SQL option allows you to set the connection string as part of the deployed package. You can add the connection strings manually with different names and values, or import from the web.config by clicking the Import button. You can choose the script for Schema Only or the database option as well. On selection of a connection string, it shows the source settings and we can set the values for the destination server.

You can also add database script files manually by clicking the Add button. You can also change the order of SQL files to run on server.

Inversion of Control : A beginner Guide

noreply@blogger.com (Amit Kumar Shinde) — Thu, 22 Mar 2012 03:31:00 +0000

What is Problem?
Let, there is a class called Kids.cs. Purpose of this class is to maintain name and age of kids of a particular person.

Kids.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IOC
{
class Kids
{
private int age;
private string name;
public Kids(int age, string name)
{
this.age = age;
this.name = name;
}

public override string ToString()
{
//return base.ToString();
string m = this.age.ToString();
return "KIDs Age " + m + " Kids Name " + name;
}

}
}
Now requirement is like each person has Kids. So at time of creation of a Person, associated Kids should also get created. So this may achieve by following code
Person.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IOC
{
class Person
{
private int age;
private string name;
private Kids obj;
public Person(int personAge,string personName, int kidsAge, string kidsName)
{
obj = new Kids(kidsAge, kidsName);
age = personAge;
name = personName;
}

public override string ToString()
{
//return base.ToString();
string s= age.ToString();
Console.Write(obj);
return "ParentAge" + s + " ParentName" + name;
}
}
}
Main.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IOC
{
class Program
{
static void Main(string[] args)
{
Person p = new Person(35, "Dev", 6, "Len");
Console.WriteLine(p);
Console.Read();
}
}
}
Output

The above code is a typical example of COMPOSITION design pattern or Object Dependency.
Note: What is Object Dependency?

When one objects needs other object for its working then it is called one object is dependent on other object.

Let there are three classes Man, Woman and Children
If Man-> Woman
And Woman -> Children
So Man -> Children
This is called Transitive Object Dependency.
Object Coupling and Object Dependency are same term.
A Good Design should contain loose object coupling or object dependency.

Problems in above approach

It is using Part of Relationship.
Here object of Kids has been created inside constructor of Person class. So here coupling is very high or tight.
If due to any reason object creation of Kids is failed. Then Person class also cannot be instantiated in its constructor itself.
If object of Person class is killed then by default object of Kids class is also getting killed.
If a new type of Kids has been created or a new property is being added in Kids class then it need code modification in Person class also.
This also raises chances of Dangling Reference.
Person class cannot work for Default constructor.
Kidsâ?T class cannot work for Default constructor.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IOC
{
class Person
{
private int age;
private string name;
private Kids obj; (Refrence)
public Person(int personAge,string personName, int kidsAge, string kidsName)
{
obj = new Kids(kidsAge, kidsName); (known Concrete class)
age = personAge;
name = personName;
}

public override string ToString()
{
//return base.ToString();
string s= age.ToString();
Console.Write(obj);
return "ParentAge" + s + " ParentName" + name;
}
}
}

How to solve above problem?

Assign task of object creation (Kids class) to some other entity, like other class, another function.
Assign task of object creation to third party.

So, assigning task of object creation to Third Party is somehow INVERTING CONTROL to third party. And this is called "INVERSION OF CONTROL"
In other words IOC could be defined as

"Delegating task of object creation to third party, to achieve low coupling between objects and to minimize dependency between objects is called Inversion of Control design pattern ".

So IOC says,

Main class (Pesron.cs) which is composing other class, should not directly depends on implementation of other class (Kids.cs) .
There should be an abstraction between classes and classes should fully depend upon that abstraction.
Abstraction could be either an interface or and abstract class.

Dependency Injection
This is the way to implement IOC. Dependency Injection

Eliminates tight coupling between objects.
Make object and application more flexible.
It facilitates creation of more loosely coupled objects and their dependencies.

"Dependency Injection isolates implementation of object from the construction of object on which it depends".

Constructor Injection

Here object reference would get pass to constructor of business class Person. In this case, since Person class depends on Kids class. So reference of Kids class will pass to constructor of Person class. So at the time of object creation of Person class, Kids class will get instantiated.
Steps to implement constructor Injection

Step 1: Create an interface

IBuisnessLogic.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IOC
{
public interface IBuisnessLogic
{

}
}

Only methods of interface will be exposed to business logic class (Person)

Step 2: Implement interface to Kids class.

Kids.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IOC
{
public class Kids :IBuisnessLogic
{
private int age;
private string name;
public Kids(int age, string name)
{
this.age = age;
this.name = name;
}

public override string ToString()
{

string m = this.age.ToString();
return "KIDs Age " + m + " Kids Name " + name;
}

}
}

Object of Kids class is going to be referenced by Person class. So this class needs to implement interface.

Step 3:

Make reference of interface in Person class.

Person.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IOC
{
class Person
{
private int age;
private string name;
IBuisnessLogic refKids;
public Person(int personAge,string personName,IBuisnessLogic obj)
{

age = personAge;
name = personName;
refKids = obj;
}

public override string ToString()
{
string s= age.ToString();

return "ParentAge" + s + " ParentName" + name;
}
}
}

Step 4:

Now to create a third party class, where task of, creation of object will be done.

IOCClass.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IOC
{
class IOCClass
{
IBuisnessLogic objKid = null;
Person p;

public void factoryMethod()
{
objKid = new Kids(12,"Ren");
p= new Person (42,"David",objKid);
}
public override string ToString()
{
//return base.ToString();
Console.WriteLine(p);
Console.WriteLine(objKid);
return "Displaying using Constructor Injection";

}
}
}

In above code inside a factorymethod (), object is getting created.

Step 5:
Now using third party class at client side

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IOC
{
class Program
{
static void Main(string[] args)
{

IOCClass obj = new IOCClass();
obj.factoryMethod();
Console.WriteLine(obj);

Console.Read();
}
}
}

Disadvantage

In constructor Injection, business logic class cannot have default constructor.
Once the class is instantiated, objectâ?Ts dependency cannot be changed then.

Setter Injection
This uses the Properties to inject the dependency. Here rather than creating reference and assigning them in constructor, it has been done in Properties. By this way, Person class could have default constructor also.

Advantage:

It is more flexible than constructor injection.
Here dependency of object can be changed without creating any instance.
Here dependency of objet can be changed without changing the constructors.
Setters has constructive and self descriptive meaningful name that simplify understanding and usning them .

Implementation:

Step 1: same as Constructor Injection.

Step 2: Same as Constructor Injection.

Step 3: Pesron.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IOC
{
class Person
{
private int age;
private string name;
//private Kids obj;
private IBuisnessLogic refKids;
public Person(int personAge,string personName)
{

age = personAge;
name = personName;

}
public IBuisnessLogic REFKIDS
{
set
{
refKids = value;

}
get
{
return refKids;
}
}

public override string ToString()
{

string s= age.ToString();

return "ParentAge" + s + " ParentName" + name;
}
}
}

In Person class, there is Property REFKIDS, which is setting and getting value of reference of interface.

Step 4:
There are some changes in third party class.

IOC.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IOC
{
class IOCClass
{
IBuisnessLogic objKid = null;
Person p;

public void factoryMethod()
{
objKid = new Kids(12,"Ren");
p= new Person (42,"David");
p.REFKIDS = objKid;
}
public override string ToString()
{
//return base.ToString();
Console.WriteLine(p);
Console.WriteLine(objKid);
return "Displaying using Setter Injection";

}
}
}

Step 5:
Same as constructor injection.

This interface would be implemented by Business Logic class. Here Kids is a business logic class.

IoC Pattern

noreply@blogger.com (Amit Kumar Shinde) — Wed, 21 Mar 2012 12:55:00 +0000

Introduction:

IoC (inversion of control) is a design pattern used to uncouple classes to avoid strong dependencies between them.
As a matter of fact every system does not make assumptions about what other systems do or should do, so no side effect when replacing a system by another one.

Let’s have a first example showing classes having strong dependencies between them. Here we have a main class Singer, which let us know the song style and what formation it is.

01public class Song
02{
03  public string GetStyle()
04  {
05      return "Rock n Roll !";
06  }
07}
08 
09public class LineUp
10{
11  public string GetFormation()
12  {
13      return "Trio";
14  }
15}
16 
17public class Singer
18{
19  Song song;
20  LineUp lineUp;
21 
22  public Singer()
23  {
24      song = new Song();
25      lineUp = new LineUp();
26  }
27 
28  public string Sing()
29  {
30      return "Singer sings " + song.GetStyle() + " and it is a " +  lineUp.GetFormation();
31  }
32}

here’s the Main method :

1Singer singer = new Singer();
2Console.WriteLine(singer.Sing());

As result we have : singer sings Rock n Roll ! and it is a Trio
But what would we do if we want to hear another song?? Hearing the same one is good but at the end it could break your tears!!
Implementation of interfaces to replaces instanciate classes (Song, LineUp), and by this way uncoupling main class Singer with the others.

01public interface ISong
02{
03  public string GetStyle();
04}
05 
06public interface ILineUp
07{
08  public string GetFormation();
09}
10 
11public class Song : ISong
12{
13  public string ISong.GetStyle()
14  {
15      return "Hip Hop !";
16  }
17}
18 
19public class LineUp : ILineUp
20{
21  public string ILineUp.GetFormation()
22  {
23      return "Solo";
24  }
25}
26 
27public class Singer
28{
29  ISong _isong;
30  ILineUp _ilineup;
31 
32  public string Singer(ISong is, ILineUp il)
33  {
34      _isong = is;
35      _ilineup = il;
36  }
37 
38  public string Sing()
39  {
40      return Singer sings " + _isong.GetStyle() + "it is a " +  _ilineup.GetFormation();
41  }
42}

here’s the Main method : Now if we want to here another artist, we just have to
instanciate so many class that we want

01//Creating dependencies
02Song oldsong = new Song();
03LineUp oldlineUp = new LineUp();
04//Injection of dependencies
05Singer singer = new Singer(oldsong,oldlineup);
06Console.WriteLine(singer.Sing());
07 
08//Creating dependencies
09Song newsong = new Song();
10LineUp newlineUp = new LineUp();
11//Injection of dependencies
12Singer singer = new Singer(newsong,newlineup);
13Console.WriteLine(singer.Sing());

Thanks for reading !!

A basic introduction to the Unity Application Block

noreply@blogger.com (Amit Kumar Shinde) — Wed, 21 Mar 2012 12:31:00 +0000

Introduction

With its latest release, the Enterprise Library from Microsoft introduces a new component named Unity. This application block provides an easy path to implement the IoC pattern, and consequently the Dependency Injection pattern.
All the references for the Enterprise Library documentation can be found at the end of the article.

Background

Inversion of Control and Dependency Injection are the key points to understand how Unity works and the benefits of including it in our projects. If you want a deep dive on these patterns: http://martinfowler.com/articles/injection.html.
The scope of this article is writing code that is loosely coupled. Let's examine the following DummyLogger class:

public class DummyLogger
{
    private IWriter _selectedWriter;

    public DummyLogger()
    {
        //The container class is in charge for the initialization of the interface. 
        //the result is a strong dependency between the two objects
        _selectedWriter = new ConsoleWriter();
    }

    public void WriteOutput(string msg)
    {
        _selectedWriter.Write(msg);
    }
}

The first thing that comes to mind to break the relationship between the two objects is to delegate the creation of the class member to someone else:

public class DummyLogger
{
    private IWriter _selectedWriter;

    public void SetWriter(IWriter writer)
    {
        _selectedWriter = writer;
    }

    public void WriteOutput(string msg)
    {
        _selectedWriter.Write(msg);
    }
}

Nothing new until now. This can be interpreted as a trivial implementation of the IoC pattern. The contained object is no more controlled by its container class.
But what if we don't care about the real implementation of the IWriter interface ? Here's where Unity and Dependency Injection comes. The concrete implementation of the class member will be "injected" by Unity depending on its configuration. The first thing we need to do is expose the class/interface with its get/set methods and mark it with the [Dependency] attribute to make it visible to the application block.

public class DummyLogger
{

    private IWriter _selectedWriter;

    public void SetWriter(IWriter writer)
    {
        _selectedWriter = writer;
    }

    public void WriteOutput(string msg)
    {
        _selectedWriter.Write(msg);
    }
}

Behind the scenes, each class/interface decorated with the [Dependency] attribute will be created according to the Unity container's configuration. This can be done programmatically or via the .config file.

<type type="George2giga.TestUnity.Library.IWriter,George2giga.TestUnity.Library" 
   mapTo="George2giga.TestUnity.Library.ConsoleWriter,George2giga.TestUnity.Library" />

Using the code

Given below is a basic implementation of Unity. Here's the class diagram of our sample application:

IWriter, the interface is shared between the logging providers:

public interface IWriter
{
    void Write(string msg);
}

Of the three logging providers, depending on the configuration, one of them will be "injected" to create the IWriter instance:

public class ConsoleWriter : IWriter
{
    #region IWriter Members

    public void Write(string msg)
    {
        Console.WriteLine(msg);
        Console.ReadLine();
    }

    #endregion
}

public class FileWriter : IWriter
{
    #region IWriter Members

    public void Write(string msg)
    {
        using (StreamWriter streamWriter = 
               new StreamWriter("c:\\TestUnity.txt",true))
        {
            streamWriter.WriteLine(msg);
        }
    }
    #endregion
}

public class EventViewerWriter : IWriter
{
    #region IWriter Members

    public void Write(string msg)
    {
        EventLog.WriteEntry("TestUnity", msg, 
                            EventLogEntryType.Information);
    }

    #endregion
}

The logging class contains the dependency property:

public class DummyLogger
{
    private IWriter selectedWriter;

    [Dependency]
    public IWriter SelectedWriter
    {
        get { return selectedWriter; }
        set { selectedWriter = value; }
    }

    public void WriteOutput(string msg)
    {
        selectedWriter.Write(msg);
    }
}

The entry point of the application is responsible for the initialization of the Unity container:

class Program
{
    static void Main(string[] args)
    {
        IUnityContainer container = new UnityContainer();
        UnityConfigurationSection section = 
          (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
        section.Containers.Default.Configure(container);
        DummyLogger dummyLogger = container.Resolve();
        dummyLogger.SelectedWriter.Write("Hello");}
}

Here is the App.config:

xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
      <section name="unity" 
         type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, 
               Microsoft.Practices.Unity.Configuration" />
    </configSections>
    <unity>
      <containers>
        <container>
          <types>
            <type 
               type="George2giga.TestUnity.Library.IWriter,George2giga.TestUnity.Library" 
               mapTo="George2giga.TestUnity.Library.ConsoleWriter,
                      George2giga.TestUnity.Library" />
          </types>
        </container>
      </containers>
    </unity>
</configuration>

Points of interest

Design patterns are without doubt a very interesting argument. With Unity, we are able to implement two of them in a very easy way. Dependency Injection allows us to create code that is decoupled, where we can create dependencies without hard-coding anything on our project.

References

Unity: http://msdn.microsoft.com/en-us/library/cc440954.aspx

Encryption and Decryption using Cryptography Application block in Enterprise Library 5.0(part 1)

noreply@blogger.com (Amit Kumar Shinde) — Wed, 21 Mar 2012 03:56:00 +0000

Introduction

In the last article (How to use logging application block in enterprise library 5.0) I have shown you how to configure the web.config for using enterprise library 5.0.

Let us learn how to use Cryptography Application Block

For using the Cryptography Application Block you have to select "Add Cryptography settings" by clicking the Block menu of the web.config (in edit mode). This adds two empty columns to the tool: one for Hash providers and other for Symmetric Cryptography Providers.

Configuring the application for using symmetric key cryptography provider

1. Click the plus-sign icon in the Symmetric Cryptography Providers column, point to Add Symmetric Cryptography Providers, and click Add Symmetric Algorithm Provider.

2. A dialog is displayed, as shown in the following screen shot. Expand the mscorlib item until you see a list of algorithm providers. Select the RijndaelManaged type and then click OK. (You can select any algorithm.Here I'm showing an example based on RijndaelManaged algorithm.).

3. The Cryptographic Key Wizard is displayed (see below). In the first screen of the wizard, select the Create a new key option, and then click the Next button.

The wizard will lead you through the process of creating and protecting a cryptographic key.

4. Click the Generate button to generate a new key, and then click the Next button, as you see here.

5. Click the ellipsis (…) button and choose a key file location (here I choose Desktop) and then click the Next button.

6. Select User mode and then click Finish, as you see here.

After clicking finish button the tool will look like the below screen shot. You can change the name

RijndaelManaged to any other name. I have changed the name to crp(not in the picture).

The xml of web.cofig is shown below

Now the code:

First you have to add the below references to the project

Microsoft.Practices.EnterpriseLibrary.Security.Cryptography.dll
Microsoft.Practices.EnterpriseLibrary.Common.dll

aspx page

<%@ 
Page 
Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>


DOCTYPE html 
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html 
xmlns="http://www.w3.org/1999/xhtml">
<head 
runat="server">
<title>title>
head>
<body>
<form id="form1" runat="server">
<div>
<asp:TextBox runat="server" ID="txt1" /> //no validations are done here so 
you have to enter text before clicking button.
<asp:Button runat="server" ID="btn1" onclick="btn1_Click" text="submit"/><br />
Encrypted Text : <asp:Label runat="server" ID="lbl1" /><br />
Decrypted Text : <asp:Label runat="server" ID="lbl2">asp:Label>
div>
form>
body>
html>

aspx.cs

using System;

using 
Microsoft.Practices.EnterpriseLibrary.Security.Cryptography;

public partial class _Default : System.Web.UI.Page 
{
protected void Page_Load(object sender, EventArgs e)
{

}
protected void btn1_Click(object sender, EventArgs e)
{
string encrypted;
string message = txt1.Text;
encrypted = Cryptographer.EncryptSymmetric("crp", message);
lbl1.Text 
= encrypted;
string plainText;
plainText = Cryptographer.DecryptSymmetric("crp", encrypted);
lbl2.Text 
= plainText;

}
}

How to use Logging Application Block in Enterprise Library 5.0

noreply@blogger.com (Amit Kumar Shinde) — Wed, 21 Mar 2012 03:55:00 +0000

Here I'm writing about Logging Application Block of Enterprise Library 5.0. For using application blocks first you have to install Microsoft Patterns and Practices Enterprise Library 5.0. After installing this you will get an edit mode while right clicking the web.config from your application .

Different application blocks available in Enterprise Library 5.0 are:

Caching Application Block
Data Access Application Block
Exception Handling Application Block
Logging Application Block
Policy Injection Application Block
Cryptography Application Block
Security Application Block
Validation Application Block

The edit mode of web.config looks like the below picture.

By clicking on the blocks menu you can add the desired blocks into your application. So here I'm adding Logging Application Block into my application. So the web.config looks like below

Use of Logging Application Block

Logging Application Block is used to write information’s to variety of locations like:

event log
an email
a database
a message queue
a text file
a WMI event
custom locations using application block extension points.

You can log messages to any locations by editing web.config without changing the c# codes.

Here I'm showing how to log information’s to an event log, an email and a text file.

1.Logging messages to event log (Event Viewer)

First you have to configure the web.config. By default the messages are logged into the event log.

You can edit the web.config Give the source name as the name of your application.

Below example shows how to log event viewer in a button click.

First you have to add the reference Enterprise Library Logging Application Block to the bin folder of your application.

aspx page


     Event Viewer

aspx.cs

using System;
using Microsoft.Practices.EnterpriseLibrary.Logging;
public partial class _Default : System.Web.UI.Page 
{
    protected void Page_Load(object sender, EventArgs e)
    {
    }
    protected void btn1_Click(object sender, EventArgs e)
    {
       
        LogEntry logEntry = new LogEntry();
        logEntry.EventId = 100;
        logEntry.Priority = 2;
        logEntry.Message = "Informational message";
        Logger.Write(logEntry);   
    
    }
}

When you click on the button the message will be logged into the event viewer. Instead of using LogEntry class, you can use only the Write() method of the Logger class as shown below.

using System;
using Microsoft.Practices.EnterpriseLibrary.Logging;
public partial class _Default : System.Web.UI.Page 
{
    protected void Page_Load(object sender, EventArgs e)
    {
    }
    protected void btn1_Click(object sender, EventArgs e)
    {
        
        Logger.Write("Informational message","EventLog",2,100);
    }
}

2. Logging messages to an email

There is no need to change the c# code only configure the web.config. You have to change the logging target listener from event log listener to email trace listener. You can do this by clicking on the + sign on the right of logging target listeners.

You have to give the From Address, Smtp port, Smtp Server, To Address in the web.config.

While clicking the button the message will be logged to the email.

3. Logging messages to a text file

No need to change the c# code. Configure the web.config. Select Flat file trace listener as logging target listener. The web.config is shown below.

While clicking the button, a log file (here trace.log) will be created in your application and the message will be logged into that file.

Conclusion

Logging Application Block in the Enterprise Library is used to log messages to different locations by configuring the web.config, without any changes in the code.

Impersonation in ASP.NET

noreply@blogger.com (Amit Kumar Shinde) — Thu, 15 Mar 2012 12:25:00 +0000

Impersonation is used when we want our ASP.NET application to assume the identity of the local windows account instead of using custom authentication. In order to access any Windows resource on such systems, you have to configure your ASP.NET application to use impersonation. You can use these settings in web.config to turn on the impersonation:

By default ASP.NET runtime does not use impersonation (unless you enable it in web.config), and the code runs in an IIS 6/7 application pool by default (like on Windows 2003 and above). This IIS application pool runs under the NT AUTHORITY\Network Service identity. On an OS with IIS 5, the ASP.NET applications run in a worker process that uses the local ASPNET account identity.

Impersonation can be implemented in two ways:

1. Configured Impersonation: If you use in web.config, you are using built-in impersonation capability in ASP.NET. This will let the user impersonate for the entire duration of the request.

2. Programmatic Impersonation: You can write custom code using Windows API method calls in C#/VB.NET (as .NET does not have a managed wrapper for this) to impersonate a user for the entire duration of a request. If you want more control, such as the ability to impersonate a user for only part of the page request, you have to do the impersonation yourself in your code following this approach. Here you need to use WindowsIdentity.Impersonate() method as shown in this article: http://msdn.microsoft.com/en-us/library/ms998351.aspx

For impersonating users across the domain, we need to use delegation: http://msdn.microsoft.com/en-us/library/ms998355.aspx

Windows authentication and Impersonation are very useful when you are developing a web application for Intra-net systems.But it is less-flexible than using custom authentication.

BillDesk Payment Gateway Integration with Asp.Net

noreply@blogger.com (Amit Kumar Shinde) — Thu, 08 Mar 2012 05:34:00 +0000

Introduction:

Now-a-days online shopping websites has become very popular, and to handle the secure Payment transactions, these are relying on popular third part Payment gateways like Billdesk, paypal etc.

BillDesk is the Payment Transaction Interface which allows the secure payment through Credit card/Online Banking transaction.

Step-by-step Transaction Process:

a. Customer logs-in at the merchant website, chooses the product/service that he intends to purchase.

b. Customer then decides to make payment at merchant’s website.

c. Merchant website will log the order by generating a Unique Order Number; and establish a connection with the BillDesk Payment Gateway Interface [refer the section on Payment Request].

d. At the BillDesk Payment Gateway; the customer is displayed with various ‘payment options’ that the customer can use. These would include – Credit Card; Online Net Banking.

e. Customer chooses the payment option at BillDesk Payment Gateway, and is taken to the page of that specific bank [if Netbanking option is chosen]. Customer then enters the relevant authentication details [ie, User ID/ Card Number/ Password] at the bank’s website; and then is requested to confirm the payment amount.

If the customer chooses to pay using Credit card then a payment page with the look and feel of the merchant is displayed for the user to make a payment.

f. Customer’s account is debited and the Customer is then directed back to the designated Return URL [RU] at Merchant website.

g. The BillDesk Payment Gateway will provide the return response to the designated Merchant return URL received in the initial transaction request. Merchant can use this response to update its system and display to the customer that the payment process was successful.

h. BillDesk payment gateway also generates a unique Transaction ID against each order number that is received – this could be displayed to the customer; and used for any queries relating to the transaction.

Payment Request:

After the customer clicks on PAY [within Merchant website], a request
needs to be generated by Merchant to following BillDesk URL for each
payment with the parameters indicated:

https://www.billdesk.com/pgidsk/pgijsp/MerchantPaymentoption.jsp

[The above URL is for example purpose only. And will be unique for each Merchant.]

A brief explanation of these parameters is below:

Parameter Name	Description	Sample Value
txtCustomerID	Order Number	1073234
txtTxnAmount	Total value of Transaction Rs.Ps.	2400.30
txtAdditionalInfo1	Source	Identity of Merchant website with Billdesk
txtAdditionalInfo2	Currency	INR or USD or GBP or EUR
txtAdditionalInfo3	Homestays	Kerela Backwaters
txtAdditionalInfo4	Arrival Date	25-Sep-09
txtAdditionalInfo5	Depature Date	28-Sep-09
txtAdditionalInfo6	Guests	2
txtAdditionalInfo7	Rooms	1
RU	Return URL – this dynamic return URL of the merchant where the online return response has to be received for that transaction	Https://payment.merchant.com (sample)

Note: Parameters are case sensitive.

Example:

<form name=’abc’ method='POST'

action='https://www.billdesk.com/pgidsk/pgijsp/MerchantPaymentoption.jsp'>

<input type='hidden' name=' txtAdditionalInfo1' value='

Identity of Merchant website with Billdesk '>

<input type='hidden' name=' txtAdditionalInfo2'

value='USD'>

<input type='hidden' name=' txtAdditionalInfo3'

value='Kerala Backwaters'>

<input type='hidden' name=' txtAdditionalInfo4' value='25-

Sep-08'>

<input type='hidden' name=' txtAdditionalInfo5' value='28-

Sep-08'>

<input type='hidden' name='RU'

value='https://payment.merchant.com'>

form>

No.	Area	Description
1	Secure BillDesk URL	Always use “https” for the BillDesk URL where the request will be posted.
2	POST method	* Always Use “POST” method * Variables must be sent as HIDDEN values
3	Referral URL	Always call the BillDesk production URL from the Referral URL only; which needs be shared at the time of integration.
4	Length of parameters	Each parameter field should not be more than 120 characters. A ‘NULL’ value will not be accepted for any parameter.
5	Disallowed characters	Special characters are disallowed in the parameters that are sent to BillDesk. For example: < > % ; ' " ^ ` $
6	Transaction Amount	During the test phase of the integration, only Rs. 2 can be used as a transaction amount.
7	Parameter Name	Parameter names (sent to BillDesk) are case-sensitive

Payment Response

Once the Payment transaction is done in the Billdesk website, the payment response is sent to the Return URL [RU] specified dynamically by Merchant for each transaction.

This response is the “Form submit” and can be retrieved by – Request.Form[“msg”]

Response Message description:

For example, suppose the Response message for a particular transaction is as follows:

MAHINDRAID|c7b9b0|MEPG9999999999|200911106652263|7800.00|EPG|NA|NA|INR|DIRECT|NA|NA|NA|10-11-2009 11:00:56|0300|NA|HOMESTAYS|INR|BBEstate-Coorg-Karnataka|17-Nov-09|20-Nov-09|3|1|NA|Transaction Successful|717696825

Please note – MERCHANTID and the CHECKSUM KEY would be provided at the time of

integration.

Payment updation process at Merchant end

The following process should be followed at Merchant end for receiving and processing the

payment response:

I. Receive and Read the Payment Response message – msg at the Return URL

II. Generate the ‘checksum value’ for the Payment Response and validate it with the ‘checksum value’ received in the Payment Response. If they match; proceed to step (c) below; else display a Payment Rejection message to the customer.

III. Update the original record in the merchant system based on the ‘AuthStatus’ field received in the Payment Response. Refer the table below for various values that are received in the AuthStatus field, and the related Transaction Status. The updation to

the original record must be done as follows:

Successful transaction [AuthStatus – 0300]

Update set STATUS = ‘SUCCESS’ where ORIGINALSTATUS=’PENDING’ and ORDERNUMBER=’

1073234’ and TRANSACTIONAMOUNT=’2400.30’

Failure transaction [AuthStatus – other than 0300]

Update set STATUS = ‘FAILURE’ where ORIGINALSTATUS=’PENDING’ and ORDERNUMBER=’

1073234’ and TRANSACTIONAMOUNT=’2400.30’

IV. The above updation process ensures the following:

i) Only the original record is updated [through the Unique Order
Number]

ii) The record is updated only once [for original status=PENDING]

iii) The record is updated for the same ‘Transaction Amount’ that was
initiated by the merchant.

Authorization status:

AuthStatus	Status Reason	Proposed Transaction Status
0300	Success	Successful Transaction
0399	Invalid Authentication at Bank	Cancel Transaction
NA	Invalid Input in the Request Message	Cancel Transaction
0002	Billdesk waiting for the response from bank	Cancel Transaction
0001	Error at Billdesk	Cancel Transaction

For all AuthStatus that is not a Success, an ErrorDescription would be provided in the Payment Response.

No.	Area	Description
1	Checksum Validation	Always validate the checksum before updating the transaction Response
2	Verify whether the updation is as per the process specified in the interface document	Only the original record is updated [through the Unique Order Number] The record is updated only once [for original status=PENDING] The record is updated for the same ‘Transaction Amount’ that was initiated by the merchant.

Sample Code:

In the Merchant website, the Page use the “Post method” to send the variables to the Billdesk website

<html>

<title>Paymenttitle>

function myfunc ()

{

var frm = document.all("form2");

frm.submit();

}

window.onload = myfunc;

script>

head>

<body>

<input type="hidden" name="txtCustomerID"

value="<%=Request("txtCustomerID")%>" />

<input type="hidden" name="txtTxnAmount"

value="<%=Request("txtTxnAmount")%>" />

<input type="hidden" name="txtAdditionalInfo1"

value="<%=Request("txtAdditionalInfo1")%>" />

<input type="hidden" name="txtAdditionalInfo2"

value="<%=Request("txtAdditionalInfo2")%>" />

<input type="hidden" name="txtAdditionalInfo3"

value="<%=Request("txtAdditionalInfo3")%>" />

<input type="hidden" name="txtAdditionalInfo4"

value="<%=Request("txtAdditionalInfo4")%>" />

<input type="hidden" name="txtAdditionalInfo5"

value="<%=Request("txtAdditionalInfo5")%>" />

<input type="hidden" name="txtAdditionalInfo6"

value="<%=Request("txtAdditionalInfo6")%>" />

<input type="hidden" name="txtAdditionalInfo7"

value="<%=Request("txtAdditionalInfo7")%>" />

form>

body>

html>

Once the Payment is done, the Bill Desk webiste posts the Response string to the Merchant website, in the form of a variable ie; “msg”.

The following sample code to be written to receive the response variable from the Billdesk website.

string _paymentResp = Request.Form["msg"];

string[] arrResponse = _paymentResp.Split('|'); //PG

string merchantId = arrResponse[0];

string _customerId = arrResponse[1];

string txnReferenceNo = arrResponse[2];

string bankReferenceNo = arrResponse[3];

string txnAmount = Convert.ToDecimal(arrResponse[4]);

string bankId = arrResponse[5];

string bankMerchantId = arrResponse[6];

string txnType = arrResponse[7];

string currency = arrResponse[8];

string itemCode = arrResponse[9];

string securityType = arrResponse[10];

string securityId = arrResponse[11];

string securityPassword = arrResponse[12];

string txnDate = arrResponse[13]; //dd-mm-yyyy

string authStatus = arrResponse[14];

string settlementType = arrResponse[15];

string additionalInfo1 = arrResponse[16];

string additionalInfo2 = arrResponse[17];

string additionalInfo3 = arrResponse[18];

string additionalInfo4 = arrResponse[19];

string additionalInfo5 = arrResponse[20];

string additionalInfo6 = arrResponse[21];

string additionalInfo7 = arrResponse[22];

string errorStatus = arrResponse[23];

string _errorDescription = arrResponse[24];

.Net Integration with Bill Desk Payment Gateway

noreply@blogger.com (Amit Kumar Shinde) — Thu, 08 Mar 2012 05:33:00 +0000

Introduction:

Now-a-days online shopping websites has become very popular, and to handle the secure Payment transactions, these are relying on popular third part Payment gateways like Billdesk, paypal etc.

BillDesk is the Payment Transaction Interface which allows the secure payment through Credit card/Online Banking transaction.

Step-by-step Transaction Process:

a. Customer logs-in at the merchant website, chooses the product/service that he intends to purchase.

b. Customer then decides to make payment at merchant’s website.

c. Merchant website will log the order by generating a Unique Order Number; and establish a connection with the BillDesk Payment Gateway Interface [refer the section on Payment Request].

d. At the BillDesk Payment Gateway; the customer is displayed with various ‘payment options’ that the customer can use. These would include – Credit Card; Online Net Banking.

If the customer chooses to pay using Credit card then a payment page with the look and feel of the merchant is displayed for the user to make a payment.

f. Customer’s account is debited and the Customer is then directed back to the designated Return URL [RU] at Merchant website.

Payment Request:

After the customer clicks on PAY [within Merchant website], a request
needs to be generated by Merchant to following BillDesk URL for each
payment with the parameters indicated:

https://www.billdesk.com/pgidsk/pgijsp/MerchantPaymentoption.jsp

[The above URL is for example purpose only. And will be unique for each Merchant.]

A brief explanation of these parameters is below:

Parameter Name	Description	Sample Value
txtCustomerID	Order Number	1073234
txtTxnAmount	Total value of Transaction Rs.Ps.	2400.30
txtAdditionalInfo1	Source	Identity of Merchant website with Billdesk
txtAdditionalInfo2	Currency	INR or USD or GBP or EUR
txtAdditionalInfo3	Homestays	Kerela Backwaters
txtAdditionalInfo4	Arrival Date	25-Sep-09
txtAdditionalInfo5	Depature Date	28-Sep-09
txtAdditionalInfo6	Guests	2
txtAdditionalInfo7	Rooms	1
RU	Return URL – this dynamic return URL of the merchant where the online return response has to be received for that transaction	Https://payment.merchant.com (sample)

Note: Parameters are case sensitive.

Example:

<form name=’abc’ method='POST'

action='https://www.billdesk.com/pgidsk/pgijsp/MerchantPaymentoption.jsp'>

<input type='hidden' name=' txtAdditionalInfo1' value='

Identity of Merchant website with Billdesk '>

<input type='hidden' name=' txtAdditionalInfo2'

value='USD'>

<input type='hidden' name=' txtAdditionalInfo3'

value='Kerala Backwaters'>

<input type='hidden' name=' txtAdditionalInfo4' value='25-

Sep-08'>

<input type='hidden' name=' txtAdditionalInfo5' value='28-

Sep-08'>

<input type='hidden' name='RU'

value='https://payment.merchant.com'>

form>

No.	Area	Description
1	Secure BillDesk URL	Always use “https” for the BillDesk URL where the request will be posted.
2	POST method	* Always Use “POST” method * Variables must be sent as HIDDEN values
3	Referral URL	Always call the BillDesk production URL from the Referral URL only; which needs be shared at the time of integration.
4	Length of parameters	Each parameter field should not be more than 120 characters. A ‘NULL’ value will not be accepted for any parameter.
5	Disallowed characters	Special characters are disallowed in the parameters that are sent to BillDesk. For example: < > % ; ' " ^ ` $
6	Transaction Amount	During the test phase of the integration, only Rs. 2 can be used as a transaction amount.
7	Parameter Name	Parameter names (sent to BillDesk) are case-sensitive

Payment Response

Once the Payment transaction is done in the Billdesk website, the payment response is sent to the Return URL [RU] specified dynamically by Merchant for each transaction.

This response is the “Form submit” and can be retrieved by – Request.Form[“msg”]

Response Message description:

For example, suppose the Response message for a particular transaction is as follows:

Please note – MERCHANTID and the CHECKSUM KEY would be provided at the time of

integration.

Payment updation process at Merchant end

The following process should be followed at Merchant end for receiving and processing the

payment response:

I. Receive and Read the Payment Response message – msg at the Return URL

the original record must be done as follows:

Successful transaction [AuthStatus – 0300]

Update set STATUS = ‘SUCCESS’ where ORIGINALSTATUS=’PENDING’ and ORDERNUMBER=’

1073234’ and TRANSACTIONAMOUNT=’2400.30’

Failure transaction [AuthStatus – other than 0300]

Update set STATUS = ‘FAILURE’ where ORIGINALSTATUS=’PENDING’ and ORDERNUMBER=’

1073234’ and TRANSACTIONAMOUNT=’2400.30’

IV. The above updation process ensures the following:

i) Only the original record is updated [through the Unique Order
Number]

ii) The record is updated only once [for original status=PENDING]

iii) The record is updated for the same ‘Transaction Amount’ that was
initiated by the merchant.

Authorization status:

AuthStatus	Status Reason	Proposed Transaction Status
0300	Success	Successful Transaction
0399	Invalid Authentication at Bank	Cancel Transaction
NA	Invalid Input in the Request Message	Cancel Transaction
0002	Billdesk waiting for the response from bank	Cancel Transaction
0001	Error at Billdesk	Cancel Transaction

For all AuthStatus that is not a Success, an ErrorDescription would be provided in the Payment Response.

No.	Area	Description
1	Checksum Validation	Always validate the checksum before updating the transaction Response
2	Verify whether the updation is as per the process specified in the interface document	Only the original record is updated [through the Unique Order Number] The record is updated only once [for original status=PENDING] The record is updated for the same ‘Transaction Amount’ that was initiated by the merchant.

Sample Code:

In the Merchant website, the Page use the “Post method” to send the variables to the Billdesk website

<html>

<title>Paymenttitle>

function myfunc ()

{

var frm = document.all("form2");

frm.submit();

}

window.onload = myfunc;

script>

head>

<body>

<input type="hidden" name="txtCustomerID"

value="<%=Request("txtCustomerID")%>" />

<input type="hidden" name="txtTxnAmount"

value="<%=Request("txtTxnAmount")%>" />

<input type="hidden" name="txtAdditionalInfo1"

value="<%=Request("txtAdditionalInfo1")%>" />

<input type="hidden" name="txtAdditionalInfo2"

value="<%=Request("txtAdditionalInfo2")%>" />

<input type="hidden" name="txtAdditionalInfo3"

value="<%=Request("txtAdditionalInfo3")%>" />

<input type="hidden" name="txtAdditionalInfo4"

value="<%=Request("txtAdditionalInfo4")%>" />

<input type="hidden" name="txtAdditionalInfo5"

value="<%=Request("txtAdditionalInfo5")%>" />

<input type="hidden" name="txtAdditionalInfo6"

value="<%=Request("txtAdditionalInfo6")%>" />

<input type="hidden" name="txtAdditionalInfo7"

value="<%=Request("txtAdditionalInfo7")%>" />

form>

body>

html>

Once the Payment is done, the Bill Desk webiste posts the Response string to the Merchant website, in the form of a variable ie; “msg”.

The following sample code to be written to receive the response variable from the Billdesk website.

string _paymentResp = Request.Form["msg"];

string[] arrResponse = _paymentResp.Split('|'); //PG

string merchantId = arrResponse[0];

string _customerId = arrResponse[1];

string txnReferenceNo = arrResponse[2];

string bankReferenceNo = arrResponse[3];

string txnAmount = Convert.ToDecimal(arrResponse[4]);

string bankId = arrResponse[5];

string bankMerchantId = arrResponse[6];

string txnType = arrResponse[7];

string currency = arrResponse[8];

string itemCode = arrResponse[9];

string securityType = arrResponse[10];

string securityId = arrResponse[11];

string securityPassword = arrResponse[12];

string txnDate = arrResponse[13]; //dd-mm-yyyy

string authStatus = arrResponse[14];

string settlementType = arrResponse[15];

string additionalInfo1 = arrResponse[16];

string additionalInfo2 = arrResponse[17];

string additionalInfo3 = arrResponse[18];

string additionalInfo4 = arrResponse[19];

string additionalInfo5 = arrResponse[20];

string additionalInfo6 = arrResponse[21];

string additionalInfo7 = arrResponse[22];

string errorStatus = arrResponse[23];

string _errorDescription = arrResponse[24];

Design Patterns In C# - Prototype Design Pattern

noreply@blogger.com (Amit Kumar Shinde) — Wed, 07 Mar 2012 03:10:00 +0000

In my last entry we looked at the Singleton design pattern, in which it allows on a single instance of a class to be created. In this entry we will look at another design pattern, the Prototype design pattern.

What is it:
The Prototype design pattern is a pattern where new instances of a class are created by cloning an initial object. Reasons for using this design pattern are (but not limited to):

Avoid the overhead of creating a new object using the [i]new[/il] keyword. This is helpful when there's a serious overhead of creating new objects.
Avoid subclasses
Use one isntance for the basis of future instances.

When we are not in a situation in which we can call an objects constructor directly, we could clone a pre-existing instance of the object (our prototype). Rather than creating more and more isntances of said object it's possible to save overhead by cloning an existing copy of your object.

Shallow & Deep Clone - Implement
When working with this design method you must create a class using the abstract modifier, meaning that it will be the only class your object will implement/inherit from. One thing to consider when using this design pattern is determining whether we want a deep clone or shallow clone.

Shallow clone: can be performed with using the Object.MemberWise Clone Method, which copies the nonstatic fields of the original object. With reference types the reference is copied meaning the original and cloned object reference to the same instance, so if a value is changed in the original object the shallow cloned object with be updated.

Deep Clone: A deep clone copies both reference and value types, giving 2 distinct instances of an object, so if object A is modified the cloned object (object B) remains unchanged. While this may be preferred in some cases, remember that there is more overhead when performing a deep clone.

For the purpose of this example we will give the option for either a deep or shallow clone of an object, but remember to make sure you know what kind of clone you need before performing the clone.

For ease of use in this example I have created a small extension method to handle to deep clone functionality since there really isnt a built-in method in the .Net framework for performing a deep clone. This method will work for any object type as it doesnt expect a certain type (it expects something of type T, which can be any serializable arbitrary type you wish). We will be cloning via Serialization, keep in mind there are several ways to deep clone an object, including Reflection and IL (Intermediate Language).

NOTE: With this method of cloning you need to add the SerializableAttribute attribute to the object you want to clone with serialization.

using System;
using System.IO;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace DZoneArticles.PrototypeDesignPattern
{
    public static class DeepCloneExtension
    {
        ///

/// method to perform a deep clone of an arbitrary (unknown at the time of cloning) object
///

        /// type of object being cloned
        /// object instance being cloned
        ///
        public static T DoDeepClone(this T obj)
        {
            //make sure the object being passed is serializable, otherwise throw an
            //exception
            if (!obj.GetType().IsSerializable)
                throw new ArgumentException("The object provided is not serializable. Please add the [Serializable()]

attribute to your object", "obj");

            // check for a null object, if found the return the defaults
            // for the object
            if (obj == null)
                return default(T);
            else
            {
                BinaryFormatter bf = new BinaryFormatter();

                using (MemoryStream ms = new MemoryStream())
                {
                    bf.Serialize(ms, obj);
                    ms.Seek(0, SeekOrigin.Begin);
                    return (T)bf.Deserialize(ms);
                }
            }
        }
    }
}
Implement Ptototype Design Pattern
Now that this is out of the way let's go into the Prototype Design pattern. For this there will be three classes in play:

EmployeePrototype: Declares an interface for cloning itself
Employee: The actual class we'll be prototyping
EmployeeManager: This class will manage the interaction between our class (Employee), the prototype (EmployeePrototype) and the client.

So let's construct a small sample application showing how the Prototype Design Process works. First we create EmployeePrototype Class. This class will be marked as abstract, meaning it will be the only class our Employee class can inherit from. So here is our protypical class:
using System;

namespace DZoneArticles.PrototypeDesignPattern
{
    public abstract class EmployeePrototype
    {
        public abstract EmployeePrototype Clone(bool deepClone);
    }
}
Now wasnt that simple, an abstract class with a single abstract method Clone, it is in that method when we determine if a deep or shallow clone is being used (which is why we pass a bvoolean value to it). Our EmployeeManager class will give us an indexer and allow us to access employees by a specified string index. Here's EmployeeManager.cs:
namespace DZoneArticles.PrototypeDesignPattern
{
    public class EmployeeManager
    {
        public Dictionary _employees = new Dictionary();

        public EmployeePrototype this[string idx]
        {
            get { return _employees[idx]; }
            set { _employees.Add(idx, value); }
        }
    }
}
Now for our final class in the prototype pattern. This will be our actual employee class. Since we're going with a simple example the class will have 2 properties: First Name & Last Name. It will also have the abstract method Clone from EmployeePrototype, and will determine, by the value passed to it, whether we're doing a deep or shallow clone:
using System;
using System.Collections.Generic;
using System.IO;

namespace DZoneArticles.PrototypeDesignPattern
{
    [Serializable()]
    public class Employee : EmployeePrototype
    {
        private string _firstName;
        private string _lastName;

        public string FirstName
        {
            get { return _firstName; }
            set { _firstName = value; }
        }

        public string LastName
        {
            get { return _lastName; }
            set { _lastName = value; }
        }

        public Employee(string fName, string lName)
        {
            this._firstName = fName;
            this._lastName = lName;
        }

        public override EmployeePrototype Clone(bool deepClone)
        {
            switch (deepClone)
            {
                case true:
                    return this.DoDeepClone() as EmployeePrototype;
                case false:
                    return this.MemberwiseClone() as EmployeePrototype;
                default:
                    return this.MemberwiseClone() as EmployeePrototype;
            }
        }
    }
}
So we have our prototype design pattern set up, let's see how it works when we put it into action:
static void Main(string[] args)
{
    EmployeeManager employee = new EmployeeManager();

    employee["John"] = new Employee("John", "Smith");
    employee["Bill"] = new Employee("Bill", "Jones");

    //now let's clone 'John Smith'
    Employee employee1 = employee["John"].Clone(true) as Employee;

    Console.ReadKey();
}
So we created 2 new employees via the EmployeeManager class. With the constructor we set it's values (first name & last name). We then created a new employee object by cloning the first employee we created. Now we can modify this new employee and not have it affect the original copy since we did a deep clone. Had we went with the shallow clone if we modified the cloned emp,oyee it would have also updated the original employee we created.

So that's how the Prototype Design Pattern works and how you can implement it in C#. While this is a real simple example it definitely can be put into action with more complex objects and situations. Thanks for reading and happy coding :)

SQL SERVER – 2008 – Step By Step Installation Guide With Images

noreply@blogger.com (Amit Kumar Shinde) — Tue, 06 Mar 2012 11:22:00 +0000

« SQL SERVER – 2008 – Four Key Pillars

SQL SERVER – 2008 – Introduction to Policy Management – Enforcing Rules on SQL Server »

SQL SERVER – 2008 – Step By Step Installation Guide With Images

June 12, 2008 by pinaldave

SQL SERVER 2008 Release Candidate 0 has been released for some time and I have got numorous request about how to install SQL Server 2008. I have created this step by step guide Installation Guide. Images are used to explain the process easier.

[Click On Images to See Larger Image]

Patterns in Real Life

noreply@blogger.com (Amit Kumar Shinde) — Tue, 06 Mar 2012 11:14:00 +0000

Introduction

In object oriented design (OO), we give clear responsibility to each object. An object is like a black box which can receive and send messages. All objects together form the complete system. Design patterns by Gang of Four introduced many general reusable solutions to commonly occurring problems in software design. I always correlate interactions between objects to real life interactions involving people and or real things. If you look around, you can see many real life examples for patterns, but played out with people instead of real objects. In this article, I will try to explain a few of these real life examples of design patterns for you.

Who can read this article?

Any one who can read English, of course, can read this article, but the targeted audience is people with some years of software experience. You need not know any special programming language, but you must know one object oriented language. Also, you are expected to be familiar with design patterns and the terminologies used in design patterns.

Composite pattern

In Composite pattern, you don’t differentiate between a leaf and a composite. The client treats a leaf or a composite the same way. You can correlate this pattern with an organization. An organization consists of many departments. Each department consists of many projects. Each project consists of many project members. A typical organization structure is as shown below.

Recursion

What makes the Composite pattern one of the most beautiful is the power of recursion. I can explain this with the same organization example. You want to find the total salary paid to all employees of the organization. It is nothing but the salary of CEO + the salary paid to all the departments. What is the salary of a department? It is the salary of the department head + the salary of all projects. What is the total salary of a project? It is the salary of the project manager + the salary of all the project members. In a nutshell, the salary of anything is the salary of self + the salary of all its sub groups.
A typical example for this in the software scenario is an XML DOM (Document Object Model) structure. A simple XML structure is shown below.

As you can see here, “employees” is a node. “employee” is another node which is a child of employees. What about name in employee? That is also a node. It is nothing but a collection of node objects. Each node can have n-number of child-nodes. If I draw a class diagram of the same, it will be like shown below.

If I create an object structure for the same in a system, based on the XML file input, you will have a structure which is as simple as a single object to a complex structure involving any number of objects. A typical structure is shown below:

To describe the advantages of the Composite pattern, I would like to take a simple organization structure as shown below. If you want to find the total number of employees in the organization, it is the sum of the root node + all its children. The calculation goes recursively, as shown below:

Another typical example of the power of recursion is GUI toolkits. For example, Java SWT (Standard Widget Toolkit). If you want to apply a theme for a dialog, you need to apply the theme for the dialog + all its child components. A child can be a composite or a widget itself. If it is a widget, there is no child for that, and the theme needs to be applied only for the widget. But if it is a composite, we need to apply the theme for all its children. Now again, a child can be a widget or a composite. The loop continues until it covers all child widgets.
Another example I can think of is the destruction of objects in C++. Take any OO language without a garbage collector. Just imagine you have a data structure like shown below. Each object has a reference only to his children and the client is aware of only the root node object. How will you destroy all the objects, leaving no memory leak? It is only a couple of lines of code that takes to destroy the complete code.

Kill a node = Kill all its children and then kill yourself.
Since the children are also of type node, the loop continues till it goes to the lowest level where there are no children.

Observer pattern

A typical example for the Observer pattern is the conventional mail delivery system. Whenever you have a mail, the postman will come and knock at your door with the mail. Just imagine if you have to go to the post office every day and check whether there are any mails. It would have been a really inefficient system as each individual needs to go to the post office periodically. This is eliminated in real life by introducing a mail delivery mechanism.

It is the same in a GUI system as shown below. Your business logic, in this case, the cassette player, will update all the GUI components periodically, just like a post man who comes to your house with mail. It would have been inefficient for the total system to implement a periodic check by each widget to get the progress.

There are two typical models for Observer based on the way data is passed. It can be a push model or a pull model. In the push model, data is pushed along with the notification. An example for this is mail delivery, magazine subscriptions etc. In the pull model, the client will be notified about what is happening. But, it is always the responsibility of the client to check whether the relevant data is there or not. An example for this is RSS feeds. Whenever there is a change in the website, and if you have subscribed for the feed, you will get a notification. But, it is up to you to go back and see if you are interested.

Factory Pattern and Abstract Factory pattern

Imagine you are constructing a house and you approach a carpenter for a door. You give the measurement for the door and your requirements, and he will construct a door for you. In this case, the carpenter is a factory of doors. Your specifications are inputs for the factory, and the door is the output or product from the factory.
Now, consider the same example of the door. You can go to a carpenter, or you can go to a plastic door shop or a PVC shop. All of them are door factories. Based on the situation, you decide what kind of factory you need to approach. This is like an Abstract Factory.

Adapter

I think this is a self explanatory pattern. You can find many real life examples for this pattern, and the simplest, which is called by the same name, is a power adapter. You have an AC power supply and the responsibility of the adapter is to provide different types of sockets adapted to the one needed.

Another example for this is a translator who is translating languages spoken by one person for another person.

Façade

Imagine you want to organize a marriage reception. You need to decorate the hall where the event is planned. You need a music band to play some music. You want to organize dinner for say 100 people, and also snack in the evening for around 50 people. If you wanted to organize such an event some 10 years back, you wanted to go to a caterer for food, a musical troop for music, and organize flowers and people to decorate them, and so and so. Some twenty years back, we needed to go to the fish market, the meat shop, the vegetable market etc., for the raw materials for the food and then organize a cook so that you have everything ready for the event. Now, life is really simpler with event managers. You just need to walk to an event manager and tell him that you need a hall decorated with flowers, dinner for 100 people, snacks for 50 people, and need a good music troop to play music while the reception is going on. You don’t need to worry about anything, and they will take care of the rest. This is a typical example for Façade. You don’t need to interact with many different objects for each and every activity. You will be provided a single interface which will act as a façade for many activities. This makes the life of clients much simpler.
Other examples for Façade are one stop bill payment shops, a support desk in a big organization which takes all kinds of support requests etc.

Decorator

A decorator decorates something. An example for Decorator is a sunglass. It takes light as input, removes all harmful parts in the light, and passes it on. If you give apple as an input to a system, and if it gives orange as output, that is not a Decorator. Another example for this is music filtering.
A software example for Decorator is JAVA I/O. Initially, I wondered why we need to create so many objects just to do a file operation. I realized how flexible and wonderful it is after some time.

Template

A typical example for the Template pattern is the Computer Engineering degree curriculum. It covers all the basic stuff required for a typical software engineer. He can’t work as it is in an industry as he needs to fill in many gaps which are required in the specific domain. But, he will have the necessary knowledge to move to any software company after completion of the course.

Reactor

Recently, I went to a restaurant in Bangalore. There was a female standing outside, receiving all the people entering the restaurant. She received us with a pleasant smile, then took us inside, and helped us find a table. She assigned a waiter to serve us, and then went back to the reception and waited for new clients. All she did was receive a new visitor. She is just like a web server serving multiple clients. In a typical web server, there is a thread simply waiting for requests from clients. Whenever there is a client request, it creates a separate thread and assigns that thread to handle the request. The thread will die down after serving the requests.

Conclusion

You can find many more examples like this in our day to day life for real life design patterns. If we correlate these, we will appreciate the patterns better. Most of these real life patterns were evolved over a long period of time by brilliant people to have efficient systems in the society. If we follow this in software systems, we can create efficient software systems just like other efficient systems around you.

Abstract Factory Design Pattern

noreply@blogger.com (Amit Kumar Shinde) — Tue, 06 Mar 2012 08:32:00 +0000

An abstract factory provides an interface for creating families of related objects without specifying their concrete classes. Sometimes one wants to construct an instance of one of a suite of classes, deciding between the classes at the time of instantiation. In order to avoid duplicating the decision making everywhere an instance is created, we need a mechanism for creating instances of related classes without necessarily knowing which will be instantiated. Abstract Factory is an abstract class defining a common protocol of Factory methods. Concrete subclasses of the abstract factory implement this protocol to answer instances of the appropriate suite of classes. This is useful when there is a need to have multiple families of products. The system shall be configured with one of multiple families of products.

Here is an example. Suppose there is a computer factory which needs to create CPU and Memory as products. An interface ComputerFactory is defined which defines the abstract methods for creating abstract CPU and Memory. A concrete computer factory is defined by the class ComputerFactoryA which creates the suit of products belonging to the ‘A’ series i.e. CPUA and MemoryA. Note that CPUA and MemoryA implement the respective interfaces CPU and Memory which represents the abstract products. There is a test class called Client which defines a static method to create the suit of products. Note that this method is a like a template which is independent of the particular suit of products. We just need to pass the object of a concrete factory of our interest and it will create the related products.


//The Abstract ComputerFactory to create an Abstract CPU and Memory
public interface ComputerFactory
{
    CPU createCPU();
    Memory createMemory();
}

//Abstract CPU
public interface CPU
{
    string GetCPU();
}

//Abstract Memory
public interface Memory
{
    string GetMemory();
}

//Concrete ComputerFactoryA tp create CPUA and MemoryA
public class ComputerFactoryA : ComputerFactory
{
    public CPU createCPU() { return new CPUA(); }
    public Memory createMemory() { return new MemoryA(); }
}

//Concrete CPUA
public class CPUA : CPU
{
    public string GetCPU() { return "CPUA"; }
}

//Concrete MemoryA
public class MemoryA : Memory
{
    public string GetMemory() { return "MemoryA"; }
}

//client class
using System;
public class Client
{
    //this is a template method; does not depend on the Concrete Factory 
    //and the Concrete classes
    public static void BuildComputer(ComputerFactory factory)
    {
        CPU cpu = factory.createCPU();
        Memory memory = factory.createMemory();
        Console.WriteLine("CPU:{0}", cpu.GetCPU());
        Console.WriteLine("Memory:{0}", memory.GetMemory());
    }    
}

This how the test code would look like:

Client.BuildComputer(new ComputerFactoryA());

What does 'N' Stands for in MS sql Queries

noreply@blogger.com (Amit Kumar Shinde) — Tue, 06 Mar 2012 05:51:00 +0000

Unicode strings

Unicode strings have a format similar to character strings but are preceded by an N identifier (N stands for National Language in the SQL-92 standard).

The N prefix must be uppercase. For example, 'Michél' is a character constant while N'Michél' is a Unicode constant.

Unicode constants are interpreted as Unicode data, and are not evaluated using a code page. Unicode constants do have a collation, which primarily controls comparisons and case sensitivity. Unicode constants are assigned the default collation of the current database, unless the COLLATE clause is used to specify a collation. Unicode data is stored using two bytes per character, as opposed to one byte per character for character data. For more information, see Using Unicode Data.

The Observer Design Pattern

noreply@blogger.com (Amit Kumar Shinde) — Sat, 03 Mar 2012 10:47:00 +0000

Introduction

I will attempt to explain what is one of the most widely used Design Patterns: Observer Pattern.

Problem domain: Implementing the Publisher/Subscriber scenario. We need a mechanism which allows us to notify subscriber objects whenever the publisher object changes state.

There is one publisher or subject class and one or more subscriber or observer classes.
Illustration

Explanation

In order for observers to receive a notification, they must implement some kind of update method which the subject can call whenever it changes state. The observers must have the freedom to register and un-register from subscription to the subject at any point in time.

The subject contains the stuff. So, whenever the stuff changes, observers need to be notified.

Here, the Observer Pattern comes to the rescue.
Implementation

We need to create two Interfaces: Subject and Observer. The interface for the subject contains the register, unregister, and notify method signatures, as follows:

public interface Subject
{
public void register(Observer o);
public void unregister(Observer o);
public void notify();
}

The interface for the observer contains an update method signature:

public interface Observer
{
    public void update(int value);
}

Now, let us assume that we are building a sample stock market gadget app. Here, the subject is the one which has the 'stuff', i.e., the stock market quotes. The observers are different classes which display the latest stock quotes to the user.

Let us have classes representing the subject/observer relationship: the StockMarket class being the subject, and we have three different observer classes: GoogleStockGadget, YahooStockGadget, and MSNStockGadget.

The StockMarket class must implement the Subject interface:

public class StockMarket : Subject
{
// A Collection to keep track of all Registered Observers
ArrayList observers = new ArrayList();

// Stores latest stock quote (example is purposely simplistic)
int newValue = 0;

public void setValue(int v)
{
    newValue = v;
}

public void register(Observer o)
{
    observers.add(o);
}

public void unregister(Observer o)
{
    int i = observers.indexOf(o);
    observers.remove(i);
}

public void notify()
{
    for (int i=0;i < observers.size();i++)
    {
      Observer ob = (Observer)observers.get(i);
      ob.update(newValue);
    }
}
}

The observers: GoogleStockGadget, YahooStockGadget, and MSNStockGadget, must implement the Observer interface.

Note that the observer classes must maintain a reference variable of type Subject.

public class GoogleStockGadet : Observer
{
   int latestValue = 0;
   Subject stockMarket; // Subject reference variable

   // Note how subject is passed in the constructor of Observer
   public GoogleStockGadet(Subject subject)
   {
    stockMarket = subject;
    stockMarket.register(this); // Registering itself to the Subject
   }

   public void update(int value)
   {
    latestValue = value;
    display();
   }

   public void display()
   {
     System.out.println("Latest Quote=" + latestValue);
   }

   public void unsubscribe()
   {
     stockMarket.unregister(this);
   }
}

Similarly, YahooStockGadget and MSNStockGadget implement the observer interface.

Now, let's see how we make it all work in the main program.

public class MainProgram
{
public static void Main(string[] args)
{
    //Initialize Subject
    StockMarket stockMarket = new StockMarket();
    int latestQuote = 0;

    // Initialize Gadgets..Note the subject being passed in Constructor
    GoogleStockGadget googleGadget = new GoogleStockGadget(stockMarket);
    MSNStockGadget msnGadget = new MSNStockGadget(stockMarket);
    YahooStockGadget yahooGadget = new YahooStockGadget(stockMarket);

    // Code for Getting latest stock
    // ....
    // ....
    stockMarket.setValue(latestQuote);

    // Updating all Registered Observers
    stockMarket.notify();

    //GoogleGadget decides to unregister/unsubscirbe
    googleGadget.unsubscribe();

}
}

With that, I end my article. Remember, the Observer Design Pattern solves the common problem of notifying several objects (i.e., Observers) about changes in the state of one principle object (or the Subject).

This, being my first article, might not be perfect, but hopefully, it has helped you in better understanding the concepts of the Observer Design Pattern.

Happy coding!

Design Pattern Implementation using C#

noreply@blogger.com (Amit Kumar Shinde) — Sat, 03 Mar 2012 09:26:00 +0000

Introduction

Design patterns may be said as a set of probable solutions for a particular problem which is tested to work best in certain situations. In other words, Design patterns, say you have found a problem. Certainly, with the evolution of software industry, most of the others might have faced the same problem once. Design pattern shows you the best possible way to solve the recurring problem.

Uses of Design Patterns

While creating an application, we think a lot on how the software will behave in the long run. It is very hard to predict how the architecture will work for the application when the actual application is implemented completely. There might issues which you cant predict and may come while implementing the software. Design patterns helps you to find tested proven design paradigm to build a solid foundation for your project. So, if you follow design pattern you can easily prevent major issues to come while building your actual project. Moreover design pattern also helps the other architects to understand your code easily.

History of Design Patterns

When the word design pattern comes into mind, the first thing that one may think is the classical book on Design Pattern "Gangs of Four" which was published by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. In this book, it is first discussed capabilities and pitfalls of Object oriented programming, and later on it discusses about the classic Design Patterns on OOPS.

You can read more about history of design patterns from here.

Types of Design Pattern

Design patterns can be divided into 3 categories.

Creational Patterns : These patterns deals mainly with creation of objects and classes.
Structural Patterns : These patterns deals with Class and Object Composition.
Behavioural Patterns : These mainly deals with Class - Object communication. That means they are concerned with the communication between class and objects.

In this article, I am going to discuss few examples of these patterns. They are
Singleton Design Pattern
Factory Design Pattern
Factory Method Design Pattern
Abstract Factory Design Pattern,
Builder Design Pattern,
Prototype Design Pattern
Adapter Design Pattern
Bridge Design Pattern
Decorator Design Pattern
Composite Design Pattern
Flyweight Design Pattern
Memento Design Pattern
Mediator Design Pattern
Observer Design Pattern
Iterator Pattern

Enabling Dynamic HTTP Compression in IIS7 on Windows Server 2008

noreply@blogger.com (Amit Kumar Shinde) — Fri, 02 Mar 2012 04:00:00 +0000

I’m not very familiar with the newer configuration screens in Windows Server 2008 so I pulled my hair out trying to update some settings. Apparently it’s just too obvious for Google to have been any help so I’m documenting it here for the next shmuck.
I wanted to enable dynamic http compression. I found the page to enable it but it wasn’t installed:

“The dynamic content compression module is not installed.” (but we won’t tell you how to install it)

It turns out that installing it is very easy and didn’t require a reboot (for me, at least):
Text only
Install it:

Open server manager
Roles > Web Server (IIS)
Role Services (scroll down) > Add Role Services
Add desired role (Web Server > Performance > Dynamic Content Compression)
Next, Install, Wait…Done!

Enable it:

Open server manager
Roles > Web Server (IIS) > Internet Information Services (IIS) Manager
Next pane: Sites > Default Web Site > Your Web Site
Main pane: IIS > Compression

With perdy pictures
Install it:

Open server manager
Roles > Web Server (IIS)
Role Services (scroll down) > Add Role Services
Add desired role (Web Server > Performance > Dynamic Content Compression)
Next, Install, Wait…Done!

Enable it:

Open server manager
Roles > Web Server (IIS) > Internet Information Services (IIS) Manager
Next pane: Sites > Default Web Site > Your Web Site
Main pane: IIS > Compression

You might be wondering why you’d want to compress content in the first place. This site has a nice analysis of the practice as well as detailed information regarding what compression level you should use (and how to set it).

10 Ways to Improve Your Web Page Performance

noreply@blogger.com (Amit Kumar Shinde) — Fri, 02 Mar 2012 03:01:00 +0000

There are a million and one ways to boost your website’s performance. The methods vary and some are more involved than others. The three main areas that you can work on are: hardware (your web server), server-side scripting optimization (PHP, Python, Java), and front-end performance (the meat of the web page).
This article primarily focuses on front-end performance since it’s the easiest to work on and provides you the most bang for your buck.

Why focus on front-end performance?

The front-end (i.e. your HTML, CSS, JavaScript, and images) is the most accessible part of your website. If you’re on a shared web hosting plan, you might not have root (or root-like) access to the server and therefore can’t tweak and adjust server settings. And even if you do have the right permissions, web server and database engineering require specialized knowledge to give you any immediate benefits.
It’s also cheap. Most of the front-end optimization discussed can be done at no other cost but your time. Not only is it inexpensive, but it’s the best use of your time because front-end performance is responsible for a very large part of a website’s response time.
With this in mind, here are a few simple ways to improve the speed of your website.

1. Profile your web pages to find the culprits.

It’s helpful to profile your web page to find components that you don’t need or components that can be optimized. Profiling a web page usually involves a tool such as Firebug to determine what components (i.e. images, CSS files, HTML documents, and JavaScript files) are being requested by the user, how long the component takes to load, and how big it is. A general rule of thumb is that you should keep your page components as small as possible (under 25KB is a good target).
Firebug’s Net tab (shown above) can help you hunt down huge files that bog down your website. In the above example, you can see that it gives you a break down of all the components required to render a web page including: what it is, where it is, how big it is, and how long it took to load.
There are many tools on the web to help you profile your web page – check out this guide for a few more tools that you can use.

2. Save images in the right format to reduce their file size.

If you have a lot of images, it’s essential to learn about the optimal format for each image. There are three common web image file formats: JPEG, GIF, and PNG. In general, you should use JPEG for realistic photos with smooth gradients and color tones. You should use GIF or PNG for images that have solid colors (such as charts and logos).
GIF and PNG are similar, but PNG typically produces a lower file size. Read Coding Horror’s weigh-in on using PNG’s over GIF’s.

3. Minify your CSS and JavaScript documents to save a few bytes.

Minification is the process of removing unneeded characters (such as tabs, spaces, source code comments) from the source code to reduce its file size. For example:
This chuck of CSS:

.some-class {
  color: #ffffff;
  line-height: 20px;
  font-size: 9px;
}

can be converted to:

.some-class{color:#fff;line-height:20px;font-size:9px;}

…and it’ll work just fine.
And don’t worry – you won’t have to reformat your code manually. There’s a plethora of free tools available at your disposal for minifying your CSS and JavaScript files. For CSS, you can find a bunch of easy-to-use tools from this CSS optimization tools list. For JavaScript, some popular minification options are JSMIN, YUI Compressor, and JavaScript Code Improver. A good minifying application gives you the ability to reverse the minification for when you’re in development. Alternatively, you can use an in-browser tool like Firebug to see the formatted version of your code.

4. Combine CSS and JavaScript files to reduce HTTP requests

For every component that’s needed to render a web page, an HTTP request is created to the server. So, if you have five CSS files for a web page, you would need at least five separate HTTP GET requests for that particular web page. By combining files, you reduce the HTTP request overhead required to generate a web page.
Check out Niels Leenheer’s article on how you can combine CSS and JS files using PHP (which can be adapted to other languages). SitePoint discusses a similar method of bundling your CSS and JavaScript;they were able to shave off 1.6 seconds in response time, thereby reducing the response time by 76% of the original time.
Otherwise, you can combine your CSS and JavaScript files using good, old copy-and-paste‘ing (works like a charm).

5. Use CSS sprites to reduce HTTP requests

A CSS Sprite is a combination of smaller images into one big image. To display the correct image, you adjust the background-position CSS attribute. Combining multiple images in this way reduces HTTP requests.
For example, on Digg (shown above), you can see individual icons for user interaction. To reduce server requests, Digg combined several icons in one big image and then used CSS to position them appropriately.
You can do this manually, but there’s a web-based tool called CSS Sprite Generator that gives you the option of uploading images to be combined into one CSS sprite, and then outputs the CSS code (the background-position attributes) to render the images.

6. Use server-side compression to reduce file sizes

This can be tricky if you’re on a shared web host that doesn’t already server-side compression, but to fully optimize the serving of page components they should be compressed. Compressing page objects is similar to zipping up a large file that you send through email: You (web server) zip up a large family picture (the page component) and email it to your friend (the browser) – they in turn unpack your ZIP file to see the picture. Popular compression methods are Deflate and gzip.
If you run your own dedicated server or if you have a VPS – you’re in luck – if you don’t have compression enabled, installing an application to handle compression is a cinch. Check out this guide on how to install mod_gzip on Apache.

7. Avoid inline CSS and JavaScript

By default, external CSS and JavaScript files are cached by the user’s browser. When a user navigates away from the landing page, they will already have your stylesheets and JavaScript files, which in turn saves them the need to download styles and scripts again. If you use a lot of CSS and JavaScript in your HTML document, you won’t be taking advantage of the web browser’s caching features.

8. Offload site assets and features

Unloading some of your site assets and features to third-party web services greatly reduces the work of your web server. The principle of offloading site assets and features is that you share the burden of serving page components with another server.
You can use Feedburner to handle your RSS feeds, Flickr to serve your images (be aware of the implications of offloading your images though), and the Google AJAX Libraries API to serve popular JavaScript frameworks/libraries like MooTools, jQuery, and Dojo.
For example, on Six Revisions I use Amazon’s Simple Storage Service (Amazon S3 for short), to handle the images you see on this page, as well as Feedburner to handle RSS feeds. This allows my own server to handle just the serving of HTML, CSS, and CSS image backgrounds. Not only are these solutions cost-effective, but they drastically reduce the response times of web pages.

9. Use Cuzillion to plan out an optimal web page structure

Cuzillion is a web-based application created by Steve Souders (front-end engineer for Google after leaving Yahoo! as Chief of Performance) that helps you experiment with different configurations of a web page’s structure in order to see what the optimal structure is. If you already have a web page design, you can use Cuzillion to simulate your web page’s structure and then tweak it to see if you can improve performance by moving things around.
View InsideRIA’s video interview of Steve Sounders discussing how Cuzillion works and the Help guide to get you started quickly.

10. Monitor web server performance and create benchmarks regularly.

The web server is the brains of the operation – it’s responsible for getting/sending HTTP requests/responses to the right people and serves all of your web page components. If your web server isn’t performing well, you won’t get the maximum benefit of your optimization efforts.
It’s essential that you are constantly checking your web server for performance issues. If you have root-like access and can install stuff on the server, check out ab – an Apache web server benchmarking tool or Httperf from IBM.
If you don’t have access to your web server (or have no clue what I’m talking about) you’ll want to use a remote tool like Fiddler or HTTPWatch to analyze and monitor HTTP traffic. They will both point out places that are troublesome for you to take a look at.
Benchmarking before and after making major changes will also give you some insight on the effects of your changes. If your web server can’t handle the traffic your website generates, it’s time for an upgrade or server migration.

SQL Server Optimization Tips for Designing Tables

noreply@blogger.com (Amit Kumar Shinde) — Thu, 01 Mar 2012 12:23:00 +0000

Normalize your tables to the third normal form.
A table is in third normal form (3NF) if it is in second normal form (2NF) and if it does not contain transitive dependencies. In most cases, you should normalize your tables to the third normal form. The normalization is used to reduce the total amount of redundant data in the database. The less data there is, the less work SQL Server has to perform, speeding its performance.

Consider the denormalization of your tables from the forth or fifth normal forms to the third normal form.
Normalization to the forth and fifth normal forms can result in some performance degradation, especially when you need to perform many joins against several tables. It may be necessary to denormalize your tables to prevent performance degradation.

Consider horizontal partitioning of the very large tables into the current and the archives versions.
The less space used, the smaller the table, the less work SQL Server has to perform to evaluate your queries. For example, if you need to query only data for the current year in your daily work, and you need all the data only once per month for the monthly report, you can create two tables: one with the current year's data and one with the old data.

Create the table's columns as narrow as possible.
This can reduce the table's size and improve performance of your queries as well as some maintenance tasks (such as backup, restore and so on).

Try to reduce the number of columns in a table.
The fewer the number of columns in a table, the less space the table will use, since more rows will fit on a single data page, and less I/O overhead will be required to access the table's data.

Try to use constraints instead of triggers, rules, and defaults whenever possible.
Constraints are much more efficient than triggers and can boost performance. Constraints are more consistent and reliable in comparison to triggers, rules and defaults, because you can make errors when you write your own code to perform the same actions as the constraints.

If you need to store integer data from 0 through 255, use tinyint data type.
The columns with tinyint data type use only one byte to store their values, in comparison with two bytes, four bytes and eight bytes used to store the columns with smallint, int and bigint data types accordingly. For example, if you design tables for a small company with 5-7 departments, you can create the departments table with the DepartmentID tinyint column to store the unique number of each department.

If you need to store integer data from -32,768 through 32,767, use smallint data type.
The columns with smallint data type use only two bytes to store their values, in comparison with four bytes and eight bytes used to store the columns with int and bigint data types respectively. For example, if you design tables for a company with several hundred employees, you can create an employee table with the EmployeeID smallint column to store the unique number of each employee.

If you need to store integer data from -2,147,483,648 through 2,147,483,647, Use int data type.
The columns with int data type use only four bytes to store their values, in comparison with eight bytes used to store the columns with bigint data types. For example, to design tables for a library with more than 32,767 books, create a books table with a BookID int column to store the unique number of each book.

Use smallmoney data type instead of money data type, if you need to store monetary data values from 214,748.3648 through 214,748.3647.
The columns with smallmoney data type use only four bytes to store their values, in comparison with eight bytes used to store the columns with money data types. For example, if you need to store the monthly employee payments, it might be possible to use a column with the smallmoney data type instead of money data type.

Use smalldatetime data type instead of datetime data type, if you need to store the date and time data from January 1, 1900 through June 6, 2079, with accuracy to the minute.
The columns with smalldatetime data type use only four bytes to store their values, in comparison with eight bytes used to store the columns with datetime data types. For example, if you need to store the employee's hire date, you can use column with the smalldatetime data type instead of datetime data type.

Use varchar/nvarchar columns instead of text/ntext columns whenever possible.
Because SQL Server stores text/ntext columns on the Text/Image pages separately from the other data, stored on the Data pages, it can take more time to get the text/ntext values.

Use char/varchar columns instead of nchar/nvarchar if you do not need to store unicode data.
The char/varchar value uses only one byte to store one character, the nchar/nvarchar value uses two bytes to store one character, so the char/varchar columns use two times less space to store data in comparison with nchar/nvarchar columns.

Consider setting the 'text in row' SQL Server 2000 table's option.
The text, ntext, and image values are stored on the Text/Image pages, by default. This option specifies that small text, ntext, and image values will be placed on the Data pages with other data values in a data row. This can increase the speed of read and write operations and reduce the amount of space used to store small text, ntext, and image data values. You can set the 'text in row' table option by using the sp_tableoption stored procedure.

If you work with SQL Server 2000, use cascading referential integrity constraints instead of triggers whenever possible.
For example, if you need to make cascading deletes or updates, specify the ON DELETE or ON UPDATE clause in the REFERENCES clause of the CREATE TABLE or ALTER TABLE statements. The cascading referential integrity constraints are much more efficient than triggers and can boost performance.

How ASP.NET Web Pages are Processed on the Web Server

noreply@blogger.com (Amit Kumar Shinde) — Wed, 29 Feb 2012 04:34:00 +0000

Introduction

Have you ever wondered, precisely, what happens on the Web server when a request for an ASP.NET Web page comes in? How does the Web server handle the incoming request? How is the HTML that is emitted to the client generated? What mechanisms are possible for us developers to work with an incoming request in its various stages of processing? In this article we'll take a rather detailed look at how ASP.NET Web pages are processed on the Web server.

Step 0: The Browser Makes an HTTP Request for an ASP.NET Web Page

The entire process begins with a Web browser making a request for an ASP.NET Web page. For example, a user might type into their browser's Address window the URL for this article, http://aspnet.4guysfromrolla.com/articles/011404.aspx. The Web browser, then, would make an HTTP request to the 4Guys Web server, asking for the particular file /articles/011404-1.aspx.

Step 1: The Web Server Receives the HTTP Request

The sole task of a Web server is to accept incoming HTTP requests and to return the requested resource in an HTTP response. The 4Guys Web server runs Microsoft's Internet Information Services (IIS) Web server. The first things IIS does when a request comes in is decide how to handle the request. Its decision is based upon the requested file's extension. For example, if the requested file has the .asp extension, IIS will route the request to be handled by asp.dll. There are numerous file extensions that map to the ASP.NET engine, some of which include:

.aspx, for ASP.NET Web pages,
.asmx, for ASP.NET Web services,
.config, for ASP.NET configuration files,
.ashx, for custom ASP.NET HTTP handlers,
.rem, for remoting resources,
And others!

In the IIS administration screens, you can configure the extension mappings. The screenshot to the right shows the configuration screen for IIS 5.0. You could, for example, add your own custom extensions here. That is, you could have requests for .scott files routed to the ASP.NET engine.
The diagram below illustrates the steps 0 and 1 of a request for an ASP.NET Web page. When a request comes into the Web server, it is routed to the proper place (perhaps asp.dll for classic ASP page requests, perhaps the ASP.NET engine for ASP.NET requests) based on the requested file's extension.

Step 2: Examining the ASP.NET Engine

An initial request for http://aspnet.4guysfromrolla.com/articles/011404.aspx will reach IIS and then be routed to the ASP.NET engine, but what happens next? The ASP.NET engine is often referred to as the ASP.NET HTTP pipeline, because the incoming request passes through a variable number of HTTP modules on its way to an HTTP handler. HTTP modules are classes that have access to the incoming request. These modules can inspect the incoming request and make decisions that affect the internal flow of the request. After passing through the specified HTTP modules, the request reaches an HTTP handler, whose job it is to generate the output that will be sent back to the requesting browser. The following diagram illustrates the pipeline an ASP.NET request flows through.

There are a number of pre-built HTTP modules that are included in the HTTP pipeline by default. These modules include:

OutputCache, which handles returning and caching the page's HTML output, if needed
Session, which loads in the session state based on the user's incoming request and the session method specified in the Web.config file
FormsAuthentication, which attempts to authenticate the user based on the forms authentication scheme, if used
And others!

In fact, you can see a precise list of what modules are used by default by going to the machine.config file (located in the $WINDOWS$\Microsoft.NET\Framework\$VERSION$\CONFIG directory) and searching for the element.

HTTP handlers are the endpoints in the ASP.NET HTTP pipeline. The job of the HTTP handler is to generate the output for the requested resource. For ASP.NET Web pages, this means rendering the Web controls into HTML and returning this HTML. For a Web service, it would involve executing the specified method and wrapping its return values into an appropriately formatted SOAP response. (For more on Web services, be sure to read: An Extensive Examination of Web Services.)
Different ASP.NET resources use different HTTP handlers. The handlers used by default are spelled out in the machine.config's section. Entries in this section refer to classes that are either HTTP handlers themselves or are HTTP handler factories. An HTTP handler factory merely returns a suitable HTTP handler instance when invoked.

Realize that you can create your own HTTP modules and HTTP handlers, and then plug them into the pipeline for all Web sites on the Web server by modifying machine.config, or you can add them to a particular Web application by modifying that application's Web.config file. A thorough discussion on using HTTP modules and handlers is far beyond the scope of this article, but realize that you can accomplish some neat things using modules and handlers. For example, you can use HTTP modules to provide a custom URL rewritter, which can be useful for automatically fixing 404 errors to using shorter and user-friendlier URLs. (See Rewrite.NET - A URL Rewriting Engine for .NET for an example of using HTTP modules for URL rewriting.) Another cool use of modules is compressing the generated HTML.
For a good discussion on HTTP modules and handlers be sure to read Mansoor Ahmed Siddiqui's article: HTTP Handlers and HTTP Modules in ASP.NET.

Step 3: Generating the Output

The final step is for the suitable HTTP handler to generate the appropriate output. This output, then, is passed back through the HTTP modules and then back to IIS, which then sends it back to the client that initiated the request. (If the client was a Web browser, the Web browser would receive this HTML and display it.) Since the steps for generating the output differ by HTTP handler, let's focus in on one in particular - the HTTP handler that is used to render ASP.NET Web pages. To retrace the initial steps, when a request comes into IIS for an ASP.NET page (i.e., one with a .aspx extension), the request is handed off to the ASP.NET engine. The request then moves through the modules. The request is then routed to the PageHandlerFactory, since in the machine.config's section we have the mapping:

The PageHandlerFactory class is an HTTP handler factory. It's job is to provide an instance of an HTTP handler that can handle the request. What PageHandlerFactory does is find the compiled class that represents the ASP.NET Web page that is being requested.
If you use Visual Studio .NET to create your ASP.NET Web pages you know that the Web pages are composed of two separate files: a .aspx file, which contains just the HTML markup and Web controls, and a .aspx.vb or .aspx.cs file that contains the code-behind class (which contains the server-side code). If you don't use Visual Studio .NET, you likely use a server-side

6 important .NET concepts: - Stack, heap, Value types, reference types, boxing and Unboxing.

noreply@blogger.com (Amit Kumar Shinde) — Wed, 29 Feb 2012 03:35:00 +0000

Introduction

This article will explain 6 important concepts Stack , heap , value types , reference types , boxing and unboxing. This article starts first explaining what happens internally when you declare a variable and then it moves ahead to explain 2 important concepts stack and heap. Article then talks about reference types and value types and clarifies some of the important fundamentals around them.

Finally the article concludes by demonstrating how performance is hampered due to boxing and unboxing with a sample code.

What goes inside when you declare a variable?

When you declare a variable in a .Net application, it allocates some chunk of memory in to the RAM. This memory has 3 things first the name of the variable, second data type of the variable and finally the value of the variable.

That was a simple explanation of what happens in the memory, but depending on what kind of data type your variable is allocated on that type of memory. There are two types of memory allocation stack memory and heap memory. In the coming sections we will try to understand these two types of memory in more details.

Stack and Heap

In order to understand stack and heap, let’s understand what actually happens in the below code internally.

public void Method1()
{
// Line 1
int i=4;

// Line 2
int y=2;

//Line 3
class1 cls1 = new class1();
}

It’s a 3 line code so let’s understand line by line how things execute internally.

Line 1:- When this line is executed compiler allocates a small amount of memory in to memory type called as stack. Stack is responsible of keeping track of running memory needed in your application.

Line 2:- Now the execution moves to the next step. As the name says stack it stacks this memory allocation on the top of the first memory allocation. You can think about stack as series of compartment or boxes put on top of each other.

Memory allocation and de-allocation is done using LIFO (Last in first out) logic. In other words memory is allocated and de-allocated at only one end of the memory i.e. top of the stack.

Line 3:- In line 3 we have a created an object. When this line is executed it creates a pointer on the stack and the actual object is stored in a different type of memory location called as ‘Heap’. ‘Heap’ does not track running memory it’s just pile of objects which can reached at any moment of time. Heap is used for dynamic memory allocation.

One more important point to note here is reference pointers are allocated on stack. The statement, Class1 cls1; does not allocate memory for an instance of Class1, it only allocates a stack variable cls1 (and sets it to null). The time it hits the new keyword it allocates on "HEAP".

Exiting the method (The fun):- Now finally the execution control starts exiting the method. When it passes the end control it clears all the memory variables which are assigned on stack. In other words all variables which are related to ‘int’ data type are de-allocated in ‘LIFO’ fashion from the stack.

The BIG catch – It did not de-allocate the heap memory. This memory will be later de-allocated by “GARBAGE COLLECTOR”.

Now many of our developer friends must be wondering why two types of memory, can’t we just allocate everything on just one memory type and we are done.

If you look closely primitive data types are not complex, they hold single values like ‘int i = 0’. Object data types are complex, they reference other objects or other primitive data types. In other words they hold reference to other multiple values and each one of them must be stored in memory. Object types need dynamic memory while primitive needs static type memory. If the requirement is of dynamic memory it’s allocated on a heap or else it goes on a stack.

Image taken from http://michaelbungartz.wordpress.com/

Value types and reference types

Now that we have understood the concept of ‘Stack’ and ‘Heap’ it’s time to understand the concept of value types and reference types.

Value types are types which hold both data and the memory on the same location. While a reference type has a pointer which points to the memory location.

Below is a simple integer data type with name ‘i’ whose value is assigned to an other integer data type with name ‘j’. Both these memory values are allocated on the stack.

When we assign the ‘int’ value to the other ‘int’ value it creates a complete different copy. In other word if you change either of them the other does not change. These kinds of data types are called as ‘Value types’.

When we create an object and when we assign one object to the other object, they both point to the same memory location as show in the below code snippet. So when we assign ‘obj’ to ‘obj1’ they both point to the same memory location.

In other words if we change one of them the other object is also affected this is termed as ‘Reference types’.

So which data types are ref type and value type?

In .NET depending on data types the variable is either assigned on the stack or on the heap. ‘String’ and ‘Objects’ are reference types and any other .NET primitive data types are assigned on the stack. Below figure explains the same in a more detail manner.

Boxing and Unboxing

WOW, you have given so much knowledge, so what’s the use of it in actual programming. One of the biggest implications is to understand the performance hit which is incurred due to data moving from stack to heap and vice versa.

Consider the below code snippet. When we move a value type to reference type the data is moved from the stack to the heap. When we move reference type to a value type the data is moved from the heap to the stack.

This movement of data from the heap to stack and vice-versa creates a performance hit.

When the data moves from value types to reference types its termed as ‘Boxing’ and the vice versa is termed as ‘UnBoxing’.

If you compile the above code and see the same in ILDASM you can see in the IL code how ‘boxing’ and ‘unboxing’ looks, below figure demonstrates the same.

Performance implication of Boxing and unboxing

In order to see how the performance is impacted we ran the below two functions 10,000 times. One function has boxing and the other function is simple. We used a stop watch object to monitor the time taken.

The boxing function was executed in 3542 MS while without boxing the code was executed in 2477 MS. In other words try to avoid boxing and unboxing. In project you always need boxing and unboxing , use it when it’s absolutely necessary.

With the same article the sample code is attached which demonstrates this performance implication.

Currently I have not put a source code for unboxing but the same hold true for the same. You can write the same and experiment it by using stopwatch class.

Top 10 Best Practices for Production ASP.NET Applications

noreply@blogger.com (Amit Kumar Shinde) — Tue, 28 Feb 2012 06:06:00 +0000

1. Generate new encryption keys

When moving an application to production for the first time it is a good idea to generate new encryption keys. This includes the machine validation key and decryption key as well as any other custom keys your application may be using. There is an article on CodeProject that talks about generating machineKeys specifically that should be helpful with this.

2. Encrypt sensitive sections of your web.config

This includes both the connection string and machine key sections. See Scott Guthrie's post for some good references. Note that if your application runs in a clustered environment you will need to share a custom key using the RSA provider as described in an MSDN article.

3. Use trusted SQL connections

Both Barry Dorrans and Alex Chang have articles which discuss this in detail.

4. Set retail="true" in your machine.config

configuration

system.web

deployment

retail

"true"

system.web>configuration>This will kill three birds with one stone. It will force the 'debug' flag in the web.config to be false, it will disable page output tracing, and it will force the custom error page to be shown to remote users rather than the actual exception or error message. For more information you can read Scott Guthrie's post or the MSDN reference.

5. Create a new application pool for your site

When setting up your new site for the first time do not share an existing application pool. Create a new application pool which will be used by only by the new web application.

6. Set the memory limit for your application pool

When creating the application pool, specifically set the memory limit rather than the time limit which is set by default. Asp.net has a good whitepaper which explains the value of this:

By default IIS 6.0 does not set a limit on the amount of memory that IIS is allowed to use. ASP.NET’s Cache feature relies on a limitation of memory so the Cache can proactively remove unused items from memory.
It is recommended that you configure the memory recycling feature of IIS 6.0.

7. Create and appropriately use an app_Offline.htm file

There are many benefits to using this file. It provides an easy way to take your application offline in a somewhat user friendly way (you can at least have a pretty explanation) while fixing critical issues or pushing a major update. It also forces an application restart in case you forget to do this for a deployment. Once again, ScottGu is the best source for more information on this.

8. Develop a repeatable deployment process and automate it

It is way too easy to make mistakes when deploying any type of software. This is especially the case with software that uses configuration files that may be different between the development, staging, or production environments. I would argue that the process you come up with is not nearly as important as it being easily repeatable and automated. You can fine tune the process as needed, but you don't want a simple typo to bring a site down.

9. Build and reference release versions of all assemblies

In addition to making sure ASP.NET is not configured in debug mode, also make sure that your assemblies are not debug assemblies. There are of course exceptions if you are trying to solve a unique issue in your production environment ... but in most cases you should always deploy with release builds for all assemblies.

10. Load test

This goes without saying. Inevitably, good load testing will uncover threading and memory issues not otherwise considered.