Chakravarthy's Space : C# 3.0

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

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.

Microsoft Test Automation User Group - MTAUG.net

Chakravarthy — Thu, 19 Jul 2007 10:28:28 GMT

A new user group that is taking into shape, specially for the teams that involve software testing. You can get to know more about this user group from http://mtaug.net or get onto http://groups.msn.com/mtaug

This group is going to be functioning in parallel with "Hyderabad .NET User Group", http://muag.net or http://groups.msn.com/dotNETUserGroupHyd

Tomorrow, 20th July 2007, is going to be the launch of the group. Am going to be there as a speaker for C# 3.0 fundamentals.. are you ?