Wednesday, March 24, 2010

Detecting Refresh or Post back in ASP.NET

Detecting Refresh or Post back in ASP.NET

The problem

There are situations where we would like to detect if the post back is from a form interaction (i.e. submit or button clicks) or is it by hitting the browser F5 refresh button. Many of them will jump saying how about checking ‘Ispostback’ value. ‘IsPostback’ will always have the value which was set previously. So for instance if the page was posted back before refresh, then the value will be true and if the page is not posted back before refresh, then the value will be false.This article will first explain the fundamentals of how to solve the above problem and later this article will go in depth of how the source code looks like.Please feel free to download my free 500 question and answer eBook which covers .NET , ASP.NET , SQL Server, WCF , WPF , WWF , Silver light , Azure @


The solution which this article proposes first came in an ASP.NET book written by Dino Esposito and it was taken further by Mr. SimoneB to make a small open source code which you can get from A brief explanation is also provided at this link.

The article will go step by step to explain the ideas proposed by Mr. Dino Esposito in a simplified manner.

The fundamental

Step 1 :- We have created a javascript which will generate unique fresh GUID in submit button click. This GUID will be stored in the HttpContext object.
• Step 2 ( User presses submit click ) :- If user presses submit button it will call the necessary javascript function to create the new fresh GUID again.
• Step 3 :- In ‘HttpHandler’ or ‘HttpModule’ the new GUID value is checked with the old GUID value. If the values are not equal then it means this was not called from a submit click and it’s a refresh event. Accordingly the HttpContext session value is set.
• Step 4 :- In the page load we can then check if this was a refresh or post back using the session variables.

3 important parts of the code

There are 3 important part of the code to be understood :-
• Javascript which generates the unique GUID.
• HtppHandler which checks if the old value is equal to the new value.
• ASP.NET page which finally checks if it’s a refresh or postback and handles logic accordingly.

Javascript code

So first lets start with the javascript code. The ‘genereateRandomSequence’ function generates unique GUID by using ‘math’ functions like ‘random’ and ‘floor’.The ‘onPostBack’function calls ‘generateRandomSequence’ function to generate GUID and attach the same to a hidden field with name ‘hdnGuid’. This hidden field is generated on fly in the ‘HttpHandler’ module which will be explained shortly. Below is the code snippet for the same.

function onPostBack()
var y=generateRandomSequence();
var hdnGuid=document.getElementById("hdnGuid");
function generateRandomSequence()
var g = "";
for(var i = 0; i < 32; i++)
g += Math.floor(Math.random() * 0xF).toString(0xF)
return g;

The above javascript function is referred in a JS files and called on the button submit click as shown in the below HTML code

<title>Untitled Page</title>
<script type="text/javascript" language="javascript" src="Client-Side_Validn.js"></script>
<form id="form1" runat="server" onsubmit="onPostBack()">
<asp:Button ID="Button1" runat="server" Text="Button" />

HttpModule code

The next important code is the ‘HttpModule’ code. As a first step let’s create a simple GUID class which help us store the GUID values as shown in the below figure.
public class GuidClass
private string guid;
public string Guid
return guid;
guid = value;

The next step is to create a simple ‘HttpModule’ class which overrides the ‘page_Init’ event and the ‘page_Load’
event. In the ‘page_Init’ event we have created a simple hidden field by name ‘hdnGuid’ which is attached to the page on the first hit itself.

void _page_Init(object sender, EventArgs e)
HiddenField hdnGuid = new HiddenField();
hdnGuid.ID = "hdnGuid";
if (!_page.IsPostBack)
hdnGuid.Value = Guid.NewGuid().ToString();

In the ‘page_Load’ event we check if the hidden field value is same as the old value. In case the value is not same that means
it’s a ‘postback’ and if the value is same then its ‘refresh’. As per situation we set the ‘httpContent.Items[“Refresh”]’ value.

void _page_Load(object sender, EventArgs e)
HiddenField h1 = (HiddenField)(_page.Form.FindControl("hdnGuid"));
GuidClass currentGuid =new GuidClass();
currentGuid.Guid= h1.Value;
System.Web.HttpContext _httpContext = System.Web.HttpContext.Current;
if (temp.Contains<string>(currentGuid.Guid))

We also need to ensure that the handler is registered in the ‘httpModules’ tag.
<add name="Myhandler" type="Myhandler"/>

ASP.NET page code

The final part is to detect in the ASP.NET page whether it’s a ‘refresh’ or ‘postback’. The below code demostrates how ‘HttpContext’ session can be referred to check the same and act accordingly.
if ((bool)HttpContext.Current.Items["IsRefresh"])

Thursday, March 18, 2010


This article will compare four important architecture presentation patterns i.e. MVP(SC),MVP(PV),PM,MVVM and MVC. Many developers are confused around what is the difference between these patterns and when should we use what. This article will first kick start with a background and explain different types of presentation patterns. We will then move ahead discussing about the state , logic and synchronization issues. Finally we will go in detail of each pattern and conclude how they differ from each other
Here’s my small gift for all my .NET friends , a complete 400 pages FAQ Ebook which covers various .NET technologies like Azure , WCF , WWF , Silverlight , WPF , SharePoint and lot more from here.

Special thanks

This whole article is abstract from GUI architectures. Great work by Mr. Martin flower.
Josh Smith and team , great work on MVVM.
Mr. Nikhil kothari's blog , awesome source for MVVM.

Background - Presentation patterns

One of the biggest problems associated with user interface is lot of cluttered code. This cluttered code is due to two primary reasons , first the UI has complicated logic to manipulate the user interface objects and second it also maintains state of the application. Presentation patterns revolve around how to remove the UI complication and make the UI more clean and manageable. Below are different variety and classifications of presentation patterns as shown in the below figure.

Presentation pattern are divided in to three important categories MVP ( Model view presenter ) , MVC ( Model view controller) and finally (PM) presenter model. MVP is further divided in to supervising controller and passive view. Presenter model is further divided by Microsoft team in two technology specific patterns MVVM for silverlight and MVVM for WPF.

3 big problems of UI :- State , Logic and Synchronization

There are 3 big problems associated with UI as listed below.
State :- State / data is one of the biggest concern in UI. State means the current data picture of your user interface. In web terminologies it can be session variable and in windows application it can be a simple UI level data. The more the UI maintains states ,the more complication is increased.
Logic :- User interface normally have UI logics like manipulating textboxes , combo boxes or any other UI elements.The more these kind of logic exists in the UI the more it becomes complex.
Synchronization :- User interfaces normally co-ordinate with domain / business components. UI also needs to synchronize data between UI elements ( textboxes , comboboxes etc) and business objects. If your UI is taking of synchronization again the UI complexity increases.

The Hero - Presentation design Pattern

Presentation design pattern helps to solve the above UI problems. The base logic of presentation design patterns is that we need to create a extra class which will consume complicated logic , data and synch issues which currently the UI does , thus making the UI dump , clean and simple. Depending on how much this class takes responsibilities defines further whether its a SC , PV , PM design pattern etc. In other words its the maturity of the presenter class which will define what kind of design pattern it is.

Some acronyms to simplify the article

AcronymFull form
VView or user Interface.
PPresenter class which has the UI logic.
LUI logic
SState of the UI
MBusiness components or domain objects.
SCSupervising controller .
PVPassive view.
PMPresenter model.
We will use the above acronym to simplify our explanation of presentation design pattern.

Supervising controller pattern ( SC )

Fundamentals about SC :-

  • State is stored in the view.

  • Presenter owns the complex presentation logic. Simple UI binding logic is taken care by using binding technologies like WPF binding and Silverlight binding. Anything complex is taken care presenter class.

  • Presenter is aware of the view.

  • View is not aware of the presenter.

  • View connects with model using technical bindings provided by WPF and Silverlight.

Passive view (PV)

Fundamentals about PV :-
  • State is stored in the view.

  • All logic of UI is stored in presenter.

  • View is completely isolated from the model. It also takes the extra task of synchronizing data between model and view.

  • Presenter is aware of the view.

  • View is not aware of the presenter.
You can read more about MVP (PV) from this link

Presentation Model (PM)

Fundamentals about SC :-

  • State is stored in the presenter.

  • Logic is stored in presenter.

  • Presenter represents a abstract view of the UI.

  • Presenter is not aware of the view.

  • View is aware of the presenter.

  • View is completely isolated from the model.


Fundamentals about SC :-
  • Presenter model is the base.

  • State is stored in the presenter.

  • Logic is stored in presenter.

  • Presenter represents an abstract view of the UI.

  • Presenter is not aware of the view.

  • View is aware of the presenter.

  • View is completely isolated from the model.

  • Uses WPF and Silverlight bindings.


Fundamentals about MVC :-

  • Does not have a presenter , has a controller.

  • Request first comes to the controller.

  • Controller binds the model with the view.

  • Logic is stored in the controller.
You can read more about MVC from this link


Below is a summary comparison table for all presentation patterns from the aspect of state , logic and synchronization.

Supervising controller



ModelView connects to model for data using databindings like WPF bindings , Silverlight bindings etc.
Passive View



Presenter model







Databinding commands of WPF , Silverlight , ASP.NET is used.


Below is a visual comparison of what we discussed above.

Sunday, March 14, 2010

4 steps to enable instrumentation in WCF

4 steps to enable instrumentation in WCF

Introduction and Goal

Many times we would like to monitor events of WCF application in production environment. We would like to monitor events like errors, security audits, performance etc. This can be achieved by extending the ASP.NET health monitoring system in WCF. The health monitoring system is also termed as instrumentation.
Here’s my small gift for all my .NET friends , a complete 400 pages FAQ Ebook which covers various .NET technologies like Azure , WCF , WWF , Silverlight , WPF , SharePoint and lot more

The event provider model

Instrumentation is provided using the event provider model. Events are notification which you receive from the WCF application which can be a security event like password change, UI click events, or exception events like application level errors. These events are captured by the provider and routed to some source like event viewer, SQL Server etc.

Both events and provider are specified in the ‘web.config’ file. The ‘eventmapping’ element is where you specify your provider and ‘rules’ elements helps you tie up the event with the provider.
What will we do in this article?
In this article we will create a simple audit function which will help us to track all calls made to the WCF service in to event viewer. So any calls by the
WCF client will be tracked and audited in to the event viewer. For every call we will be tracking details like number of threads, working sets, app domains, when
the message was created and when was it raised. Below is the snippet for the same which will be tracked in the event viewer.

***************start health monitoring event*******************
message created at:Event Created at :3/14/2010 11:32:37 AM
message raised at:Event Created at :3/14/2010 11:32:37 AM
Heap size 3480664
Number of threads 19
Number of Working sets 32165888
Number of domains 1
Request rejected 0******************End Health Monitoring event*********************

Step1: Create the main event class
The first step is to create a class which will help us to track the calls made to the WCF service. This class needs to be inherited from ‘WebAuditEvent’ class. This class helps us to track audit events, generate information about security related operation and provide both success and failure audit events.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Management;
namespace healthmonitering
public class CustomAudit:WebAuditEvent

In the same class lets add 3 private fields ,’ msgcreated’ , ‘ msgraised’ and ‘WebProcessStatistics’. By using ’ msgcreated’ and ‘ msgraised’ we can track at what time event is
created and raised. ‘WebProcessStatistics’ will provide information for assessing the health of a running process.
private string msgcreated = string.Empty;
private string msgraised = string.Empty;
private static WebProcessStatistics processStatistics;

Implement the necesarry public constructors that call the protected equivalents in the parent WebAuditEvent class.Base keyword is used to access the member of
base class within the derived class as shown in the below code snippet. Note we have created the ‘WebProcessStatistics’ object and set it to the private member

public CustomAudit(string message, object eventsource, int eventcode)
: base(message, eventsource, eventcode)
msgcreated = string.Format("Event Created at :{0}", EventTime.ToString());
processStatistics = new WebProcessStatistics();

In both the constructors we are checking at what time event is created. Now override the Raise method as shown in the below code snippet.
public override void Raise()
msgraised = string.Format("Event Created at :{0}", EventTime.ToString());

Override the ‘FormatCustomEventDetails’ method with the message we want to log in the eventviewer. Note, we have used ‘WebProcessStatistics’ to get information like Heap size,Number of threads,Number of Working sets,Number of domains and Request rejected.

public override void FormatCustomEventDetails(WebEventFormatter formatter)
formatter.IndentationLevel += 1;
formatter.AppendLine("***************start health monitoring event*******************");
formatter.AppendLine(string.Format("message created at:{0}",msgcreated));
formatter.AppendLine(string.Format("message raised at:{0}", msgraised));
formatter.AppendLine(string.Format("Heap size {0}", processStatistics.ManagedHeapSize.ToString()));
formatter.AppendLine(string.Format("Number of threads {0}", processStatistics.ThreadCount.ToString()));
formatter.AppendLine(string.Format("Number of Working sets {0}", processStatistics.WorkingSet.ToString()));
formatter.AppendLine(string.Format("Number of domains {0}", processStatistics.AppDomainCount.ToString()));
formatter.AppendLine(string.Format("Request rejected {0}", processStatistics.RequestsRejected.ToString())); ;
formatter.AppendLine("******************End Health Monitoring event*********************");
formatter.IndentationLevel -= 1;

In the Raise method, we are checking at what time event raised and in ‘FormatCustomEventDetails’ we are appending the result in the audit event.
Step2:- Create the WCF service and change web.config

namespace WcfService3
public interface IService1
string Audit();

In the ‘Audit’ function We are going to implement our health monitering functionality in health operation contract.
In the Service1.svc.cs class implement the ‘Audit’ function by creating the ‘CustomAudit’ object and calling the ‘Raise’ function as shown in the below code snippet.

public class Service1 : IService1
public string Audit()
Healthmonitering.CustomAudit webevent = new Healthmonitering.CustomAudit("Some on called", this, WebEventCodes.WebExtendedBase + 1);
return "Event Audited";

In the constructor we are sending message, eventsource and event code as a parameter.
Now go to the ‘web.config’ and under ‘system.web’ element and add the ‘healthmonitoring’ tag.
Specify ‘CustomAudit’ class in the ‘eventMappinga’ element and mapping of the class with event viewer in the ‘rules’ element tag as shown in the below code snippet.


<add name="healthmonitering" type="Healthmonitering.CustomAudit "/>
<add name="healthmonitering" eventName="healthmonitering" provider="EventLogProvider" minInterval="00:00:01"/>


Step 3 :- Consume the WCF service in the ASPX client.

So let’s add a ASPX button, consume the client service and call the ‘Audit’ function in the button click event as shown in below code snippets.
<asp:Button ID="Button1" runat="server" Text="Invoke" onclick="Button1_Click" />

Now in the button click event write these lines

protected void Button1_Click(object sender, EventArgs e)
ServiceReference1.Service1Client proxy = new WebApplication1.ServiceReference1.Service1Client();
string result = proxy.Audit();

Here we are creating the proxy,invoking the ‘audit’ method and displaying the result of the ‘audit’ method.

Step 4 :- See the audit data in Eventviewer

Run the web application which is consuming the WCF service and press the button to invoke the WCF audit function.
The ‘Audit’ function internally calls the ‘Raise’ event which logs the message in an event viewer. So go to Start->run->type eventvwr.It contains information like Heap size,Number of threads,Number of Working sets,Number of domains and Request rejected as shown in the below figure.