Dot Net Complete Help, Dot Net Tips, Dot Net Complete Information

Generics in VB.NET

2010-03-12T15:11:00.000+05:30

Introduction of Generics
Generics are very useful if you know what they are and how to use them. In this article we will show you what generics are and what they are used for. We will show you situations where the usage of generics makes sense. You will understand what the term generic stands for and how it can be used in your own projects.

C++ was one of the first languages, which used some types of generics, however they were called “templates”. C# uses a similar syntax as the C++ templates, however in C# they are much easier to use. Generics are first available in Whidbey. Earlier versions of the CLR don’t support it. <> is used in C# to define a generic. However in VB.NET we use the keyword “Of”. In this article we will only discuss the VB.NET syntax.

What are Generics?
The term “generic” means not to be bound to any specific type regardless of whether we are referring it to any programming language or not! Just think of a “glass”, which can be filled with the following types: water, juice, soda etc. As you can see it is not bound to one type. It can be filled with any type. In the same way we can refer it to VB.NET. We could create a class called “Glass” which could store any of these types depended on the users choice.

Generics in one sentence : Generics can be used to store collections, which are not bound to any data type.

Why should I use Generics?
Just imagine that you are working in a class where you would need to store different data types in a collection. Of course you could use an array, but don’t forget that you will need to create different arrays for different data types, which will just bloat your code. Furthermore your code will be unnecessary longer than needed. In that case we can use generics. We could use one generic class that could handle all of data types, without requiring writing the code again and again. This will save our time, resources, and increase the performance, because the user would not need to cast the data types. In summary we can say that generics are used for the following reasons:

Performance
Type Safe
Code Reuse

Performance
How can generics help the developer to get a better performance? This is simple. The data-types are checked in the compile-timer rather than in run-time. Simply this change will improve the performance. No type casting necessary at run-time. However you should know that performance and speed are not the main aspects to use generics, but in maintainability and cleaner code.

Type Safe
This means that whenever you add an object to the collection it is checked at compile time. That means that the data type should be safe and if you pass a wrong data-type to the collection, it will throw an error during the compile time and not in the run time. This way you can make sure to handle all errors so that they don’t appear at run time, when the client is using the application.

Code Reuse
If you want to store different data types in a (non-generic) collection, than you won’t have any other option than declaring different collections for that. For example: You will need to declare a collection for integers, another for strings and another for double data types. These will unnecessary bloat your code. When using generics you just need to set the data type as a parameter and viola you can use it with whatever type you like.

Simple Example
We have read a lot by now. It’s time to see some code. To demonstrate how simple it is to use we have chosen a simple example. Lets see how it looks like:

Our Gen Class:

Public Class Gen(Of T)

    Dim dataType As T

    Public Property Val() As T

        Get

            Return dataType

        End Get

        Set(ByVal value As T)

            dataType = value

        End Set

    End Property

End Class

Our Main:

Sub Main()

        ' This one accepts strings

        Dim mystring As New Gen(Of String)

        mystring.Val = "hello world"

        System.Console.WriteLine(mystring.Val)

         ' Change the declaration so that it accepts now an integer

        Dim myInt As New Gen(Of Integer)

        myInt.Val = 5

        System.Console.WriteLine(myInt.Val)

         Console.WriteLine("Press Enter to finish ... ")

        Console.Read()

End Sub

Our Output

hello world
5

How it works
As you can see above we have only two main parts. The first is the class “Gen” and the second is the main function. The “Gen” class is generic. As already described in the introduction we need the “Of” keyword to declare it as generic. In C# and C++ we can use <> to create generic classes.

The “T” next right to the “Of” represents our data-type which we will pass when we create a new instance of that class. The rest of the code should be familiar to you.

The interesting part is going on in the main function where we create two instances of the “Gen” class. In the first instance we are using a String. This will allow passing string values to the class variables.

Dim mystring As New Gen(Of String)
mystring.Val = "hello world"
System.Console.WriteLine(mystring.Val)

In the second instance we are using an Integer. Here we can use integer values to pass to the class variables.

Dim myInt As New Gen(Of Integer)
myInt.Val = 5
System.Console.WriteLine(myInt.Val)

As you can see this was our first simple generic example. To get the same result without using generic, will cost you two classes. Your code will just bloat for nothing. The first one would need a string and the second one could use an integer, but what if you decide to create a third data-type, lets say a double? Well then you will need to create a third class, which will again make your code longer than it already is. While using generics you only need one class for any data-type.

Source : weblogs.asp.net

Rich Text Editor - Part II

2010-03-05T19:05:00.000+05:30

Introduction
After we have explored how to create a rich text editor, it is time to add some new features which will extend its usability and benefits. In this article we will get to know how new features were implemented. Again, all the major functionalities are written in javascript.

Below are the newly added features.

Strike Through: This will strike through the text entered by the user.
Decrease-Increase Indent: This will decrease or increase the text indent.
Insert Images: This will open a new window giving the user the ability to upload an image to the server and insert it directly into the editor.
Copy, Cut, and Paste: This will copy, cut or paste the text entered by the user into the clipboard.
Print: It allows only the text to be printed by opening the Print Setup dialog.
Bulleted List & Numbered List: It adds a bullet or number at the beginning of the text.
Super-Sub script: It will format the text into super script or sub script.
Insert Lines: It adds lines to the text.

Add HTML code to the user control
We will add new HTML elements to add more features into the toolbar. We will place images for all the above mentioned actions and handle all the events to perform their functionalities.

Listing 1
<IMG class=StrikeOut id=Strikethrough
onmouseover="ChangeImg('Strikethrough','strikethrough.over.gif')"
title="Strike Through" onclick="Formats('StrikeThrough','<%= this.HamEditorChildID %>' )"
onmouseout="ReturnImg('Strikethrough','strikethrough.gif',imgStatusUnderLine)"
src="Images/strikethrough.gif" >

In the above listing we added an img HTML control. The onmouseover event will call a javascript function (which I already explained in the previous article), will change the image to a selected one, the onclick event will call another function which will apply the formatting into the selected text, and onmouseout will return the image to its previous state. For the rest of the features we will use the same concept except for the Insert Images.

Figure 1

Javascript File
We will add the new functions to the already created javascript file to handle the events for all the new features. They are all defined in one javascript file linked to this editor.

Listing 2
function Formats(style,editorId)
{
    // Save the Iframe id
    var finalDivId = editorId + '_content';

    // Set the focus back to the text
    document.frames[finalDivId].focus();

    // Apply the new style
    document.frames[finalDivId].document.execCommand(style);

    // Set the focus back to the text
    document.frames[finalDivId].focus();
}

The above function is used by almost all the new event handlers. It takes two parameters; the first is the style to be applied, for example Copy, Paste, etc; the second is the editor id. We used the same function used before (execCommand) to apply the transformation.

Listing 3
function SetBorders(id)
{
    // set the borders to the emoticons icons onmouseover
    var imgBorder = document.getElementById(id);

    imgBorder.style.borderStyle = "solid";
    imgBorder.style.borderWidth = "thin";
    imgBorder.style.borderColor = "#688B9A";
}

The above function is being called when the insert emoticons div layer is shown. When the mouse is over an emotion, what we do is call this function which will set the borders for the table cell. In this way, it will be obvious for the user to see that he is over a specific emoticon. Notice the x image we added, it allows the user to close the div layer if he does not want to add any emoticons.

Figure 2

Listing 4
function ClearBorders(id)
{
    // Clear the borders of the emoticons icons onmouseout event
    var imgBorder = document.getElementById(id);

    imgBorder.style.borderStyle = "solid";
    imgBorder.style.borderWidth = "thin";
    imgBorder.style.borderColor = "white";
}

The above function will be called when the mouse is out of a specific emotion to clear its borders.

Listing 5
function SetImage(editorId,path,e)
{
    // Get the click location
    var height = e.clientY + parseInt('5');

    // Get the height inside the clicked image
    var offsetHeight = parseInt(e.offsetY);

    height = height - offsetHeight;

    // Get the click location(width)
    var width = e.clientX

    // Get the width inside the clicked image
    var offsetWidth = parseInt(e.offsetX);
    width = width - offsetWidth;

    // Save the iframe id
    var finalDivId = editorId + '_content';
    path = unescape(path);

    // Insert an image from the users Computers.
    window.open('UploadImages.aspx?path=' + path +
        '&f=' + finalDivId,null,'width=500px,height=50px,titlebar=no,menubar=no,statusbar=no,toolbar=no,top='
        + height + 'left=' + width );

}

For the insert images new feature, we created a new webform called UploadImages.aspx. This form will be open when the user clicks on insert images icon to allow the user to select an image from his/her computer and upload it into the server in order to be able to insert it into the text editor. It contains two other fields to let the user specify the width and height of the image he/she wants to insert after it was uploaded. Below is a picture of the text editor when this new window is being opened.

Figure 3

The user has the ability to browse his/her computer to select an image and in its code behind and we are handling the upload part into the web server. I gave a great option for the administrator to set the directory on the web server where the image is going to be uploaded. I will explain it in detail in the code behind part. The maximum number of digits of the height and width properties is 3. The minimum value for the height property is 100 px and the maximum value of the width property is 150 px; as you can see they are their default values.

Listing 6
function insertsImage(imageurl,editorId,height,width)
{
    opener.document.frames[editorId].focus();

    if(imageurl != "" | editorId!= "")
    {
        imageurl = unescape(imageurl);
        var imageurl = imageurl + '"' + "width=" + width + "px" + " " + "height="+ height + "px";

        // Save the iframe id
        opener.document.frames[editorId].document.execCommand('InsertImage',false,imageurl);
    }

    opener.document.frames[editorId].focus();
}

This function will be called when the user clicks on insert image. In its click event we are uploading the file and then inserting the image through javascript into the text editor with the specified width and height.

Figure 4

Code Behind
We will see how the upload images code behind is implemented and how the administrator of this editor can set the default directory where the images can be uploaded.

Listing 7
public string FilePath
{
    get
    {
        return _filePath;
    }
    set
    {
        _filePath = Server.HtmlEncode(Request.ApplicationPath + value);
    }
}

The above listing is a property of type string which the administrator can use to set the default upload directory. The below listing will show you how to use it in your webform to specify the directory. This path will be sent to the UploadImages.aspx page query string when it is being opened from the javascript function.

Listing 8
string imagePath = "/UserImages";
((hamHtmlEditor)this.FindControl("HamHtmlEditor1")).FilePath = imagePath;

Listing 9
public string Location
{
    get
    {
        return _location;
    }
    set
    {
        _location = value;
    }
}

The above property is being used to get the editor ID in order to be able to insert it directly after being uploaded to the web server.

Listing 10
if(heightValidator.IsValid && widthValidator.IsValid)
{
    string elementToInsert = Request.QueryString["f"];

    if(UploadImage.PostedFile != null && UploadImage.PostedFile.ContentLength > 0)
    {
        try
        {
            string fileName = System.IO.Path.GetFileName(UploadImage.PostedFile.FileName);
            string fileLocation = Request.QueryString["path"] + "/" + fileName;
            this.ImagePath = Server.HtmlEncode(fileLocation);
            this.Location = elementToInsert;
            Button1.Enabled = false;

            UploadImage.PostedFile.SaveAs(Server.MapPath(fileLocation));
        }
        catch(Exception ex)
        {
            Response.Write("<script language=javascript>alert('"+
                ex.Message.ToString().Replace(@"\",@"\\")+"');</script>");
        }
        finally
        {
            Button1.Enabled = true;
        }
    }
}

The above code is written inside the insert images' button click. Its purpose is to upload the image to the already specified directory after it checks if the height and width values are correct. The try and catch blocks are used to handle exceptions.

Listing11
public bool ShowHeader
{
    get
    {
        return _Header;
    }
    set
    {
        _Header = value;
    }
}

A new property of type Boolean is introduced. Once it is set to false the toolbar will not show up. I added this property to give you the ability to show only read-only text after the text is being posted.

Figure 5

The above figure is the rich text editor when its ShowHeader property is set to false. The toolbar and the below other icons will be invisible. In this way, you can use it only for displaying your saved text.

Figure 6

Here is a final version of the editor with all the new features being used.

Conclusion
This editor is being tested on IE only for this release. Hope you gained useful information throughout this article. I would like to have feedback from my blog readers.

Source : aspalliance.com

Rich Text Editor - Part I

2010-03-04T11:40:00.000+05:30

Introduction
The editor contains the following elements:

1). A toolbar containing all the functionality (listed below)

Alignment (left, center, right)
Font formatting (bold, underline, italic, font size, font name, font color)
Word counts, remove formatting, insert lines, undo, redo, and insert emoticons

2). An HTML page integrated inside an Iframe and a text area element integrated inside another iframe.

3). Two icons for displaying "View as HTML" and "Design Mode," a textbox holding the value of the word count, and finally two hidden textboxes to preserve the data entered by the user.

To keep up with this demonstration, you should have knowledge in javascript language and in HTML.

Add HTML code to the user control
We will create a user control and create the necessary HTML elements. The user control does not contain <head>, <body> or <form> tags.

We will create 3 tables for displaying the icons for the toolbar plus 3 dropdown lists; 2 are placed at the top of the control and 1 is placed at the bottom of the control. Three common events are being used for each icon, onmouseover, onmouseup, onclick and they are handled using javascript which are all embedded inside a javascript file. Separating the javascript code from the HTML code will let your code be well understood and debugged. Then we will create 3 div layers, the first layer contains the already created HTML page. I have used an HTML page because if the user has entered a url it will automatically render its HTML code the same for the sake of using icons inside your text. The second will contain a text area element which is used for displaying the HTML code to the user during runtime and the third will contain the emoticons which will be shown when the user click on the insert emoticons image.

To enable the user to enter data at runtime, you have to add set the page "designMode" property on to where the control is being used.

Listing 1
(onload="document.frames['HamHtmlEditor1_content'].document.designMode='on'")

Figure1

Javascript File
We will write functions for handling the events raised by the user. First, we will define global variables. Each of these variables has its own functionality, but most are created to store a value indicating if an icon was previously clicked or no by default its value is equal to No. Only one variable has another purpose, this variable is called (sourceText) and will be equal to the text entered by the user.

Listing 2
var sourceText= '';
var imgStatusBold = 'No';
var imgStatusItalic = 'No';
var imgStatusUnderLine = 'No';
var imgStatusLeft = 'No';
var imgStatusCenter = 'No';
var imgStatusRight = 'No';
var imgStatusRemoveF= 'No';
var imgStatusWCount = 'No';
var imgStatusInsertL = 'No';

Based on the value of the above variables, when the user clicks on an icon, if the specific variable's value is equal to “Yes” it indicates that this icon is not as the equal to the one loaded when the user control has been loaded and then directly we change the icon to its first status and set its variable to “No.” If the value was “No” then we will change the icon and its proper variable to “Yes.”

Three common functions are called onmouseover, onmouseup, and onclick. Onmouseover, a function (ChangeImg()), is used to change the icon when the user places his mouse at a certain icon. This function takes 2 parameters. The toolbar icons are contained in a folder called "Images" under the root element of the web application.

Listing 3
function ChangeImg(id, imgsrc)
{
   var imgSrc = "Images/" + imgsrc;
   document.getElementById(id).src = imgSrc;
}

Onmouseup function is used to return the icon to its previous state when the mouse leaves a specific icon; it takes 3 parameters (icon id, new icon name, and a variable).

Listing 4
function ReturnImg(id, imgsrc, ownVar)
{
   if(ownVar == 'No')
   {
       var imgSrc = "Images/" + imgsrc;
       document.getElementById(id).src = imgSrc;
   }
}

The third parameter is used to indicate either this icon was selected or not. Its default value is No.

Onclick function is called to perform a specific action. A single javascript method is used for all the actions, plus for each action a specific criteria.

Listing 5
document.frames['HamHtmlEditor1_content'].document.execCommand('JustifyLeft',false,null);

The above method is used to align the text entered by the user to the left. ExecCommand is used to execute a command on a document. It consists of predefined functions which are used to manipulate the page layout directly into the browser. Do not use it until the page has finished loading.

Listing 6
function MakeBold(boldover, bold)
{
   var img = document.getElementById('Bold')
   var imgBold = "Images/" + boldover
   var imgNotBold = "Images/" + bold

   img.src = imgBold;

   if(imgStatusBold == 'Yes')
   {
       imgStatusBold='No';
       img.src = "Images/" + bold;
   }
   else
   {
       imgStatusBold= 'Yes'
   }

   document.frames['HamHtmlEditor1_content'].document.execCommand('bold',false,null);
   document.frames['HamHtmlEditor1_content'].focus();
}

The function above is used to format the text entered by the user as bold. When he clicks on this icon, we should change it to another one. Set the global variable for this action to “Yes” which means that it has been selected. We will use this variable each time the user clicks on it to see if it has been previously selected or no, and then we will make the transformation to the text into bold. It takes 2 parameters, the first is to store the bold-over image location (url) and the second is to store the bold image location (url). The same concept is used to make the text Italic and underlined.

To apply alignments into the text, we use the same as the MakeBold() function, but instead, the 3 alignment functionalities work in a parallel way which means that if a specific alignment is selected all others will be unselected and will retain their original status.

Now we will create a function that counts how many words the user has entered. A variable is defined with default value equal to 0. Another variable is defined that holds the text entered. We will split the spaces in this variable, add the splitting results to an array and check each element length in the array. If it is equal to zero then it is a space, else add 1 to the specific variable. After this stage we will set the value of the textbox to the count variable.

Listing 7
var wordCount = document.frames['HamHtmlEditor1_content'].document.body.innerText;
var count = 0;

countWithSpace = wordCount.replace('\n', '');
countWithoutSpaces = countWithSpace.split(' ');

for(i=0;i<countWithoutSpaces.length;i++)
{
   if(countWithoutSpaces[i].length>0)
   {
       count +=1;
   }

   window.parent.document.getElementById('HamHtmlEditor1_TxtCount').value = count;
}

When the "Remove Formatting" image is clicked, we call a javascript function which sends "RemoveFormat" to the execCommand to remove all the formats applied to the text. It is very useful if a user wants to remove all the formats that he already applied into the text.

Listing 8
function RemoveFormating()
{
   document.frames['HamHtmlEditor1_content'].document.execCommand('RemoveFormat');
   document.frames['HamHtmlEditor1_content'].focus();
}

"Undo" & "Redo" are done the same as the above javascript function, but they send "undo" or "redo" to the execCommand to undo or redo the user action. It takes 1 parameter which is the execCommand function name.

Listing 9
function Formats (style)
{
   document.frames['HamHtmlEditor1_content'].document.execCommand(style);
   document.frames['HamHtmlEditor1_content'].focus();
}

When the user clicks on "Insert emoticons" icon, we will show the third div layer placed directly after this icon which contains all the emoticons images. When doing this we have to use Javascript.

Listing 10
function ShowDiv(images)
{
   var div = document.getElementById(images);
   if(div.style.display == 'block')
       div.style.display = 'none';
   else
       div.style.display = 'block';
}

Figure2: Shows the editor when the "insert emoticons" is clicked.

When the user clicks on any emoticon inside the third div layer, another javascript function is called to insert that image and to place the cursor back to the editor. This method takes 3 parameters. The first parameter is passed to execCommand that inserts the image into the document (insertimage), the second is the image location (url), and the third is the id of the div layer.

Listing 11
function insertImages(style,url,images)
{
   document.getElementById(images).style.display = 'none'
   document.frames['HamHtmlEditor1_content'].focus();

   HamHtmlEditor1_content.document.execCommand(style,'',url)

   document.frames['HamHtmlEditor1_content'].focus();
}

When the "View as HTML" image is clicked, the second div layer is shown and the first layer is hidden. The "readonly" property of this div layer is set to "true" which means that the user at runtime cannot edit it, then we will get the HTML code and insert it into that div layer.

Listing 12
function TransformtoHtml()
{
   document.getElementById('HamHtmlEditor1_Div2').style.display = 'block';
   document.getElementById('HamHtmlEditor1_Div2').innerText =
   document.frames['HamHtmlEditor1_content'].document.body.innerHTML;
}

When the "Design view" image is clicked, the third div layer (containing the HTML code) is just hidden.

Listing 13
function TransformToText()
{
   document.getElementById('HamHtmlEditor1_Div2').style.display = 'none';
}

The dropdown lists are used to let the user selects the predefined data entered to manipulate the text.

The first one is used to change the font size; sizes may vary from 1 (10 pt) to 7 (22 pt). We will handle the onclick event by calling a javascript function. This function gets the user selected from the dropdown list and sends it as a third parameter to the execCommand command. The first parameter is the FontSize, in which you are telling this command to execute the FontSize function with its specific size.

Listing 14
function ChangeFont()
{
   var fontSize = document.getElementById('FontDropDownonchange');

document.frames['HamHtmlEditor1_content'].document.execCommand('FontSize',0,fontSize.options[fontSize.selectedIndex].text);
   document.frames['HamHtmlEditor1_content'].focus();
}

The code below is used to change the font name; the first parameter of the execCommand command takes fontname as first parameter, the second is false or 0, and the third is the user’s selection.

Listing 15
function ChangeFontName()
{
   var fontName = document.getElementById("FontFamilyName");

   document.frames['HamHtmlEditor1_content'].document.execCommand('FontName',false, document.frames['HamHtmlEditor1_content'].focus();
}

The third is used to change the font color; the colors are predefined so if you want to add more colors you can modify the HTML code of this dropdown list.

Listing 16
function ChangeFontColor()
{
   var fontColor = document.getElementById("Color");

   document.frames['HamHtmlEditor1_content'].document.execCommand('ForeColor',false,fontColor.options[fontColor.selectedIndex].text);
   document.frames['HamHtmlEditor1_content'].focus();
}

The final function will assign the text entered by the user to a hidden input HTML element and store its specific HTML code to another hidden HTML element. It is called when the editor loses the focus (onblur) event of the iframe containing the HTML page. In this way, we can use the two properties created as you will see in the next section to get the hidden inputs values from the code behind.

Listing 17
function CloneText()
{
document.getElementById('HamHtmlEditor1_ContentTxt').innerText = document.frames['HamHtmlEditor1_content'].document.body.innerText;
   document.getElementById('HamHtmlEditor1_ContentHtml').value = document.frames['HamHtmlEditor1_content'].document.body.outerHTML;
}

After completing this stage, you will have the javascript file ready; all you need to do now is to link it to the page where you want to use the user control by adding the below code in the <head> tag.

<script src="HTMLEditor.js" language="javascript" type="text/javascript></script>

If you want to debug the code included in the javascript, add the word "debugger;" at the beginning of the code. In this way the compiler will start the debugging mode. Or you can go to your internet
explorer options, navigate to Advanced, unselect the disable script debugging (internet explorer), unselect disable script debugging (other) and now add your breakpoints.

Editor Properties
If you want to save the text entered by the user to a .txt file or the HTML code to another .txt file, you can use the two properties added to this control.

First create two fields in your ascx.cs page.

Listing 18
protected System.Web.UI.HtmlControls.HtmlInputText ContentTxt;
protected System.Web.UI.HtmlControls.HtmlInputText ContentHtml;

Create two protected string variables which will store the above created fields' values.

Listing 19
protected string _text;
protected string _html;

The first property is called "ContentText" which can get the text and assign it to a string variable in your code behind.

ContentTxt is declared as HtmlInputText control in the field area. Its property value will be stored into the _text string variable.

Listing 20
public string ContentText
{
   get
   {
       return _text = ContentTxt.Value;
   }
   set
   {
       _text = value;
   }
}

The second is called "ContentInnerHtml" which can get the specific HTML code for the entered text.

ContentInnerHtml is declared as HtmlInputText in the field area. Its property value will be stored into the _html string variable.

Listing 21
public string ContentInnerHtml
{
   get
   {
       return _html = ContentHtml.Value;
   }
   set
   {
       _html = value;
   }
}

Adding a Stylesheet
We will create a Stylesheet (Styles.css) to modify the toolbar and iframes UI. We will set the toolbar background color to blue and the background to repeat. Then we will give the same color to both the right and bottom borders of iframes. You are free to add whatever modification on the control user interface (UI) by modifying the below code.

Listing 22
.HtmlView
{
         background-color:white;
         border-bottom-width:medium;
         border-bottom-style:solid;
         border-bottom-color:cornflowerblue;
         border-right-width:medium;
         border-right-color:cornflowerblue;
         border-right-style:solid;
}

.FirstDiv
{
         background-color:white;
         border-bottom-width:medium;
         border-bottom-style:solid;
         border-bottom-color:cornflowerblue;
         border-right-width:medium;
         border-right-color:cornflowerblue;
         border-right-style:solid;
}

.toolbar
{
   background-color:cornflowerblue;
    background-repeat:repeat;
}

Now it is time to link this Stylesheet to your webform where you dragged the user control by adding the below code inside the <head> tag.

<LINK href="Styles.css" type="text/css" rel="stylesheet">

Figure 3

If you need to include more than one instance of the user control in a page, you have to create dynamical ids for all the div layers. You may have noticed the div layers’ ids are set to "userControlID_divlayer."

Conclusion
As you saw in this article, we explained it in detail using the javascript language and XHTML.

I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

Source : aspalliance.com

GridView in ASP.NET

2010-02-24T11:51:00.000+05:30

Introduction
The GridView control is one of the most powerful controls in ASP.NET. It's highly customizable and most Web developers are familiar with it. It requires too much work for mundane tasks such as sorting the rows based on columns, editing or deleting rows, etc.

GridView control further enhances the flexibility of the previous DataGrid control. The GridView control reduces the amount of code you need to write.

The Controls: The GridView and DetailsView controls under the Data tab in the Toolbox.

Figure 1 shows the GridView and DetailsView controls found under the Data tab in the Toolbox.

Configuring the SqlDataSource Control
Create a Web application using Visual Studio. In the default page, drag-and-drop the SqlDataSource control. Using this control declaratively establishes a connection to a SQL data source without writing any code. In the days of ASP.NET 1.x, you needed to write elaborate code to access data sources using ADO.NET. Now, you have controls that encapsulate all the logic needed to access a data source.

To configure the SqlDataSource control to connect to a SQL Server 2000 database, click on the Configure Data Source... link in the Smart Tag (see Figure 2).

The SqlDataSource Control: Click on the Configure Data Source... link to configure the SqlDataSource control.

Click on the New... button to establish a new data connection.

Select the Northwind database (see Figure 3). Click on Test Connection to verify that the connection is working. Click OK when done.

Specify the Database Properties: Select the Northwind database to specify the database properties.

You should see the data connection details (see Figure 4). Click Next to proceed.

View the Connection Details: After specifying the database properties, you should see the data connection details.

You have the option to save the connection string to the web.config file. If you do so, every time you need the connection string you can simply reference the connection string stored in web.config. In this example case, name the connection as NorthWindConn.

If you examine your web.config now, you will see the added <connectionStrings> element:

<configuration xmlns= "http://schemas.microsoft.com/.NetConfiguration/v2.0">
<appSettings/>
   <connectionStrings>
       <add name="NorthWindConn" connectionString="Server=(local);Integrated Security=True; Database=Northwind;Persist Security Info=True" providerName="System.Data.SqlClient" />
   </connectionStrings>
...
...

Click on Next.

In the next step, specify the column that you want to retrieve (see Figure 5). Click on Next when you're done.

Construct the SQL Statements: Specify the column that you want to retrieve construct the SQL statements.

You can now test the SQL query that you have created in the previous step. Click on the Test Query button to execute the SQL query (see Figure 6). When done, click Finish.

Test the Query: Click on the Test Query button to execute the SQL query.

Your SqlDataSource control is now configured. Switch to Source view to see the source of the SqlDataSource control. Note how the control references the connection string using the "<%$ %>" directive:

<asp:SqlDataSource ID="SqlDataSource1" Runat="server" SelectCommand="SELECT [ProductID], [ProductName], [SupplierID], [CategoryID], [QuantityPerUnit], [UnitPrice] FROM [Alphabetical list of products]" ConnectionString="<%$ ConnectionStrings: NorthWindConn %>">
</asp:SqlDataSource>

Configuring the GridView Control
Having configured the SqlDataSource control, you can now drag-and-drop the GridView control to the page. In the Smart Tag, select SqlDataSource1 in the Choose Data Source dropdown list to bind the SqlDataSource control with the GridView control.

You should also check the Enable Paging, Enable Sorting, and Enable Selection checkboxes (see Figure 7). Figure 7 shows how the GridView control looks after applying the Sand & Sky auto-format.

Configuring the GridView Control: This is how the GridView control looks after applying the Sand & Sky auto-format.

Press F5 to load the page using the Web browser and you should see something similar to Figure 8.

Testing the GridView Control: Press F5 to load the page using the Web browser.

Editing and Deleting Rows in the GridView Control
To make the data editable, switch to Source view and add two new attributes: UpdateCommand and DeleteCommand:

<asp:SqlDataSource ID="SqlDataSource1"
     Runat="server"
     SelectCommand="SELECT [ProductID], [ProductName], [SupplierID], [CategoryID],
     [QuantityPerUnit], [UnitPrice] FROM [Alphabetical list of products]"
     ConnectionString="<%$ ConnectionStrings:NorthWindConn %>"
     UpdateCommand="UPDATE Products SET ProductName = @ProductName,
     SupplierID= @SupplierID, CategoryID =@CategoryID , QuantityPerUnit = @QuantityPerUnit ,
     UnitPrice = CONVERT(money,@UnitPrice) WHERE ProductID=@ProductID"
     DeleteCommand="DELETE FROM Products WHERE ProductID=@ProductID">
</asp:SqlDataSource>

The UpdateCommand and DeleteCommand attributes specify the SQL statements that execute when you perform an update or delete operation.

After adding the two attributes, the Smart Tag for the GridView control gains two additional checkboxes—Enable Editing and Enable Deleting. Check the two additional options.

Press F5 to test the page again. This time you will be able to make changes to the rows in the GridView control (see Figure 9).

Editing a Row: After pressing F5, you'll be able to make changes to the rows in the GridView control.

The DetailsView Control
The DetailsView control is similar to the GridView control with one notable exception it displays one record at a time. To see how the DetailsView control works, drag-and-drop a DetailsView control onto the page. Bind it to SqlDataSource1 and check all the checkboxes shown in Figure 10.

Using the DetailsView Control: Bind the control to SqlDataSource1 and check all the checkboxes.

Press F5 to load the page. You will be able to browse through all the records as well as edit or delete them.

Inserting a New Record
You've seen how to display, edit, and delete records using the GridView and DetailsView controls. To let users add new records, simply modify the source view of the SqlDataSource control by adding the InsertCommand attribute:

<asp:SqlDataSource ID="SqlDataSource1"
     Runat="server"
     SelectCommand="SELECT [ProductID], [ProductName], [SupplierID], [CategoryID],
        [QuantityPerUnit], [UnitPrice] FROM [Products]"
     ConnectionString="<%$ ConnectionStrings:NorthWindConn %>"
     UpdateCommand="UPDATE Products SET ProductName = @ProductName,
        SupplierID= @SupplierID, CategoryID = @CategoryID ,
        QuantityPerUnit = @QuantityPerUnit , UnitPrice = CONVERT(money,@UnitPrice)
        WHERE (ProductID=@ProductID)"
     DeleteCommand="DELETE FROM Products WHERE ProductID=@ProductID"
     InsertCommand="INSERT INTO Products (ProductName, SupplierID, CategoryID,
        QuantityPerUnit, UnitPrice) VALUES (@ProductName, @SupplierID, @CategoryID,
        @QuantityPerUnit,CONVERT(money,@UnitPrice))">
</asp:SqlDataSource>

When this is done, the DetailsView control's Smart Tag will display the Enable Inserting checkbox. Check that checkbox to allow users to add a new record.

Add a new record by clicking on the New link on the DetailsView control (see Figure 11).

Add a New Record: Add a new record by clicking on the New link on the DetailsView control.

Codeless Controls
Using the new GridView and DetailsView controls in ASP.NET have not required you to write a single line of code. You simply configure the controls declaratively, and the controls perform most of the work for you.

Summary
I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

Source : www.devx.com

New Features in the .NET Framework 4

2010-02-19T16:49:00.000+05:30

Recently, Microsoft released the newer version of its IDE Visual Studio 2010 and .Net FX 4. The newer version of this framework includes the next version of ASP.Net, ASP.Net 4.0.

Adding MetaKeyword and MetaDescription Using Page object
Meta keywords and description are most important components of a page when we want to make it search engine friendly. Every search engine will look for these tags to know more information of the page contents. ASP.Net 2.0 introduced a new feature where one can add these tags from the code behind using HtmlMeta class. It would have been better if we are able to do this through Page directive (Page class). ASP.Net 4.0 added 2 new properties on the Page object to let you define the Meta keywords and Description.

Refer the code below,

The above code will add the meta tags in the output html.

More Control on Controls ViewState
ViewState is one of the important factors if we start looking at improving the performance our asp.net site. Till ASP.Net 3.x, we have EnableViewState property both at Page level and server control level to control the view state. Disabling the ViewState at page level will disable the viewstate to all the page controls. In order to improve the performance, one need to switch off the viewstate for individual control for which saving the viewstate is not necessary and hence disabling viewstate at page level is not a suitable option. To overcome this difficulty, asp.net 4.0 added a new property to Page object and controls called ViewStateMode.

This property can take 3 values,

1). Enabled
This value will enable the view state. This is the default value for the Page object.

2). Disabled
This value will disable the viewstate

3). Inherit
This value will make the control to inherit the setting of the parent. This is the default value for a control.

With this property, we can disable the viewstate for the page and enable it for the control if only required.

Consider the following code,

CodeBehind

When the page executed we will get the following output,

When the button is clicked,

Since, the viewstate is disabled at page level (Page object) and the viewstate is enabled for “Label1” we will get the above output on Button click. Please note that if we have not set the value, the default will be “inherit” (for Label2).

ClientID Generation for ASP.Net Controls
In order to access a server control from a client side script, a developer will require getting its client id. Predicting the ClientID of any control that is packed inside a parent like UserControls, MasterPage or any DataBound controls is a challenging task till day. For example, if we have 2 TextBox control inside a page that have an associated MasterPage then the ClientID will be similar to,

This is done to make the ID of the control unique in the page.

In earlier versions for asp.net, we can register a server side hidden control which can hold the ClientID of the server control to access it from client side.

ASP.Net 4.0 addresses this difficulty by providing a new property called ClientIDMode for every controls and Page object. We can also set the property in configuration files.

This property will take the following 4 values,

1). Static
Setting this value will make the ClientID same as the ID. It will not concatenate ID of the parent naming containers.

2). Predictable
This will be useful to predict the ClientID of child controls in data controls. Setting this property will prevent the “ctlxxx” prefix in the ClientID. We will see more about this value later in this section.

3). Legacy
This value will make the ClientID generation same as earlier versions of ASP.Net

4). Inherit
This value will make the control to inherit the parent control’s setting. This is the default value for this property.

For example,

This setting will make all the page controls to have ClientID same as ID. For example, if we have 2 Textbox control, the output will be similar to,

To set this property in Web.Config file/Machine.config file,

The above setting should be inside <System.Web> section.

Child Control’s ClientID in Data Control
For example, if we have child controls inside a ListView control the ClientID will be generated like below by default.

Because the ListView control has Label control to display data in each column of every row we have SPAN tag with ClientID’s generated.

To make this ID’s predictable from clientside; we can set the ClientIDMode of the ListView control to "Predictable" and ClientIDRowSuffix to one or more number of the columns from the database. Multiple column names should be a comma separated value. Please note that Repeater control will not support ClientIDRowSuffix property.

Consider the below,

The above setting will remove the prefix “ctlxx” and will append the value of the column specified in ClientIDRowSuffix. This will generate the ClientID’s like,

The above HTML is for single row. Next row will have the next employee’s name appended at the end.

ListView control Improvements
ListView control is new databound control that is released in ASP.Net 3.5. To display data, we need to define 2 mandatory templates, LayoutTemplate and ItemTemplate. In ASP.Net 4.0 version, the LayoutTemplate is made optional and only defining ItemTemplate will display the data.

Empty Website project and Cleaner Web.Config file
Visual Studio 2010 includes a new project template to create empty ASP.Net 4.0 Web application project (Similar to Empty Website Template in older version). These empty project templates will now include Web.Config file which is very clean and simple. Due to so many new additional features released, the web.config file is overloaded with information on handlers and modules (for asp.net ajax, etc). To maintain the Web.config easily, Visual Studio 2010 (from beta 2) includes only entries to identify the target framework used. Rest of the needed settings are moved to machine.config file.

Routing in Webforms
Routing is a technique where asp.net webforms can be accessed with a friendly and descriptive URL’s. Hence, the ugly URL’s with querystring can now be converted to a meaningful and descriptive which will be easy to remember and will improve the search engine rank.

CSS Improvements
The other major improvements in ASP.Net 4.0 are on the way the HTML rendered to the client browser. The rendered HTML will be complaint with latest HTML standards.

Few things will be,

1). A new property called controlRenderingCompatibilityVersion is added to the Pages element of configuration files.

The value “3.5” indicates the controls are rendered in legacy ways. The value “4.0” indicates the control will be rendered with the latest improvements of 4.0 framework.

2). Till 3.5 framework, setting “Enabled=false” for any control will render disabled attributes in the HTML for the control. According to the latest HTML standard the disabled attribute should be set only for INPUT tags. ASP.Net 4.0 addresses this issue by rendering disabled attribute to only INPUT tags and a CSS class called “aspNetDisabled” to other controls to disable it when controlRenderingCompatibilityVersion property is set to “4.0”.

Below you can find a HTML rendered for a Label and TextBox control when controlRenderingCompatibilityVersion property is set to “4.0”.

3). From ASP.Net 2.0, the hidden fields generated for viewstate are packed inside a div tag for XHTML standard. This leads a small white space on the page. ASP.Net 4.0 now includes this div with a css class “aspNetHidden”. We can now define the class to prevent the white space by setting border to 0.

4). Menu controls render markup that is semantically correct and compliant with accessibility guidelines.

5). Validation controls do not render inline styles.

RabioButtonList and CheckboxList Changes
From ASP.Net 4.0, the RadioButtonList and CheckBoxList controls includes 2 more value fro the property RepeatLayout.

1). OrderedList
The radiobutton/checkbox is rendered as li elements within an ol element.

2). UnorderedList
The radiobutton/checkbox is rendered as li elements within an ul element.

Improvements in Code Expressions
There is a new code expression syntax that is being shipped with ASP.Net 4.0. We commonly use the following syntax to output a value from aspx page called code expression.
<%= HTMLOutput %>

There is a new code expression releasing with ASP.Net 4.0 version that will html encode the value.
<%: HTMLOutput %>

The above code expression will output the value after doing html encode. i.e. the above expression is equivalent to
<%= HttpUtility.HtmlEncode(HTMLOutput) %>

Permanent Redirection with HTTP 301 Moved Permanently Response
When we move our internet page to a different location, it is always required to send “HTTP 301 Moved Permanently” response to the search engines to hold back the page rank before redirecting to the new page. Understanding this need asp.net 4.0 includes a new method to do redirection called RedirectPermanent().

Refer below,
Response.RedirectPermanent("new url")

Conclusion
This article series detailed on some of the enhancements the new framework brings for a webdeveloper.

Source : www.codedigest.com

Website Navigation Using a SiteMap

2010-02-16T12:03:00.000+05:30

The ASP.NET 2.0 infrastructure consisting of SiteMap, SiteMapDataSource and navigational controls. These pieces can help you to quickly put up an aesthetically pleasing web site.

The SiteMap Class
For web site navigation, ASP.NET 2.0 offers an infrastructure that provides site map information for web page development using navigational controls and SiteMapDataSource controls. The SiteMap class depends therefore on SiteMapProvider and XmlSiteMapProvider (default) classes. The navigation support infrastructure may use all of the following items:

Provider classes
Web.sitemap file (XML)
Navigational Controls
SiteMapPath control

SiteMap is a container of site information (folders and files) represented in an XML format that provides the root node of the site, the SiteMapProvider used, and tracks the provider objects. System.Web.SiteMap inherits from System.Object. The default provider XMLSiteMapProvider works through the Web.sitemap. Besides being useful for site navigation, the sitemap also provides a easy way for search engines to look for pages on the site.

Create the folder structure for the site
Here is an example of a site with two folders, ColdFusion61 and MSAccess at the site http://localhost/Tutorials. This was the same site that was created in the tutorial for describing the concept of a Master page in VS2005. The unexpanded folder structure is shown in this picture.

The ColdFusionMX61 contains two web pages, Default.aspx and Coldfusion.aspx. The MSAccess folder contains three web pages, Ado.aspx, DAP.aspx, and Default.aspx. Besides these, each of the folders have their own images directory (now empty) to keep the images related to these folders. This detail is shown in the next picture.

Web Site Navigation Using a SiteMap - Adding a SiteMap to the site
After highlighting the project, right click to access the drop-down menu. Click on Add New Item... which brings up the following window.

When you highlight the SiteMap icon you will find Web.sitemap as the name of the file. If you click on the Add button this file will be added to your site as shown. Before clicking the Add button you may choose a name of your own, but do not change the extension. Extensions such as *.sitemap and *.config are protected by ASP.NET for security reasons.

Site structure is in an XML file
Web.sitemap is an XML file with a special structure. It comes with a default template for a folder and a folder/file structure with three attributes, URL, Title, and Description as shown. In a rendered page these can be seen in the address bar, item's control name, and a tool-tip text showing the description.

Here <siteMap/> is the root and it has <siteMapNode/> children. These children represent the folder. These children also contain children which are the files in the folder. As shown here, the default that is added has three <siteMapNodes/> which can be used to represent one folder and two files in the folder.

The SiteMap XML file has been modified to reflect the folder structure shown earlier, as shown in the next picture. Only the structure of the ColdFusionMX61 folder has been partially implemented in this file. Also shown is the provision made for the MSAccess Folder to contain the files DAP.aspx and Ado.aspx. It must be remembered that all the ASPX files will be ContentHolder files. The title, URL and description values for both the ColdFusionMX61 folder and the file it contains have been added to the declaration. The comments should help in identifying these attributes.

Add the structure of the MSAccess folder along the same lines. Make use of intellisense at every step as shown. This will add to the correctness of the formatting.

The completed Web.sitemap file is shown in the next paragraph.

<?xml version="1.0" encoding="utf-8" ?>
<siteMap xmlns="http://schemas.microsoft.com/AspNet/SiteMap-File-1.0" >

 <siteMapNode url="~/Default.aspx" title="Home" description="Home Page">


<--   Folder   -->
<siteMapNode title="ColdFusionMX61" url="~/ColdFusionMX61/Default.aspx" Description="CFMX Tutorials">

<-- File     -->
<siteMapNode url="~/ColdFusionMX61/Coldfusion.aspx" title="CFMX" description="All tutorials on CFMX" />
</siteMapNode>


<--   Folder   -->
<siteMapNode title="MSAccess" url="~/MSAccess/Default.aspx" description="MS Access 2003 related">

<-- Two Files     -->
<siteMapNode title="ActiveXDataObjects" url="~/MSAccess/Ado.aspx" description="Using MS Access Application"/>
<siteMapNode title="Data Access Pages" url="~/MSAccess/DAP.aspx" description="Enabling for the web"/>
</siteMapNode>
</siteMapNode>
</siteMap>

Web Site Navigation Using a SiteMap - Site Navigation with Menu Control
Site navigation as implemented in ASP.NET 2.0 uses the idea of providers to interact with the site structure data captured in the XML file Web.sitemap. The default provider that is provided reads the Web.sitemap file and creates a SiteMap object. The navigational controls that you will find in the toolbox use the sitemap object to implement the navigation. Instead of the default provider, a custom provider may also be used. This tutorial uses the built-in or default provider for site navigation.

For navigational aids there are several options like drop-down, Treeview, and Menu which are not specific for navigation but are wired to the hierarchical structure of the site by means of the SiteMapDataSource control. On the other hand you may also use a SiteMapPath control which is specially programmed for site navigation.

Web Site Navigation Using a SiteMap - Where should we place the menu control?
Since the navigational menu should be available from all pages, the ideal place for the menu control is the Master Page. We need to add a SiteMapDataSource control which runs at the "Server" that extracts site structure related data that feeds a navigational control. We also need to add a navigational control which will look up this data source to navigate through the web pages. We will be adding two controls from the toolbox where they are shown in the next picture.

You may drag and drop them onto the locations shown on the MasterPage.

The design view of this page is shown in the next picture.

The menu control has a large number of properties, both static and dynamic, as well as for interactive display. However its DataSourceID property should match with the SitaMapDataSource's ID Property as shown in the next picture.

<asp:Menu ID="Menu1"
runat="server"
DataSourceID="SiteMapDataSource1" Height="277px"
BackColor="#FFFBD6"
DynamicHorizontalOffset="2"
Font-Names="Verdana"
Font-Size="0.4em"
ForeColor="#990000"
StaticSubMenuIndent="10px">
<StaticMenuItemStyle HorizontalPadding="5px" VerticalPadding="2px" Font-Size="Small" />
<DynamicHoverStyle BackColor="#990000" ForeColor="White" />
<DynamicMenuStyle BackColor="#FFFBD6" />
<StaticSelectedStyle BackColor="#FFCC66" />
<DynamicSelectedStyle BackColor="#FFCC66" />
<DynamicMenuItemStyle Font-Size="Medium" HorizontalPadding="5px" VerticalPadding="2px" />
<StaticHoverStyle BackColor="#990000" ForeColor="Maroon" Font-Size="Medium" />
<StaticMenuStyle BackColor="#FFFFC0" BorderColor="#C0C000" />
</asp:Menu>

<asp:SiteMapDataSource ID="SiteMapDataSource1" runat="server" />

With this association between the menu control and the SiteMapDataSource, the site navigation can be immediately verified as shown in the following two displays. This picture shows the page Coldfusion.aspx. When you hover over the menu you can see the various pages to which you can navigate using this menu. The placement of the menu control and its look may not be aesthetically pleasing, but the idea is to demonstrate the functionality of navigation.

You may navigate to another page, such as Ado.aspx, and you will see the following display in your browser.

Summary
Site navigation is extremly easy to implement using the ASP.NET 2.0 infrastructure consisting of SiteMap, SiteMapDataSource and navigational controls. This can be very useful for those interested in getting an aesthetically pleasing web site up and running in record time. For those of you who used the Site Diagram, the Site Designer and the Navigation Bar controls in Visual InterDev, the functionality provided with in .NET Framework for site navigation should be a Godsend. It must be remembered that site pages not included in the Web.sitemap cannot be reached by the navigation controls unless you take other measures.

Source : www.aspfree.com

Globalization and localization in ASP.NET

2010-02-03T16:11:00.000+05:30

Introduction of Globalization and localization

Applications must be designed to accommodate users from various cultures. Users in different parts of the world use different languages and different formatting standards for numbers, currency, and dates. International applications should be customizable according to the preferences of users belonging to different nations, cultures, or regions.

An application uses the locale to identify the preference of a user. The local is the combination of a language and a country. For example, the locale of a user speaking English and belonging to the United States is "en-US". The locale includes information about the formats used for representing time and date, symbols and conventions used for representing currency, and the character encoding scheme being used.

The structure of an internationalized application is divided into two blocks:

Code Block : Contains the application code or the executable part of an application. This block will remain the same for all locales.
Data Block : Contains all the resources, such as text and images used by the user interface (UI). This block is locale-specific, and each locale will have one data block.

The process of making an application ready for customers is called internationalization. It includes three phases:

Globalization : Involves writing the executable code for an application in such a way that makes it culture-neutral and language-neutral. While incorporating globalization, you must ensure that the culture-specific details are not hard-coded into the executable code. The primary task in this phase is to identify the various locale-sensitive resources and to isolate these resources from the executable code.
Localizability : An application that has been globalized must be tested to ensure that its executable code is independent of the culture and language-specific data. This is called localizability testing. The focus of localizability testing is to check how the application adapts itself to different locales.
Localization : Involves the customization of an application for a specific locale. One major task in this phase is the translation of resources identified during the globalization phase. During this phase, various resources, such as images and text, for the designated locale are created.

When designing an international application, you should ensure the following factors:

User Interface (UI) : The language used to design different UI components, such as menu, message box, static-text holder (label), is not fixed during design phase of the application.
Information Formats : The formats of different elements, such as currency, number, and date, are not fixed during design phase of the application.

The different aspects of an application that should be taken into account while incorporating localization are:

Formats : The formats used for displaying numbers, time, dates and currency should be considered while incorporating localization.
Graphics : The locale-sensitive graphics, such as maps, traffic signs, and calendar should be considered while incorporating localization.

Implementing Globalization
The System.Globalization namespace provides different classes that enable you to determine locale-specific information, such as te language and country of an application at run time. The System.Globalization namespace includes classes that enable you to localize your application. For example, the Calendar class contains different calendars, such as JulianCalendar and GrgorianCalendar.

Using the CultureInfo Class
Every locale is identified by a culture. The general format of the culture is as follows:

Language code : Represents a two-letter representation of a language. It is always written in lowercase. For example, the language code for Arabic is "ar" and that for Russian is "ru".
Country/Region code : Represents a two-letter representation of a country or a region. It is always written in uppercase. For example, the country code for Russia is "RU" and that for France is "FR".

Cultures are of two types:

Neutral culture : Signifies a culture that is linked only to a language and not to a country. For example, "ru" is a neutral code.
Specific culture : Signifies a culture that is linked to both a country and a language. For example, "ru-RU" is a specific code.

Here describes some of the commonly used properties of the CultureInfo class:

CurrentCulture - Returns an instance of the CultureInfo class that represents the culture for the current thread

CurrentUICulture - Returns an instance of CultureInfo class that represents the culture for culture-specific resources.

DisplayName - Returns the name of the culture in format: <Language code>-<country/region code>

EnglishName - Returns the English name of the culture in f<Language code>-<country/region code> format

Name - Returns the name of the culture in <Language code>-<country/region code> format

LCID - Returns the culture identifier for the instance of the CultureInfo class. Every culture has an identifier. For e.g., 0x0407 is the identifier for "de-DE" culture

The following table describes some of the commonly used methods of the CultureInfo class:

GetCultures - Returns a list of supported cultures.

GetFormat - Returns an object that represents the format of a specified type. For e.g., this method will return an object representing the format of the date when the specified type is date/time.

The following code snippet shows how to use the CultureInfo class:

CultureInfo my_CI = new CultureInfo ("ru-RU");

In the preceding code snippet, a new CultureInfo class instance by the name, my_CI, is created that sets the culture of the instance to "ru-RU".

Working with Resources
A resource is any non-executable data that is logically deployed with an application. A resource might be displayed in an application as an error message or as a part of the UI. Examples of resources include the strings displayed in the UI based on the culture settings of the system or a set of images. A separate resource file should be created for each culture for which the application is to be customized. Information is stored in a resource file in the key/value format. For example, to store the welcome message you must assign a the message to a key. Like this:

WelcomeText = "Welcome to my homepage";

In the preceding code snippet, WelcomeText is the key and "Welcome to my homepage" is the value. There are specific naming conventions to follow when naming resource files. The resource file for default culture should be Strings.txt or Strings.ResX, and for any other culture Strings.culture-name.ResX. Where Strings represents the name of the file. For e.g., Strings.fr-CA.resx. After resource files are created in the text form, they need to be converted into a binary format recognized by the .NET Framework.

Generating Resource File
You can use the Resource File Generator (ResGen.exe) command prompt utility to convert a resource file in the text format into the binary format. The syntax is as follows:

resgen [/compile] [inputfilename.extension] [outputfilename.extension]

The extension of the input filename will be .resource.

Creating Resource-Only Assemblies
To create a resource-only assembly, perform the following steps:

Create a new Visual C# project with the Empty Project template.
From the Project menu, select the Add Existing Item option to add the resources files to the project.
In Solution Explorer, right-click your project and select the Properties option. The property page opens.
In the Output Type drop-down menu, change the output type of your project to class Library. This will cause your assembly to be compiled as a .dll file.
Build you application.

The output will be a DLL file, which will contain all the resource files you added.

Creating Satellite Assemblies
Satellite assemblies are resource-only assemblies that contain only culture-specific resources. The name of the resources included in a satellite assembly should follow this naming convention:

Filename.culture-subculture.resource
The name of a resource file included within a satellite assembly should reflect the culture to which it belongs. All applications will contain one culture-neutral main assembly, which will be loaded by default when a request is sent to the application. The relationship between the main assembly and the satellite assembly under the Windows platform follows a hub-and-spoke model. When a Web application is deployed, the main assembly is always copied in the bin folder in the application root. Satellite assemblies are copied into the subfolders beneath the bin folder in the application root. Satellite assemblies are copied into the subfolders beneath the bin folder based on their culture. For example, the satellite assembly for the culture, fr, will be copied into the bin\fr folder and that for the culture, fr-CA, will be copied into the bin\fr\CA folder.

Perform the following steps to create a satellite assembly:

Open the Web application to which you need to add resource files.
From the project menu, select the Add existing Item option to add the resource files to your application. Resource files should be named according to the naming conventions.
From the Build menu, select the Build solution option to build your solution.
Culture-specific resource files are automatically compiled into satellite assemblies and placed in an appropriate directory structure.

The difference between resource-only and satellite assemblies is that resource-only assemblies can contain any resource, such as images and text. Satellite assemblies contain only culture-specific resources.

You can also use the AL.exe utility to link resource files to your application. The AL (Assembly Linker) is a command prompt utility shipped with the standard version of Visual Studio .NET.

Retrieving Resources at Run Time
The System.Resources namespace provides different classes, which enable you to retrieve values from resource files. This namespace contains the ResourceManager class which manages all the resources associated with an application.

ResourceManager Class
It can be used to retrieve resources from an assembly. Each instance of the ResourceManager class is associated with an assembly that contains the resources. This class provides different constructors that can be used according to the need. For example, when you need to retrieve resources from an assembly, use the ResourceManager constructor, which has the following syntax:

ResourceManager ( "BaseName" , "Assembly Name", Type)

In the preceding syntax:

BaseName : Represents the root name of the resource.
Assembly Name : Represents the name of the assembly, which contains the resource.
Type : Represents the ResourceSet, which is the set of resources for a specific culture. The resources associated with each culture have a ResourceSet associated with them.

If the resources are stored in a folder instead of an assembly, you can use the FileBasedResourceManager function of the ResourceManager class. This function takes the following three parameters:

BaseName : Represents the root of the resource
ResourceDir : Represents the folder in which the resource is to be searched.
Type : Represents the ResourceSet.

The other important classes in the System.Resources namespace are:

ResourceWriter : Used to write into a resource file.
ResourceReader : Used to read form a resource file.

Configuring a Web application for Globalization
In ASP.NET, you can use the Web.config file to configure an application for globalization. The <globalization> tag enables you to configure locale-specific information, such as culture and encoding. The <globalization> tag has the following attributes:

requestEncoding : Allows you to specify the assumed encoding of incoming requests. The default value of this attribute is utf-8.
responseEncoding : Allows you to specify the encoding used for the response data. The default value is utf-8.
fileEncoding : Allows you to specify the way in which the .aspx, .asmx, .asax files are encoded in a Web application. The default value is utf-8.
culture : Allows you to specify the culture.
uiCulture : Allows you to specify the UI culture.

The following code snippet shows an example of how to use the <globalization> tag to configure a Web application:

Example
Here we will be creating an ASP.NET application that is locale-aware. For simplicity sake we our only creating it for 2 cultures, although its just the repetition of steps that would be required if you wish to implement using more cultures.

Our application will have an user interface with a drop down list from where the user can select the culture of his choice and then the Text values of the controls would be as per the selected culture.

Solution:
Perform the following steps for the same:

Create a new Web application and I have named it "globalization" as per this example.
Change the name of the Webform1.aspx to culture.aspx.
Design the culture form. Drag two label controls, a dropdownlist and a button.
Create two resource Files. For this right-click the project file and select the Add->New folder. Rename this folder as Resources.
Now add new items to this project, select resource assembly file from the template pane. Rename it as strings.resx.
In the name column write "msg" and in the value column write "Welcome to my homepage", in this strings.resx file. Save this file and close it.
Drag this file to the "Resources" folder from the solution explorer.
Similarly add another .resx file, remember to use the culture convention of renaming it. We will be renaming it for France culture so, the it would be renamed as "strings.fr-FR.resx".
Now we need to generate strings.Resources file and strings.fr-FR.resources file.For this go to the command prompt of Visual Studio .NET (go to start->all programs->Microsoft Visual Studio .net 2003->Visual Studio .net tools->Microsoft Visual Studio .net command prompt)
Type the following command there: resgen strings.resx
You will need to navigate to the "Resources" folder using " cd " command of DOS, since you have this .resx file in Resources folder.
Do this for all your .resx files and their respective .resources files would be generated, as shown in the figure below:

You can see these files in your Resources folder of your application as shown in the figure.

The main code performing this functionality is given below.

private void Page_Load(object sender, System.EventArgs e)
{
System.Resources.ResourceManager rm =ResourceManager.CreateFileBasedResourceManager( "strings", Server.MapPath("Resources")+Path.DirectorySeparatorChar , null);
string a = Session["lang"].ToString ();
CultureInfo cinfo=new CultureInfo(a);
lblmsg.Text=rm.GetString ("msg",cinfo);
}

Here Session["lang"] is assigned the value of the selected item form the drop down list, that contains the available cultures for the site.

The first output screen looks like this:

When you select any culture, the message is displayed in that particular culture as provided by you in the .resx files.

Summary
I have tried to cover some important aspects of implementing Globalization in ASP.NET 2.0. I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

Source : www.beansoftware.com

HTTP Handlers and HTTP Modules in ASP.NET

2010-02-02T14:34:00.000+05:30

Introduction
Web servers serve resources that have been put on the Internet and provide other services like security, logging, etc. At the beginning of the Internet era, client's needs were very limited; .htm files were often satisfactory. As time passed, however, client's requirements extended beyond the functionality contained in .htm files or static files.

Developers needed a way to extend or complement the functionality of Web servers. Web server vendors devised different solutions, but they all followed a common theme. All Web server complement technologies allowed developers to create and plug in components for enhancing Web server functionality. Microsoft came up with ISAPI (Internet Service Application Programming Interface).

ISAPI is an important technology that allows us to enhance the capabilities of an ISAPI-compliant Web server (IIS is an ISAPI-compliant Web server). The following components serve this purpose:

ISAPI Extensions
ISAPI Filters

ISAPI extensions are implemented by using Win32 DLLs. You can think of an ISAPI extension as a normal application. ISAPI extensions are the target of http requests. That means you must call them to activate them.

ISAPI filter as just that: a filter. It sits between your Web server and the client. Every time a client makes a request to the server, it passes through the filter. Clients do not specifically target the filter in their requests, rather, clients simply send requests to the Web server, and then the Web server passes that request to the interested filters. Filters can then modify the request, perform some logging operations, etc.

ASP.NET Request Processing

ASP.NET request processing is based on a pipeline model in which ASP.NET passes http requests to all the modules in the pipeline. Each module receives the http request and has full control over it. The module can play with the request in any way it sees fit. Once the request passes through all of the HTTP modules, it is eventually served by an HTTP handler. The HTTP handler performs some processing on it, and the result again passes through the HTTP modules in the pipeline.

The following figure describes this flow.

During the processing of an http request, only one HTTP handler will be called, whereas more than one HTTP modules can be called.

Http Handlers

HTTP handlers are the .NET components that implement the System.Web.IHttpHandler interface. Any class that implements the IHttpHandler interface can act as a target for the incoming HTTP requests. HTTP handlers are somewhat similar to ISAPI extensions. One difference between HTTP handlers and ISAPI extensions is that HTTP handlers can be called directly by using their file name in the URL, similar to ISAPI extensions.

These classes can be mapped to http requests by using the web.config or machine.config file. Once that is done, ASP.NET will instantiate http handler whenever the corresponding request comes in. ASP.NET also supports the creation of http handlers by means of the IHttpHandlerFactory interface. ASP.NET provides the capability of routing http requests to an object of the class that implements the IHttpHandlerFactory interface.

Registering HTTP Handlers in Configuration Files

ASP.NET maintains its configuration information in the following configuration files:

machine.config
web.config

machine.config file contains the configuration settings that apply to all the Web applications installed on that box.

web.config file is specific to each Web application. Each Web application can have its own web.config file. Any sub directory of a Web application may have its own web.config file; this allows them to override the settings imposed by the parent directories.Here is a generic example of adding an HTTP handler:

In the above XML,

The verb attribute specifies the HTTP verbs supported by the handler. If the handler supports all of the HTTP verbs, simply use "*", otherwise list the supported verbs in a comma separated list. So if your handler supports only HTTP GET and POST, then verb attribute will be "GET, POST".
The path attribute specifies the path or wildcard specification of the files for which this handler will be invoked. For example, if you want your handler to be called only when test.xyz file is requested, then the path attribute will contain "test.xyz"; similarly if you want your handler called for any file having .xyz extension, the path attribute will contain "*.xyz".
The type attribute specifies the actual type of the handler or handler factory in the form of a combination of namespace, class name and assembly name. ASP.NET runtime first searches the assembly DLL in the application's bin directory and then searches in the Global Assembly Cache (GAC).

Use of HTTP Handlers by the ASP.NET Runtime

Believe it or not, ASP.NET uses HTTP handlers for implementing a lot of its own functionality. ASP.NET uses handlers for processing .aspx, .asmx, .soap and other ASP.NET files.

The following is the snippet from the machine.config file:

Implementing HTTP Handlers
Steps involved in implementing our HTTP handler are as follows:

Write a class which implements IHttpHandler interface
Register this handler in web.config or machine.config file.
Map the file extension(.htm) to ASP.NET ISAPI extension DLL (aspnet_isapi.dll) in Internet Services Manager.

Step1

Create a new C# Class Library project in Visual Studio.NET and name it "MyHandler". Visual Studio.NET will automatically add a class named "Class1.cs" into the project. Rename it "NewHandler"; open this class in the code window and change the class name and constructor name to "NewHandler".

The following is the code for the NewHandler class.

Let's compile it and place it in the bin directory of the webapp virtual directory.

Step 2

Step 3

Since we are creating a handler for handling files of a new extension, we also need to tell IIS about this extension and map it to ASP.NET. If we don't perform this step and try to access the Hello.htm file, IIS will simply return the file rather than pass it to ASP.NET runtime. As a consequence, the HTTP handler will not be called.

Launch the Internet Services Manager tool, right click on Default Web Site, select Properties, go to Home Directory tab and press Configuration button. This will popup Application Configuration dialog. Click Add button and fill the Executable field with the path to the aspnet_isapi.dll file and fill .htm in the Extension field. Leave the other fields as is; the dialog box should look as follows:

Close the Application Configuration and Default Web Site Properties dialog boxes by pressing the OK button.

Now we are good to go. Launch Internet Explorer and go to the following url:

http://localhost/webapp/hello.htm

You should see the following page:

Session State in HTTP Handlers

Maintaining session state is one of the most common tasks that Web applications perform. HTTP handlers also need to have access to the session state. But session state is not enabled by default for HTTP handlers. In order to read and/or write session data, HTTP handlers are required to implement one of the following interfaces:

IRequiresSessionState
IReadOnlySessionState.

An HTTP handler should implement the IRequiresSessionState interface when it requires read-write access to the session data. If a handler only needs read access to session data, then it should only implement the IReadOnlySessionState interface.

Both of these interfaces are just marker interfaces and do not contain any methods. So if we want to enable session state for our NewHandler handler, then declare the NewHandler class as followed:

public class NewHandler : IHttpHandler, IRequiresSessionState

HTTP Modules

HTTP modules are .NET components that implement the System.Web.IHttpModule interface. These components plug themselves into the ASP.NET request processing pipeline by registering themselves for certain events. Whenever those events occur, ASP.NET invokes the interested HTTP modules so that the modules can play with the request.

There are four more events that we can use. These events are as follows:

Application_OnStart : This event is raised when the very first request arrives to the Web application.
Application_OnEnd : This event is raised just before the application is going to terminate.
Session_OnStart : This event is raised for the very first request of the user's session.
Session_OnEnd : This event is raised when the session is abandoned or expired.

Registering HTTP Modules in Configuration Files

Once an HTTP module is built and copied into the bin directory of our Web application or copied into the Global Assembly Cache, then we will register it in either the web.config or machine.config file.

Since configuration settings are inheritable, the child directories inherit configuration settings of the parent directory. As a consequence, child directories might inherit some unwanted HTTP modules as part of the parent configuration; therefore, we need a way to remove those unwanted modules. We can use the remove node for this.

If we want to remove all of the inherited HTTP modules from our application, we can use the clear node. The following is a generic example of adding an HTTP module:

The following is a generic example of removing an HTTP module from your application.

In the above XML,

The type attribute specifies the actual type of the HTTP module in the form of class and assembly name.
The name attribute specifies the friendly name for the module. This is the name that will be used by other applications for identifying the HTTP module.

Use of HTTP Modules by the ASP.NET Runtime

ASP.NET runtime uses HTTP modules for implementing some special features. The following snippet from the machine.config file shows the HTTP modules installed by the ASP.NET runtime.

All of the above HTTP modules are used by ASP.NET to provide services like authentication and authorization, session management and output caching. Since these modules have been registered in machine.config file, these modules are automatically available to all of the Web applications.

Implementing an HTTP Module for Providing Security Services

Our HTTP module will basically provide a custom authentication service. It will receive authentication credentials in HTTP request and will determine whether those credentials are valid. Through the User.Identity object, it will associate those roles that are accessible to our Web application pages to the user's identity. Following is the code of our HTTP module.

Now let's see this authentication mechanism in action. Currently we are only allowing the following users to log in to our system:

User id = Admin, Password = Admin123, Role = Administrator
User id = Main, Password = Main123, Role = User

Note that user id and password are case-sensitive.

First try logging-in without providing credentials. Go to http://localhost/webapp2/index.aspx and you should see the following message.

Now try logging-in with the user id "Admin" and password "Admin123". Go to http://localhost/webapp2/index.aspx?userid=Admin&password=Admin123 and you should see the following welcome message.

Now try to log-in with the user id "Main" and password "Main123". Go to http://localhost/webapp2/index.aspx?userid=Mansoor&password=mas and you should see the following welcome page.

Now try to log-in with the wrong combination of user id and password. Go to http://localhost/webapp2/index.aspx?userid=Main&password=xyz and you should see the following error message.

This shows our security module in action. You can generalize this security module by using database-access code in the AuthenticateAndGetRoles method. To specify this, change the authentication node in web.config file of webapp2 to look like this:

Similarly, don't allow anonymous users to our Web site. Add the following to web.config file:

Users should at least have anonymous access to the file that they will use for providing credentials. Use the following configuration setting in the web.config file for specifying index.aspx as the only anonymously accessible file:

Conclusion

As you might have realized with HTTP handlers and modules, ASP.NET has put a lot of power in the hands of developers. I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

What's New in ASP.NET 3.5?

2010-01-21T15:14:00.000+05:30

If you are not ready to upgrade your existing ASP.NET 2.0 applications to ASP.NET 3.5, you will want to upgrade to Visual Studio 2008 because of all its Web development-friendly new features, including full support for ASP.NET 2.0 development. You can maintain and improve your ASP.NET 2.0 applications with Visual Studio 2008.

The changes in ASP.NET 3.5 as one of two categories: ASP.NET 3.5 specific features and ASP.NET-related Visual Studio 2008 enhancements such as nested master page support.

Review these new ASP.NET 3.5 specific features:

The ListView control
The DataPager control
The LinqDataSource
Integrated AJAX support
Improved designer support for AJAX control extenders

Review these new ASP.NET 3.5-related Visual Studio 2008 enhancements:

Nested Master Page support
Multi-Framework Targeting
Enhanced Web design experience
JavaScript IntelliSense
JavaScript debugging
CSS Properties window
Manage Styles tool window

Microsoft paid particular attention to making sure that .NET 3.5 is a smooth upgrade from .NET 2.0 with a goal of not requiring you to modify any existing code when moving your code to .NET 3.5. Another piece of good news is that there are no project model changes with Visual Studio 2008. When building new ASP.NET applications you can choose from the Web Site or Web Application project models and select the .

ASP.NET 3.5 Specific Features
First discuss a couple new controls added to ASP.NET 3.5, starting with the ListView and the DataPager.

The ListView Control
You could have an ASP.NET control with the free form templating capabilities of the Repeater control and the data editing capabilities of the DataGrid control. Imagine no more because that control exists in ASP.NET 3.5—the new control.

The ListView supports data binding to all the traditional data sources such as SQLDataSource, ObjectDataSource, XMLDataSource as well as the new LinqDataSource.

You have complete control of how the ListView presents your data through the use of 11 templates.

LayoutTemplate
AlternatingItemTemplate
EditItemTemplate
EmptyDataTemplate
EmptyItemTemplate
GroupTemplate
GroupSeparatorTemplate
InsertItemTemplate
ItemTemplate
ItemSeparatorTemplate
SelectedItemTemplate

The two most important templates are the LayoutTemplate and the ItemTemplate. The LayoutTemplate is the outer shell containing the HTML that defines the overall look and feel of the control while the ItemTemplate contains the HTML that specifies how each bound record will appear.

Simple example to an example complete with the ability to insert, update, and delete data. I used the ListView's smart tag option to configure the data capabilities as well as the look and feel I wanted for this sample. The result is a ListView complete with the templates that control the formatting for adding, updating, and deleting records in the ListView.

Configure ListView: Select Configure ListView for ListView configuration options.

ListView Configuration Options: The options include selecting a layout, style, data updating options, and paging.

The ListView control does not support paging, but that is not a problem because it does work hand-in-hand with the new DataPager control.

The DataPager Control
The control provides paging capabilities. It is an external control that points at the control it provides paging support for. As an external control, you gain the advantage of being able to place it anywhere on the page and configuring what it is going to look like. The DataPager works with controls that implement the IPageableItemContainer interface. At the moment, the DataPager only works with the new ListView control because it's the only one that implements the IPageableItemContainer interface.

The DataPager's PageControlID specifies which control the DataPager will provide paging support.The PageSize setting determines how many rows of data will be displayed on each page. There are three different types of field controls available, NextPreviousPagerField, NumericPagerField, and TemplatePagerField.

DataPager with Paging Options: Here's a Web page utilizing the DataPager control and the NextPreviousPagerField and NumericPagerField options.

The NextPreviousPagerField provides an interface for users to move from page to page or jump to the first or last page.The NumericPagerField provides an interface for users to select a page by page number. The TemplatePagerField provides a mechanism for you to develop a custom paging interface.

NextPreviousPagerField: The figure shows the process of adding the NextPreviousPagerField in the Source window.

NumericPagerField: Here's how you add a NumericPagerField in the Source window.

The LinqDataSource Control
The control is an ASP.NET control that, like the and controls, is used to declaratively bind ASP.NET controls to a data source. What makes the LinqDataSource unique is that instead of binding directly to something such as a database or data access layer object, which you can still do, you bind to a LINQ-friendly data model such as a LINQ to SQL object relational model (ORM).

Integrated AJAX Support
Back in the day before Microsoft released ASP.NET 3.5, you had to download and install the Microsoft ASP.NET AJAX 1.0 framework to build or deploy an AJAX-enabled application. But those days are gone now, because AJAX is now treated as a first-class citizen in Visual Studio and the libraries are now included in .NET 3.5. When you build a new Web site, you no longer need to specify an AJAX-ready Visual Studio project template.

No AJAX Templates: The new Web site dialog box does not contain AJAX-specific templates.

Improved Designer Support for AJAX Control Extenders
AJAX control extenders provide a way to add capabilities and functionality to controls already on a page. The ASP.NET AJAX Control Toolkit is a great community-driven collection of free control extenders that you can use to easily add AJAX functionality to your pages.

With Visual Studio 2005, you had to manually wire up the controls with the extender control you wanted to use. Visual Studio 2008's improved designer support for ASP.NET AJAX control extenders has made the process much easier by providing Smart Tag options to add or remove extenders from a particular control. When Visual Studio 2008 detects that one or more extenders exist for the control you have selected it will display the control's Smart Tag. Selecting Add Extender will display the Extender Wizard for you to select which extender you would like to use.

Add Extenders: When Visual Studio 2008 detects extenders are present for a control, Add Extender is added to the Smart Tag options.

Selecting Extenders: You can select an extender for a specific control type.

ASP.NET 3.5-Related Visual Studio 2008 Enhancements
The Visual Studio 2008 IDE has been enhanced to improve your productivity when developing Web applications.

Nested Master Pages Support
Visual Studio 2005 didn't really support nested master pages. The problem was that pages based on master pages could not be edited within the Visual Studio 2005 designer. Microsoft has corrected this behavior with Visual Studio 2008.

Nested Master Page Template: The Nested Master Page template has been added to the Add New Item dialog box.

The process for creating a nested master page is slightly different depending on which project model you are using: Web Site or Web Application Project. Use a project based on the Web Application Project model for this example. Add a new item to a project and select the Nested Master Page template and enter a name for the nested master. Next, need to select the master page I want to base my nested master page on.

Select Master: Select the master template you wish to base your nested master page on.

The process for creating a new page from a nested master page is the same as it was in ASP.NET 2.0. The good news is that now you can work with the new nested master page based in the WYSIWYG Designer in Visual Studio 2008.

Multi-Framework Targeting
When you open an existing project, or create a new one, you are given the option to select which framework version you want to target. The Visual Studio 2008 IDE will adjust itself to your framework selection and only offer features, options, controls, templates, and assemblies, among other things, based on the targeted framework. This includes automatically updating the assemblies referenced in your project and sections in the Web.config file.

Target Framework Version: You can target a specific framework version when creating a new Web site.

One of the benefits of the multi-framework targeting support is that all the new features added to Visual Studio 2008, such as nested master page support, enhanced JavaScript support, and the HTML editor enhancements, are available to you as you continue to work on and support your ASP.NET 2.0-based Web sites.

The process of specifying which version of the .NET Framework to target for an existing project depends on which project model you are using and unfortunately, which language you are using. If you are using the Web Site project model, regardless of the language selected, select the Build option on the project Property Pages and select the framework you want to target from the dropdown.

Target Framework from Project Properties: For existing Web site projects you can specify the target framework from the project properties.

If you are using the Web Application project model, here is where things get interesting. For projects written in C#, things are simple. Open the project properties and select the framework you wish to target on the Application tab.

Targeting Framework in C#: For C# Web application projects you can specify the target framework from the Application tab on the Property Pages.

For Visual Basic projects created with the Web Application Projects model, open the project properties, select the Compile tab, and click the Advanced Compile Options button. Select the framework from the Target framework dropdown.

Targeting Framework in VB: For Visual Basic Web application projects you can specify the target framework on the Advanced Compiler Settings dialog box.

Enhanced Web Designer
The Split View feature displays the Design View and the HTML source in two different panes at the same time. While in Split View, changes you make in the Design pane automatically updates the source in the HTML pane. You would expect that changes you make in the HTML source pane would automatically be reflected in the Design pane, right? Wrong. You need to either save the page or click the button displayed at the top of the Design pane to synchronize the two panes.

Split Pane: The Split pane enables you to see the HTML source and Design surface at the same time.

By default, the two panes are split horizontally with the HTML pane on top and the Design pane on the bottom. To display the two panes side-by-side, from the Tools menu select Options, make sure "Show All Settings" is checked, drill into the HTML Designer option, select General, and check the Split views vertically option.

Split Pane View Options: You can specify a vertical or horizontal display for the Split pane.

While you view the Options dialog box, let me point out a nice addition made to Visual Studio 2008. Select the Text Editor option, drill into the HTML option and select the Validation option. Right out of the box, Visual Studio 2008 is configured to display those pesky HTML, CSS, and JavaScript errors as warnings instead of errors.

HTML/CSS Error Options: Select the option for HTML and CSS warnings to stop getting them listed as errors.

JavaScript IntelliSense
Visual Studio 2008's built-in support for JavaScript IntelliSense.this makes such a difference writing JavaScript code in Visual Studio 2005 versus Visual Studio 2008. Being able to select JavaScript keywords and language features from an IntelliSense list makes building AJAX applications so much easier.

JavaScript Intellisense: IntelliSense displays JavaScript keywords and types.

You just need to declare an external JavaScript reference either manually or by dragging the .js file into the tag and IntelliSense picks up on the functions contained in the external library.

Intellisense for External JavaScript Libraries: IntelliSense picks up the members of an external JavaScript library.

JavaScript Debugging
Microsoft dramatically improved this situation because you can now set breakpoints in your JavaScript code located in regular ASP.NET pages (.aspx), external code files (.js), and in your master pages (.master).

JavaScript Breakpoints: You can set breakpoints in your JavaScript code.

In addition, you can now set breakpoints in your client-side JavaScript code and your server-side Visual Basic or C# code on the same page and utilize a single debugger session to step though all the code.

JavaScript Debugging: The runtime debugger displaying a JavaScript breakpoint.

One of the most significant additions to the JavaScript debugging experience is the improved object inspection support, which provides more detailed object property and property type information.

JavaScript Object Inspector: JavaScript object inspection has been improved.

CSS Properties Window
The new CSS Properties window makes keeping track and changing CSS values quick and easy.

CSS Properties Window: The CSS Properties window displays all the CSS properties for the selected item.

Manage Styles Window
It helps you visually manage the CSS styles used on the page you are currently working with in both Design and Source view. You will find it on the View menu, just after the CSS Properties menu option. When an item is circled it means that rule is currently used somewhere on the current page. Hover over a style to display the rule values for that rule. Select a rule and you'll see a preview of its appearance in the Selected Style Preview section at the bottom of the Manage Styles window. Double-click on a rule to open the style sheet in which it resides.

Manage Styles Window: The Manage Styles window displays all the styles in a CSS file and indicates which elements are in use.

At the top of the Manage Styles window you will see an option to create new styles and an option to load an additional style sheet into the Manage Styles window if your project utilizes more than a single style sheet. You can click the Options button to display a number of display options.

CSS Options: The Options button provides categorizing and display options for the CSS elements.

Summary
All these new features in ASP.NET 3.5 and Visual Studio 2008 should peak your interest and the coverage here should help jumpstart your learning process. I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

Difference Between MVP and MVC

2010-01-20T12:38:00.000+05:30

If we would compare the diagrams of MVP and MVC patterns

We could see that MVP design pattern implementation has a view totally unaware of model. Presenter is the one exclusively communicating with the model and sending DTO to model or performing direct manipulation with the view UI elements.

On the other hand, in MVC we have next two "read data" cases:

A view reading data directly from model and perform "declarative data binding" of its controls or
controller retrieving data from model, pass that context data to view while loading the appropriate view and view then binds to that sent context data

In most of the "update data" use cases we have a view sending updated context data to controller, where controller performs some validation and/or business logic and updates the model with that data.

Navigation aspects
In general, MVP pattern is based on standard ASP NET page controller pattern implementation, where Page A performs Response.Redirect("PageB") and that results with page B loading with complete page life cycle events fired etc. MVP adds to that sequence just one additional step: injecting the view to presenter.

Beside that "default" ASP NET page controller based implementation, there are various ways how the MVP implementation can be enhanced.

One of them is the utilization of application controller and Page Flow Application Block (which I presented last week on my Web Client Software Factory session) where application controller centralizes flow and navigation concerns and behaves as shared context container for multiple views covering the same use case.

Page flow application block is a block using the NET 3.0 workflow engine enhanced with additional UI designer used in defining navigation flows. The end result is that you have a separate project with workflow definition describing navigation flow use cases. In a way, that is something very similar to the purpose front controller has.

MVP summarized: Navigation is handled on a per page basis using page controller pattern approach.

MVC.NET framework is different - more "web suitable" approach to the same concern of efficient handling navigation. It is based on front controller design pattern driven routing engine, which in general represents intercepting of every http request on a http handler level and checking if there are mapped controller types responsible for handling intercepted Url.

As we can see on first diagram, the flow in MVC starts with controller class and not with web page - view. When controller is been invocated, it usually:

Retrieves some data from model,
Performs business logic and
Picking the appropriate view to which he pass the processed model data
Loads the view - which then renders without the need of complete page life cycle being executed

In a way, that is something similar to what we have in Supervising controller MVP pattern, with a difference that in supervising controller the view (page) is still been loaded first and then the presenter class is been created.

MVC summarized: The navigation is handled in one centralized configurable place for all the pages based on front controller pattern.

I found one thing important enough to be emphasized here: Front controller (routing engine) is a part of Microsoft MVC.NET framework, but that is its separate part and pattern different then MVC pattern.

To illustrate how routing engine is important for MVC framework, I'll just mentioned briefly that I've been working on a POC which was supposed to handle on efficient way the need for having various page UI flavors of the same page - based on multiple business conditions.

I choose to built platform based on MVP pattern where multiple views are sharing the same presenter enhanced with custom routing front controller engine. The end result of this solution based on a front controller + MVP is something which looks very much like what I've seen in MVC.NET framework but just with standard web forms used.

Advantages of the MVP
All you need to develop the presenter is an interface of the view. That interface of the view in passive view version of MVP represents page UI elements, so in a sense it can be considered as page abstraction or even as page contract between the designers and developers.

Passive view is very cumbersome to be implemented and sometimes lead to complex presenters, the advantages of its usage are much higher in standard waterfall development process, because it enables tech leads to translate the Functional Requirement Document requirements right at the beginning of development phase and produce sets of view interfaces.

Communication on relation tech lead->developer is concentrated to the beginning of development phase with very precise set of artifacts defining requirements. Once the interface of the views would be defined and verified as the one matching the Functional Requirement Document requirements, developers are able to start developing their presenters including the unit tests to verify that Functional Requirement Document functional requirements are fulfilled well.

The end result of that activity would be a list of unit tests representing Functional Requirement Document requirements. Percentage of successfully "green" test of that list can be used then to track realistic project progress.

What we get as the end result is:

Totally decoupled and effective working streams of tech lead, developer and designer
Set of artifacts useful in tracking the real project implementation progress and as a guidance to developers what requirements they have to met.

Summary
I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

Model View Presenter (MVP) With ASP.NET

2010-01-11T15:36:00.000+05:30

Introduction of Model View Presenter
Model-View-Presenter (MVP) is a variation of the Model-View-Controller (MVC) pattern but specifically geared towards a page event model such as ASP.NET. MVP was originally used as the framework. The primary differentiate of MVP is that the Presenter implements an Observer design of MVC but the basic ideas of MVC remain the same: the model stores the data, the view shows a representation of the model, and the presenter coordinates communications between the layers. MVP implements an Observer approach with respect to the fact that the Presenter interprets events and performs logic necessary to map those events to the proper commands to manipulate the model.

Example
In this example the client wants a page that shows the current time.The ASPX page that will show the time is the "View." The "Presenter" is responsible for determining the current time and giving the Model to the View.

[TestFixture]
public class CurrentTimePresenterTests
{
    [Test]
    public void TestInitView()
    {
        MockCurrentTimeView view = new MockCurrentTimeView();
        CurrentTimePresenter presenter = new CurrentTimePresenter(view);
        presenter.InitView();

        Assert.IsTrue(view.CurrentTime > DateTime.MinValue);
    }

    private class MockCurrentTimeView : ICurrentTimeView
    {
        public DateTime CurrentTime
        {
            set { currentTime = value; }

            // This getter won't be required by ICurrentTimeView,

            // but it allows us to unit test its value.

            get { return currentTime; }
        }
        private DateTime currentTime = DateTime.MinValue;
    }
}

The above unit test, along with the diagram, describes the elements of the MVP relationship.The very first line creates an instance of MockCurrentTimeView. As seen with this unit test, all of the Presenter logic can be unit tested without having an ASPX page, i.e. the View. All that is needed is an object that implements the View interface; accordingly, a mock view is created that stands in place of the "real" view.

The Presenter can now manipulate the View. As seen in the diagram, the Presenter only talks to a View interface. It does not work with a concrete implementation directly. This allows multiple Views, implementing the same View interface, to be used by the same Presenter.

Finally, the Presenter is asked to InitView(). This method will get the current time and pass it to the View via a public property exposed by ICurrentTimeView. A unit-test assertion is then made that the CurrentTime on the view should now be greater than its initial value. A more detailed assertion could certainly be made if needed.

The View interface
As a first step towards getting the unit test to compile, ICurrentTimeView.cs should be created. This View interface will provide the conduit of communication between the Presenter and the View. In the situation at hand, the View interface needs to expose a public property that the Presenter can use to pass the current time, the Model, to the View.

public interface ICurrentTimeView
{
    DateTime CurrentTime { set; }
}

The View only needs a setter for the current time since it just needs to show the Model, but providing a getter allows CurrentTime to be checked within the unit test. So instead of adding a getter to the interface, it can be added to MockCurrentTimeView and need not be defined in the interface at all. In this way, the exposed properties of the View can be unit tested without forcing extraneous setters/getters to be defined in the View Interface. The described unit test above shows this technique.

The Presenter
The presenter will handle the logic of communicating with the Model and passing Model values to the View. The Presenter, needed to make the unit test compile and pass, is as follows.

public class CurrentTimePresenter
{
    public CurrentTimePresenter(ICurrentTimeView view)
    {
        if (view == null)
            throw new ArgumentNullException("view may not be null");

        this.view = view;
    }

    public void InitView()
    {
        view.CurrentTime = DateTime.Now;
    }

    private ICurrentTimeView view;
}

Once the above items have been developed -- the unit test, the mock view, the view and the presenter -- the unit test will now compile and pass successfully. The next step is creating an ASPX page to act as the real View.

The View
The actual View needs to do the following:

The ASPX page needs to provide a means for displaying the current time. As shown below, a simple label will be used for display.
The code-behind must implement ICurrentTimeView.
The code-behind needs to create the Presenter, passing itself to the Presenter's constructor.
After creating the Presenter, InitView() needs to be called to complete the MVP cycle.

Conclusion
A drawback to the above example is that MVP seems like a lot of work for such little gain. We've gone from having one ASPX page to having a Presenter class, a View interface and a unit testing class. The gain has been the ability to unit test the Presenter, i.e. the ability to conveniently unit test code that would normally be found in the code-behind page. The advantages of MVP shine when developing and maintaining enterprise web applications, not when writing "hello world"-like samples.

ASP.NET 2.0 TreeView Control

2009-12-29T10:50:00.000+05:30

Introduction of Tree View Control
ASP.NET 2.0 introduces a new control named TreeView that provides a seamless way to consume information from hierarchical data sources such as an XML file and then display that information. You can use the TreeView control to display information from a wide variety of data sources such as an XML file, site-map file, string, or from a database. In this article, we will discuss this new control in depth and understand how to use this feature rich control in your ASP.NET applications. Apart from statically data binding the TreeView control with the contents of an XML file, we will also demonstrate how to populate this control dynamically by adding nodes at runtime. Finally, we will see how to apply XSL transformation on XML data before displaying that information in a TreeView control.

Hierarchical Data
One of the important ways of organizing data which now pervades IT is hierarchical data. ASP.NET has a series of controls that make it both easy and logical to utilize hierarchical data. TreeView is one of the important controls that can be easily bound to data source controls such as SiteMapDataSource, XmlDataSource to display hierarchical information. Before we go onto take a look at the TreeView, let us understand the common types of hierarchical data.

Folders - The way folders are structured in a Windows file system denotes a hierarchical way of storing data.
XML - XML documents are self-describing meaning that the metadata that is required to qualify the data is actually contained in the XML document itself providing a flexible way of handling XML data.
SiteMap - Sitemap is nothing but an XML format that provides a consistent way of describing the navigation structure of a web site including all the pages contained in that web site.
Menu system - A menu system can also use an XML document as its input and displays the contents of the XML document in a hierarchical manner.
XmlDataSource - This control allows you to bind to XML data, which can come from a variety of sources such as an external XML file, a DataSet object and so on. Once the XML data is bound to the XmlDataSource control, this control can then act as a source of data for other data-bound controls such as TreeView and Menu. For example, you can use the asp:XmlDataSource control to represent a hierarchical XML data source.
SiteMapDataSource - This control basically retrieves the site map information from the web.sitemap file.

The architecture of TreeView control is very similar to the design of controls for tabular data. It is data bound to any of the above hierarchical data source controls to display the information.

TreeView Control
The ASP.NET 2.0 TreeView control is a completely new control introduced with ASP.NET 2.0 that is available under the Standard tab in the Toolbox. You can use the TreeView control in any situation in which you need to display hierarchical data. For example, you can use this control when displaying a navigation menu, displaying database records from database tables in a Master/Detail relation, displaying the contents of an XML document, or displaying files and folders from the file system. It is also possible for you to programmatically access the TreeView object model to dynamically create trees, populate nodes, set properties and so on. The TreeView control consists of nodes and there are three types of nodes that you can add to a TreeView control.

Root - A root node is a node that has no parent node. It has one or more child nodes.
Parent - A node that has a parent node and one or more child nodes
Leaf - A node that has no child nodes

The easiest way to use the TreeView control is to specify a static set of tree nodes. For example, you can use the TreeView control to display a simple navigational menu for a Web site. Or, you can use the TreeView control to display the table of contents for a help file.

You specify the appearance of a static TreeView control by declaring one or more TreeNode controls within the TreeView control's [Nodes] tag. The following code demonstrates how to declare a TreeView control and a root node.

As you can see in the above code, the root node is declared using the asp:TreeNode inside the Nodes element. Each node has a Text and a Value property. The value of the Text property is displayed in the TreeView, while the Value property is used to store any additional data about the node, such as data passed to the post back event associated with the node. The text displayed through a node can be in one of two modes: selection mode and navigation mode. By default, a node is in selection mode. To put a node into navigation mode, you can set the node's NavigateUrl property to a value other than an empty string ("").

Customizing the Appearance of the TreeView Control
The TreeView control provides ImageUrl properties such as RootNodeImageUrl, ParentNodeImageUrl, and LeafNodeImageUrl. These custom images are rendered to the left of the node's text. You can override the default image for the node type using the ImageUrl property. The TreeView control also provides CollapseImageUrl and ExpandImageUrl properties for the expanded and collapsed indicators. These are usually represented by plus and minus icons. There is also a property named NoExpandImageUrl that can be used for rendering an image for nodes which have no children. You can turn off the default image using the ShowExpandCollapseboolean property.

In addition to custom images, the TreeView control also supports TreeNodeStyle properties for each node types. These style properties override the NodeStyle property, which applies to all node types. A node can also have a different style applied when it is selected. When Selected property is set to true, the node is selected and the SelectedNodeStyle properties overrides any corresponding unselected style properties for the selected node. It is also possible for you to render check boxes between the node and image by setting the ShowCheckBoxes property to a boolean value.

Implementation
Now that we have understood the theory behind the TreeView controls, let us look at the following examples.

How to use the TreeView control to display site navigation structure
How to implement TreeView data binding with an XML file
How to dynamically populate nodes in a TreeView control
How to perform XSL transformation on XML data before displaying that information through a TreeView control

Let us start our implementation by discussing the first example in the above list.

Using the TreeView Control to Display Site Navigation Structure
In this example, we will use the TreeView control to display hierarchical information about the site structure using the contents of the web.sitemap file. In the web.sitemap file, you specify the list of nodes that specify the navigation structure of the site, which can be completely independent of the site folder layout or other structure. When a SiteMapDataSource is placed on the page, it will specifically look for a file with that name and then read the contents of the web.sitemap file and consume that information. Once the information is available in the data source control, you can then bind a TreeView control to the data source control to display that information in the web page.

Fire up Visual Studio 2005 and create a new ASP.NET Web Site named TreeView by selecting New Web Site from the File menu. In the New Web Site dialog box, click the Browse button and select Local IIS as the location and click Open. In the New Web Site dialog box, enter http://localhost/MyProjects/15Seconds/TreeView as the location of the web site. Then click OK.

Once the project is created, add a web.sitemap file by selecting Add New Item from the Web Site menu. In the Add New Item dialog box, select Site Map and click Add. This will result in a new file named web.sitemap being added to the web site.

Modify the code in the web.sitemap file to look as shown below.

Now that we have the web.sitemap file created, let us create a new ASP.NET Web Form and name it as SiteNavigation.aspx. To the newly added web form, add a TreeView and SiteMapDataSource controls to it. Set the ExpandImageUrl and CollapseImageUrl properties of the TreeView control to "Images/closed.gif" and "Images/open.gif" respectively. Then set the DataSourceID property of the TreeView to the ID of the SiteMapDataSource control we added earlier. After modification, the code should look like the following.

When you execute the above code, you will see an output that is somewhat similar to the following screenshot.

The advantage of using the TreeView control with a SiteMapDataSource is that Web site navigation information can be maintained in a central location. The default provider for the SiteMapDataSource control is the XmlSiteMapProvider, which retrieves site navigation information from the web.sitemap file. Note that the web.sitemap file must always appear in the root directory of your ASP.NET application.

Implementing TreeView Data Binding with an XML File
In this example, we will bind the TreeView control to an XML file. To accomplish this, you need to go through the following two steps.

Add an XmlDataSource control to the page and set its DataFile property to the name of the XML File
Then add a TreeView control and set its DataSourceID property to the ID of the XmlDataSource control.
Then map the nodes and their attributes in the XML file to the TreeView nodes by declaring the asp:TreeNodeBinding elements as part of the TreeView declaration.

For the purposes of this example, let us create an XML file named Categories.xml that looks like the following.

Once the XML file is created, create a new Web Form named TreeViewDataBinding.aspx and modify its code to look like the following.

The above code listing contains a TreeView control that is bound to an XML file through an XmlDataSource control. This is accomplished by setting the DataSourceID property of the TreeView control to the XmlDataSource control. The TreeView associates properties of individual TreeNode objects to attributes of XML nodes in the hierarchy. When you perform data binding, attributes in the individual XML elements are promoted to properties of the data item. Also note that the TreeView hierarchy exactly matches the hierarchy of the source XML. Because of this, you normally construct the XML specifically for binding to the TreeView.

Executing the above code results in the following output.

Now that we have understood how to statically bind an XML file to a TreeView control, let us now understand the steps involved in dynamically populating the treeview control with contents from a database.

Dynamically Populating Nodes in the TreeView
You will dynamically populate the nodes in the TreeView with data from the database. The first level of nodes will represent master data — in this case, authors. When users click a node, the child nodes for that author will be created by making a query to the database that fetches all the titles for that particular author. For this example, let us create a new web form named DynamicTreeView.aspx and modify its code to look like as shown below.

The above code consists of two utility methods named FillAuthors and FillTitlesForAuthors, which are used to retrieve the list of authors and the list of titles for a specific author respectively. The FillAuthors method starts by retrieving the connection string from the web.config file by invoking the ConnectionString property of the ConnectionStringSettings class. The connection string is defined in the web.config as shown below.

The above code consists of two utility methods named FillAuthors and FillTitlesForAuthors, which are used to retrieve the list of authors and the list of titles for a specific author respectively. The FillAuthors method starts by retrieving the connection string from the web.config file by invoking the ConnectionString property of the ConnectionStringSettings class. The connection string is defined in the web.config as shown below.

Once the connection string is retrieved, it then creates an instance of the SqlConnection object passing in the connection string as an argument to its constructor. After that it creates SqlCommand, SqlDataAdapter, and DataSet objects. Then it fills the DataSet object with the results of the sql query execution by invoking the Fill method of the DataSet object. Then the code loops through all the rows contained in the DataTable adding them one at a time to the TreeView control. The implementation of the FillTitlesForAuthors is very similar to the FillAuthors method except that it executes a different query in this case. While constructing the query, it also uses the author id value that is retrieved from the currently selected node.

Now that we have had a look at the code for the methods, let us look at the declaration of the TreeView control. The TreeView control associates the OnTreeNodePopulate method with an event handler named Node_Populate. The Node_Populate method simply checks the depth of the node and it is 0, it invokes the FillAuthors method and if it is 1, it invokes the FillTitlesForAuthors method. As part of the TreeView declaration, we also set the PopulateOnDemand property of the asp:TreeNode element to true. This property allows you to indicate that the node will be populated dynamically through the code.

If you execute the above code, you will see the following output.

Transforming XML Data and Displaying that Information in a TreeView Control
It is also possible for you to transform the XML data before it is displayed by the TreeView control. You can do this by setting the TransformFile property of the XmlDataSource control. This is very useful in scenarios when the original XML structure is not suitable for display through the TreeView control. In that case, you can transform the XML data using XSL and then bind that transformed XML to the TreeView control.

As with the XML data, you typically load the style sheet from a file, indicated by the TransformFile property, but you can also use it in string form directly using the Transform property.

For the purposes of this example, we will use the Categories.xml file that we used in our previous example. We will transform the categories.xml file using a Stylesheet named categories.xsl. Code for the categories.xsl file is shown below.

Now that we have created the XSL, let us create a new page that exercises the above XSL. To this end, create a new page named TreeViewXmlTransformation.aspx and modify its code to look like the following.

As you can see from the above code, the ValueField and TextField attributes of the asp:TreeNodeBinding element are set to the new XML element names that are produced by the XML. If you execute the above code, you will see an output that is somewhat similar to the following screenshot.

As you can see from the above screenshot, the root node is shown as categories-list, which is produced as a direct result of the XSL transformation.

Conclusion
In this article, we have understood the features of the new ASP.NET 2.0 TreeView control and how to use that in your web applications. We also demonstrated how to consume the site navigation structure from the web.sitemap and then display that information in a TreeView control. We also discussed the implementation of populating treeview nodes dynamically with the contents from the database. We also understood how to apply XSL transformation on XML data before displaying that information in a TreeView control.

source : www.15seconds.com

WCF Interview questions

2009-12-19T13:44:00.000+05:30

What is WCF?
Windows Communication Foundation (WCF) is an SDK for developing and deploying services on Windows. WCF provides a runtime environment for services, enabling you to expose CLR types as services, and to consume other services as CLR types.

WCF is part of .NET 3.0 and requires .NET 2.0, so it can only run on systems that support it.

What is three major points in WCF?
We Should remember ABC.

Address --- Specifies the location of the service which will be like http://Myserver/MyService.Clients will use this location to communicate with our service.

Binding --- Specifies how the two paries will communicate in term of transport and encoding and protocols

Contract --- Specifies the interface between client and the server.It's a simple interface with some attribute.

Difference between WCF and Web services?

Web Services

1.It Can be accessed only over HTTP
2.It works in stateless environment

WCF

WCF is flexible because its services can be hosted in different types of applications. The following lists several common scenarios for hosting WCF services:

IIS
WAS
Self-hosting
Managed Windows Service

What are various ways of hosting WCF Services?
There are three major ways of hosting a WCF services

1). Self-hosting the service in his own application domain. This we have already covered in the first section. The service comes in to existence when you create the object of Service Host class and the service closes when you call the Close of the Service Host class.

2). Host in application domain or process provided by IIS Server.

3). Host in Application domain and process provided by WAS (Windows Activation Service) Server.

What was the code name for WCF?
The code name of WCF was Indigo .

WCF is a unification of .NET framework communication technologies which unites the following technologies:-

NET remoting
MSMQ
Web services
COM+

What are the main components of WCF?
The main components of WCF are

1. Service class
2. Hosting environment
3. End point

How to deal with operation overloading while exposing the WCF services?
By default overload operations (methods) are not supported in WSDL based operation. However by using Name property of OperationContract attribute, we can deal with operation overloading scenario.

[ServiceContract]

interface ICalculator
{

   [OperationContract(Name = "AddInt")]

   int Add(int arg1,int arg2);

   [OperationContract(Name = "AddDouble")]

   double Add(double arg1,double arg2);

}

What is Transport and Message Reliability?
Transport reliability (such as the one offered by TCP) offers point-to-point guaranteed delivery at the network packet level, as well as guarantees the order of the packets. Transport reliability is not resilient to dropping network connections and a variety of other communication problems.

Message reliability deals with reliability at the message level independent of how many packets are required to deliver the message. Message reliability provides for end-to-end guaranteed delivery and order of messages, regardless of how many intermediaries are involved, and how many network hops are required to deliver the message from the client to the service.

What is Proxy and how to generate proxy for WCF Services?
The proxy is a CLR class that exposes a single CLR interface representing the service contract. The proxy provides the same operations as service's contract, but also has additional methods for managing the proxy life cycle and the connection to the service. The proxy completely encapsulates every aspect of the service: its location, its implementation technology and runtime platform, and the communication transport.

The proxy can be generated using Visual Studio by right clicking Reference and clicking on Add Service Reference. This brings up the Add Service Reference dialog box, where you need to supply the base address of the service (or a base address and a MEX URI) and the namespace to contain the proxy.

Proxy can also be generated by using SvcUtil.exe command-line utility. We need to provide SvcUtil with the HTTP-GET address or the metadata exchange endpoint address and, optionally, with a proxy filename. The default proxy filename is output.cs but you can also use the /out switch to indicate a different name.

SvcUtil http://localhost/MyService/MyService.svc /out:Proxy.cs

When we are hosting in IIS and selecting a port other than port 80 (such as port 88), we must provide that port number as part of the base address:

SvcUtil http://localhost:88/MyService/MyService.svc /out:Proxy.cs

What are contracts in WCF?
In WCF, all services expose contracts. The contract is a platform-neutral and standard way of describing what the service does.

WCF defines four types of contracts.

Service contracts

Describe which operations the client can perform on the service.

There are two types of Service Contracts.

ServiceContract - This attribute is used to define the Interface.
OperationContract - This attribute is used to define the method inside Interface.

[ServiceContract]

interface IMyContract
{

   [OperationContract]

   string MyMethod( );

}

class MyService : IMyContract
{

   public string MyMethod( )

   {

      return "Hello World";

   }

}

Data contracts
Define which data types are passed to and from the service. WCF defines implicit contracts for built-in types such as int and string, but we can easily define explicit opt-in data contracts for custom types.

There are two types of Data Contracts.

DataContract - attribute used to define the class
DataMember - attribute used to define the properties.

[DataContract]

class Contact
{
   [DataMember]

   public string FirstName;

   [DataMember]

   public string LastName;

}

If DataMember attributes are not specified for a properties in the class, that property can't be passed to-from web service.

Fault contracts
Define which errors are raised by the service, and how the service handles and propagates errors to its clients.

Message contracts
Allow the service to interact directly with messages. Message contracts can be typed or untyped, and are useful in interoperability cases and when there is an existing message format we have to comply with.

How to define a service as REST based service in WCF?
WCF 3.5 provides explicit support for RESTful communication using a new binding named WebHttpBinding.

The below code shows how to expose a RESTful service

[ServiceContract]

interface IStock
{

[OperationContract]

[WebGet]

int GetStock(string StockId);

}

By adding the WebGetAttribute, we can define a service as REST based service that can be accessible using HTTP GET operation.

Where we can host WCF services?
Every WCF services must be hosted somewhere. There are three ways of hosting WCF services.

They are

1. IIS
2. Self Hosting
3. WAS (Windows Activation Service)

What is address in WCF and how many types of transport schemas are there in WCF?
Address is a way of letting client know that where a service is located. In WCF, every service is associated with a unique address. This contains the location of the service and transport schemas.

WCF supports following transport schemas

HTTP
TCP
Peer network
IPC (Inter-Process Communication over named pipes)
MSMQ

What is endpoint in WCF?
Every service must have Address that defines where the service resides, Contract that defines what the service does and a Binding that defines how to communicate with the service. In WCF the relationship between Address, Contract and Binding is called Endpoint.

The Endpoint is the fusion of Address, Contract and Binding.

What is binding and how many types of bindings are there in WCF?
A binding defines how an endpoint communicates to the world. A binding defines the transport (such as HTTP or TCP) and the encoding being used (such as text or binary). A binding can contain binding elements that specify details like the security mechanisms used to secure messages, or the message pattern used by an endpoint.

WCF supports nine types of bindings.

Basic binding
Offered by the BasicHttpBinding class, this is designed to expose a WCF service as a legacy ASMX web service, so that old clients can work with new services. When used by the client, this binding enables new WCF clients to work with old ASMX services.

TCP binding
Offered by the NetTcpBinding class, this uses TCP for cross-machine communication on the intranet. It supports a variety of features, including reliability, transactions, and security, and is optimized for WCF-to-WCF communication. As a result, it requires both the client and the service to use WCF.

Peer network binding
Offered by the NetPeerTcpBinding class, this uses peer networking as a transport. The peer network-enabled client and services all subscribe to the same grid and broadcast messages to it.

IPC binding
Offered by the NetNamedPipeBinding class, this uses named pipes as a transport for same-machine communication. It is the most secure binding since it cannot accept calls from outside the machine and it supports a variety of features similar to the TCP binding.

Web Service (WS) binding
Offered by the WSHttpBinding class, this uses HTTP or HTTPS for transport, and is designed to offer a variety of features such as reliability, transactions, and security over the Internet.

Federated WS binding
Offered by the WSFederationHttpBinding class, this is a specialization of the WS binding, offering support for federated security.

Duplex WS binding
Offered by the WSDualHttpBinding class, this is similar to the WS binding except it also supports bidirectional communication from the service to the client.

MSMQ binding
Offered by the NetMsmqBinding class, this uses MSMQ for transport and is designed to offer support for disconnected queued calls.

MSMQ integration binding
Offered by the MsmqIntegrationBinding class, this converts WCF messages to and from MSMQ messages, and is designed to interoperate with legacy MSMQ clients.

What is service and client in perspective of data communication?
A service is a unit of functionality exposed to the world.
The client of a service is merely the party consuming the service.

Summary
I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

Understanding View State in ASP.NET

2009-12-07T17:44:00.000+05:30

What is ViewState and what it is not?
There are some common misconceptions about ViewState. Let me discuss these points here for the benefit of the readers. ViewState does not hold the controls, rather it holds the values of the form controls and their corresponding ID's that would otherwise be lost due to a post back because they do not post with the form. ViewState is not used to hold session data or to transmit data between pages. ViewState does not recreate the dynamically created controls of a page. It does not restore the values to the controls after a post back operation. Taken aback? Yes, it is true. Even when the ViewState for a control is disabled, still the value would be retained after a post back of the page occurs, for input controls like TextBox or DropDownList. So then, what is ViewState? ViewState represents the state of a page when it was last processed on the web server. It holds the values of a control that has been dynamically changed.

How does ViewState work?
All server controls have a property called ViewState. If this is enabled, the ViewState for the control is also enabled. Where and how is ViewState stored? When the page is first created all controls are serialized to the ViewState, which is rendered as a hidden form field named __ViewState. This hidden field corresponds to the server side object known as the ViewState. ViewState for a page is stored as key-value pairs using the System.Web.UI.StateBag object. When a post back occurs, the page de-serializes the ViewState and recreates all controls. The ViewState for the controls in a page is stored as base 64 encoded strings in name - value pairs. When a page is reloaded two methods pertaining to ViewState are called, namely the LoadViewState method and SaveViewState method. The following is the content of the __ViewState hidden field as generated for a page in my system.

Enabling and Disabling ViewState
By default, ViewState is enabled for all server controls. ViewState can be enabled and disabled in any of the following ways.

Page Level
Control Level
Application Level
Machine Level

To enable or disable ViewState in the Page Level, use the following in the Page directive of the ASP.NET page.

To enable or disable ViewState at the Control Level, use the following:

To enable or disable ViewState in the Application Level, use the following:

To enable ViewState in the Machine Level, use the following:

Saving and Restoring Values to and from the ViewState
ViewState works with the following types.

Primitive types
Arrays of primitive types
ArrayList and Hashtable
Any other serializable object

To add an ArrayList object to the ViewState use the following statements.

To retrieve the object later use:

Performance Issues
The size of the ViewState for a page should be minimal for a better performance in page rendering. Remember that the data in the ViewState makes a round trip and incurs more network bandwidth usage. Therefore, ViewState should always be used judiciously. For pages and controls that do not require a post back at all, set the EnableViewState property of the page or the control of the page to false. It is always preferable to keep the ViewState out of the aspx page for performance improvements of the web application. To accomplish this, the methods SavePageStateToPersistenceMedium and LoadPageStateFromPersistenceMedium can be used. Use the following in the web.config or the machine.config file to disable ViewState for all the pages in a particular application or for all applications.

Note that only controls contained within a form tag in the .aspx page can store ViewState. Further, even if ViewState for a page is disabled, still the page itself saves about 20 bytes of information into ViewState to distribute post back data and ViewState values to the correct controls on post back. So, for pages that do not post back at all, remove the runat="server" tag completely for a reduction of the page size by an amount of 20 bytes. This reduction can be substantial for a number of such pages of the application running over the network. ViewState should only be enabled for pages and controls that use it. Avoid using ViewState for controls like the DataGrid and the DataRepeater as the ViewState size for these controls is quite huge. Setting the EnableViewState properties or these controls to false would result in a huge reduction of the size of the rendered html and hence the bandwidth.

During the testing phases of an application, the ViewState size should be tested. I am giving a code below that can detect the size of the ViewState of a page with ease. I have created a MasterPageBase class that all the other pages in the application need to inherit. The code for the class is as shown below.

Security Issues
For security measures (to ensure that the ViewState is not tampered) one of the following two measures can be adopted.

Use the EnableViewStateMac property
Use Encryption of ViewState content

The EnableViewStateMac property ensures a Machine Authentication Check (MAC). This should be set at the page level or in the application’s web.config file. When set, this property appends a hash code to the ViewState before rendering. Whenever a post back occurs, this hash code is recalculated and checked with the one that is stored in the __ViewState hidden field of the form. It they do not match, the page is rejected, thus ensuring that the ViewState is not tampered.

To encrypt the contents of the ViewState, use the following in the machine.config file.

When to use the ViewState
View state is a good way to store data in between postbacks, because it doesn't take up any memory on the server side and it doesn't impose any arbitrary usage limits (such as a timeout). So, what might force you to abandon view state for another type of state management? Here are three possible reasons:

You need to store mission-critical data that the user cannot be allowed to tamper with. (An ingenious user could modify the view state information in a postback request.) In this case, consider session state.
You need to store information that will be used by multiple pages. In this case, consider session state, cookies, or the query string.
You need to store an extremely large amount of information, and you don't want to slow down page transmission times. In this case, consider using a database, or possibly session state.

ViewState Errors
There is a common ViewState error that is often encountered when transferring the control from one aspx page to another. Let there be two aspx pages, first.aspx and second.aspx. Let there be a text box and a submit button in the first.aspx page. If we now use the Server.Transfer in the handler for the submit button click event in the first.aspx page to transfer the control from the page first.aspx to the page second.aspx, a ViewState error would occur. This is because the EnableViewStateMac property of the second.aspx page is set to true by default, just as it is in all other aspx pages. This problem can be overcome by setting the property to false in the second.aspx page.

Conclusion
ASP.NET ViewState is a great feature for web developers. It maintains a state of a page as it moves back and forth. However, when using ViewState one should be well aware of the performance considerations of its usage. It is preferable to enable tracing for a page to know the size of the ViewState for a page in the development cycle of a project. The ViewState size should be optimized well before the application goes to deployment to avoid lengthy operations in the page load cycles of the pages of your application.

ASP.NET 3.5 ListView & DataPager

2009-12-04T15:58:00.000+05:30

ASP. NET 3.5 introduced two new data bound controls ListView & DataPager . ListView Web server control enables us to display the data from a data source and if a DataPager is attached then it enables paging in the ListView.

ListView is a data bound control similar to DataList and DataRepeater controls but it provides edit, insert, and delete , sort operations on the data that it bounded like a GridView control. Unlike GridView control ListView gives the user full control over the rendering of the page. using templates and styles(CSS) the user can generate clean HTML UI according to his needs.

DataPager Web control is used to page data and display navigation controls for data-bound controls that implement the IPageableItemContainer interface.ListView implements the IPageableItemContainer and will use DataPager to support Paging.

Binding ListView to a DataSource.
We can use any ASP.NET datasource control to bind to the ListView control by setting the DataSourceID property of the ListView control to the name of the Datasource control.

This sample is using AccessDataSource control to bind to the ListView control.

ListView provides built in support for sort functionality. It has a sort event, which can be specified by setting the commandName property of the control, which is part of the ListView control to the 'Sort'. The Sort event supports command argument which can be used to identify which control raised the sort event. The handler for sort event is registered by setting the OnSorting property of the ListView to the handler name.

Specifying the Sort Event on the control's

Handling the raised sort event
protected void ListView1Sorting(Object sender, ListViewSortEventArgs e)
{
    String strImage;
    if (e.SortDirection == SortDirection.Ascending)
        strImage = "asc.gif";
    else
        strImage = "desc.gif";
    Image sortSender = (Image)ListView1.FindControl("Image1");
    Image sortSubject = (Image)ListView1.FindControl("Image2");
    Image sortRecdate = (Image)ListView1.FindControl("Image3");
    Image sortBody = (Image)ListView1.FindControl("Image4");

    if (e.SortExpression == "From")
    {
        sortSender.ImageUrl = strImage;
        sortSender.Visible = true;
        sortSubject.Visible = false;
        sortRecdate.Visible = false;
        sortBody.Visible = false;
    }
    else if (e.SortExpression == "Subject")
    {
        sortSubject.ImageUrl = strImage;
        sortSender.Visible = false;
        sortSubject.Visible = true;
        sortRecdate.Visible = false;
        sortBody.Visible = false;
    }
    else if (e.SortExpression == "recdate")
    {
        sortBody.ImageUrl = strImage;
        sortSender.Visible = false;
        sortSubject.Visible = false;
        sortRecdate.Visible = true;
        sortBody.Visible = false;
    }
    else if (e.SortExpression == "Body")
    {
        sortBody.ImageUrl = strImage;
        sortSender.Visible = false;
        sortSubject.Visible = false;
        sortRecdate.Visible = false;
        sortBody.Visible = true;
    }
    else
    {

        sortSender.Visible = false;
        sortSubject.Visible = false;
        sortRecdate.Visible = false;
        sortBody.Visible = false;
    }
}

Specifying ListView Templates
ListView provides various templates which we can use to display the data. The templates are:

- LayoutTemplate

- ItemTemplate

- ItemSeparatorTemplate

- GroupTemplate

- GroupSeparatorTemplate

- EmptyItemTemplate

- EmptyDataTemplate

- SelectedItemTemplate

- AlternatingItemTemplate

- EditItemTemplate

- InsertItemTemplate

The display hierarchy of the various templates in ListView are shown below.

The main layout of a ListView control is created by defining a LayoutTemplate. The LayoutTemplate will include controls that acts as a placeholder for the data like Table, Panel, Label or HTML controls like table, div, or span elements that have a runat attribute set to "server". Item template is the main template which will show the data bounded to the ListView in a repeated manner. This template typically contains controls that are data-bound to data columns or other individual data elements. These two templates are mandatory.

GroupTemplate will be used to group the items. The EditItemtemplate, SelectedItemTemplate, InsertItemTemplate are shown at that particular operation like insert, edit, select. ItemSeparatorTemplate, GroupSeparatorTemplate are used to separate the individual items and group Items Separately.

We will use each template to embed the necessary HTML controls like table, tr, td, div, span or server controls to display the UI according to our needs.

The following example shows the basic structure of a ListView with mandatory templates...

An item placeholder must be specified on ListView. It will be specified in LayoutTemplate or GroupTemplate.

In order to specify a item placeholder set a control's ID property to "itemPlaceholder". The item placeholder control must also specify runat="server". If you want to provide a different ID, you can specify it using the ItemPlaceholderID attribute of the ListView control.

If Grouping is used, GroupTemplate will act as place holder for ItemTemplate. In this case a Groupplaceholder must be specified in ListView. An Groupplaceholder can be specified in LayoutTemplate by setting a control's ID property to "groupPlaceholder" or setting the GroupPlaceholderID attribute of the ListView control to a control which is specified in LayoutTemplate.

Example code for setting ID properties of control's to "itemPlaceholder", "groupPlaceholder"

Example code for setting itemPlaceholderID, groupPlaceholderID properties to control's ID's.

Preparing the LayoutTemplate for the Email Viewer
We need to create the LayoutTemplate as shown below using the necessary HTML controls like table, tr, td (with styles) for formatting and the ASP.Net Server Controls (Buttons, LinkButtons, DataPager) for displaying the Headers as well as footers. We need to use a itemplaceholder for displaying the items from data source.

Preparing DataPager
The DataPager control is used to page data and to display navigation controls for data-bound controls that implement the IPageableItemContainer interface.

A DataPager control can be associated to the data-bound control by using the PagedControlID property. Alternatively, the DataPager control can be placed inside the data-bound control hierarchy.

DataPager control will display navigation controls by adding the pager fields to the control. DataPager supports following types of pager fields.

NextPreviousPagerField: Enables to navigate through pages one page at a time, or to jump to the first or last page. It shows first, prev, next, last buttons. The button type may be of Button, Image, LinkButton.

NumericPagerField: enables to navigate through pages by displaying page numbers on the datapager.

TemplatePagerField: we can create custom UI by using TemplatePagerField. We can use Labels, buttons, images to create custom UI as well as programmatic control of the DataPager.

In order to create the DataPager according to the above image we need to use NumericPagerField as well as TemplatePagerField as part of the DataPager Fields. We can use DataPager control's properties like PageSize, TotalRowCount, StartRowIndex to create the TemplatePagerField.

PageSize gives the no of the pages currently displayed in DataPager.

TotalRowCount is the no of rows presented in the datasource attached to the DataPager.

StartRowIndex is the current first row's index in the data source .

Preparing ItemTemplate & Alternative ItemTemplate
We need to embed the necessary HTML tags as well as Server controls like checkboxes, labels, buttons in order to get the following look for the ItemTemplates as well as AlternativeItemTemplates. The data will be bounded to the properties of the control's by using inline ASP.Net code <%#Eval("datafieldname")%>, where datafiledname is the column name in the datasoure.

Preparing EditItemTemplate & InsertItemTemplate
Similarly we can create EditItemTemplate as well as InsertItemTemplate, but instead of labels we will use TextBoxes like below.

Conclusion
DataPager is nice control for some scenarios, but it should be much better. It looks like DataPager always select complete data source (it just use data source of ListView). That is not efficient, even not acceptable if you have more than 100 pages. In that case it is better to select only page you want to show, instead of selecting all rows from large table. Also, DataPager works only with ListView. It cannot use Repeater or DataList.

XML

2009-12-04T10:51:00.000+05:30

What is XML ?
XML stands for eXtensible Markup Language is not really a language but a framework for defining and using markup languages. Markup languages are used for creating units of information called XML documents, which have two standard representations: as a linear text with markup and as a tree data structure.

A tree is a connected set of nodes and a parent-child relationship defined on them. One special node is called the root. Every node except the root has exactly one parent node, and the root is the only node that doesn’t have a parent.

Trees are always drawn upside down, with the root on top and leaves at the bottom. If you start from any node that is not a root, go up to its parent, and continue up the tree, sooner or later you get to the root.

The nodes you encounter along the way are called the ancestors of the node you started from. The root is an ancestor of all nodes in the tree, and all nodes in the tree are its descendants. If node P is the parent of node C, then C is usually called a child of P. Children of the same node are called siblings. Nodes that have no children are called leaves.

A program that takes a text and checks the correctness of its syntax is called a parser. A parser does not simply return a Boolean answer (“correct” or “not correct”): if the text is grammatically correct, it builds an internal representation of its syntactical structure. Such internal representations are called syntax diagrams. For XML documents (as well as computer programs), syntax diagrams form a tree structure.

An XML document consists of text data and markup. The markup indicates the syntactical structure of the document.

document contains three elements: encounter, greeting, and response. Here is the greeting element.An element consists of a start tag, the element’s content (which can be empty), and an end tag. A start tag minimally consists of the “<” character, a tag name, and the “>” character. The tag name can be followed by attribute declarations. An end tag consists of the character sequence “

An element consists of a start tag, the element’s content (which can be empty), and an end tag. A start tag minimally consists of the “<” character, a tag name, and the “>” character. The tag name can be followed by attribute declarations. An end tag consists of the character sequence “

What is the tree structure of the document shown . In XML, the parent-child tree relationship corresponds to how elements are nested within each other in the linear text. In our example, encounter properly contains greeting and response; therefore, in the tree, encounter is the parent of greeting and response, whereas greeting and response are children of encounter and siblings to each other. Leaf elements are either empty or contain only text.

XML Parsing
A parser for a programming language knows only that one programming language. to parse a program, the parser has to consult the grammar of the language. But XML parsers are different on both counts. The same parser can do all XML languages, and, to parse a document, the parser does not need to know the grammar of its markup language. A general XML requirement is that the elements of an XML document must form a tree and that the tree structure of elements must be clearly shown in markup.

Tree conditions must be met in XML parsing is :

There must be an element that contains all other elements. This is the root of the element tree.
Start and end tags must be properly nested; overlapping elements are not allowed.
All elements, including empty elements, must have both the start tag and the end tag.

All the parser needs to construct the syntactical tree is a stack to push a start tag on and pop it off when the matching end tag is found. If in the end the stack is empty, the document is well formed.

Procedure :

Start by creating the root node and make it the current node.
When a start tag is encountered, create a child of the current node and make it the current node. Put the start tag name on stack.
When an end tag is encountered, check to see that its tag name is the same as the name on top of the stack. If it is not the same, declare failure and exit. If it is the same, close the current node (that is, pop the tag name off the stack) and make its parent the current node.
If in the end the stack is empty, declare success, and return the tree. If it is not empty, declare failure and exit.

XML parsers within XML-aware browsers follow this procedure.

Why Is XML Great ?

XML makes it easy to agree on a common language or data format. A common language is the main prerequisite for cooperation.
Iit is very easy to switch between the linear text and the syntax tree view of an XML document. XML parsers are standard, high quality, ubiquitous, and free, and they can perform the switch both ways without any loss of significant information.
With XML, it is easy to construct networks of cooperating computer programs that receive XML text over the network, parse it into its internal representation, perform some computations on it, convert it back into linear text and send it over the network to another program for further processing.
XML is a major enabling technology for cooperation, both between human agents and between computer programs (interoperability).

Problems with programming language parsers :

Parsers for programming languages are difficult to write.
The resulting binary objects are parser and platform specific.
Transition from binary to textual form (disassembly) is hard and frequently illegal; certainly, no standard APIs are available for doing that.

But simple XML parsers that only check for well-formedness and construct a syntax tree are easy to write, and their output is standard, platform independent, and easy to convert back to linear text form.

Summary
I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

Integrating Reporting Services 2005 Into a Web Application

2009-11-28T14:03:00.000+05:30

Introduction

Microsoft has made it much easier to integrate its SQL Reporting Services into ASP.NET web applications. Most desired functionality of Reporting Services can be achieved through its ReportViewer control, which is the focus of this article. For those of you who need very fine and detailed customization of embedding RS reports into applications.

Instructions

Go ahead and start up Visual Studio 2005. Click on the New \ New Website item in the file menu. In the dialog box select the ASP.NET Website, your language preference (C# is used in this article), and where you would like your website to be built. Click on OK.

One of most difficult tasks in embedding the ReportViewer control is ensuring that it fills 100% of the space you want it to fill, no more, no less. You also want the ReportViewer to use its own scroll bars, not the browser's.

The code I have written is basically a template that you can use which sets an area for a header, a custom control bar, and the report itself.

Since the ReportViewer has difficulty taking up 100% of the space in a table (probably not 100% XHTML), you are going need to remove any XHTML settings.

In the ASP.NET code, you will need to delete (or change) this line:

You may also probably need to change the validation from a non-XHTML setting to a setting such as HTML 4.01.

If your target audience will only be using the IE browser, change the body tag so it looks like this:

If any of the users will also using the Mozilla browser, change the body tag so that the height is 99.3%. This is to avoid a double vertical scroll bar effect where you see both the ReportViewer's scroll bar and the browser's scroll bar. There will be an almost unnoticeable space at the bottom of Mozilla browser. Take note, that the contents within the ReportViewer may not display correctly (nor will they in Report Manager). So develop reports for Mozilla at your own risk at this time.

Next go ahead and replace any existing code between the

tags with the below code:

Go ahead and switch to the Design view since it is now time to add the ReportViewer control.

In the Data section within the Toolbox, drag the ReportViewer control onto the last row of your table, which should be taking up most of the page. Next you want to set the control's properties so that it points to the right server and the right report. Under properties, go to the Server Report section. Right above the section you should see a property called ProcessingMode. In most cases you are going to want use an instance of a Report Server. So for the purposes of this tutorial, set this property to Remote, even if the Report Server instance is on the same computer as your web app. Next, you want to set the ServerReport settings.

First, type in address of the Report server in the ReportSeverUrl field.

The syntax is:

http:// NameOfServer / reportserver

i.e. http://ServerOne/reportserver

Next type in the location of the report in the ReportPath field.

i.e. /MyReports/TheReport

The location is easy to know since it is the same path structure that you see in the Report Manager. Also, always be sure the put a forward slash first before the actual path.

Unless you want the ReportViewer to be an absolute size, go ahead and set the height and width settings under the Layout section to be 100%. The ReportViewer will by default show controls to set the parameters for the report. These often look a little ugly, and I would recommend most developers to create their own parameter controls. This can be done in the control bar row of the template provided above. To get rid of the ReportViewer's parameter controls set the ShowParameterPrompts in the properties underneath Appearance to false.

Those should be all the settings you need to make for the ReportViewer to display correctly, unless your version of Visual Studio has other default settings. Double check to make sure the ASP.NET looks similar to this code:

Now, the report is ready to be processed. You can go ahead and preview your website and the report should generate just fine.

Displaying a Report through the C#/VB Code

In many cases, you may need to pass parameters to a report or your code (or the end users) may need to have control over which report is generated. For example you may have a Drop-Down-List that lets the user select which report they wish to view. They can then click on a button that generates the report that accepts a parameter for the current time. (The Button and Drop-Down-List can be placed in the custom control bar section of the template.)

So the code inside the Click-Button-Event-Handler function is where we will need to put in our custom ReportViewer code. The code in this article is C#, but the VB code shouldn't be too much different.

First, if you didn't set the Report Server Url via the visual designer, you can do it here.

this.ReportViewer1.ServerReport.ReportServerUrl =
    new System.Uri("http://ServerOne/reportserver");

One problem/bug that is rather common in the ReportViewer control is when you change to a different report via the website itself coming from a drill-through report, an ASP.NET error can occur. This is because the ReportServer is thinking that the new report is still a drill-through when it is not. To get around this problem use the following code:

while (this.ReportViewer1.ServerReport.IsDrillthroughReport)
{
    this.ReportViewer1.PerformBack();
}

This code will set whichever report you want to display next to be the parent.

Next you want to set the new report path:

// Could also be set to the selection of a ListBox.

string strReport = "/MyReports/TheReport";
this.ReportViewer1.ServerReport.ReportPath = strReport;

If parameters are needed, you are going need to first declare an array of ReportParameter objects.

Microsoft.Reporting.WebForms.ReportParameter[] RptParameters =
    new Microsoft.Reporting.WebForms.ReportParameter[1];

In this case, we only need one parameter.

Next, assign the first index (0) of the RptParameters array to a new ReportParameter object where the constructor function takes the syntax:

ReportParameter(ReportParameterName, Value);

i.e.

string strTime = System.DateTime.Now.ToShortTimeString();

RptParameters[0] =
    new Microsoft.Reporting.WebForms.ReportParameter("CurrentTime", strTime);

Then, you need set the RptParameters object to the ReportViewer control.

this.ReportViewer1.ServerReport.SetParameters(RptParameters);

Finally, to put these changes into action, call the Refresh() function:

this.ReportViewer1.ServerReport.Refresh();

So in its entirety, the code inside the button-clicked event-handler function should look like this:

this.ReportViewer1.ServerReport.ReportServerUrl =
    new System.Uri("http://serverone/reportserver");

while(this.ReportViewer1.ServerReport.IsDrillthroughReport)
{
    this.ReportViewer1.PerformBack();
}

// Could also be set to the selection of a ListBox.

string strReport = "/MyReports/TheReport";
this.ReportViewer1.ServerReport.ReportPath = strReport;
Microsoft.Reporting.WebForms.ReportParameter[] RptParameters =
    new Microsoft.Reporting.WebForms.ReportParameter[1];

string strTime = System.DateTime.Now.ToShortTimeString();
RptParameters[0] =
    new Microsoft.Reporting.WebForms.ReportParameter("CurrentTime", strTime);

this.ReportViewer1.ServerReport.SetParameters(RptParameters);
this.ReportViewer1.ServerReport.Refresh();

If you like you can delete the ReportPath from the properties in the visual designer. This will ensure that a report does not load until your own code loads a report itself. However, this will also remove the ReportViewer control bar, which you may wish to keep so that the website looks more structured. What I usually do is set the default ReportPath to point to a report that is basically a welcome screen. From there, the end user can choose parameters from my selection controls, and then when ready, the user can click on a view button that generates the desired report.

Summary
I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

Comparison for VB.NET and C#

2009-11-23T16:29:00.000+05:30

Introduction

Some people like VB.NET's natural language, case-insensitive approach, others like C#'s terse syntax. But both have access to the same framework libraries. We will discuss about the differences in the following topics:

Advantages of both languages

VB.NET

Support for optional parameters - very handy for some COM interoperability.
Support for late binding with Option Strict off - type safety at compile time goes out of the window, but legacy libraries which don't have strongly typed interfaces become easier to use.
Support for named indexers.
Various legacy VB functions (provided in the Microsoft.VisualBasic namespace, and can be used by other languages with a reference to the Microsoft.VisualBasic.dll). Many of these can be harmful to performance if used unwisely, however, and many people believe they should be avoided for the most part.
The with construct: it's a matter of debate as to whether this is an advantage or not, but it's certainly a difference.
Simpler (in expression - perhaps more complicated in understanding) event handling, where a method can declare that it handles an event, rather than the handler having to be set up in code.
The ability to implement interfaces with methods of different names. (Arguably this makes it harder to find the implementation of an interface, however.)
Catch ... When ... clauses, which allow exceptions to be filtered based on runtime expressions rather than just by type.
The VB.NET parts of Visual Studio .NET compiles your code in the background. While this is considered as an advantage for small projects, people creating very large projects have found that the IDE slows down considerably as the project gets larger.

XML documentation generated from source code comments. (This is coming in VB.NET with Whidbey (the code name for the next version of Visual Studio and .NET), and there are tools which will do it with existing VB.NET code already.)
Operator overloading - again, coming to VB.NET in Whidbey.
Language support for unsigned types (you can use them from VB.NET, but they aren't in the language itself). Again, support for these is coming to VB.NET in Whidbey.
The using statement, which makes unmanaged resource disposal simple.
Explicit interface implementation, where an interface which is already implemented in a base class can be re-implemented separately in a derived class. Arguably this makes the class harder to understand, in the same way that member hiding normally does.
Unsafe code. This allows pointer arithmetic etc, and can improve performance in some situations. However, it is not to be used lightly, as a lot of the normal safety of C# is lost (as the name implies). Note that unsafe code is still managed code, i.e., it is compiled to IL, JITted, and run within the CLR.

New Features of both languages in 2005 version

VB.NET

Visual Basic 2005 has many new and improved language features -- such as inheritance, interfaces, overriding, shared members, and overloading -- that make it a powerful object-oriented programming language. As a Visual Basic developer, you can now create multithreaded, scalable applications using explicit multithreading. This language has following new features,

Continue Statement, which immediately skips to the next iteration of a Do, For, or While loop.
IsNot operator, which you can avoid using the Not and Is operators in an awkward order.
Using...End. Using statement block ensures disposal of a system resource when your code leaves the block for any reason.

Public Sub setbigbold(ByVal c As Control)

           Using nf As New System.Drawing.Font("Arial",12.0F, FontStyle.Bold)
                c.Font = nf
                c.Text = "This is 12-point Arial bold"
           End Using
         End Sub

Explicit Zero Lower Bound on an Array, Visual Basic now permits an array declaration to specify the lower bound (0) of each dimension along with the upper bound.
Unsigned Types, Visual Basic now supports unsigned integer data types (UShort, UInteger, and ULong) as well as the signed type SByte.
Operator Overloading, Visual Basic now allows you to define a standard operator (such as +, &, Not, or Mod) on a class or structure you have defined.
Partial Types, to separate generated code from your authored code into separate source files.
Visual Basic now supports type parameters on generic classes, structures, interfaces, procedures, and delegates. A corresponding type argument specifies at compilation time the data type of one of the elements in the generic type.
Custom Events. You can declare custom events by using the Custom keyword as a modifier for the Event statement. In a custom event, you specify exactly what happens when code adds or removes an event handler to or from the event, or when code raises the event.
Compiler Checking Options, The /nowarn and /warnaserror options provide more control over how warnings are handled. Each one of these compiler options now takes a list of warning IDs as an optional parameter, to specify to which warnings the option applies.
There are eight new command-line compiler options:

The /codepage option specifies which codepage to use when opening source files.
The /doc option generates an XML documentation file based on comments within your code.
The /errorreport option provides a convenient way to report a Visual Basic internal compiler error to Microsoft.
The /filealign option specifies the size of sections in your output file.
The /noconfig option causes the compiler to ignore the Vbc.rsp file.
The /nostdlib option prevents the import of mscorlib.dll, which defines the entire System namespace.
The /platform option specifies the processor to be targeted by the output file, in those situations where it is necessary to explicitly specify it.
The /unify option suppresses warnings resulting from a mismatch between the versions of directly and indirectly referenced assemblies.

With the release of Visual Studio 2005, the C# language has been updated to version 2.0. This language has following new features:

Generics types are added to the language to enable programmers to achieve a high level of code reuse and enhanced performance for collection classes. Generic types can differ only by arity. Parameters can also be forced to be specific types.
Iterators make it easier to dictate how a for each loop will iterate over a collection's contents.

    // Iterator Example
     public class NumChar
        {
           string[] saNum = {"One", "Two", "Three","Four", "Five", "Six","Seven", "Eight", "Nine",   "Zero"};
           public
             System.Collections.IEnumerator
             GetEnumerator()
             {
                foreach (string num in saNum)
                yield return num;
             }
        }
      // Create an instance of

      // the collection class

      NumChar oNumChar = new NumChar();
      // Iterate through it with foreach

      foreach (string num in oNumChar)
      Console.WriteLine(num);

Partial type definitions allow a single type, such as a class, to be split into multiple files. The Visual Studio designer uses this feature to separate its generated code from user code.
Nullable types allow a variable to contain a value that is undefined.
Anonymous Method is now possible to pass a block of code as a parameter. Anywhere a delegate is expected, a code block can be used instead: There is no need to define a new method.

button1.Click += delegate { MessageBox.Show("Click!") };

The namespace alias qualifier (::) provides more control over accessing namespace members. The global :: alias allows to access the root namespace that may be hidden by an entity in your code.
Static classes are a safe and convenient way of declaring a class containing static methods that cannot be instantiated. In C# v1.2 you would have defined the class constructor as private to prevent the class being instantiated.
There are eight new compiler options:

/langversion option: Can be used to specify compatibility with a specific version of the language.
/platform option: Enables you to target IPF (IA64 or Itanium) and AMD64 architectures.
#pragma warning: Used to disable and enable individual warnings in code.
/linkresource option: Contains additional options.
/errorreport option: Can be used to report internal compiler errors to Microsoft over the Internet.
/keycontainer and /keyfile: Support specifying cryptographic keys.

Conclusion

I think that this article will help you understand both language features and also you can choose a language based on your taste.

ASP.NET INTRODUCTION

2009-11-21T12:10:00.000+05:30

Introduction

Unlike the ASP runtime, ASP.NET uses the Common Language Runtime (CLR) provided by the .NET Framework. The CLR is the .NET runtime, which manages the execution of code. The CLR allows the objects, which are created in different languages, to interact with each other and hence removes the language barrier. CLR thus makes Web application development more efficient.

In addition to simplifying the designing of Web applications, the .NET CLR offers many advantages. Some of these advantages are listed as follows.

1). Improved performance

The ASP.NET code is a compiled CLR code instead of an interpreted code. The CLR provides just-in-time compilation, native optimization, and caching. Here, it is important to note that compilation is a two-stage process in the .NET Framework. First, the code is compiled into
the Microsoft Intermediate Language (MSIL).

Then, at the execution time, the MSIL is compiled into native code. Only the portions of the code that are actually needed will be compiled into native code. This is called Just In Time compilation. These features lead to an overall improved performance of ASP.NET applications.

2). Flexibility

The entire .NET class library can be accessed by ASP.NET applications. You can use the language that best applies to the type of functionality you want to implement, because ASP.NET is language independent.

3). Configuration settings

The application-level configuration settings are stored in an Extensible Markup Language (XML) format. The XML format is a hierarchical text format, which is easy to read and write. This format makes it easy to apply new settings to applications without the aid of any local administration tools.

4). Security

ASP.NET applications are secure and use a set of default authorization and authentication schemes. However, you can modify these schemes according to the security needs of an application.
In addition to this list of advantages, the ASP.NET framework makes it easy to migrate from ASP applications.

Creating an ASP.NET Application

1).Use a text editor

In this method, you can write the code in a text editor, such as Notepad, and save the code as an ASPX file. You can save the ASPX file in the directory C:inetpubwwwroot. Then, to display the output of the Web page in Internet Explorer, you simply need to type http://localhost/.aspx in the Address box. If the IIS server is installed on some other machine on the network, replace "localhost" with the name of the server. If you save the file in some other directory, you need to add the file to a virtual directory in the Default WebSite directory on the IIS server. You can also create your own virtual directory and add the file to it.

2).Use the VS.NET IDE

In this method, you use the IDE of Visual Studio .NET to create a Web page in a WYSIWYG manner. Also, when you create a Web application, the application is automatically created on a Web server (IIS server). You do not need to create a separate virtual directory on the IIS server.
From the preceding discussion, it is obvious that the development of ASP.NET Web applications is much more convenient and efficient in Visual Studio .NET.

ASP.NET Web pages consist of HTML text and the code. The HTML text and the code can be separated in two different files. You can write the code in Visual Basic or C# . This separate file is called the code behind file. In this section, you'll create simple Web pages by using VB as well as C#.
Before you start creating a Web page, you should be familiar with basic ASP.NET syntax. At the top of the page, you must specify an @ Page directive to define page specific attributes, such as language.

To specify the language as VB for any code output to be rendered on the page.

This line indicates that any code in the block, <% %>, on the page is compiled by using VB.

To render the output on your page, you can use the Response.Write() method.

Creating a Visual Basic Web Application

You can create an ASP.NET application using Visual Basic by creating a Visual Basic

Web Application project.

To do so, complete the following steps:

Select File ® New ® Project. The New Project dialog box appears.
Select Visual Basic Projects from the Project Types pane.
Select ASP.NET Web Application from the Templates pane.

The Name box contains a default name of the application. The Location box contains the name of a Web server where the application will be created. However, you can change the default name and location. In this case, the name of the sample application is SampleVB.

Deploying an ASP.NET Web Application

After creating and testing your ASP.NET Web applications, the next step is deployment.

Deployment is the process of distributing the finished applications (without the source code) to be installed on other computers.

In Visual Studio .NET, the deployment mechanism is the same irrespective of the programming language and tools used to create applications. In this section, you'll deploy the "Hello World" Web application that you created. You can deploy any of the application that was created by using VB or C#. Here, you'll deploy the application created by using VB.

To do so, follow these steps:

Open the Web application project that you want to deploy. In this case, open the SampleVB project.
Select File ® Add Project ® New Project to open the Add New Project dialog box.
From the Project Types pane, select Setup and Deployment Projects.From the Templates pane, select Web Setup Project.
Change the default name of the project. In this case, change it to "SampleVBDeploy."
Click OK to complete the process. The project is added in the Solution Explorer window.

Summary
I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

Reading Address Book from Yahoo, Gmail, MSN

2009-10-06T12:25:00.000+05:30

When we are developing a scoal networking websites or Some Referal websites, when the user registration completed then we have to provide an interface to invite the registerd user friends. For this purpose we have to provide option to get AddressBook from various Email Providers.

Here I am taking some popular Email Providers like Yahoo, Google, MSN, In order to Read the Address book of Yahoo, Google, MSN we have access the API which provided by them itself.

Few days before I download one dll from net. Its provided by Ideabubling. It contains all API of Yahoo,Google, MSN which is ready to use. Here In this application I use the dll.

The Core Functionality is, when user provides Email Address and Password, If these details are valid then we will call getContact method and these details are stored in DataTable. You can see the sample code here..

DataTable dtContatct = new DataTable();

MailType mt = FindTheMailType();

MailClient.GetContacts(mt, strUserid, strPassword, out boolIsOK, out dtContatct, out strError);

dtContatct = MailClient.GetFormat(mt, dtContatct);

Here “mt” is the mail type. It will check what type of Email Address It is. Either Yahoo, Gmail, etc.

Then this DataTable is binded with GridView, so that User can able to see his contcats and he can select some of the or all to send a mail.

You can see the Screen Shot..

Download Complete Application.. Click Here..!

Summary
I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

Tab Control Extender, TextBoxWatermark Control Extender, ToggleButton Control Extender

2009-09-24T17:46:00.000+05:30

1). Tab Control Extender

AJAX Tab Control Extender also belongs to ASP.Net AJAX Control toolkit library provided by Microsoft’s official open source community. AJAX Tab control extender provides the functionality to display the multiple things on a single web page in the form of tabs. AJAX Tab control extender is a set of two types of toolkit controls: one is AJAX TabContainer and other is TabPanel. AJAX TabContainer extender control holds the set of TabPanel to create a set of tabs along with their related content. AJAX TabPanel further provides two types of Templates to create the tabs and their content. HeaderTemplate of AJAX TabPanel creates the tab with specified text as its heading and ContentTemplate creates the content view for the associated TabPanel.

ASP.Net AJAX Tab Extender Control Properties

CssClass: accepts the name of CSS class that could override the styles of default CSS class styles to display the AJAX Tabs. You can customize the look and feel of Tabs using CssClass property.

Height: sets the height of AJAX Tab Container excluding the Tabs section.

Width: sets the width of AJAX Tab Container. It sets the width of body section of the AJAX TabContainer containing content.

ScrollBars: Accepts the different types of values to display the scrollbars. ScrollBars property of AJAX Tab Extender control supports the following set of values:

Auto
Both
Horizontal
None
Vertical

onClientActiveTabChanged: Accepts the name of a client-side javascript function to fire it for tabChanged client-side event.

onActiveTabChanged: This event executes at server side when postback occurs after tab changed event.

OnClientClick: Accepts the name of a client-side javascript function to fire it for onclick client-side event for tabs.

HeaderText: Sets the text to be displayed on Tabs.

HeaderTemplate: Header template provides a container for AJAX TabPanel to render the Tab with specified text.

ContentTemplate: Content template provides a container for AJAX TabPanel to render the content body with specified text.

HTML Code for ASP.Net AJAX Tab Control Extender

Tab Extender CSS Class Styles

You can change the look and feel of ASP.Net AJAX Tab extender control by overriding the CSS class names and styles. AJAX Control Toolkit has a predefined set of CSS class styles specially created for different sections of AJAX Tab extender control e.g.: active tab style, style for on mouse over state (hover), inactive style etc. Each state of Tab extender has been associated with CSS class styles in AJAX Control Toolkit that can be used for customizing the theme of AJAX Tabs control. While working with AJAX Tab extender control if you will not apply any CssClass style to it then it will render the Tabs with default CSS rules and styles.

Default Look of AJAX Tab Extender Control

CSS Class Names for ASP.Net AJAX Tab Extender Control

.ajax__tab_header: this CSS class has been associated with tab header container of AJAX TabContainer that wraps all the tabs at the top.

.ajax__tab_outer: this CSS class controls the style of left edge of a tab.

.ajax__tab_inner: this CSS class controls the style of right edge of a tab.

.ajax__tab_tab: it applies the style to the center portion of a tab containing the text.

.ajax__tab_hover: this CSS class applies its styles while mouse over state of a tab.

.ajax__tab_active: this CSS class applies its styles on the currently selected tab.

.ajax__tab_body: it applies the CSS styles on the TabPanel content container associated with each tab.

2). TextBoxWatermark Control Extender

The TextBoxWatermark extender control of ASP.Net 2.0 AJAX control toolkit is attached to the Textbox server control of ASP.Net. TextboxWatermark extender control is managed by CSS styles to display the watermarked message inside the Textbox control. TextBoxWatermark control allows you to display the Hint inside the user input fields i.e. Textbox that disappears as soon as the user sets focus into the Textbox. You can pass the Hint Text that you want to display inside the Textbox control. TexboxWatermark extender control is very easy to use due to its very few properties to provide the desired functionality.

TextboxWatermarkExtender Control Properties

TargetControlID: ID of Textbox control in which watermarked text will appear.

WatermarkText: Text that will appear inside the associated Textbox control.

WatermarkCssClass: CSS class name that will adjust the style, look and feel of watermarked Textbox.

Sample Code for TextboxWatermarkExtender Control

3). ToggleButton Control Extender

ToggleButton AJAX extender control provides the functionality to use the ASP.Net 2.0 checkbox with new look. Custom images hide the checkboxes with images to show the checked and unchecked state of the attached checkbox control. You can specify the image URL for each different state of the checkbox control e.g.: checked and unchecked state of checkbox when its enabled property is true, checked and unchecked state of checkbox when its enabled property is false.

AJAX ToggleButton Control Properties

TargetControlID: ID of the checkbox control to attach it with AJAX toggle button extender control.

CheckedImageUrl: URL of the image to display as the checked state of toggle button checkbox control.

UncheckedImageUrl: URL of the image to display the unchecked state of target togglebutton checkbox control.

CheckedImageOverUrl: URL of the image for mouse over event when the attached togglebutton checkbox control is in checked state.

UncheckedImageOverUrl: URL of the image for mouse over event when the attached togglebutton checkbox control is in unchecked state.

DisabledCheckedImageUrl: URL of the image to display the checked state of the associated togglebutton checkbox control when its Enable property is false.

DisabledUncheckedImageUrl: URL of the image to display the unchecked state of the togglebutton checkbox control when its Enable property is false.

CheckedImageAlternateText: Alt text attribute for the checked image, when togglebutton is in the checked state.

UncheckedAlternateText: Alt text attribute for the unchecked image, when togglebutton is in the unchecked state.

ImageHeight/ImageWidth: Height and width of the images used for displaying the states of togglebutton checkbox.

Sample Code for ToggleButton Control Extender

Summary
I hope this article fulfills its purpose. I would like to have feedback from my blog readers.

RoundedCorners Control Extender, Slider Control Extender, Slideshow Extender Control, Star Rating Extender Control

2009-09-24T11:19:00.000+05:30

1). RoundedCorners Control Extender

The AJAX RoundedCorners extender control displays the targeting Panel with round shaped edges. You can set the color of the edges same as the background color of the associated Panel control. RoundedCornersExtender also provides the feature to set the edges with alternate styles such as round corners for BottomLeft, TopLeft etc.

AJAX RoundedCornersExtender Properties

TargetControlID: ID of the target Panel Control.

Radius: Radius of the round edges of the targeting Panel control. Default value is 5. Greater value for Radius property generates the broader round corners.

Color: Adjusts the color of the corners associated with extender.

Corners: This property provides the combinations for the corners of the associated Panel. Following are the different combinations or values for Corners property that generates the round edges at the specified value for this property:

All
Bottom
BottomLeft
BottomRight
Left
None
Right
Top
TopLeft
TopRight

Sample Code for AJAX RoundedCornersExtender Control

When I use Corners property "All" then

When I use Corners property ="Bottom" then

When I use Corners property ="Left" then

When I use Corners property ="Right" then

2). Slider Control Extender

The AJAX Slider extender control provides the functionality of slider bar rider that targets the ASP.Net 2.0 Textbox server control. It gets and sets the property of attached asp:textbox control that changes the position of slide extender control as well.

AJAX Slider control also displays the current position value in other textbox or label control if its ID is passed into the BoundControlID property of the Slider extender control. You can also specify the orientation of slider control as horizontal or vertical. Just define the maximum and minimum value for the AJAX slider extender it moves to and fro and changes the return value.

Precision point can also be specified if you want decimal point values using the slider control position.

Slider moves on the slider rail with a smooth moving effect it its animation property is set enabled. Default values for the slider extender are 0 to 100; if user does not specify these values then slider extender control uses the default set. You can also display the tool tip of slider control using {0} string format that dynamically changes the tool tip value according to the current position of the AJAX slider extender control.

AJAX Slider Extender Control Properties

TargetControlID: ID of the target textbox control, it stores the position state of slider extender control.

BoundControlID: ID of the textbox or label control, to display the current position value of slider control.

Decimals: number of precision point places required after decimal point.

Maximum: maximum value for the slider extender control position.

Minimum: minimum value for the slider control position.

Length: Height or width of the slider control according to the orientation of extender.

Steps: Number step division to cover the complete slider rail path.

EnableHandleAnimation: to enable or disable the animated movement feature of slider extender control.

Orientation: Changes the direction of slider rail to Horizontal or Vertical direction.

TooltipText: It displays the text as tooltip for mouse hover action. You can use {0} placeholder to display the current value of the slider extender control.

Sample Code for AJAX Slider Extender Control

3). Slideshow Extender Control

ASP.Net 2.0 AJAX Slideshow extender is becoming popular these days due to its feature to display the set of images in the form of powerpoint slideshow style. AJAX SlideShow extender takes the ID of image control of ASP.Net 2.0 to display the images in it according to the time interval fixed for it. You can also specify the auto start event to change the images in SlideShow extender when the page loads. Also you can enable the loop to run the SlideShow in continuous manner that loads the first image again after displaying the last image and plays the SlideShow repeatedly.

The AJAX SlideShow extender also has features to associate Label and Button controls of ASP.Net 2.0 to display the Image Name, Description and button controls to stop/play or viewing the next and previous image in the slide show. Associated button controls allow the users to stop the automated running Slide show and view the images manually by using next/ previous buttons.

AJAX SlideShowExtender Properties

TargetControlID: ID of the Image control to display the images of SlideShow program.

AutoPlay: Enables the feature to start to SlideShow automatically when page loads.

ImageTitleLabelID: ID of the Label control to display the Title/Name of the image.

ImageDescriptionLabelID: ID of the Label control to display the Description of the image.

NextButtonID: ID of the Button control to view the next image.

PlayButtonID: ID of the Button to play the SlideShow. Play Button performs the two functions. When user clicks on play button it plays the slide show and changes the text of the Play Button according to the property of AJAX SlideShow extender StopButtonText. When user again clicks on the PlayButton it stops the SlideShow.

PlayButtonText: Text to be displayed on the PlayButton e.g.: Play

StopButtonText: Text to be displayed on the PlayButton to stop the SlideShow. By Default PlayButton displays the PlayButtonText when user clicks the PlayButton to view the Slide Show then its Text changes to StopButtonText.

PreviousButtonID: ID of the Button to view the previous image.

Loop: If Loop is set to true then it plays the SlideShow in repeat/continuous order.

SlideShowServiceMethod: Name of the page script web service method to pass the array of Slide Show images.

You can use any method name for WebMethod but its return type should be of AjaxControlToolkit.Slide[].

Example

Output: when you run this application you will get the following result and image will be change automatically

4). Star Rating Extender Control

ASP.Net AJAX star rating extender control provides the functionality to rate the items such as pictures, articles or stories published on ASP.Net web pages. AJAX star rating control is very commonly used on community based ASP.Net web sites that allow the users to express their interest and satisfaction towards the associated item in terms of number of stars he/she gives to it using rating control. You can customize the look and feel of ASP.Net AJAX rating extender control using CSS styles. You can also adjust the behavior and display type of AJAX rating control using its different types of properties such as RatingAlign, RatingDirection, CurrentRating, Direction, HorizontalAlign etc. CSS styles based properties of AJAX star rating extender control allows you to set the CSS class styles to customize the different states of rating control e.g.: filled, saved and empty.

ASP.Net AJAX Star Rating Control Properties

CurrentRating: this property allows setting the default rating value.

MaxRating: Maximum value for rating that user can set using AJAX rating extender control. Default is 5

AutoPostBack: to allow the web page postback when user clicks the rating item.

ReadOnly: to enable or disable the rating control. If true then user can rate the items else not.

RatingAlign: this property supports two types of values: Horizontal, Vertical. By default it works with Horizontal alignment. This property changes the orientation of rating control whether to display the rating items vertically or horizontally.

RatingDirection: this property also supports two types of values: LeftToRightTopToBottom and RightToLeftBottomToTop. Rating direction property changes the way, how a user can set the value for rating. LeftToRightTopToBottom value for this property allows the user to select the rating value from left to right direction if RatingAlign="Horizontal" and top to bottom if RatingAlign="Vertical". RightToLeftBottomToTop value works similarly.

StarCssClass: Allows setting the common styles for different states of rating control items.

WaitingStarCssClass: Allows setting the style for rating control item while it is saving the selected value.

FilledStarCssClass: sets the style for active star items of rating control.

EmptyStarCssClass: sets the style for inactive stars of rating control.

OnChanged: calls the ClientCallBack event when the rating is changed by the user.

Tag: Optional. Passes the custom parameter to the ClientCallBack event

Sample HTML Code for ASP.Net AJAX Rating Control

Summary
I hope this article fulfills its purpose. I would like to have feedback from my blog readers.