Let’s consider we have below class for Customer entity. We will create a list of Customers and based on the value of “ShowURL” we are going to display the Web Sites URL.

    /// <summary>
    /// Customer Class
    /// </summary>
    internal sealed class Customer
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public string WebSite { get; set; }
        public bool ShowURL { get; set; }
    }

Here’s the code snippet for creating List and binding with GridView Control.

  /// <summary>
        /// Handles the Load event of the Page control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        protected void Page_Load(object sender, EventArgs e)
        {
            List<Customer> emps = new List<Customer>()
            {
                new Customer{ID=1, Name="Customer 1",WebSite="http://abhijitjana.net",ShowURL=true},
                new Customer{ID=2, Name="Customer 2",WebSite="http://abhisheksur.com",ShowURL=false},
                new Customer{ID=3, Name="Customer 3",WebSite="http://jebarson.info" ,ShowURL=true},
                new Customer{ID=4, Name="Customer 4", WebSite="http://atulvarma.com", ShowURL=false}

                };
            myGrid.DataSource = emps;
            myGrid.DataBind();
        }

In this example we are going to illustrate the binding with TemplateField, so here is the design view of GridView where we have Two column with two different template field. First one is the container of Name and second on is the container of Web Site.

Below images shows the output of the above binding.

Well, as of now all the site link are getting displayed in the GridView. But we have to display the links based on the value of “ShowURL”  field.

The most common solution we can find is “set visibility during GridView RowDataBound Event” as shown in below

/// <summary>
        /// Handles the RowDataBound event of the myGrid control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Web.UI.WebControls.GridViewRowEventArgs"/> instance containing the event data.</param>
        protected void myGrid_RowDataBound(object sender, GridViewRowEventArgs e)
        {
            if (e.Row.RowType == DataControlRowType.DataRow)
            {
                Customer cust = e.Row.DataItem as Customer;
                if (!cust.ShowURL)
                {
                    LinkButton lnkWebURL = e.Row.FindControl("lnk") as LinkButton;
                    if (lnkWebURL != null)
                    {
                        lnkWebURL.Visible = false;
                    }
                }
            }
        }

Above code will hide the link button from the GridView as shown in below image.

Well, do we really need to override myGrid_RowDataBound() for this small task ? Can’t we do it using Binding Expression. One similar question had  asked over  at Code Project and I am going to share the answer  which I have provided .

We can use Operator with in Bind Expression. Hence, we can set the visibility of Control using Binding Expression. We really don’t need to write code in RowDataBound just set the visibility of LinkButton as shown in below

How it works ?

This will do exactly we did in myGrid_RowDataBound() event. But we followed a different approach.  Eval(“ShowURL”) find evaluate the value of ShowURL From the GridView data source and then set the properties of LinkButton Visibility.  Based on the visible properties of LinkButton, controls renders on page.

We can also use any conditional operator with in the  Binding Expression as well as shown in below

That’s all. Very simple, but this will give you some idea to think on using Binding Expression in different ways as well.

Hope this helps.

Cheers !

Aj

Well the exact question was below,

Visual Studio IDE Process Attach Window display below below information for processes

• Process Name
• ID
• Title
• Type
• User Name
• Session

In default view of Process Attach window, processes are filtered based on  User Name  which is current context user and the Session. So, if you are logged in with a user, let say “Domain\User1” and your Worker Process (w3wp.exe) is running on same account then only you can view the process over there. This is not only for the worker processes, it is true for all other processes as well.

So, if you worker process running on some other credentials ( Account on which your Application Pool Running ) , you won’t be able to see the worker process list .

To view all the process which are running one other credentials you have to select “Show Process from all users” and “Show Processes in all sessions” . On Select of the above two checkboxes you will able to view the all the running process from where you can select respective worker process (w3wp.exe) to attach.

Yes, pretty simple.  You can check out my answer here as well  http://bit.ly/nehkhH

Here is one of my old post where I talked about Identifying Worker Process (w3wp.exe) – IIS 6.0 and IIS 7.0 for Debugging ASP.NET Application . This will help you to identify a particular worker process when multiple is running. If you are using IIS 7.0 and upper version you can take help of IIS Manager to identify the same.  This post will help you to know more details. How to use IIS Manager to get Worker Processes (w3wp.exe) details information ?

[ New Blog Post ] Not able to view all the running Worker Process in Visual Studio – Process Attach Window – Resolution bit.ly/qgWZXa—
Abhijit Jana (@AbhijitJana) August 18, 2011

If you wondering what is IntelliTrace,  Well, IntelliTrace debugging  is only available with Visual Studio 2010 Ultimate edition, which collects debugging information in background and can be used at any point to time to analysis previous debugging data. IntelliTrace collected debugger information into a trace log file (.iTrace ) that can then be opened and debugged using Visual Studio later.  You can use the log file at any point of time to see what happened exactly at background during your live debugging. To know more details, you can see my several articles published on IntelliTrace  and for step by step guide read “Debugging Application using IntelliTrace” from MSDN .

As we are going to use IntelliTrace, first do the initial setup for IntelliTrace from Tools > Option > IntelliTrace.  We have to select the second option “IntelliTrace events and call information” as this setting will collects all the event as well as internal call information.

As of now, that is all about IntelliTrace setting, Let’s have a quick look into ASP.NET Page Life Cycle startup, Any request comes from clients, first hits the kernel level HTTP.SYS of IIS.  HTTP.SYS and WAS Interacts each others and pass the request to proper Application Pool. Then Worker Process takes care of each and individual request. If you are interested, please read one of my article,Beginner’s Guide: How IIS Process ASP.NET Request which talks about internal of ASP.NET Request Processing. Once the request done with HTTP Pipeline Processing, request enters into Page Lifecycle  state.  Below pictures illustrate the same.

It is bit difficult to remember exactly what happens and when during the ASP.NET page lifecycle.  But if you really look into general stages of ASP.NET Page lifecycle, we can majorly classified below stages

1. Page Request
2. Start
3. Page Initialization
4. Load
5. Validation
6. Postback event handling
7. Rendering
8. Unload

To know more about each and individual stages, please read this article from MSDN .

Now let me start with a simple web application that consist of a Master Pages, User Control and Main page having some data in grid. I am putting master pages, user controls, grid view together  to show how they really works internally.  Both the Grid and User controls reads some data from Data Base.

If I run the web application, I will get the below out put.

Now, get back to Visual Studio and Break the IntelliTrace Event from IntelliTrace Window ( Debug > Window > IntelliTrace Call Window )

Once you click on “Break All” , you will get so many events including thread, file access ( Which depends on IntelliTrace Settings ). But to make it very simple, filter the information based on the ASP.NET as shown in below picture

Let’s have a in-depth look what are the information it captured.  If you click on the first event, which is actually an Asynchronous call the the HTTP Handler initialized and first GET request the ASPX Page.

Click on the “Call View” for more details, below information will appear which talks about many internal stuff of ASP.NET.

Let’s start with Application_Start() Event is fired when the first instance of the HttpApplication class is created. It allows you to create objects that are accessible by all HttpApplication instances during the Application Life Cycle. If you click on the particular row in the IntelliTrace window, you will be automatically redirect to to code as well.

On finishing of the Application_Start(), the next event fire is “Session_Start”. IntelliTrace will also capture the information for Session.

Once the request passed through Session_Start(), it’s entered into actual Page Life Cycle state is which the Process Request for a particular page.  If you look at the below picture, it’s talks about  everything of a page life cycle.  IntelliTrace Captured all in-between events of  Page_Process Request Start to Page_Process Request End.  Note, we send the the request for Defualt.aspx ( Get / Default.aspx) , hence ASP.NET Engine will start the processing for Default.aspx.  As this Page has a user control and contain with in a Master page you can see there are several events fired with in process request that are related with master pages and user controls. 

Image : Page Process Request

Before explaining about the above images, here is some golden rule that ASP.NET follows during page life cycle events.  PreInit() of request pages fired first and followed by init event of User Control, Master Pages and then finally init event for the requested page. This is the sequence how ASP.NET fired up events. Below image illustrate the same.

Now, coming back to Page Process Request image, I have marked the images with few numbers to under stand the sequence of execution.

With the start of ASP.NET Page Process Request, ASP.NET runtime engine called a method ASP.<Pagename> _aspx.FrameworkInitialize() , or Page.FrameworkInitialize() method  to initializes the Page object and creates the control tree based on the declarative nature of the page. One more thumb rule here is, you should not override this methods, if you are doing so don’t forget to call base class’s FrameworkInitialize method.

If you again deep dive with with in Bind Control Tree,  you can see the each and every control binding.  During this phase asp.net did some top level binding for aspx pages, like page title set, setting up the master pages and also Add the Content Templates for Content Place holder. Note, if you don’t have the master page, you won’t be able to see this events during page life cycle. I took example with master page so that I can cover all the stuff.

Once done with the FrameworkInitialize(), Request moves to Page OnPreInit() events.  If you use the IntelliTrace navigator, you can go to inside of event recorded by IntelliTrace also can see the corresponding code.   You can read Page.PreInit() for more details.

Once done with PreInit(),  request moves to FrameworkInitilization() of Master Page. During this phase, ASP.NET creates control tree for the master pages.

during this phase you can also find , how each and every controls adding to control tree.

Once ASP.NET done with FrameworkInitialize of  Master pages,  ASP.NET engine fires Init() event for  User Control . This events raised after all controls have been initialized . Read more about Init()

The next event it will fire is, init of Master page, if you are not overriding it the event will move to Init() event  of Default.aspx page.

Once done with Page_Init(), ASP.NET fires Page_Load() event for  default.aspx page. followed by Page_Load of Mater Page and then User Control . Below is the sequence diagram for Page_Load() for page, master page and User control, yes it’s revers the over of Init() method.

IntelliTrace Traps the Same, Using IntelliTrace we can see, first Page_Load() of default.aspx fires, followed by Page_Load() of master page, then Page_Load() of User control.

In the next phase, before Saving the Data on View State it will load all the data from backend . You can see the corresponding ADO.NET events, that fires for load data from from backend saver.

Once that is done, SaveViewState() methods is been called to store the data with in View State.  “Save State Completed” raised after view state and control state have been saved for the page and for all controls.

once the View data been saved, ASP.NET calls Render method that that writes out the control’s markup to send to the browser

You can also override other methods of page lifecycle to get more details view. On Page Post back, you can explore the different events for post back as well,  like if you clicked on some button, IntelliTrace will show you how post back has been initialized also you can view the sequence of ASP.NET Page life while post back.

To summarize the whole stuff, I have discussed how you can use the power of IntelliTrace to visualize the each and every events which are related with ASP.NET Page life cycle. Most of us knows about the basic events of Page Life Cycle, but using IntelliTrace you must have see something new stuff and also  seen what are the internal methods been called during page lifecycle.

That’s all guys !  Hope you have enjoyed the reading ! Let me know if you have any query regarding this !

Cheers !

Aj

ASP.NET Internals : Visualizing ASP.NET Page Life Cycle using IntelliTrace http://wp.me/ppvPE-IT—
Abhijit Jana (@AbhijitJana) June 26, 2011

ASP.NET Provides below methods to clearing or removing Session information.

• Session.Clear()
• Session.RemoveAll()
• Session.Abandon()
• Session.RemoveAt(index)
• Session.Remove(string);

We will be mainly focusing the first 3 methods.

Let’s start with Session.Clear() and Session.RemoveAll(). Well, you may ask, why I am starting with two methods together. Yes, we are in same track. Both Session.Clear() and Session.RemoveAll() does the same job. Let’s explore it

Session.Clear () Vs. Session.RemoveAll()

Let’s assume  stored below information with in session variable.

now, if you want to remove all the items from session you can use either Session.RemoveAll() or Session.Clear().   if you check the definition  from meta data file you will get below details, where description says the same.

Then what is the difference between these two ? Ok, Session.RemoveAll() Calls Clear() method internally. Yes it is.  if you explore this with IL Disassembler ( for Session.Web.dll ) you will find, Session.RemoveAll() is calling Clear() for that the session object instance.

Open IL DASM, browse System.Web.dll from Framework Directory and navigate to System.web > System.Web.SessionState > System.Web.SessionState.HttpSessionState

Now check for Clear() and RemoveAll() method using IL DASM

Session.Clear() :

Session.RemoveAll() : Calling Clear() internally.

If this looks like bit difficult to understand you can use Reflector ( I used Red get Reflector, you can download free trial)  to get the more details.

As show in below image, Session.Clear()  clearing the Session Container .

And if you check the details for Session.RemoveAll(), you will find, it is calling Clear() method internally.

Most important thing, you can check the dependency graph for this two method, you will find, Session.RemoveAll() depends on Clear() method.

Session.Clear() is used by RemoveAll() and Session.RemoveAll() depends on Session.Clear()

Now, what does this two methods do ?

• They  removes all keys and values from the session-state collection . which means just remove the session items nothing more than that and session ID Will remain Same

Session ID Before Remove

Now, if you use Session.RemoveAll() or Session.Clear() , it will just clear the items from session collection, but Session Id will remain Same.

This means, if you add another new  element in the same session context, ID will remain same.

Now, you may have once question, why we need two different method where as they are performing the same job. Well as per my understand this is just for providing a generic using of collection by using RemoveAll() method and supporting the all other previous method structure. Clear() is their from beginning from Classic ASP Version, which used to do the clean up the Session Container. So RemoveAll() is just a wrapper which use Clear() internally and provide a collection method to remove all the session information.

Session.Clear() and Session.RemoveAll() never raised Session_End() . Session_End raised by Session.abandon() and if we are not explicitly calling the Abandon(), then Session_End will fire on SessionTimeOut

Hope this give you a clear understanding of internal details of Session.RemoveAll() and Session.Clear().

where as Abandon method destroys all the objects stored in a Session object and releases their resources. Once you call this method, Session_End will raised automatically.

When you abandon a session, the session ID cookie is not removed from the browser of the user. Therefore, as soon as the session has been abandoned, any new requests to the same application will use the same session ID but will have a new session state instance.

Read Complete Details on : How and why session IDs are reused in ASP.NET

If we don’t call Abandon method explicitly, the server destroys these objects when the session times out.  Which means, for Session.Clear() and Session.RemoveAll(), just session data get removed, but session still alive, but Session.Abandon() Destroy the all object.

So, if you want to know the main difference with Session.Clear() / Session.RemoveAll()  and Session.Abandon()

• Clear removes items immediately from session collection, Abandon destroy the objects.
• Abandon raised Session.End()
• Clear keeps SessionState and resources associated with it where as abandon releases them and GC can collect them any time

Here is an nice link, which talk about different opinion about this three methods http://bit.ly/kr7diK

And, finally Session.RemoveAt(index) and Session.Remove(string) removed the item from specified index and from given item name of session collection. If either of index or item variable missing, it will throw an exception. This methods are useful when we want to remove some specific item from session Collection.

Well, that’s all. The main objective was to look inside Session.Clear(), Session.RemoveAll() and Session.Abandon(). Hope this gave you a good understanding.

Cheers !

Abhijit

[New Blog Post ] ASP.NET Internals : "Clearing ASP.NET Session Variables" a in-depth look http://wp.me/ppvPE-H1 #aspnet #dotnet #webdev #dev—
Abhijit Jana (@AbhijitJana) June 03, 2011

Well, One of the easiest way that we can implement is by Enum.GetNames(Type enumType)which retrieves the name list of enumberation  and Enum.GetValues(Type enumType), which returns the list of values for each names .

Once we have the Names and Values, we can easily bind with any ListControl by just iterating with them.

  public void BindEnumToListControls(Type enumType, ListControl listcontrol)
        {
            string[] names;
            Array values;
            int countElements, upperBound, lowerBound;
            names = Enum.GetNames(enumType);
            values = Enum.GetValues(enumType);
            for (countElements = 0; countElements <= names.Length - 1; countElements++)
            {
                listcontrol.Items.Add(new ListItem(names[countElements].ToString(), values.GetValue(countElements).ToString()));
            }
        }

You will have the below output

Now let’s have a quick look on how to call BindEnumToListControls() method, yeah very simple

  protected void Page_Load(object sender, EventArgs e)
        {
            BindEnumToListControls(typeof(CustomerType), DropDownList1);
            BindEnumToListControls(typeof(CustomerType), checkboxlist);
            BindEnumToListControls(typeof(CustomerType), ListBox1);
            BindEnumToListControls(typeof(CustomerType), RadioButtonList1);
        }

You must be thinking why iterating through each and every names why not using LINQ instead of that.  Well, it’s time to optimized it .

The easiest way to do it with LINQ is to convert the enum into Dictionary and Set the DataSource of List. Why Dictionary ? Because we want to bind with both Key and Value Pair for Dropdown list.

  public void BindEnumToListControls(Type enumType, ListControl listcontrol)
        {
            string [] names = Enum.GetNames(enumType);
           List.DataSource = strNames.Select((key, value) =>
                                       new { key, value }).ToDictionary(x => x.key, x => x.value + 1);
            listcontrol.DataTextField = "Key";
            listcontrol.DataValueField = "Value";
            listcontrol.DataBind();
        }

Above code will do the same as we have in the previous output.  But this approach certainly having a small problem . . If you look into the ViewSource of the above generated html and verify the Value Field for each and every control. All the value field are containing the sequential value.

In some certain case, Enum may contain the Value as well, so that time we need to bind the actual value instead of overriding the value while creating the Dictionary as shown in below snippet .

I was thinking for some different approach but which leads me using for-each only. Then I look for some solution, and found one very interesting post, which handles this in a smart way.

      public void BindEnumToListControls(Type enumType, ListControl listcontrol)
        {
            string [] names = Enum.GetNames(enumType);
            listcontrol.DataSource = Enum.GetValues(typeof(CustomerType)).Cast<Int32>()
                                      .ToDictionary(currentItem =>
                                          Enum.GetName(typeof(CustomerType), currentItem));
            listcontrol.DataTextField = "Key";
            listcontrol.DataValueField = "Value";
            listcontrol.DataBind();
        }

Now from the below image, you can see the Customer Type value is applied to the List elements.

Looking for simplest and handy  ways, here is two nice post by Suprotim Agarwal

How to Bind an ASP.NET DropDownList to an Enumeration with two lines of code

How to Bind An Enum Name and Value to an ASP.NET DropDownList

Cheers !
AJ

To make it very simple let’s consider we have a contact form with Name, Email, Web Site and Comments Field. Our objective is to load and show the help content based on the control selection as shown in below image.

Content for the help file is being retrieved from one static HTML file which is kept in the server. On the selection of the ASP.NET control, based on the Control Id we have to retrieved the content.

Below is the HTML Content which is being read as help content for the controls.

One selection of  any Text Box in web form, jQuery will send a call to sever to load the Help content for Text box. Now question is how the content is getting matched with the control ? . This is simply done using Control Id. You may have noticed that I have given an  id for every  div element which is actually the same id of the ASP.NET Control in our web forms. On  every jQuery.Load() after loading the file form server, first filter will apply then content will be rendered.

Below is the sample code for the same

 <script type="text/javascript">
        $(document).ready(function () {
            var textboxes = $(":text");
            var textareas = $("textarea");
            $(":text").focus(function () {
                textboxes.removeClass("textboxstyleClass");
                textareas.removeClass("textboxstyleClass");
                $(this).addClass("textboxstyleClass");
                var id = $(this).attr('id');
                $("#helpviewer").slideUp();
                $("#helpviewer").slideDown("slow");
                $("#helpviewer").load('Help/Help.htm ' + "#" + id);
            });

            $("textarea").focus(function () {
                textboxes.removeClass("textboxstyleClass");
                $(this).addClass("textboxstyleClass");
                var id = $(this).attr('id');
                $("#helpviewer").slideUp();
                $("#helpviewer").slideDown("slow");
                $("#helpviewer").load('Help/Help.htm ' + "#" + id);
            });
        });
    </script>

How it works ?

Let’s have a quick look how the things happens in back end. Below diagram is the over all representation of the whole process.

Let me explain the steps by considering  “Email” text box has been selected by end user

1. On Selection of “Email” Text Box,  Control.focus() event will fire, as this has already been associated with the text box.

2. Below statement gets the “id” for corresponding selected textbox control.

var id = $(this).attr('id');

3. Now Current Value of id=”textEmail” [ As we considered “Email” text box is selected ]

4. $(control).load() will actually do the job for reading the content from server. Please read more about .load() function

below code block will load all the content and render the value with  “helpviewer” placeholder.

$("#helpviewer").load('Help/Help.htm ')

But, as we need the filtered content, we need to pass the ID of the control to  filtered the content based on the id.

On run time, below is the constructed statement which is been used to load the Help Text  content for Email Text Box.

$("#helpviewer").load('Help/Help.htm #textEmail ')

5/ 6 / 7 . Content filtered based on the id and rendered with the div element.

I have added few animated event like showup() and showdown() to looks the things bit fancy.

Quick Demo

Below is the complete code block .

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

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head id="Head1" runat="server">
    <title></title>
    <style type="text/css">
        td
        {
            font-weight: 100;
            color: brown;
        }
        table
        {
            border: 1px solid gray;
        }

        .textboxClass
        {
            border: 1px;
            border-color: #6E6E6E;
            border-style: solid;
            background-color: #ffffff;
        }

        .textboxstyleClass
        {
            border: 1px;
            border-color: #C73E2C;
            border-style: solid;
            background-color: #D9D9D9;
        }

        #btnsubmit
        {
            border: 1px;
            border-color: #C73E2C;
            border-style: solid;
            background-color: #D9D9D9;
        }
    </style>
    <script type="text/javascript" src="Scripts/jquery-1.4.1.min.js"></script>
    <script type="text/javascript">
        $(document).ready(function () {
            var textboxes = $(":text");
            var textareas = $("textarea");
            $(":text").focus(function () {
                textboxes.removeClass("textboxstyleClass");
                textareas.removeClass("textboxstyleClass");
                $(this).addClass("textboxstyleClass");
                var id = $(this).attr('id');
                $("#helpviewer").slideUp();
                $("#helpviewer").slideDown("slow");
                $("#helpviewer").load('Help/Help.htm ' + "#" + id);
            });

            $("textarea").focus(function () {
                textboxes.removeClass("textboxstyleClass");
                $(this).addClass("textboxstyleClass");
                var id = $(this).attr('id');
                $("#helpviewer").slideUp();
                $("#helpviewer").slideDown("slow");
                $("#helpviewer").load('Help/Help.htm ' + "#" + id);
            });
        });
    </script>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <table cellpadding="2" cellspacing="2">
            <tr>
                <td colspan="2">
                    <div style="border-bottom-style: 1px;">
                        Contact Form
                    </div>
                </td>
            </tr>
            <tr>
                <td>
                    Name
                </td>
                <td>
                    <asp:TextBox CssClass="textboxClass" runat="server" ID="textName" Width="348px" />
                </td>
            </tr>
            <tr>
                <td>
                    Email
                </td>
                <td>
                    <asp:TextBox CssClass="textboxClass" runat="server" ID="textEmail" Width="348px" />
                </td>
            </tr>
            <tr>
                <td>
                    Web Site
                </td>
                <td>
                    <asp:TextBox CssClass="textboxClass" runat="server" ID="textWebSite" Width="348px" />
                </td>
            </tr>
            <tr>
                <td>
                    Comments
                </td>
                <td>
                    <asp:TextBox CssClass="textboxClass" runat="server" TextMode="MultiLine" ID="textComments"
                        Height="72px" Width="425px" />
                </td>
            </tr>
            <tr>
                <td colspan="2" align="right">
                    <asp:Button ID="btnsubmit" Text="Submit" runat="server" />
                </td>
            </tr>
            <tr>
                <td colspan="2">
                    <div id="helpviewer" style="border: 1px solid gray; display: none">
                    </div>
                </td>
            </tr>
        </table>
    </div>
    </form>
</body>
</html>

This is a simple demonstration, you can use this approach to make some good stuff  like for every control you can Append some image and show some tool tip, use some nice javascript tool tip etc.

Hope this will help.

Cheers !

AJ

The basis of the complete implementation is stands on developing a custom ASP.NET Control. Here I will be developing a custom ASP.NET Repeater control which inherits  from Repeater as you can see in the bellow code snippet.

Now, once you inherits you control from default Repeater control, you have access of all methods and properties of Repeater control. The most important thing to here that you need to know about ITemplate Interface. ITemplate defines the behavior for populating a templated ASP.NET server control with child controls . These ITemplate having a method InstantiateIn which actually instantiate the template with in the control object.  As we required an Template here I created a  properties named “EmptyTemplate” of type “ITemplate”

   [PersistenceMode(PersistenceMode.InnerProperty)]
        public ITemplate EmptyTemplate
        {
            get;
            set;
        }

In the above code snippets you have notices I have added one attributes as

 PersistenceMode(PersistenceMode.InnerProperty)] 

These actually define the type of the property with PersistenceMode Enumeration. InnerProperty tells the control that these properties should be used a inner nested tag not as top level attributes.  I discussed about few other values in later part of this article.

Once we are done with the Property define , we just need to override the CreateChildControls() and OnDataBinding() Events.

     /// <summary>
        /// Creates the child controls.
        /// </summary>
        protected override void CreateChildControls()
        {
            base.CreateChildControls();
            EnabledEmptyTemplate();
        }

        /// <summary>
        /// Raises the DataBinding event.
        /// </summary>
        /// <param name="e">An <see cref="T:System.EventArgs"/> object that contains the event data.</param>
        protected override void OnDataBinding(EventArgs e)
        {
            base.OnDataBinding(e);
            EnabledEmptyTemplate();

        }

        /// <summary>
        /// Enableds the empty template.
        /// </summary>
        private void EnabledEmptyTemplate()
        {
            if (this.Items.Count <= 0 && EmptyTemplate != null)
            {
                this.Controls.Clear();

                EmptyTemplate.InstantiateIn(this);

            }
        }

While overriding those methods, I have internally called a method EnabledEmptyTemplate() which actually checks for the Item Counts, if its &lt;=0,  it will Instantiate the EmptyTemplate.

That’s all. If you build the control, you will get an Control Icon with in ToolBox, which you can directly drag and drop.

Now let’s consider you have bellow Student Data Source which you want to bind with this gridview

Sample Student Data Source and binding with repeater

  public partial class _Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            List<MyClass> names = new List<MyClass>()
            {
            new MyClass { Name ="Student 1", Address="Address 1"},
            new MyClass { Name ="Student 2", Address="Address 2"},
            new MyClass { Name ="Student 3", Address="Address 3"},
            new MyClass { Name ="Student 4", Address="Address 4"}
            };
                  ExRepeater1.DataSource = names;
            ExRepeater1.DataBind();
        }
    }

    class MyClass
    {
        public string Name { get; set; }
        public string Address { get; set; }
    }

Design View for Custom Repeater

    <cc1:ExRepeater ID="ExRepeater1" runat="server"  >
            <HeaderTemplate>
                <table>
                    <tr>
                        <td>
                            Name
                        </td>
                        <td>
                            Address
                        </td>
                    </tr>
                 </HeaderTemplate>
            <ItemTemplate>
                <tr>
                    <td>
                        <%#Eval("Name")%>
                    </td>

                    <td>
                        <%#Eval("Address")%>
                    </td>
                </tr>
            </ItemTemplate>
            <EmptyTemplate>
               <tr><td> No Records Exist !!!!</td></tr>
            </EmptyTemplate>
            <FooterTemplate>
            </table>
            </FooterTemplate>
        </cc1:ExRepeater>

Output

Now, if there is no records in the data source, output will be look like below

Well, this is exactly what we were looking for. So now you have one Template called “EmptyTemplate” where you can put what ever the content you want to rendered if the data source is empty.

ShowHeaderWhenEmpty

You have noticed, the message “No Records Exists” is being displayed along with the header. Now if you want the same features like GridView, that you need control on the showing or hiding header when records is empty.

Let’s add a bool type property with name ShowHeaderWhenEmpty ,

This properties will accepts a Boolean value based on that Header will be shown. One more point over here is,  PersistenceMode.Attribute, which means I am going to use the properties as a top level attributes tag. So ShowHeaderWhenEmpty will be accessible as shown in below

Below Snippets describes how to implement the ShowHeaderWhenEmpty Properties.

      /// <summary>
        /// Enableds the empty template.
        /// </summary>
        private void EnabledEmptyTemplate()
        {
            if (this.Items.Count <= 0 && EmptyTemplate != null)
            {
                this.Controls.Clear();

                // Instantiate Header Template When Item count 0
                if (ShowHeaderWhenEmpty == true)
                {
                    HeaderTemplate.InstantiateIn(this);
                }

                EmptyTemplate.InstantiateIn(this);
            }
        }

ShowFooterWhenEmpty

Like Header, you can implement the same to show or hide footer when there is no records in repeater.

      /// <summary>
        /// Enableds the empty template.
        /// </summary>
        private void EnabledEmptyTemplate()
        {
            if (this.Items.Count <= 0 && EmptyTemplate != null)
            {
                this.Controls.Clear();
                EmptyTemplate.InstantiateIn(this);
            // Instantiate Footer Template When Item count 0
                if (ShowFooterWhenEmpty == true)
                {
                    FooterTemplate.InstantiateIn(this);
                }

            }
        }

ShowCount

By this properties I just wanted to show the customization or enhancement idea. Let’s say you want to display the number of total records at the end of the repeater, so by using these properties you can enable or disabled it.

If you make it true, you will get the number of records count at the end of repeater records.

Below is the implementation for the same.

      /// <summary>
        /// Enableds the empty template.
        /// </summary>
        private void EnabledEmptyTemplate()
        {
            if (this.Items.Count <= 0 && EmptyTemplate != null)
            {
                this.Controls.Clear();

                // Instantiate Header Template When Item count 0
                if (ShowHeaderWhenEmpty == true)
                {
                    HeaderTemplate.InstantiateIn(this);
                }

                EmptyTemplate.InstantiateIn(this);
            }
        }

ShowFooterWhenEmpty

Like Header, you can implement the same to show or hide footer when there is no records in repeater.

       /// <summary>
        /// Raises the DataBinding event.
        /// </summary>
        /// <param name="e">An <see cref="T:System.EventArgs"/> object that contains the event data.</param>
        protected override void OnDataBinding(EventArgs e)
        {
            base.OnDataBinding(e);
            EnabledEmptyTemplate();
            if (ShowCount == true)
            {

                this.Controls.Add(new LiteralControl("<br/>Total Number of Records : " + this.Items.Count ));
            }
        }

Put everything Together :

// Custom Repeater With EmptyItemTemplate and ShowHeaderWhenEmpty Properties
namespace RepeaterTest
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web;
    using System.Web.UI.WebControls;
    using System.ComponentModel;
    using System.Web.UI;

    /// <summary>
    /// Advance ASP.NET Repeater with EmptyTemplate, ShowHeaderWhenEmpty, ShowFooterWhenEmpty
    /// </summary>
    [ToolboxData("<{0}:ExRepeater runat=server>")]
    public class ExRepeater : Repeater
    {
        #region Repeater Properties

        /// <summary>
        /// Gets or sets a value indicating whether [show header when empty].
        /// </summary>
        /// <value>
        /// 	<c>true</c> if [show header when empty]; otherwise, <c>false</c>.
        /// </value>
        [PersistenceMode(PersistenceMode.Attribute)]
        public bool ShowHeaderWhenEmpty
        {
            get;
            set;
        }

        [PersistenceMode(PersistenceMode.Attribute)]
        public bool ShowFooterWhenEmpty
        {
            get;
            set;
        }

        /// <summary>
        /// Gets or sets the empty template.
        /// </summary>
        /// <value>The empty template.</value>
        [PersistenceMode(PersistenceMode.InnerProperty)]
        public ITemplate EmptyTemplate
        {
            get;
            set;
        }

        /// <summary>
        /// Gets or sets the empty template.
        /// </summary>
        /// <value>The empty template.</value>
        [PersistenceMode(PersistenceMode.Attribute)]
        public bool ShowCount
        {
            get;
            set;
        }

        #endregion

        #region Repeater Methods

        /// <summary>
        /// Creates the child controls.
        /// </summary>
        protected override void CreateChildControls()
        {
            base.CreateChildControls();
            EnabledEmptyTemplate();
        }

        /// <summary>
        /// Raises the DataBinding event.
        /// </summary>
        /// <param name="e">An <see cref="T:System.EventArgs"/> object that contains the event data.</param>
        protected override void OnDataBinding(EventArgs e)
        {
            base.OnDataBinding(e);
            EnabledEmptyTemplate();
            if (ShowCount == true)
            {

                this.Controls.Add(new LiteralControl("<br/>Total Number of Records : " + this.Items.Count ));
            }
        }

        /// <summary>
        /// Enableds the empty template.
        /// </summary>
        private void EnabledEmptyTemplate()
        {
            if (this.Items.Count <= 0 && EmptyTemplate != null)
            {
                this.Controls.Clear();

                // Instantiate Header Template When Item count 0
                if (ShowHeaderWhenEmpty == true)
                {
                    HeaderTemplate.InstantiateIn(this);
                }

                EmptyTemplate.InstantiateIn(this);
            }
        }

        #endregion
    }
}

Summary : In this post I have explained how you can customize your repeater control by adding must needed features likes EmptyTemplate, ShowHeaderWhenEmpty,ShowFooterWhenEmpty,ShowCount.

Hope this will help !

Cheers !

AJ

This ASP.NET Development Server is nothing but a executable file (WebDev.WebServer) which used by Visual Studio to execute you web application when it’s running in the context of Visual Studio.  You can find the executable file at <\Program Files (x86)\Common Files\microsoft shared\DevServer\10.0> . This folder contain two different executable

• WebDev.WebServer20.EXE
• WebDev.WebServer40.EXE

WebDev.WebServer20 is targeted to CLR 2.0, which means all the ASP.NET Application which are targeted till FW .NET 3.5 will be taking care by WebDev.WebServer20.EXE and WebDev.WebServer40.EXE for ASP.NET 4.0 based application.

Now, let’s see how we can use these executable to run an ASP.NET 4.0 Application with out using Visual Studio.

Step 1 : Open the Command Prompt for “Program Files (x86)\Common Files\microsoft shared\DevServer\10.0”

Easiest way to go there, type Cmd in the address bar ( If you are using Win 7), this will directly open command prompt with exact path .

Source for this cmd Tip : http://twitter.com/#!/pbrooks/status/35734806549495808 

Step 2: [Optional] Type WebDev.WebServer40 and Press Enter, this will open a popup window with the details of required parameter

Step 3 : If you are done with review, type below command in your command prompt

Note : Port number should be valid and not in used by any other process and path is location of your published web apps.

Step 4: Once done, press Enter, you will see a pop up notification in system tray

If you double click on that icon you will get below window of ASP.NET Development server, which is exactly same notification window which we used to get when we run some ASP.NET Application from Visual Studio.

This indicates your application is running now.

Step 4: Open IE > Type http://localhost:<portnumber> , you are there !

Now let us look at the value. It looks likes an encrypted string. This is nothing but Base64 Encoded string and it is not an encrypted string.  So it can be easily decoded.

The main reasons for making it Base64 encoding are as follows:

1.  Base64 makes a string suitable for HTTP transfer

2. It makes it a little harder to read .

But people often get confused that this is an encrypted string.

Let us try to decode the string using ViewState Decoder (A nice tool created by Fritz Onion).

After decoding the string, we can see the exact data that is stored inside the ViewState. 

You can write few lines of code to decode the text and you will get the exact view state information.

So here is how the ViewState Works,

By default, ViewState is serialized into a base-64 encoded string. On PostBack, the ViewState information is loaded and reapplied to the persisted state of the Control in the Control Hierarchy.

There are two different ways in which you can prevent someone from decrypting the ViewState data.

1. You can make sure that the view state information is tamper-proof by using “hash code“. You can do this by adding “EnableViewStateMAC=true” in your page directive. MAC Stands for “Message Authentication Code”

When we use EnableViewStateMac=”True”, during ViewState save, ASP.NET internally used a hash code. This hash code is a cryptographically strong checksum. This is added with the ViewState content and stored in hidden filed. During  post back, the checksum data is verified again by ASP.NET. If there are some mismatches, Post back will be rejected.

2. Second option is to set ViewStateEncryptionMode=”Always” with your page directives. This will encrypt the view state data. You can do this in the following way:

The ViewStateEncryptionMode has three different options that can be set:

• Always : encrypt the view state always
• Auto  : encrypt if any control requests specifically for encryption . For this to happen, the control must call Page.RegisterRequiresViewStateEncryption() method to request encryption.
• Never : Never encrypt the ViewState data

If you make the ViewStateEncryptionMode=”Always” and try to decode the ViewState data, you will get information as shown below.

We can also enable these settings for “EnableViewStateMAC” and ViewStateEncryptionMode” in web.config .

Note: Try to avoid ViewState Encryption if it is not necessary as it can cause the performance issues.

If you are a beginner with ViewState, please read my article on ViewState – Beginner’s Guide To View State

Items collections of HttpContext is and IDictionary key-value collections and that are shared across a single HTTPRequest. Yes, HttpContext.Current.Items  valid for  a single HTTPRequest.  Once after processing, server  information  is sent back to the browser, the variables that were set in the Items[] collection will lost. Where as for Session Variable, information valid for multiple request as this is user specific. The session variable only  expires either on Session Time Out or explicitly clear the values.

Let’s have a quick look how we can store information in in HttpContext.Current.Items

 HttpContext.Current.Items["ModuleInfo"] = "Custom Module Info”
 

And retrieve it like

 string contextData = (string)(HttpContext.Current.Items["ModuleInfo"]);
 

As I said,  HttpContext.Current.Items, stores data for very limited time period, then when we can use this ?  Yes, This is extremely useful when we can want to share content between HttpModule and HTTPHandler.

Because each and every client requests pass through the HTTP Pipeline and HTTP Pipeline consists of HTTP Module and HTTP Handler. So If you are writing one custom HTTP Module by Implementing IHttpModule and you want pass some information from this module  to current requested  page or any other module you can use the HttpContext.Current.Items  to store the data.

Similarly, you use HTTPContext  Items collection when you are sharing same information across the different instance based on the user request and that request could be change for different request.

While using Context Items collections you need to keep one things that, Items collections holds the objects, so you need to do proper type casting while retrieving it.

To Summarize, in ASP.NET HttpContext.Current.Items allows us to hold information for an single request. We can use it to store short term information. Storing such kind information extremely helpful to send information across different custom modules or to requested pages. You have to make sure that, the data you are using in HttpContext.Current.Items  is only valid for that current request and data should be flashed out automatically when request sent to browser for any new request you have to store the data again. Where as session variable is valid for every request unless session timeout not reached or we are explicitly clear the session.

Hope this will help !

Thanks !

AJ