Chakravarthy's Space : Code

CheckBoxList validation

Chakravarthy — Thu, 21 May 2009 05:04:00 GMT

Within our current project, we faced a requirement such that there are multiple checkboxes and the user is required to select any one of them (at least one of them). So as there are multiple checkboxes, decided to go with CheckBoxList control. Now the problem is that, we need to show a error message if the user is not selected any one of them. The problem also extends not just there, but the display text should be culture specific.

So the story started long after I've written this post. But editing this entire post due to a simple non supportive feature by IE. I’ll come to that point later in this post, let me first detail the requirement and solution. There is one more solution for this unsupported error. Please read thru the post.

For all the client side validations, it is widely known that validation controls supported by ASP.NET framework are popularly used. But these controls can’t handle the CheckBoxList. Hence the following solution.

Step 1: Place your CheckBoxList control in a separate div as shown below. Observe that the text for these controls are populated from database depending upon the user culture

<div id="cblItems1">
    <asp:CheckBoxList ID="cblOptions" runat="server">
        <asp:ListItem Text="<%$Resources:CommonFormFields, Repair%>"></asp:ListItem>
        <asp:ListItem Text="<%$Resources:CommonFormFields, Calibration%>"></asp:ListItem>
        <asp:ListItem Text="<%$Resources:CommonFormFields, RepairCalibration%>"></asp:ListItem>
        <asp:ListItem Text="<%$Resources:CommonFormFields, OnlineService%>"></asp:ListItem>
    </asp:CheckBoxList>
</div>

Step 2: Use ASP:Lable and get the error message while loading and place in a separate div and hide this div by default as mentioned below. Please note the div ID as cblError1 and the style is set to hidden by default

<div id="cblError1" style="visibility: hidden">
    <asp:Label ID="lblReq1" runat="server" Text="<%$Resources:CommonFormFields, SelectAny%>"></asp:Label>
    </div>

Step 3: Write a JScript function that reads all the client side rendered elements as input objects and checks whether any of them are checked or not. Code explains more in detail

function CheckListValidation(cblItm, errDiv)
{
    var tDiv = document.getElementById(cblItm);
    var chkitems = tDiv.childNodes[1];
    var chkitm = chkitems.getElementsByTagName("input");
    for (var i = 0; i < chkitm.length; i++) 
    {
        if (chkitm.checked) 
        {                    
                return true;
        }
    }
    document.getElementById(errDiv).style.visibility = 'visible';
    return false;
}

Step 4: Now it is the turn of invoking this function from the button click. Every button is having a method called as “OnClientClick” along with Click. Invoke this function from that method as mentioned below

<asp:Button ID="btnAddMore" runat="server" Text="Add More" 
OnClientClick="return CheckListValidation('cbOptions','cblError1');"
    OnClick="btnAddMore_Click" />

Step 5: All setup and the code is running fine. But there is a problem with this code while running in IE. IE 6 and above doesn’t support the getElementsByTag

var vTe = document.getElementsByTagName(..);

There is a long story for this. Let me post one more post for the better mechanism of CheckBoxList Validation. Until then, what are your comments??

VS 2008 and .NET 3.5 Training Kit

Chakravarthy — Mon, 17 Dec 2007 09:40:07 GMT

The Visual Studio 2008 and .NET Framework 3.5 Training Kit includes presentations, hands-on labs, and demos. This content is designed to help you learn how to utilize the Visual Studio 2008 features and a variety of framework technologies including: LINQ, C# 3.0, Visual Basic 9, WCF, WF, WPF, ASP.NET AJAX, VSTO, CardSpace, SilverLight, Mobile and Application Lifecycle Management.

I've downloaded this, if any one require this, you can drop me a mail or can collect from me.

ASP.NET 3.5 Extensions Preview

Chakravarthy — Mon, 10 Dec 2007 15:15:08 GMT

The ASP.NET 3.5 Extensions Preview provides a glimpse of new, powerful functionality being added to ASP.NET 3.5 and ADO.NET next year. This release delivers features that enable high-productivity data scenarios and creates the best server for rich clients. The release includes an ASP.NET model-view-controller (MVC) framework, ASP.NET Dynamic Data, Silverlight controls for ASP.NET, ADO.NET Data Services, an Entity Framework runtime, new features for ASP.NET AJAX and a wide variety of API References as hosted at ASP.NET Official site.

You can download the ASP.NET 3.5 Preview, which contain all the Siliverlight controls, ADO.NET Data Services and many more. There is a forum specially dedicated to ASP.NET 3.5 Preview at ASP.NET Forums.

Calling .NET Component from a classic ASP page

Chakravarthy — Thu, 06 Dec 2007 11:24:07 GMT

After a long time, today, got a requirement from ASP page. Our current client has a major application written in classic ASP 2.0, and we have given him an extension functionality written in .NET with VB as programming language.

Now, we have 2 different applications running at the same box with 2 different technologies, ie., an ASP application and an ASP.NET application. For both of the applications, there is a common functionality talking to the database via a webservice written in Java. The current situation demand a common library that will be reused at both ASP.NET pages as well as ASP pages. Apart of the requirement, the one point that led me to post here is "How to call a .NET Assembly in a Classic page"

Creating .NET Assembly

Imports System
Imports System.Runtime.InteropServices
Public Class MyLibClass
    Public Function MyLibFunction() As String
        Return " Invoked the method from COM successfully .."
    End Function
End Class

With the above code, you can generate a .NET DLL after compiling with either Visual Basic Command Line Utility, VBC.EXE or from the Visual Studio Environment. While compiling this code, give extra attention at the assembly attribute to make the DLL Visible to COM as mentioned below.

<Assembly: ComVisible(True)>

If you are using the Visual Studio Environment, go to the Project Properties, at the Compile section don't forget to check the "Register COM interop" check box. This check box will be by default unchecked, indicating that the DLL will not be exposed to COM.

Now the assembly is ready to reuse. But before we start the actual implementation, if you want the Assembly should be register with the GAC, you have to take the assistance from StrongNameKey file. You can create a Strongname Key file with the command utility SN.EXE or from the Visual Studio as well. The command to create the Strongname Key file is as mentioned below

> sn -k strongnamekeyfile.snk

Once you are done with the strong name key file generation, you can attach the key file either with the /keyfile:strongnamekeyfile.snk option or with the assembly attribute as <Assembly: AssemblyKeyFile("strongnamekeyfile.snk")>

Now it is the final time to compile your code and do the calling stuff from ASP page. Once you compile the code from Visual Studio, you will have 3 files, .PDB / .TLB / .DLL. The .DLL is the actual file. You have to do 2 things to share this DLL.

Register as COM as well as with GAC

Now that the DLL is ready, we will take the assistance of REGASM command line utility to register as public assembly.

> regasm /codebase /tlb:a.tlb OurAssemblyFile.dll

With this command, the DLL will be registering at the registry. Please don't forget to use the /codebase option. To register the same with GAC use the following command

> gacutil /if OutAssemblyFile.dll

This command will register with the GAC and is available as reference within the .NET Framework. With the first command, the object is ready to invoke from ASP code. You can use the COM component with Server.CreateObject("OurAssemblyFile.ClassName") command from ASP page. The actual implementation at any ASP page will look like as mentioned below

 dim objCom 
 set objCom = Server.CreateObject("libraryNameSpace.libraryClass")
 objCom.DoSomeWork() ' this method doesn't return any value

Finally, if this page throw any kind of error as Unindentified Class name, then the only solution is to reset the IIS.

C# 3.0 - What's New : {Properties}-Part2

Chakravarthy — Fri, 12 Oct 2007 10:07:56 GMT

Property of the class can be considered as the mechanism of accessing the private variables of the class. In other words, properties act as wrappers to the private variables. Though, the new feature related to this is not so great from the point of technology, but highly meaningful from the developer point of view. In a large class code, having many fields and exposed as Properties, it is really difficult to remember the private fields association with the respective definition of properties. The new feature of Properties in C# 3.0 language specification says that the developer doesn't require to define the private variables that are associated with the respective properties. During the good olden days, we are used to the following coding mechanism to declare the property via a private variable.

        // The private Variable declaration
        string strEmpName;

        // Property Declaration
        public string EmployeeName
        {
            get {
                // Returning the value from the private variable
                return strEmpName;
                }
            set {
                // Assigning the value to private Variable
                strEmpName = value; 
                }
        }

But hence forth, by using the C# 3.0 version, we doesn't require to define as above but just as simple as mentioned below

        public string EmployeeName { get; set; }

How simple is this, by this method we doesn't require to remember which is property and which is a private variable. But bottom line remains the same as of the old tradition, the only thing that every one has to remember is that, there is no need to declare a private variable and association of the same with the exposed property. Beneath the code, the compiler creates a private variable for each property that you define as such. To justify, use any reflector to understand the emitted IL code and the Assembly signature. You will surprise to note that a separate private variable is associated by the compiler.

Technorati Tags: C# v3.0

The importance of 'Return' keyword at JavaScript

Chakravarthy — Sat, 15 Sep 2007 12:26:53 GMT

Recently, while coding for a Text Field value padded with left zeros, realised the importance of the RETURN key word for the FUNCTION written in JavaScript. Before i mention the actual importance, let me describe you the situation.

Scenario: A Text box need to be padded with zeros and should have the length of 7 digits, even the data entered is less than 7.

Ex: When the key board input being 88, the text box should show 0000088. Note the ZEROs padded on left.

So, started with a JavaScript function as mentioned below

function PadZeros(x)
    {
        var v = x.value;
        while(v.length<7)
        {
            v = '0' + v;
        }
        var ss = document.getElementById(x.id);
        ss.value = v;
    }

After this, the text box is padding with ZEROs and the code is perfectly running. To allow this to code execute for any given text box, all you have to do is, add the ATTRIBUTE to that text box. And while adding keep one thing in mind that, we would be calling this function on BLUR, ie., LOST FOCUS of the text box. The code is as mentioned below.

            this.txtPCode.Attributes.Add("onblur", "PadZeros(this);");

Please note the 'this' keyword. The usage of 'this' keyword has many possibilities. Let me see that, one day will post where the 'this' keyword is used and their context. And also note that, neither the function is returning any value nor the text box is added with the code that handles the output of the function. Will come to that in short.

Every thing is working perfectly well and going on smooth. But suddenly, i realised that the text box is just padding ZEROs when there is no Input. I see all ZEROs in the text box as 0000000. Then came the real trick to the function.

function PadZeros(x)
    {
        var v = x.value;
        if(v.length == 0)
        {
            var vTe = document.getElementById(x.id);
            vTe.focus();
            alert('Please enter Provider Code .. ');
        }
        while(v.length<7)
        {
            v = '0' + v;
        }
        var ss = document.getElementById(x.id);
        ss.value = v;
    }

What do you see here is the mechanism to set the focus back to the text box. Great... but that even is not solving my purpose of leaving the text box blank when there is no input. This function is still adding ZEROs to no input and showing all ZEROs. Then came the purpose of the 'return' keyword. The entire requirement is simply solved by this keyword. All i've done is.. changed the code as mentioned below.

function PadZeros(x)
    {
        var v = x.value;
        if(v.length == 0)
        {
            var vTe = document.getElementById(x.id);
            vTe.focus();
            alert('Please enter Provider Code .. ');
            return false;
        }
        while(v.length<7)
        {
            v = '0' + v;
        }
        var ss = document.getElementById(x.id);
        ss.value = v;
        return true;
    }

At the code behind added 'return' as shown here

            this.txtPCode.Attributes.Add("onblur", "return PadZeros(this);");

That's all.. hoollaa... What do you say ?

Technorati Tags: JavaScript, PadZeros, return

C# 3.0 - What's New : {Implicit}-Part1

Chakravarthy — Fri, 24 Aug 2007 05:33:00 GMT

Recent development in my technical life is that, started working out with Orcas Beta 2. So, thought to blog about the latest happenings with C# language. The idea emerged to start a series of posts related to C# new features. This is the first of ever such kind of blogging specific to a topic.

C# 3.0 has many-a-new features. To start with, let me take a concept of Implicitly Typed Variables.

Implicitly Typed Variables

In the good old days, the developer has to worry about the type of the variable. Say for instance, whether to use long or double for a counter. Here all that we observe is that the language that is built upon is the type specific. Hence forth the developer is not required to define the type of the variable at the time of declaration, but it is the task of the compiler to decide what type of the object the variable is. All that the developer has to do is that, use the var keyword while declaring the variable, similar to that of JScript or Visual Basic style. Hey!!! Stop!!!!! don't get confuse with the type of VAR variables declared at JScript or Visual basic.

Let's first discuss the difference between VAR variables at JScript and VAR variables of C#

VAR JScript	VAR C#
This is of no type	The type of the variable is defined by the value declared and decided at the compile time
Technically have no type. Can consider of limited types, namely, string literal, numeric, boolean	Type agnostic, have specific predefined formats
Type conversion is coercion	Type casting is simple and handled by CLR
No mechanism for parsing	explicit functions for parsing to specific type

Now, let us see the difference between the language specific VAR of VisualBasic 6.0 and C# 3.0

VAR in VB (but not .NET)	VAR in C# 3.0
By definition, these are Variant	Type of the variable is defined at the compile time
Could be any allowed type from with in the known types of the language	Type is decided by the value associated with the variable
Largest among all the known data tydpes	Size depends on the type of the value initialised

To summarize, the variables declared in C# 3.0 are type specific, thou used the key word VAR, during the declaration. Thus, we can conclude that the compiler is the responsible point to decide the type of the variable. Hence we can say with comfort that, the variables from C# 3.0 are Implicitly Typed variables.

Some examples as mentioned below.

            var vIntVal = 10; // This will be the System.Int32 type
            var vLongVal = 10000000000; // This will be the System.Int64 type
            var vDoubleVal = 10.0; // This will be the System.Double type
            var vFloatVal = 10.0f; // This will be the System.Single type
            float vFlVal = 10.0f; // Thou defined using float key word, but inherits from Struct System.Single 
            var vStrVal = "String Value ";  // This will be the System.String type

So, from the above declarations, it is pretty clear that the variable is defined by the value associated during the declaration. The type is not just limited to the kind of data types as explained above, but you can extend this to any type of the variable that you use while writing code for iterations, similar such as foreach. Below is the example for other known types.

            foreach (var vTable in ds.Tables) // Implicitly declared a variable of Data Table Type
            {
                foreach (var vRow in ((DataTable) vTable).Rows) // Implicit declaration of DataRow variable
                {

                }
            }

By using such, one can extend any extent. The limit is the imagination of the developer. What do you say?

Source:

1) http://cobdev.cob.isu.edu/psb/jscript/306.htm for JScript
2) http://www.1sayfa.com/1024/diger/vb/ch07.htm for Visual Basic 6.0 Datatypes

del.icio.us Tags: CSharp, 3.0, Code, Tips, Implicit

Runtime Polymorphism

Chakravarthy — Mon, 20 Aug 2007 11:00:50 GMT

One of the frequently seen situations from a technical standpoint in a large scale of Business Layer objects is, invoking methods from different objects when they contain same method name. Today, am going to make it simple to give an example for Runtime Polymorphism. Leave your comments if am mistaken

At this stage, I don’t think to mention about "Polymorphism", as hope that you are aware of how polymorphic behavior can be fused using C#. If you want a start up, in simple words, implementation of one Method with many definitions, as mentioned below.

class Employee
{
/// <summary>
/// Invoked for the Regular salaried employes
/// </summary>
/// <param name="intEmpId">Employee ID</param>
/// <param name="intAbscentDays">Number of days</param>
/// <returns></returns>

public long CalculateSal(int intEmpId, int intAbscentDays)
{
return (GetEmpSal(intEmpId) * (GetWorkingDays(DateTime.Now.Month) - intAbscentDays));
}

/// <summary>

/// Invoked for the employees, who work as Daily wage
/// </summary>
/// <param name="lSalPerDay">Salary per day</param>
/// <param name="intDays">For number of days</param>
/// <returns></returns>
public long CalculateSal(long lSalPerDay, int intDays)
{
return lSalPerDay * intDays;
}
}

A simple way of invoking is as mentioned below.

Employee eTe = new Employee();

long lSal = eTe.CalculateSal(124, 2);
long lSal = eTe.CalculateSal(678.35, 18);

So, by now, you are clear how to write polymorphic method and as well as how to use. Let’s jump to how you can make the Runtime Polymorphism.

To continue the discussion, first we need to know that there are 2 basic types of polymorphism. They are, Overloading, referred as Compile time polymorphism, and Overriding also called as Run-Time polymorphism. What you have seen above is the first kind of polymorphism. The second type is referred as late binding. In other words, the selection of the method for execution at runtime depends on the reference of the actual object that is triggering the invoking of the method. Now let's explore that with some example.

Let us take a small class, as mentioned below with few properties. This class acts as a base class for us.

    public class EmpNames
    {
        public string FirstName { get; set; }
        public string MiddleName { get; set; }
        public string LastName { get; set; }
    }

We will now inherit this into the following classes. Observe that the both classes doesn't have any direct relation with each other and can be instantiated as is.

    /// <summary>
    /// This class calculate the wages for given number of days
    /// </summary>
    public class Wages : EmpNames 
    {
        /// <summary>
        /// This will calculate the wages for the employees
        /// </summary>
        /// <param name="Params">Wage per Day, Number of Working days in a month</param>
        /// <returns> WagePerDay * WorkingDays </returns>
        public double CalculateSalary(ArrayList Params)
        {
            return double.Parse(Params[0].ToString()) * int.Parse(Params[1].ToString());
        }
    }


    /// <summary>
    /// This class will calculate the salary
    /// </summary>
    public class Salried : EmpNames
    {
        /// <summary>
        /// This will calculate the salary for the employees
        /// </summary>
        /// <param name="Params">Working days Per Month, Leaves, Salary Per Month</param>
        /// <returns> Full Salary in case no value for Leaves. Other case, (SalaryPerMonth/WorkingDays) * (WorkingDays - Leaves) </returns>
        public double CalculateSalary(ArrayList Params)
        {
            double dSal=double.Parse(Params[2].ToString());
            int intLeaves = int.Parse(Params[1].ToString());
            if (!intLeaves.Equals(0))
            {
                int intWrkDays = int.Parse(Params[0].ToString());
                dSal = (dSal / intWrkDays) * (intWrkDays - intLeaves);
            }
            return dSal;
        }
    }

Now that we have these two classes, We can write our code to instantiate them as individual. But the point of this post is to describe the "RunTime Polymorphism". Before we go further, note that, each class has the method "CalculateSalary" and as they are not directly related, you can instantiate them with out any hassle.

            EmpNames empObj;

            ArrayList alValues = new ArrayList();
            alValues.Add(30); //Just add all the fields as this

            bool bSalaried = true; //am using this variable for validation of emp

            if (bSalaried) //Validating whether Salaried or Wages 
                empObj = new Salried();
            else
                empObj = new Wages();

After executing the above lines of code, you are sure about the type of the variable empObj. This is Runtime initiating the object. But this is not the purpose of our current topic.

            double dVal;

            //The below line will throw compile time error
            //dVal = empObj.CalculateSalary(alValues);
            dVal = ((Wages) empObj).CalculateSalary(alValues);

What do you see from the last line of the above code? Did you find that the method invoked is from a class type. Now, think that, what if the class is being instantiated as Salaried and the last line is being invoked?

This is called as RunTime Polymorphism.

del.icio.us Tags: Runtime Polymorphism, CSharp, Tips

-----------------------
Declaimer: What ever you read here is out of my own experience. No one shall be made responsible for the contents and issues that are mentioned here. If you have something to share in person on this post, pl drop me a mail at dskcheck@gmail.com with the title in the subject.