Saurabh Nijhawan

Single Key Multiple Values Data Structure for one to many mapping

nijhawan.saurabh — Wed, 31 Oct 2012 06:58:00 GMT

For updated version of the article please visit www.agnosticdevs.com

Dictionaries are good, they are great to store Key / Value pairs but what if you want to store multiple values for a single key?

Dictionaries would not allow duplicate keys. You can obviously create a Dictionary like Dictionary<int, List<string>>, but ToLookup extension method saves you time in a way that you just have to tell it how keys are calculated and it'd make the DS for you. Additionally it' gives you functionality to iterate over the groupings etc.

Given an IEnumerable<T>, you can easily convert it to a ILookup<TKey, TElement> without any hassles.

I came across a nice way to represent such a Data Structure using one of the Extension Method (ToLookup) present in System.Linq Namespace which converts an IEnumerable<T> to an ILookup<TKey, TElement>.

Now, there are two parameters this method expects (The other overload expects 3 parameters):

IEnumerable<TSource> - This list would contain the actual data.
Func<TSource, TKey> keySelector - The Delegate which which computes the keys

The method returns the following:

ILookup<TKey, TElement>

This DS would store Keys and multiple values along those keys.

Let's see a small example:

   12  using System;
   13     using System.Collections.Generic;
   14     using System.Linq;
   15 
   16     /// <summary>
   17     /// </summary>
   18     internal class Program
   19     {
   20         #region Methods
   21 
   22         /// <summary>
   23         /// </summary>
   24         /// <param name="args">
   25         /// The args.
   26         /// </param>
   27         private static void Main(string[] args)
   28         {
   29             // Create an array of strings.
   30             var list = new List<string> { "IceCream1", "Chocolate Moose", "IceCream2" };
   31 
   32             // Generate a lookup Data Structure
   33             ILookup<int, string> lookupDs = list.ToLookup(item => item.Length);
   34 
   35           // Enumerate groupings.
   36             foreach (var group in lookupDs)
   37             {
   38                 foreach (string element in group)
   39                 {
   40                     Console.WriteLine(element);
   41                 }
   42             }
   43         }

The Template Method Design Pattern using C# .Net

nijhawan.saurabh — Mon, 15 Oct 2012 20:45:00 GMT

For updated version of the article please visit www.agnosticdevs.com

First of all I'll just put this pattern in context and describe its intent as in the GOF book:

Template Method:

Define the skeleton of an algorithm in an operation, deferring some steps to

Subclasses. Template Method lets subclasses redefine certain steps of an algorithm

without changing the Algorithm's Structure.

Usage:

When you are certain about the High Level steps involved in an Algorithm/Work flow you can use the Template Pattern which allows the Base Class to define the Sequence of the Steps but permits the Sub classes to alter the implementation of any/all steps.

Example in the .Net framework:

The most common example is the Asp.Net Page Life Cycle. The Page Life Cycle has a few methods which are called in a sequence but we have the liberty to modify the functionality of any of the methods by overriding them.

Sample implementation of Template Method Pattern:

Let's see the class diagram first:

And here goes the code:

EmailBase.cs

    1 using System;
    2 using System.Collections.Generic;
    3 using System.Linq;
    4 using System.Text;
    5 using System.Threading.Tasks;
    6 
    7 namespace TemplateMethod
    8 {
    9     public abstract class EmailBase
   10     {
   11 
   12         public bool SendEmail()
   13         {
   14             if (CheckEmailAddress() == true) // Method1 in the sequence
   15             {
   16                 if (ValidateMessage() == true) // Method2 in the sequence
   17                 {
   18                     if (SendMail() == true) // Method3 in the sequence
   19                     {
   20                         return true;
   21                     }
   22                     else
   23                     {
   24                         return false;
   25                     }
   26 
   27                 }
   28                 else
   29                 {
   30                     return false;
   31                 }
   32 
   33             }
   34             else
   35             {
   36                 return false;
   37 
   38             }
   39 
   40 
   41         }
   42 
   43         protected abstract bool CheckEmailAddress();
   44         protected abstract bool ValidateMessage();
   45         protected abstract bool SendMail();
   46 
   47 
   48     }
   49 }
   50 
 
 
 EmailYahoo.cs
 

    1 using System;
    2 using System.Collections.Generic;
    3 using System.Linq;
    4 using System.Text;
    5 using System.Threading.Tasks;
    6 
    7 namespace TemplateMethod
    8 {
    9     public class EmailYahoo:EmailBase
   10     {
   11 
   12         protected override bool CheckEmailAddress()
   13         {
   14             Console.WriteLine("Checking Email Address : YahooEmail");
   15             return true;
   16         }
   17         protected override bool ValidateMessage()
   18         {
   19             Console.WriteLine("Validating Email Message : YahooEmail");
   20             return true;
   21         }
   22 
   23 
   24         protected override bool SendMail()
   25         {
   26             Console.WriteLine("Semding Email : YahooEmail");
   27             return true;
   28         }
   29 
   30 
   31     }
   32 }
   33 
 
 EmailGoogle.cs
 

    1 using System;
    2 using System.Collections.Generic;
    3 using System.Linq;
    4 using System.Text;
    5 using System.Threading.Tasks;
    6 
    7 namespace TemplateMethod
    8 {
    9     public class EmailGoogle:EmailBase
   10     {
   11 
   12         protected override bool CheckEmailAddress()
   13         {
   14             Console.WriteLine("Checking Email Address : GoogleEmail");
   15             return true;
   16         }
   17         protected override bool ValidateMessage()
   18         {
   19             Console.WriteLine("Validating Email Message : GoogleEmail");
   20             return true;
   21         }
   22 
   23 
   24         protected override bool SendMail()
   25         {
   26             Console.WriteLine("Semding Email : GoogleEmail");
   27             return true;
   28         }
   29 
   30 
   31     }
   32 }
   33 
 
 Program.cs
 

    1 using System;
    2 using System.Collections.Generic;
    3 using System.Linq;
    4 using System.Text;
    5 using System.Threading.Tasks;
    6 
    7 namespace TemplateMethod
    8 {
    9     class Program
   10     {
   11         static void Main(string[] args)
   12         {
   13             Console.WriteLine("Please choose an Email Account to send an Email:");
   14             Console.WriteLine("Choose 1 for Google");
   15             Console.WriteLine("Choose 2 for Yahoo");
   16             string choice = Console.ReadLine();
   17             EmailBase email; 
   17 
   18             if (choice == "1")
   19             {
   20                 email = new EmailGoogle(); // Rather than newing it up here, you may use a factory to do so.
   21                 email.SendEmail();
   22 
   23             }
   24             if (choice == "2")
   25             {
   26                 email = new EmailYahoo(); // Rather than newing it up here, you may use a factory to do so.
   27                 email.SendEmail();
   28             }
   29         }
   30     }
   31 }
   32 

Final Words:

It's very obvious that why the Template Method Pattern is a popular pattern, everything at last revolves around Algorithms and if you are clear with the steps involved it makes real sense to delegate the duty of implementing the step's functionality to the sub classes.

Implementing Linked Lists in C#

nijhawan.saurabh — Sat, 06 Oct 2012 18:28:00 GMT

For updated version of this blog/post, please visit www.agnosticdevs.com

Why?

The question is why you need Linked Lists and why it is the foundation of any Abstract Data Structure.

Take any of the Data Structures - Stacks, Queues, Heaps, Trees; there are two ways to go about implementing them -

Using Arrays
Using Linked Lists

Now you use Arrays when you know about the size of the Nodes in the list at Compile time and Linked Lists are helpful in a way that you are free to add as many Nodes to the List as required at Runtime.

How?

Now, let's see how we go about implementing a Simple Linked List in C#.

Note: We'd be dealing with singly linked list for time being, there's also another version of linked lists - the Doubly Linked List which maintains two pointers (NEXT and BEFORE).

Class Diagram

Let's see the Class Diagram first:

Code

    1 // -----------------------------------------------------------------------
    2 // <copyright file="Node.cs" company="">
    3 // TODO: Update copyright text.
    4 // </copyright>
    5 // -----------------------------------------------------------------------
    6 
    7 namespace CSharpAlgorithmsAndDS
    8 {
    9     using System;
   10     using System.Collections.Generic;
   11     using System.Linq;
   12     using System.Text;
   13 
   14     /// <summary>
   15     /// TODO: Update summary.
   16     /// </summary>
   17     public class Node
   18     {
   19         public Object data { get; set; }
   20 
   21         public Node Next { get; set; }
   22     }
   23 }
   24 
 
 
 

    1 // -----------------------------------------------------------------------
    2 // <copyright file="LinkedList.cs" company="">
    3 // TODO: Update copyright text.
    4 // </copyright>
    5 // -----------------------------------------------------------------------
    6 
    7 namespace CSharpAlgorithmsAndDS
    8 {
    9     using System;
   10     using System.Collections.Generic;
   11     using System.Linq;
   12     using System.Text;
   13 
   14     /// <summary>
   15     /// TODO: Update summary.
   16     /// </summary>
   17     public class LinkedList
   18     {
   19         private Node Head;
   20 
   21         public void AddNode(Node n)
   22         {
   23             n.Next = this.Head;
   24             this.Head = n;
   25 
   26         }
   27 
   28         public void printNodes()
   29         {
   30 
   31             while (Head!=null)
   32             {
   33                 Console.WriteLine(Head.data);
   34                 Head = Head.Next;
   35 
   36             }
   37 
   38         }
   39     }
   40 }
   41 
 
 
 
 

    1 using System;
    2 using System.Collections.Generic;
    3 using System.Linq;
    4 using System.Text;
    5 
    6 namespace CSharpAlgorithmsAndDS
    7 {
    8     class Program
    9     {
   10         static void Main(string[] args)
   11         {
   12             LinkedList ll = new LinkedList();
   13             Node A = new Node();
   14             A.data = "A";
   15 
   16             Node B = new Node();
   17             B.data = "B";
   18 
   19             Node C = new Node();
   20             C.data = "C";
   21             ll.AddNode(A);
   22             ll.AddNode(B);
   23             ll.AddNode(C);
   24 
   25             ll.printNodes();
   26         }
   27     }
   28 }
   29 

Final Words

This is just a start, I will add more posts on Linked List covering more operations like Delete etc. and will also explore Doubly Linked List / Implementing Stacks/ Heaps/ Trees / Queues and what not using Linked Lists.

Difference between Factory Method and Abstract Factory design patterns using C#.Net

nijhawan.saurabh — Thu, 27 Sep 2012 09:44:00 GMT

For updated version of the article please visit www.agnosticdevs.com

First of all I'll just put both these patterns in context and describe their intent as in the GOF book:

Factory Method:

Define an interface for creating an object, but let subclasses decide which class

to instantiate. Factory Method lets a class defer instantiation to subclasses.

Abstract Factory:

Provide an interface for creating families of related or dependent objects without

specifying their concrete classes.

Points to note:

Abstract factory pattern adds a layer of abstraction to the factory method pattern. The type of factory is not known to the client at compile time, this information is passed to the client at runtime (How it is passed is again dependent on the system, you may store this information in configuration files and the client can read it on execution).
While implementing Abstract factory pattern, the factory classes can have multiple factory methods.
In Abstract factory, a factory is capable of creating more than one type of product (Similar products are grouped together in a factory)

Sample implementation of factory method pattern

Let's see the class diagram first:

ProductFactory.cs

    1 // -----------------------------------------------------------------------
    2 // <copyright file="ProductFactory.cs" company="">
    3 // TODO: Update copyright text.
    4 // </copyright>
    5 // -----------------------------------------------------------------------
    6 
    7 namespace FactoryMethod
    8 {
    9     using System;
   10     using System.Collections.Generic;
   11     using System.Linq;
   12     using System.Text;
   13 
   14     /// <summary>
   15     /// TODO: Update summary.
   16     /// </summary>
   17     public abstract class ProductFactory
   18     {
   19         /// <summary>
   20         /// </summary>
   21         /// <returns>
   22         /// </returns>
   23         public abstract Product CreateProductInstance();
   24     }
   25 }
   26 
 
 
ProductAFactory.cs 

    1 // -----------------------------------------------------------------------
    2 // <copyright file="ProductAFactory.cs" company="">
    3 // TODO: Update copyright text.
    4 // </copyright>
    5 // -----------------------------------------------------------------------
    6 
    7 namespace FactoryMethod
    8 {
    9     using System;
   10     using System.Collections.Generic;
   11     using System.Linq;
   12     using System.Text;
   13 
   14     /// <summary>
   15     /// TODO: Update summary.
   16     /// </summary>
   17     public class ProductAFactory:ProductFactory
   18     {
   19         public override Product CreateProductInstance()
   20         {
   21             return new ProductA();
   22         }
   23     }
   24 }
   25 
 
 
 ProductBFactory.cs

    1 // -----------------------------------------------------------------------
    2 // <copyright file="ProductBFactory.cs" company="">
    3 // TODO: Update copyright text.
    4 // </copyright>
    5 // -----------------------------------------------------------------------
    6 
    7 namespace FactoryMethod
    8 {
    9     using System;
   10     using System.Collections.Generic;
   11     using System.Linq;
   12     using System.Text;
   13 
   14     /// <summary>
   15     /// TODO: Update summary.
   16     /// </summary>
   17     public class ProductBFactory:ProductFactory
   18     {
   19         public override Product CreateProductInstance()
   20         {
   21             return new ProductB();
   22 
   23         }
   24     }
   25 }
   26 

Product.cs

    1 // -----------------------------------------------------------------------
    2 // <copyright file="Product.cs" company="">
    3 // TODO: Update copyright text.
    4 // </copyright>
    5 // -----------------------------------------------------------------------
    6 
    7 namespace FactoryMethod
    8 {
    9     using System;
   10     using System.Collections.Generic;
   11     using System.Linq;
   12     using System.Text;
   13 
   14     /// <summary>
   15     /// TODO: Update summary.
   16     /// </summary>
   17     public abstract class Product
   18     {
   19         public abstract string Name { get; set; }
   20     }
   21 }
   22 

 
 ProductB.cs
 
    1 // -----------------------------------------------------------------------
    2 // <copyright file="ProductB.cs" company="">
    3 // TODO: Update copyright text.
    4 // </copyright>
    5 // -----------------------------------------------------------------------
    6 
    7 namespace FactoryMethod
    8 {
    9     using System;
   10     using System.Collections.Generic;
   11     using System.Linq;
   12     using System.Text;
   13 
   14     /// <summary>
   15     /// TODO: Update summary.
   16     /// </summary>
   17     public class ProductB:Product
   18     {
   19          public ProductB()
   20         {
   21 
   22             Name = "ProductB";
   23         }
   24         public override string Name { get; set; }
   25     }
   26 }
   27 

 
 
 ProductA.cs
 
    1 // -----------------------------------------------------------------------
    2 // <copyright file="ProductA.cs" company="">
    3 // TODO: Update copyright text.
    4 // </copyright>
    5 // -----------------------------------------------------------------------
    6 
    7 namespace FactoryMethod
    8 {
    9     using System;
   10     using System.Collections.Generic;
   11     using System.Linq;
   12     using System.Text;
   13 
   14     /// <summary>
   15     /// TODO: Update summary.
   16     /// </summary>
   17     public class ProductA:Product
   18     {
   19         public ProductA()
   20         {
   21 
   22             Name = "ProductA";
   23         }
   24 
   25         public override string Name { get; set; }
   26     }
   27 }
   28 

Sample implementation of Abstract Factory pattern

Here's the class diagram:

As said earlier, the Abstract factory pattern adds another layer of abstraction to the factory method pattern so the Product/ProductFactory classes that we used earlier in Factory Method pattern implementation would be reused here.

    1 // -----------------------------------------------------------------------
    2 // <copyright file="ApplicationCaller.cs" company="">
    3 // TODO: Update copyright text.
    4 // </copyright>
    5 // -----------------------------------------------------------------------
    6 
    7 namespace FactoryMethod
    8 {
    9     using System;
   10     using System.Collections.Generic;
   11     using System.Linq;
   12     using System.Text;
   13 
   14     /// <summary>
   15     /// TODO: Update summary.
   16     /// </summary>
   17     public class ApplicationCaller
   18     {
   19         public Product PassFactory(ProductFactory pf)
   20         {
   21 
   22           Product product = pf.CreateProductInstance();
   23             return product;
   24         }
   25     }
   26 }
   27 
 
 

    1 using System;
    2 using System.Collections.Generic;
    3 using System.Linq;
    4 using System.Text;
    5 
    6 namespace FactoryMethod
    7 {
    8     using System.Configuration;
    9     using System.Net.Mime;
   10 
   11     class Program
   12     {
   13         static ProductFactory CreateSpecificFactory()  
   14         {
   15 
   16             string facType = System.Configuration.ConfigurationSettings.AppSettings["FactoryName"];
   17             if (facType == "ProductAFactory")
   18             {
   19                 return new ProductAFactory();
   20             }
   21             else
   22             {
   23                 return new ProductBFactory();
   24             }
   25         }
   26 
   27         static void Main(string[] args)
   28         {
   29             Console.WriteLine(new ApplicationCaller().PassFactory(CreateSpecificFactory()).Name);
   30 
   31         }
   32     }
   33 }
   34 

Add finally the type of factory to be used would be decided at runtime, in this sample we are reading this information from a config file and passing it to the application.

    1 <?xml version="1.0" encoding="utf-8" ?>
    2 <configuration>
    3   <appSettings>
    4     <add key="FactoryName" value="ProductBFactory"/>
    5   </appSettings>
    6 </configuration>

Debugging not working in ASP.NET Browser showing errors like , Page cannot be displayed.

nijhawan.saurabh — Mon, 30 Apr 2012 06:10:00 GMT

For updated version of the article please visit www.agnosticdevs.com

Quick Checks:

Is it a .aspx page or by mistake you are trying to open a masterpage or a user control. Just check once.
Also try to clean and recompile your solution.
Make sure to close ASP.NET development server, or reset IIS.
Make sure all projects are in 'Debug' mode.
Make sure all projects are targeted to the same .NET Framework version.

Object Oriented JavaScript using Prototype Object

nijhawan.saurabh — Wed, 11 Nov 2009 18:39:00 GMT

For updated version of the article please visit www.agnosticdevs.com

Object Oriented JavaScript using Prototype Object

This document describes the benefit of using Object Oriented Approach in JavaScript Codes and implements Calendar Management component having a few functions like Add/Edit/Delete Events on selected date.

As we all know Object Oriented Programming (OOP) is a major part and practice for reusability. Most of the times even if we are following standard ways to code on server-side, we just forget or omit about client side structure of application. As a result it becomes hectic to manage later, when application is modified to release a newer version of the same.

As per my personal experience on the same, I found prototyping and object oriented JavaScript a perfect solution. There may be a lot of other ways as well, but this article will discuss about prototyping and inheritance in JavaScript.

Note: To understand the logic completely, you must have clear understanding on concepts like, Inheritance, constructors, Classes and objects. This will help you to understand the approach in this article better.

What is Prototype?

Prototyping is a concept taken from C++, the way of declaring the variable in Class and initializing it outside the class, using SCOPE RESOLUTION Operator (::). In the same way in JavaScript, prototype object can be treated as a way to implement the logic of scope resolution operator.

For Example:-

C++

class X

  public:

      static int count;

};

<?xml:namespace prefix = o />

int X::count = 10;                // define static data member

JavaScript

function X()

{

X.prototype.count = 0; /// this is equivalent to writing it outside X

}

X.prototype.count = 10; ///initialize the count outside X

Note: prototype is static part of JavaScript Classes.

There are many advantages of using this approach, while coding big applications having complex Client Side Data Handling and manipulation, e.g. Ajax, Rich Text Editing, Slide Shows, Video Show-Reels, Light Box or Light Shows etc. Here I have listed a few:

Structured: The Coding for any functionality can be structured in a very easily understandable way. For example, any one may co-relate the two complex defined Entities by a way of having familiarity to OOPs.
Reusable: The Class components created using this approach can be readily reused in any other application with nominal changes.
Plug and Play: As components can be reused for other applications, this is very easy to merge two components e.g, a Spell check component can be included in Rich Text Editor.

How it works:

In JavaScript, Classes are functions or in simple words: to declare a class and to declare a function the same syntax is used.

Example 1:

function Vehicle(_Model, _Make, _Color, _IsFourWheelDrive, _Mileage) {

//public variables for class

this.Model = _Model;

this.Make = _Make;

this.Color = _Color;

this.IsFourWheelDrive = _IsFourWheelDrive;

this.Mileage = _Mileage;

this.Acceleration = 0;

/// Private variables for Class

var EngineNumber = "ABC0000" + this.Make;

}

///Common function for all Instances

Vehicle.prototype.Accelerate = function(_Acceleration) {

this.Acceleration = _Acceleration;

}

var VehMiniCooper = new Vehicle("Mini", "Cooper", "White", false, 10);

VehMiniCooper.Accelerate(160);

Example 2:

var Vehicle = function() { };

Vehicle.prototype = {

Initialize: function(_Model, _Make, _Color, _IsFourWheelDrive, _Mileage) {

this.Model = _Model;

this.Make = _Make;

this.Color = _Color;

this.IsFourWheelDrive = _IsFourWheelDrive;

this.Mileage = _Mileage;

this.Acceleration = 0;

/// Private variables for Class

var EngineNumber = "ABC0000" + this.Make;

Accelerate: function(_Acceleration) {

this.Acceleration = _Acceleration;

}

};

var VehMiniCooper = new Vehicle();

VehMiniCooper.Initialize("Mini", "Cooper", "White", false, 10);

VehMiniCooper.Accelerate(30);

Here both code snippets implement the same logic for vehicle class, but with two different syntaxes.

The prime logic behind not defining the Accelerate() function inside Vehicle class is to keep and use only one instance of function Accelerate() for instances of class Vehicle. This will save memory and the same logic will be implemented for all instances automatically.

In the above code we have different code blocks, (private and public). The variables defined with this.xxxxx are public variables and are accessible outside the class using object of the same class. The variable defined directly using var keyword are private variables accessible only inside the class.

The functions or variables are defined with classname.prototype, are static in scope and are initialized only once.

Our Example of Calendar:

We will learn the following in the implementation of Calendar:

Implementation of Enumerations in JavaScript.
Extending Predefined DataTypes such as Date.
Creating Custom Classes in JavaScript.
Using all the above together to write a complex logic simply.

Please refer the code with this article to follow up:

Implementation of Enumerations in JavaScript:

Enumeration is a basic data type in any language, which has all its possible values pre-defined with it. This type cannot store any other value other then specified list with it.

JavaScript does not support this kind of DataTypes by default. But we can create the same manually to make it simpler for ourselves.

In our sample calendar, we will surely need Enumerations for Day and Month Names. So for the same, we may code like this:

var DayOfWeek = {

Sunday: 0,

Monday: 1,

Tuesday: 2,

Wednesday: 3,

Thursday: 4,

Friday: 5,

Saturday: 6,

GetDayName: function(iDay) {

switch (iDay) {

case 0:

return "Sunday";

break;

case 1:

return "Monday";

break;

case 2:

return "Tuesday";

break;

case 3:

return "Wednesday";

break;

case 4:

return "Thursday";

break;

case 5:

return "Friday";

break;

case 6:

return "Saturday";

break;

}

};

var NamesOfMonth = {

January: 1,

February: 2,

March: 3,

April: 4,

May: 5,

June: 6,

July: 7,

August: 8,

September: 9,

October: 10,

November: 11,

December: 12,

GetMonthName: function(iMonth) {

switch (iMonth.toString()) {

case "1":

return "January";

break;

case "2":

return "February";

break;

case "3":

return "March";

break;

case "4":

return "April";

break;

case "5":

return "May";

break;

case "6":

return "June";

break;

case "7":

return "July";

break;

case "8":

return "August";

break;

case "9":

return "September";

break;

case "10":

return "October";

break;

case "11":

return "November";

break;

case "12":

return "December";

break;

}

};

In the above code snippet, we have DayOfWeek and NamesOfMonth as our datatypes. The above type can be used as:

var Cal = new CalendarHelper(DayOfWeek.Wednesday, "DivCalendar");

Cal.GetCalendar(NamesOfMonth.October, 2009);

Here, the CalendarHelper is the class defined in the .js file and DayOfWeek.Wednesday refers to Numeric value 3, similarly NamesOfMonth.October refers to Numeric value 10.

Extending Predefined DataTypes such as Date.

Extending itself means, adding on some functionality to existing classes. It’s similar to inheritance but still have some difference. Inheritance is to create a new class to add some functionality and reuse the rest as it is. On the other hand Extending means just to add new functionality to it.

In JavaScript, Both of the above terminologies can be implemented logically:

Inheritance:

var ExtendedDate = function() { };

ExtendedDate.prototype = Date.prototype; // inheritance using Prototype Object

ExtendedDate.prototype.Initialize = function() {

///Your Implementation of own logic

this.getDate(); /// here, this is the instance of current object of New Extended Class ExtendedDate

};

Extension:

Date.prototype.DaysInMonth = function(iMonth, iYear) {

return 32 - new Date(iYear, iMonth, 32).getDate();

}

Date.prototype.Initialize = function(iYear, iMonth, iDay) {

this.setFullYear(iYear, iMonth, iDay);

this.DayOfWeek = this.getDayName();

return this;

};

In above code samples, ExtendedDate is new inherited Class from Date and the other snippet simply shows the extended version of Date class with 2 functions DayInMonth and Initialize.

Creating Custom Classes in JavaScript.

Other then Inheritance and Extension, we can also create Custom Classes to implement Complex Logics.

Here in the attached Sample, we have CalendarHelper Class created to render monthly calendar with all events marked in the same.

var CalendarHelper = function(StartDayOfWeek, Container) {

this._StartDayOfWeek = StartDayOfWeek;

this._Container = Container;

};

As described earlier in the article, functions are treated as classes in JavaScript. The above snippet initializes the CalendarHelper Object with reference of a Class having _StartDayOfWeek and _Container Properties.

Further this class can be extended to have more features such as:

InitializeTemplates
HandleEvents
InitializeEvents
AddEvent
GetCalendar

Example:

CalendarHelper.prototype.GetCalendar = function(Month, Year) {

this._Month = Month;

this._Year = Year;

this.InitializeTemplates();

document.currentCalObj = this;

$.post("AjaxCallerService.axd", { method: "GetAllEventsForMonth", month: Month, year: Year }, this.HandleEvents);

}

Please refer to code samples for whole implementation of the above sample.

Using all the above together to write a complex logic simply.

First of all the Constructor of Calendar class to initialize Start day of the Week and Container where to render the Calendar.

var CalendarHelper = function(StartDayOfWeek, Container) {

this._StartDayOfWeek = StartDayOfWeek;

this._Container = Container;

};

Now, we need to define the basic HTML Templates for the Calendar in InitializeTemplates Method of Calendar.

CalendarHelper.prototype.InitializeTemplates = function() {

this.CalendarTemplate = new String("<TABLE CLASS=\"Calendar\" CELLSPACING=\"0\">{THeads}{TBodys}{TFoot}</TABLE>");

this.THeadTemplate = new String("<THEAD><TR><TH><A HREF=\"javascript:void(0);\" REL=\"{PreviousYear}\" REV=\"{PreviousMonth}\" ID=\"BtnPrevious\">«</A></TH></TH><TH COLSPAN=\"5\" CLASS=\"HeaderTitle\">{MonthName}, {Year}</TH><TH><A HREF=\"javascript:void(0);\" REL=\"{NextYear}\" REV=\"{NextMonth}\" ID=\"BtnNext\">»</A></TH></TR><TR>{Heads}</TR></THEAD>");

this.BodyTemplate = new String("<TBODY>{TRs}</TBODY>");

this.TrTemplate = new String("<TR>{TDs}</TR>");

this.HeadTemplate = new String("<TH>{Data}</TH>");

this.TDTemplate = new String("<TD>{Data}</TD>");

this.TFootTemplate = new String("<TFOOT><TR>{Heads}</TR></TFOOT>");

this.BlankTDTemplate = new String("<TD CLASS=\"padding\" COLSPAN=\"{Colspan}\"></TD>");

this.TodaysDateTemplate = new String("<TD CLASS=\"today\">{Data}</TD>");

this.EventTemplate = new String("<LI><SPAN CLASS=\"title\">{Dated}</SPAN><SPAN CLASS=\"desc\">{Description}</SPAN></LI>");

this.EventDateTemplate = new String("<TD CLASS=\"date_has_event\">{Data}<DIV CLASS=\"events\"><UL>{Events}</UL></DIV></TD>");

}

This will help us to maintain Rendering logic flexible enough to make any changes in the layout whenever some design changes are required.

Define the function to get calendar for specific month:

CalendarHelper.prototype.GetCalendar = function(Month, Year) {

this._Month = Month;

this._Year = Year;

this.InitializeTemplates();

document.currentCalObj = this;

$.post("AjaxCallerService.axd", { method: "GetAllEventsForMonth", month: Month, year: Year }, this.HandleEvents);

}

This will call the function to initialize Templates and initiate a call to Server for Events. The JQuery Method $.post makes the call to IhttpHandler AjaxCallerService.axd and attaches HandleEvents method to Async Callback to handle JSON response from the same.

Handle JSON Response

CalendarHelper.prototype.HandleEvents = function(Data) {

var Events = eval(Data);

var C = document.currentCalObj;

C._Events = new Array();

for (var i = 0; i < Events.length; i++) {

var EventDate = eval(Events[i].Dated.toString().replace(/\/Date$(\d+)$\//gi, "new Date($1)"));

var Key = (EventDate.getMonth() + 1).toString() + EventDate.getDate().toString() + EventDate.getFullYear().toString();

if (C._Events[Key] == null)

C._Events[Key] = new Array();

C._Events[Key][C._Events[Key].length] = Events[i];

}

var NumberOfDays = 0;

var CustomDayOfWeekEnum = new Array();

var iWeekDayCounter = 0;

var DayDiff = 7 - C._StartDayOfWeek;

var FirstDayOfMonth = (new ExtendedDate(C._Year, C._Month - 1, 1)).getDay();

var CalRows = new String();

var CalDays = new String();

var Heads = new String();

..............................

/// Logic continues… please check the Attachments for whole code.

}

The above function renders the calendar to specified container and applies CSS to it. But this is not completed yet, as we still need to bind actions to show hide Events on mouseover and mouseout.

Bind mouseover and mouseevent to Dates to show Event Popup

CalendarHelper.prototype.InitializeEvents = function() {

$('.date_has_event').each(function() {

// options

var distance = 10;

var time = 250;

var hideDelay = 500;

var hideDelayTimer = null;

// tracker

var beingShown = false;

var shown = false;

var trigger = $(this);

var popup = $('.events ul', this).css('opacity', 0);

// set the mouseover and mouseout on both element

$([trigger.get(0), popup.get(0)]).mouseover(function() {

// stops the hide event if we move from the trigger to the popup element

if (hideDelayTimer) clearTimeout(hideDelayTimer);

// don't trigger the animation again if we're being shown, or already visible

if (beingShown || shown) {

return;

} else {

beingShown = true;

// reset position of popup box

popup.css({

bottom: 20,

left: -76,

display: 'block' // brings the popup back in to view

})

// (we're using chaining on the popup) now animate it's opacity and position

.animate({

bottom: '+=' + distance + 'px',

opacity: 1

}, time, 'swing', function() {

// once the animation is complete, set the tracker variables

beingShown = false;

shown = true;

});

}

}).mouseout(function() {

// reset the timer if we get fired again - avoids double animations

if (hideDelayTimer) clearTimeout(hideDelayTimer);

// store the timer so that it can be cleared in the mouseover if required

hideDelayTimer = setTimeout(function() {

hideDelayTimer = null;

popup.animate({

bottom: '-=' + distance + 'px',

opacity: 0

}, time, 'swing', function() {

// once the animate is complete, set the tracker variables

shown = false;

// hide the popup entirely after the effect (opacity alone doesn't do the job)

popup.css('display', 'none');

});

}, hideDelay);

});

}

The above class can be used in the following way:

var Cal = new CalendarHelper(DayOfWeek.Wednesday, "DivCalendar");

Cal.GetCalendar(NamesOfMonth.October, 2009);

</script>

The above whole implementation is based on JQuery, Thanks to www.JQuery.org for such a wonderful tool.

CREDITS:

“Alok Arora

Development Team Leader - XentaQSys Technologies

Technical Consultant – Learning Geeks

Join my ASP.NET Knowledge base group by sending "ADD ME!" on gordo_matthews0207@yahoo.ca”

Thanks and Regards

Setting AlterNateRow BackColor For Two Rows At A Time In GridView

nijhawan.saurabh — Mon, 12 Oct 2009 12:04:06 GMT

This was part of a question asked on asp.net forums, i thought of sharing it here as well.

“How can i have first two rows with one color in a GridView and another color for the next two rows and so on.”

Here’s The Code:

protected void Page_Load(object sender, EventArgs e)

{

int count = 0;

for (int i = 0; i < GridView1.Rows.Count;i+=2 )

{

if (count % 2 == 0)

{

if (i != GridView1.Rows.Count - 1)

{

int j = i + 1;

GridView1.Rows[i].BackColor = System.Drawing.Color.Blue;

GridView1.Rows[j].BackColor = System.Drawing.Color.Blue;

}

else

{

GridView1.Rows[i].BackColor = System.Drawing.Color.Blue;

}

else

{

if (i != GridView1.Rows.Count - 1)

{

int k = i + 1;

GridView1.Rows[i].BackColor = System.Drawing.Color.Red;

GridView1.Rows[k].BackColor = System.Drawing.Color.Red;

}

else

{

GridView1.Rows[i].BackColor = System.Drawing.Color.Red;

}

count++;

}

Creating a N/3-Tier/Layered Application

nijhawan.saurabh — Tue, 06 Oct 2009 19:39:00 GMT

For updated version of the article please visit www.agnosticdevs.com

“In most of the Business Solutions, we tend to implement good-reusable code. There are a lot of different ways to achieve the same.

So, we are here to discuss one of those ways. This Article is about Layered/Tiered architecture using C#.NET. This sample implements a Business need to Register Employee with HR Details, using SQL Database as backend.

What is N/3-tier architecture?

N/3-Tier Architecture is an Approach to separate the Business logic (e.g. set validations and rules), Data Access and User Interface. It helps to make the logics and validations simpler, separate from Database logics and still keeping the Data access code reusable.

In a scenario, where you have to change the whole UI of an Application and the Business Rules, Database structure etc. is still kept same. The simple approach may be like writing the whole application again and setup validation, rules and db access again.

But, still this can be avoided, if we use N\3-Tier architecture.

A few more benefits are listed below:

Business logic is designed separately that’s why it is fully reusable. The new application may simply utilize the same class library reference to setup business rules.
In case, there’s some requirement to change some database logic, the only layer this affects is Data Access. Business logic or UI is least affected by the same.
The instantiation of Object is totally dependent on the Layers and Access Components, so no Memory Resources are wasted.
All three layers can be designed by a different set of specialized Developers, and this makes it easy to develop application faster and easily as the development of all three layers can be carried out in parallel mode.

I believe there are a lot more other benefits, that you may explore yourself in detail.”

As per the above theory, we have three layers:

Presentation Layer or User Interface (UI)
Object Mapping Tier (OM)
Business Logic Layer (BLL)
Data Access Layer (DAL)

The above 3 layers will be coded into separate projects and included into a single VS Solution.

How it works:

These three projects are to be created under same solution, in a manner to achieve the 3 Tier or Layered Model for our application. The Type of projects and naming convention as per our example can possibly be as follows:

Business Logic Layer

Type : Class Library

Name : BLL

Parent : _3TierArchitecture (VS Solution)

Other Project Outputs to be referred : DAL, OM

Data Access Layer

Type : Class Library

Name : DAL

Parent : _3TierArchitecture (VS Solution)

Other Project Outputs to be referred : OM

Presentation Layer or User Interface:

Type : Web Application

Name : EmployeeManagement

Parent : _3TierArchitecture (VS Solution)

Other Project Outputs to be referred : BLL

The above convention/sequence should be maintained to ensure no references are missed.

Here, the prime motive behind creating a separate layer for OM is to ensure the DAL is a standalone layer and to be able to type cast object of BLL to a DAL understandable form. As we are not adding the reference of BLL into DAL there must be something to carry the data to BLL and vice versa.

The actual sequence of data flow:

Input to DB:

We create objects of Business Objects (defined in BLL) in Presentation Layer, BLL performs validations, processes, calculations, and other steps evolved logics, then finally BLL Object is converted to OM object and is sent to DAL to be stored in Database.

Output to UI or Presentation Layer:

We call a BLL function with some parameter; BLL performs validations on input parameters and Calls DAL function with same parameter, DAL Queries database with the parameters provided returns the Data to BLL in OM Format or DataTable, BLL casts the object of returned information on the basis of OM ReturnType requested. Then finally return the BLL object to Presentation Layer.

For the above sequence, we need to refer Class Library (DLL) of DAL and OM into BLL, Class Library of OM into DAL and Class Library of BLL into EmployeeManagement Project (UI)

After creating the above structure your solution should look similar to this screen:

Step-1: Business Object Mapping and Business Object Modeling (OM and BLL)

Now, we need to draw the structure for our entity employee in database to identify the Business Objects of our application.

Let’s say, we have a requirement to register employee with its personal and HR details. For the same we have these two tables in our database:

In the above figure we have two tables called tblEmployee and tblEmployeeHRDetails. On the basis of the same we can say:

We have two business entities

Employee – personal information
Employee - HR Information
Referrer Person

We have following Business Rules:

Employee – HR information is dependent on the existence of Employee – Personal information.
Referrer is dependent on Employee HR Information.
Each Employee may have 2 referrers.

So the above can be interpreted as the following class structures:

As per the above diagram, we have:

3 Object Mapping Classes
1. BaseEmployee
2. BaseEmployeeHRDetails
3. EmployeeReferrer
3 Business Objects
1. Employee
2. EmployeeHRDetails
3. EmployeeReferrer
3 Rules
1. Employee to HR-Details
2. EmployeeHRDetails.Referrer1 to EmployeeReferrer
3. EmployeeHRDetails.Referrer2 to EmployeeReferrer

There are a lot more business object and rules that can be identified here but still we are trying the sample as simple as possible. So once you are through with this one, try to identify them all at your end.

Note: A few examples can be:

Employee.PermanentAddressInfo and Employee.CurrentAddressInfo
EmployeeHRDetails.EmployeeStatusID
EmployeeHRDetails.EmployeeStatusID
EmployeeHRDetails.DepartmentID

and many more….

The sample OM BaseEmployee should look like:

public class BaseEmployee

{

#region Properties

private Int64 _ID;

/// <summary>

/// ID of Employee Record, database column "ID"

/// </summary>

public Int64 ID

{

get

{

return _ID;

}

set

{

_ID = value;

}

private string _FirstName;

/// <summary>

/// First Name of employee, Database Column "FirstName"

/// </summary>

public string FirstName

{

get

{

return _FirstName;

}

set

{

_FirstName = value;

}

// Other properties

}

The corresponding BLL Class for the above should look like:

public class Employee : BaseEmployee

{

private static DALEmployee _ObjDal;

#region Properties

/// <summary>

/// ID of Employee Record, database column "ID"

/// </summary>

public new Int64 ID

{

get

{

return base.ID;

}

set

{

base.ID = value;

}

/// <summary>

/// First Name of employee

/// </summary>

public new string FirstName

{

get

{

return base.FirstName;

}

set

{

if (value == "")

throw new Exception("First name can not be blank");

else if (value.Split("0123456789".ToCharArray()).Length > 1)

throw new Exception("First name can not have numeric characters");

/// in the same way as above, you can implement your validations on data prior to

/// assigning the same to your Properties.

base.FirstName = value;

}

In the above code, notice the two things:

The class is inherited from BaseEmployee (OM) to make compatible with the same while passing the object of BLL to DAL, refer to DAL block for Code sample.
Use of new keyword in property declarations for this class. This is concept of shadowing(VB) or hiding(C#). Using this feature of C# we are hiding the OM.BaseEmployee.ID and other properties, creating a mapping for BLL Properties. So that a specific set of validations can be performed before initializing the OM Layer Properties. Validation Example can be found in above code as BLL.Employee.FirstName Property.

The next step is to define method to make calls to DAL and perform DB interactions wherever required.

Write to Database:

/// <summary>

/// Update the Employee Information to database.

/// </summary>

/// <returns></returns>

public Boolean Update()

{

BaseEmployee ObjEmployee = this;

return _ObjDal.Update(ref ObjEmployee);

}

In the same, BLL.Employee Class we have defined the above function.

Here, the _ObjDal is a private static object of DAL.DALEmployee Class, so as to keep the DAL Object single in all instances.

As you may notice the object of current Class (BLL.Employee denoted as this) is first converted to OM.BaseEmployee and then passed to DAL.DALEmployee’s Update method. That is how BLL communicates with DAL without creating any cyclic reference to DAL and BLL (BLL-DAL-BLL).

Note: Implementation of Update method can be found DAL block.

Read from Database:

public Employee(Int64 EmployeeID)

{

this.ID = EmployeeID;

BaseEmployee ObjEmployee = this;

_ObjDal.GetEmployeeByID(ref ObjEmployee);

}

In a common scenario where you may require to fetch the object from database by ID (Primary key Column), you may overload the constructor like above.

Here, we have first converted the object of current class (BLL.Employee) to OM.BaseEmployee and then passed the reference of the same to DAL.DALEmployee.GetEmployeeByID. In the implementation part of the same method database record is loaded in DataTable/DataSet or DataReader objects and values are assigned to object reference of OM.BaseEmployee, which ultimately affects the current class automatically.

Step-2: Data Access Layer: (DAL)

Now, here we need to identify the methods required for various Business Objects. As per our requirements, we have the following:

Employee
1. Register or Add
2. GetEmployeeByID
3. Update
4. GetEmployeeByDepartment

EmployeeHRDetails
1. Update
EmployeeReferrer
1. Update

Sample Update Method:

public Boolean Update(ref BaseEmployee ObjEmployee)

{

SqlConnection SqlCn = new SqlConnection(_ConnectionString);

SqlTransaction SqlTran = null;

try

{

SqlParameter[] Params;

SqlParameter ParamID = new SqlParameter("@EmployeeID", SqlDbType.BigInt);

ParamID.Value = ObjEmployee.ID;

SqlParameter ParamFirstName = new SqlParameter("@FirstName", SqlDbType.NVarChar, 200);

ParamFirstName.Value = ObjEmployee.FirstName;

SqlParameter ParamMiddleName = new SqlParameter("@MiddleName", SqlDbType.NVarChar, 200);

ParamMiddleName.Value = ObjEmployee.MiddleName;

Params = new SqlParameter[] { ParamID, ParamRefByName1, ParamRefByAddress1, ParamRefByPhoneNo1, ParamRefByEmail1, ParamRefByName2, ParamRefByAddress2, ParamRefByPhoneNo2, ParamRefByEmail2, ParamDeptID, ParamEmpTypeID, ParamDOJ };

//Uncomment the following lines in order to implement actual execution, this is just a sample.

SqlHelper.ExecuteNonQuery(SqlTran, _UpdateHrDetails, Params);

SqlTran.Commit();

SqlCn.Close();

SqlCn.Dispose();

return true;

}

catch (Exception Ex)

{

// Process your transaction Rollbacks here (if any) then Pass exception to BLL

if (SqlTran != null)

SqlTran.Rollback();

throw Ex;

}

Please refer the full method in Code samples.

Sample GetEmployeeByID Method

public void GetEmployeeByID(ref BaseEmployee ObjEmployee)

{

try

{

DataTable DtEmployee = new DataTable();

SqlParameter ParamID = new SqlParameter("@ID", SqlDbType.BigInt);

ParamID.Value = ObjEmployee.ID;

SqlParameter[] Params = new SqlParameter[] { ParamID };

DtEmployee.Load(SqlHelper.ExecuteReader(_ConnectionString, CommandType.StoredProcedure, _GetEmployeeByID, Params));

if (DtEmployee.Rows.Count > 0)

{

ObjEmployee.AlternateEmail = DtEmployee.Rows[0]["AlternateEmail"].ToString();

ObjEmployee.BloodGroup = DtEmployee.Rows[0]["BloodGroup"].ToString();

ObjEmployee.CurrentAddress = DtEmployee.Rows[0]["CurrentAddress"].ToString();

ObjEmployee.CurrentLandLine = DtEmployee.Rows[0]["CurrentLandline"].ToString();

ObjEmployee.CurrentMobile = DtEmployee.Rows[0]["CurrentMobile"].ToString();

ObjEmployee.DateOfBirth = Convert.ToDateTime(DtEmployee.Rows[0]["DateOfBirth"].ToString());

ObjEmployee.DrivingLicenseNumber = DtEmployee.Rows[0]["DrivingLicenseNumber"].ToString();

ObjEmployee.FirstName = DtEmployee.Rows[0]["FirstName"].ToString();

ObjEmployee.IsMarried = Convert.ToBoolean(DtEmployee.Rows[0]["IsMarried"]);

ObjEmployee.LastName = DtEmployee.Rows[0]["LastName"].ToString();

ObjEmployee.MiddleName = DtEmployee.Rows[0]["MiddleName"].ToString();

ObjEmployee.PassportNumber = DtEmployee.Rows[0]["PassportNumber"].ToString();

ObjEmployee.PermanentAddress = DtEmployee.Rows[0]["PermanentAddress"].ToString();

ObjEmployee.PermanentLandline = DtEmployee.Rows[0]["PermanentLandline"].ToString();

ObjEmployee.PermanentMobile = DtEmployee.Rows[0]["PermanentMobile"].ToString();

ObjEmployee.SpouseFatherName = DtEmployee.Rows[0]["SpouseFatherName"].ToString();

}

DtEmployee.Dispose();

}

catch (Exception Ex)

{

// Process your transaction Rollbacks here (if any) then Pass exception to BLL

throw Ex;

}

Note: There can be many more implementations and requirements but we here want to keep it simple. Any more complex logic can also be implemented using the same pattern. Try it yourself.

CREDITS:

“Alok Arora

Development Team Leader - XentaQSys Technologies

Technical Consultant – Learning Geeks

Join my ASP.NET Knowledge base group by sending "ADD ME!" on gordo_matthews0207@yahoo.ca”

Thanks and Regards

Sending HTML Mail Using Gmail SMTP (using System.Net.Mail namespace)

nijhawan.saurabh — Mon, 05 Oct 2009 23:18:00 GMT

INTRODUCTION: Sending emails requires SMTP server and hence usually you won’t be able to send emails from your local machine [In case you have SMTP server configured on your local machine, you can surely send emails using that!].

The other way out would be to use a third parties SMTP server to send Emails.

In this Article I am going to use Gmail’s SMTP to send Emails.

Using System.Net.Mail; //Include This NameSpace

MailMessage MyMailMessage = new MailMessage();

MyMailMessage.From = new MailAddress("cadbuaryguy@gmail.com");

MyMailMessage.To.Add("learninggeeks@yahoo.com");

MyMailMessage.Subject = "Feedback Form";

MyMailMessage.IsBodyHtml = true;

MyMailMessage.Body = "<table><tr><td>" + txtName.Text + txtEmail.Text + txtComments.Text + "</table></tr></td>";

SmtpClient SMTPServer = new SmtpClient("smtp.gmail.com");

SMTPServer.Port = 587;

SMTPServer.Credentials = new System.Net.NetworkCredential("cadbuaryguy@gmail.com", System.Configuration.ConfigurationSettings.AppSettings["pwd"].ToString());

SMTPServer.EnableSsl = true;

try

{

SMTPServer.Send(MyMailMessage);

Response.Redirect("Thankyou.aspx");

}

catch (Exception ex)

{

}

ASP.NET Authorization Vs Authentication

nijhawan.saurabh — Mon, 05 Oct 2009 20:09:00 GMT

For updated version of the article please visit www.agnosticdevs.com

Authorization:

in contrast to Authentication implies, "What resources are accessible to the users". This means that once the user logs in (or hasn't logged in), we need to restrict users to access resources on our website according to his/her roles that we'd provide him/her.

Authentication:

on the other hands confirms the identity of the user on the basis of a pair of Username and Password.

Example of how to implement Authorization:

Authorization logic is defined in the web.config file under <System.Web> tag:

1. <authorization>

2. <allow roles="Administrators" />

3. <deny users="*" />

4. </authorization>

The above code would mean that just allow the users whose role in the database is defined to be "Administrators" and deny access to any other user.

1. <authorization>

2. 3. <allow roles="Administrators"/>

4. <deny roles="Supervisors"/>

5. <deny roles="Employees"/>

6. <deny users="*"/>

7. <deny users="?"/>

8. 9. </authorization>

The above code would mean that just allow the users who's role in the database is defined to be "Administrators, Supervisors , Employees " and deny access to any other users and anonymous users as well. ‘?’ refers to Anonymous users.

NOTE: Remember that permissions are validated from top to bottom, and if ASP.NET doesn't find any explicit denial, then it will grant access by default.