Tuesday, June 30, 2009

Kill Bugs Like a Frog

GIBRALTAR is very cool! Learn more on their website.

Part logging tool, part application monitor, part profiler.All frog.

Gibraltar isn't really a frog, and it won't turn you into one, either. It just reminds us of one with its simple, natural bug-spotting powers. You can also think of Gibraltar as a flight recorder that monitors your .NET applications making it easier for you to test and support them.

We're proud of Gibraltar, and we'd like to tell you more about it. You can download a full-featured trial now, or check out this short video to learn how Gibraltar can streamline your software testing and support processes for any .NET application.

Gibraltar records and sends error and usage information to your support staff and provides powerful, yet simple analysis and visualization tools so you can triage customer issues faster, better optimize development priorities and continuously improve software quality.

With Gibraltar, you will find and kill software bugs faster and easier than ever before. You'll also provide more effective customer support and have new insights into how users interact with your applications.

So please, click the large triangular play button to the right and watch a short video demonstration of Gibraltar in action. Or click the links to learn more, or download a free trial.

Original post can be found here

Friday, June 26, 2009

Creational Patterns - Singleton

By  Susan Abraham May 31, 2005


Most programming involves usage of Design Patterns in one form or other .There are around 23 Design Patterns that are available. They are categorized as given below:

I] Creational Patterns

  1. Singleton
  2. Factory
  3. Abstract Factory
  4. Builder
  5. Prototype

II] Structural Patterns

  1. Adapter
  2. Bridge
  3. Composite
  4. Decorator
  5. Facade
  6. Flyweight
  7. Proxy

III] Behavioral Pattern

  1. Chain Of Responsibility
  2. Command
  3. Interpreter
  4. Iterator
  5. Mediator
  6. Memento
  7. Observer
  8. State
  9. Strategy
  10. Template Method
  11. Visitor

This paper discusses the implementation of the Singleton Design Pattern.

The Concept

Design patterns are commonly defined as time-tested solutions to recurring design problems.

The most striking benefits of Design Patterns are as follows:

  • They provide you with a way to solve issues related to software development using a proven solution. The solution facilitates the development of highly cohesive modules with minimal coupling. They isolate the variability that may exist in the system requirements, making the overall system easier to understand and maintain.
  • Design patterns make communication between designers more efficient. Software professionals can immediately picture the high-level design in their thoughts immediately the name of the pattern used to solve a particular issue when discussing system design

Singleton Pattern: In the Singleton Pattern we have at any given instance a single instance of the Singleton Class active. All instantiation of the Singleton Class references the same instance of the Class. The pattern also provides a global point of access to the sole instance of the class.

Class Diagram

Sequence Diagram


Steps for implementing the Singleton Pattern:

Create a project of type Console Application. Name it SingletonTest.

Add a Class File named Singleton and add the following code

/// <summary>
/// Summary description for Singleton.
/// </summary>
public class Singleton
private static Singleton instance;
/// <summary>
/// Standard default Constructor
/// </summary>
protected Singleton() {}
/// <summary>
/// Static method for creating the single instance
/// of the Constructor
/// </summary>
/// <returns></returns>
public static Singleton Instance()
// initialize if not already done
if( instance == null )
instance = new Singleton();
// return the initialized instance of the Singleton Class
return instance;

Step 3:
Create a Client class that would access the Singleton Class as follows :

/// <summary>
/// Summary description for Client.
/// </summary>
class Client
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
// Constructor is protected -- cannot use new
Singleton s1 = Singleton.Instance();
Singleton s2 = Singleton.Instance();
if( s1 == s2 )
Console.WriteLine( "The same instance" );

Step 4:
Run the Application it would display the following output:


Thus we have implemented the Singleton Design Pattern using the .Net framework.Like any Concepts/Theory Singleton Pattern also has its pros and cons.

Benefits of Singleton Pattern:

  1. Instance control: Singleton prevents other objects from instantiating their own copies of the Singleton object, ensuring that all objects access the single instance.
  2. Flexibility: Because the class controls the instantiation process, the class has the flexibility to change the instantiation process.

Drawbacks of Singleton Pattern:

  1. Overhead. Although the amount is minuscule, there is some overhead involved in checking whether an instance of the class already exists every time an object requests a reference. This problem can be overcome by using static initialization.
  2. Possible development confusion. When using a singleton object (especially one defined in a class library), developers must remember that they cannot use the new keyword to instantiate the object. Because application developers may not have access to the library source code, they may be surprised to find that they cannot instantiate this class directly.
  3. Object lifetime. Singleton does not address the issue of deleting the single object. In languages that provide memory management (for example, languages based on the .NET Framework), only the Singleton class could cause the instance to be deallocated because it holds a private reference to the instance. In languages, such as C++, other classes could delete the object instance, but doing so would lead to a dangling reference inside the Singleton class.


Original Post can be found here

Monday, June 1, 2009

Retrieve All Active Sessions Data

Posted by: The Code Project Latest Articles, on 31 May 2009

Helps to view all the active Session IDs, Session Keys, and Session Values in an ASP.NET application.


As far as I know, in ASP.NET, we do not have a predefined class library to find out all the active session IDs and their data. This article helps you list all the active session keys using a simple logic.


This code can be used to track the active sessions of an application.

Using the code

This simple application has two pages: one to view the data (Manager.aspx) and the other to enter the current date time into the session.

In the application, create a variable of type Dictionary<string, HttpSessionState> and store it into the application memory. It facilitates us to keep the “Session IDs” of all the sessions and a “Session” object reference. read more...

View original