Everything in a single blog

upcasting and downcasting

2010-06-14T03:22:00.000-07:00

The original aim of this article was to explain Up-casting and Down-casting. Having started writing the article, I was struggling to find an ideal way to describe these two concepts. Having thought further about it, one way I found was to introduce the concept of polymorphism to help explain up and down-casting. This has expanded the article further and when you have finished reading it, you should hopefully understand the three concepts better.

Polymorphism

Polymorphism is a powerful aspect of object oriented programming. According to many searches on the Internet to find a definitive meaning, I have found two that seem to explain it quite nicely, these are "Having many forms" and "Having multiple forms".

Consider the following. Ask yourself, what is a circle? Most would say a circle is a shape. A square, rectangle and a triangle are also shapes. So, what we are saying is a shape can take on many forms or has multiple forms. So how do we implement this concept in C#?

First we need to design our base class, this will be called Shape. Our shape class will implement a constructor that will accept an X and Y co-ordinate and a method that will draw our shape. Below is the code for our shape class.

public class Shape

{

protected int m_xpos;

protected int m_ypos;

public Shape()

{

}

public Shape(int x, int y)

{

m_xpos = x;

m_ypos = y;

}

public virtual void Draw()

{

Console.WriteLine("Drawing a SHAPE at {0},{1}", m_xpos, m_ypos);

}

}

We now need to make our Draw method behave polymorphically. To do this, we declare our method with the keyword virtual in our base class. When we derive a class from shape we are able to implement a specific version of Draw by overriding the base class implementation of Draw. To do this, we use the keyword override when declaring our Draw method in our derived classes.

What we will now do is implement two derived classes from our shape base class. We will implement Circle and Square. This will show how we override our base class Draw method.

Circle and Square derived classes

One thing to note about the base class is the fact that I have used protected variables for the X and Y co-ordinates. Ideally you would use public properties and declare m_xpos and m_ypos as private.

Here are our two derived classes.

public class Square : Shape

{

public Square()

{

}

public Square(int x, int y) : base(x, y)

{

}

public override void Draw()

{

Console.WriteLine("Drawing a SQUARE at {0},{1}", m_xpos, m_ypos);

}

}

And finally Circle...

public class Circle : Shape

{

public Circle()

{

}

public Circle(int x, int y) : base(x, y)

{

}

public override void Draw()

{

Console.WriteLine("Drawing a CIRCLE at {0},{1}", m_xpos, m_ypos);

}

}

Notice, the highlighted code blocks. We have overridden the base class implementation of Draw in each of our derived classes. Basically override tells the compiler that we are intentionally overriding the behaviour of Draw.

We will now test the classes we have written, by putting together a simple piece of code that will create an instance of Shape, Circle and Square and call the Draw methods for each type.

class Program

{

static void Main(string[] args)

{

Shape sh = new Shape(100, 100);

sh.Draw();

Square sq = new Square(200, 200);

sq.Draw();

Circle ci = new Circle(300, 300);

ci.Draw();

}

}

The output generated by the test code is:

Drawing a SHAPE at 100,100

Drawing a SQUARE at 200,200

Drawing a CIRCLE at 300,300

So what's happened that's polymorphic? Well, at this point absolutely nothing! Consider the code below.

class Program

{

static void Main(string[] args)

{

Shape[] shapes = new Shape[3];

shapes[0] = new Shape(100, 100);

shapes[1] = new Square(200, 200);

shapes[2] = new Circle(300, 300);

foreach (Shape shape in shapes)

shape.Draw();

}

}

What we have done is to create an array of the type Shape. Because Square and Circle are derived from Shape, we are able to put them in our array. What we are then doing is looping through all the elements of our array and calling Draw for each of our types. Because we have overridden the Draw method in each of our derived classes the output of our code is:

Drawing a SHAPE at 100,100

Drawing a SQUARE at 200,200

Drawing a CIRCLE at 300,300

If we did not override Draw in one of our derived classes, the base class implementation of Draw would be called. For example, if we declared Draw in our Circle class as follows:

public void Draw()

{

Console.WriteLine("Drawing a CIRCLE at {0},{1}", m_xpos, m_ypos);

}

Our output would be:

Drawing a SHAPE at 100,100

Drawing a SQUARE at 200,200

Drawing a SHAPE at 300,300

By declaring the method as shown above, we will receive a compiler warning as follows:

Polymorphism.Circle.Draw() : Hides inherited member.

Polymorphism.Shape.Draw() :To make the current member override that implementation, add the override keyword. Otherwise add the new keyword.

If we do not want to override the base class method, we need to use the new keyword when declaring our method, for example:

public new void Draw()

{

Console.WriteLine("Drawing a CIRCLE at {0},{1}", m_xpos, m_ypos);

}

This will remove the compiler warning. Basically we are telling the compiler that we are not overriding the base class implementation.

So what have we achieved with polymorphism? What we have been able to do is create an array of shapes and add a specific shape to each element of the array. When drawing each shape, we have not concerned ourselves with the fact that the shape could be a circle or a square. We have simply said, "here is an array of shapes, please draw them!" It is the responsibility of the compiler to discover the real type and to ensure that the correct implementation is called.

Up-casting

Now we come on to one of the original goals of the article. With the simple example above of polymorphism, you should be able to quickly understand what up-casting is, in fact we have already used up-casting in our example.

The diagram below is a UML diagram for our polymorphism example.

Figure 1: UML Diagram For Shape.

Consider the following code:

Shape s = new Circle(100, 100);

We have cast Circle to the type Shape. This is perfectly legal code (as we saw in the Polymorphism example). This is possible, because Circle has been derived from Shape and you expect all methods and properties of Shape to exist in Circle. Executing the Draw method by doing s.Draw() gives the following output:

Drawing a CIRCLE at 100,100

If we had declared the Draw method in Circle as follows, public new void Draw() the output would have been:

Drawing a SHAPE at 100,100

As we have already mentioned, marking the method with new, tells the compiler that we are not overriding the base class implementation of the method.

So why is this called up-casting? Consider the diagram above. From Circle, we are moving up the object hierarchy to the type Shape, so we are casting our object "upwards" to its parent type.

Up-casting is implicit and is safe. What do we mean by safe? Well, we can happily cast Circle to Shape and expect all the properties and methods of Shape to be available.

Down-casting

The flip side of the coin to up-casting is ...yes you guessed it, down-casting. Down-casting takes a little more understanding and you have to be very careful when down-casting types.

To help us better understand down-casting, we are going to add a new method to our Circle class. This will be a simple method called FillCircle.

public void FillCircle()

{

Console.WriteLine("Filling CIRCLE at {0},{1}", m_xpos, m_ypos);

}

Using the example from up-casting, we know that we are able to write the following:

Shape s = new Circle(100, 100);

We are then free to call the Draw method. Having added the FillCircle method to our Circle class, are we able to call this method by doing the following?

s.FillCircle ();

In short, the answer is no. Because we have cast Circle to the type Shape, we are only able to use methods found in Shape, that is, Circle has inherited all the properties and methods of Shape. If we want to call FillCircle, we need to down-cast our type to Circle. Why is it called down-casting? Quite simply, we are moving down the object hierarchy, from Shape down to Circle.

So how do we code a down-cast from Shape to Circle? The code for doing this is quite simple:

Circle c;

c = (Circle)s;

Simply, we are declaring c as the type Circle and explicitly casting s to this type. We are now able to call the FillCircle method by doing the following:

c.FillCircle();

This gives us the following output:

Drawing a CIRCLE at 100,100

Filling CIRCLE at 100,100

We could also write ((Circle)s).FillCircle() reducing the lines of code needed to down-cast our type and call the required method.

Down-casting is potentially unsafe, because you could attempt to use a method that the derived class does not actually implement. With this in mind, down-casting is always explicit, that is, we are always specifying the type we are down-casting to.

The as and is keywords

To demonstrate as and is, lets implement a FillSquare method in our Square class. Our code could be:

Public void FillSquare()

{

Console.WriteLine("Filling SQUARE at {0},{1}", m_xpos, m_ypos);

}

Taking some code from our polymorphism example, as follows:

class Program

{

static void Main(string[] args)

{

Shape[] shapes = new Shape[3];

shapes[0] = new Shape(100, 100);

shapes[1] = new Square(200, 200);

shapes[2] = new Circle(300, 300);

foreach (Shape shape in shapes)

shape.Draw();

}

}

We have Circle and Square in our array of type Shape. How do we know what type we have to down-cast to in order to call the correct routine to fill the shape?

Within the foreach statement, we have to test the type of shape being drawn before we down-cast, we will use the is keyword to test type. We will modify the code above, to ensure the correct method is called to fill our shapes as they are drawn.

foreach (Shape shape in shapes)

{

shape.Draw();

if (shape is Circle)

((Circle)shape).FillCircle();

if (shape is Square)

((Square)shape).FillSquare();

}

Within the loop, we are performing a test to see if the type of shape is a Circle or a Square, depending on the result, we are down-casting our type in order to call the correct fill routine. Our output now is:

Drawing a SHAPE at 100,100
Drawing a SQUARE at 200,200
Filling SQUARE at 200,200

Drawing a CIRCLE at 300,300

Filling CIRCLE at 300,300

I have highlighted the changes our code has made to the output. The alternative to the is keyword is as. We can write:

Circle c = shape as Circle;

The difference is that as tries to cast shape to a type (in our example Circle). If the cast fails, c is set to null. For example:

Circle c = shape as Circle;

If(c!=null)

c.FillCircle();

Conclusion

Quite a lot of ground has been covered in this article. Whilst the polymorphism example is very simple, it gives you an understanding of what polymorphism is and how you could implement it in your design.

The down-casting example is a little contrived. Some of you may be thinking why not just implement a base class method for filling the shapes and override it in the derived classes. The idea of implementing the fill routines as I did was to aid in the explanation of down-casting and has only been done for this reason.

ICSE CBSE comparision : ICSE vs CBSE after 8th Standard and 10th standard

2010-03-04T09:21:00.000-08:00

1. Which Board is difficult CBSE or ICSE
Ans. ICSE is difficult than CBSE
...........................................................
2. Why ICSE is difficult than CBSE
Ans. ICSE is little ahead of CBSE. The course covered by ICSE in 7th standard is done in 8th standard in CBSE.
...........................................................
3. Which Subjects in ICSE are difficult as compared to CBSE
Ans. In ICSE there is more emphasis on literature. The students who do not like literature and Scoial Sciences finds it difficult. Science and Maths are almost the same in ICSE and CBSE.
...........................................................
4. Which board is easy for scoring?
Ans. CBSE is more liberal and students can get better marks as compared to ICSE.
...........................................................
5. Which board should I choose for my kid?
Ans. This depends on the caliber of the child, and his area of interest.
If the child is not so good at language and literature then, it is better to go for CBSE.
If you want your child to take up management roles then, ICSE is far better then CBSE. ICSE gives a good command over language.
If you want your child to score more percentage in boards, go for CBSE.
If you want an overall better academic growth, go for ICSE because 2% or 5% more is boards does not matter a lot in the overall career. Even if the child becomes an engineer from the best institute, he might not rise in his career if he does not have an excellent command over his language.
...........................................................
6. Which board is better close to the engineering / Medical entrance exam?
Ans. Both boards cover complete syllabus that is needed for the entrance exams. CBSE being a little easier, the student gets more time to prepare for various entrance exams.
...........................................................
7. I am in CBSE board, can I switch to ICSE?
Ans. Technically anyone can shift from one board to the other but if you are in higher class, it is not good to change board. ICSE might be little difficult for you.
...........................................................
8. I want to do MBA which board should I choose?
Ans. If you are seriously planning to do an MBA from some good B- School, you should go for ICSE.

Powerful Leg & Knee Strengthening Exercises Using Your Body Weight

2010-03-02T00:38:00.000-08:00

Knee strengthening exercises like Knee Circles strengthen your knees and legs by using your body weight as resistance.

Do this simple yet effective knee exercise in combination with other stretching and strengthening exercises for the lower body, such as the Forward Lunge, the Thigh Burner and the Forward Backward Bend (see below), and you will develop strong, flexible legs.

Having strong, flexible legs is important for upper body support and goodbalance. Doing regular leg stretching and strengthening exercises also stimulates vital nerve and energy channels from your spine to your toes. Check with your health professional though before trying any new leg or knee exercises, particularly if you have a history of problems in this area.

Knee Circles - Strengthen Your Knees & Ankles

How

1. Stand with your feet together.

Bend your legs and squat down slightly.

Put your hands on your knees so that your palms cover your kneecaps.

Keep your feet firmly on the ground and your eyes focused on your toes.

2. Slowly and gently begin moving your knees in small, clockwise circles.

Don't make the circles too big - keep your knees above your toes.

If your feet lift up, it means your knees are moving around too widely.

Do 10-15 circles then repeat in the other direction.

Build up to 25-30 circles in each direction, or simply do the exercise for a couple of minutes 2-3 times a day.

Benefits

Strengthens your knees & ankles
Relieves pain & stiffness in your knee & ankle joints

Tips

Breathe slowly, deeply and evenly through your nose
Keep the exercise soft - Don't force it
Stop if you feel any pain

When done regularly, Knee Circles is an effective exercise to strengthen your knees and ankles. No weights are required other than your body weight. Knees Circles and the other leg and knee strengthening exercises on this site are therefore convenient to do any place you like. To enhance the effects of the above knee exercise, also include some (or all) of these other leg and knee strengthening exercises in your routine:

C Sharp Window Forms

2010-02-17T12:13:00.000-08:00

This page contains a number of C# codes for the Amateur/Beginners in the Visual C# and .Net PlatForm Environment.

This Tutorial will take anyone from the scratch to a good Windows Form creator although I am still learning at my spare time.

Source Code:

//MyForm1.cs
//This Tutorial will Teach you how to create a Form without Caption Heading
using System;
using System.Drawing;
using System.WinForms;
class MyForm : System.WinForms.Form
{
public MyForm()
{
}
public static void Main()
{
Application.Run(new MyForm());
}
}
/*
To Compile make a batch File in Dos Mode as compile.bat
csc /r:System.dll /r:System.Drawing.dll /r:System.WinForms.dll
/r:Microsoft.Win32.InterOp.dll /out:MyForm1.exe MyForm1.cs
*/

OutPut:

Source Code:

//MyForm2.cs
//This Tutorial will Teach you how to create a Form with Caption Heading
using System;
using System.Drawing;
using System.WinForms;
class MyForm : System.WinForms.Form
{
public MyForm()
{
//Text to be Displayed in the Caption-Title Bar
this.Text = "Form Tutorial No.2 From JAYANT";
}
public static void Main()
{
Application.Run(new MyForm());
}
}
/*
To Compile make a batch File in Dos Mode as compile.bat
csc /r:System.dll /r:System.Drawing.dll /r:System.WinForms.dll
/r:Microsoft.Win32.InterOp.dll /out:MyForm2.exe MyForm2.cs
*/

OutPut:

Source Code:

//MyForm3.cs
//This Tutorial will Teach you how to create a Form with Added Functionality describing Size
using System;
using System.Drawing;
using System.WinForms;
class MyForm : System.WinForms.Form
{
public MyForm()
{
//Text to be Displayed in the Caption-Title Bar
this.Text = "Form Tutorial No.3 From JAYANT";
this.StartPosition = FormStartPosition.CenterScreen;
this.AutoScaleBaseSize = new Size(5,13);
this.ClientSize = new Size(400, 200); //Size except the Title Bar-CaptionHeight
this.MinTrackSize = new Size(400, (200 + SystemInformation.CaptionHeight) );
this.MaximizeBox = false;
}
public static void Main()
{
Application.Run(new MyForm());
}
}
/*
To Compile make a batch File in Dos Mode as compile.bat
csc /r:System.dll /r:System.Drawing.dll /r:System.WinForms.dll
/r:Microsoft.Win32.InterOp.dll /out:MyForm3.exe MyForm3.cs
*/

OutPut:

Source Code:

//MyForm4.cs
//This Tutorial will Teach you how to create a Form with Label on the Form
using System;
using System.Drawing;
using System.WinForms;
class MyForm : System.WinForms.Form
{
Label label1;
public MyForm()
{
label1 = new Label();
label1.UseMnemonic = true;
label1.Text = "First &Name:";
label1.Location = new Point(15,15);
label1.BackColor = Color.Pink;
label1.ForeColor = Color.Maroon;
label1.BorderStyle = System.WinForms.BorderStyle.FixedSingle;
label1.Size = new Size (label1.PreferredWidth, label1.PreferredHeight + 2);
//Text to be Displayed in the Caption-Title Bar
this.Text = "Form Tutorial No.4 From JAYANT";
this.StartPosition = FormStartPosition.CenterScreen;
this.AutoScaleBaseSize = new Size(5,13);
this.ClientSize = new Size(300, 200); //Size except the Title Bar-CaptionHeight
this.MinTrackSize = new Size(300, (200 + SystemInformation.CaptionHeight) );
this.AutoScroll = true;
this.MaximizeBox = false;
this.Controls.Add(label1);
}
public static void Main()
{
Application.Run(new MyForm());
}
}
/*
To Compile make a batch File in Dos Mode as compile.bat
csc /r:System.dll /r:System.Drawing.dll /r:System.WinForms.dll
/r:Microsoft.Win32.InterOp.dll /out:MyForm4.exe MyForm4.cs
*/

OutPut:

Source Code:

//MyForm5.cs
//This Tutorial will Teach Mouse clicking Events and MessageBox(without Title_Heading) calling
using System;
using System.Drawing;
using System.WinForms;
class MyForm : System.WinForms.Form
{
Label label1;
public MyForm()
{
label1 = new Label();
label1.UseMnemonic = true;
label1.Text = "First &Name:";
label1.Location = new Point(15,15);
label1.BackColor = Color.Pink;
label1.ForeColor = Color.Maroon;
label1.BorderStyle = System.WinForms.BorderStyle.FixedSingle;
label1.Size = new Size (label1.PreferredWidth, label1.PreferredHeight + 2);
//Text to be Displayed in the Caption-Title Bar
this.Text = "Form Tutorial No.5 From JAYANT";
this.StartPosition = FormStartPosition.CenterScreen;
this.AutoScaleBaseSize = new Size(5,13);
this.ClientSize = new Size(300, 200); //Size except the Title Bar-CaptionHeight
this.MinTrackSize = new Size(300, (200 + SystemInformation.CaptionHeight) );
this.AutoScroll = true;
this.MaximizeBox = false;
this.Controls.Add(label1);
this.Click += new EventHandler(clicking);
}
public void clicking(object ob, EventArgs e)
{
MessageBox.Show("You clicked on Form Area");
}
public static void Main()
{
Application.Run(new MyForm());
}
}
/*
To Compile make a batch File in Dos Mode as compile.bat
csc /r:System.dll /r:System.Drawing.dll /r:System.WinForms.dll
/r:Microsoft.Win32.InterOp.dll /out:MyForm5.exe MyForm5.cs
*/

OutPut:

Source Code:

//MyForm6.cs
//This Tutorial will Teach Mouse clicking Events and MessageBox(with Title_Heading) calling
using System;
using System.Drawing;
using System.WinForms;
class MyForm : System.WinForms.Form
{
Label label1;
public MyForm()
{
label1 = new Label();
label1.UseMnemonic = true;
label1.Text = "First &Name:";
label1.Location = new Point(15,15);
label1.BackColor = Color.Pink;
label1.ForeColor = Color.Maroon;
label1.BorderStyle = System.WinForms.BorderStyle.FixedSingle;
label1.Size = new Size (label1.PreferredWidth, label1.PreferredHeight + 2);
//Text to be Displayed in the Caption-Title Bar
this.Text = "Form Tutorial No.6 From JAYANT";
this.StartPosition = FormStartPosition.CenterScreen;
his.AutoScaleBaseSize = new Size(5,13);
this.ClientSize = new Size(300, 200); //Size except the Title Bar-CaptionHeight
this.MinTrackSize = new Size(300, (200 + SystemInformation.CaptionHeight) );
this.AutoScroll = true;
this.MaximizeBox = false;
this.Controls.Add(label1);
this.Click += new EventHandler(clicking);
}
public void clicking(object ob, EventArgs e)
{
MessageBox.Show("You clicked on Form Area","Title_JAYANT");
}
public static void Main()
{
Application.Run(new MyForm());
}
}
/*
To Compile make a batch File in Dos Mode as compile.bat
csc /r:System.dll /r:System.Drawing.dll /r:System.WinForms.dll
/r:Microsoft.Win32.InterOp.dll /out:MyForm6.exe MyForm6.cs
*/

OutPut:

Source Code:

//MyForm7.cs
//This Tutorial will Teach Mouse clicking Events and changing the Form colour
using System;
using System.Drawing;
using System.WinForms;
class MyForm : System.WinForms.Form
{
Label label1;
public MyForm()
{
label1 = new Label();
label1.UseMnemonic = true;
label1.Text = "First &Name:";
label1.Location = new Point(15,15);
label1.BackColor = Color.Pink;
label1.ForeColor = Color.Maroon;
label1.BorderStyle = System.WinForms.BorderStyle.FixedSingle;
label1.Size = new Size (label1.PreferredWidth, label1.PreferredHeight + 2);
//Text to be Displayed in the Caption-Title Bar
this.Text = "Form Tutorial No.7 From JAYANT";
this.BackColor = Color.BurlyWood;
this.StartPosition = FormStartPosition.CenterScreen;
this.AutoScaleBaseSize = new Size(5,13);
this.ClientSize = new Size(300, 200); //Size except the Title Bar-CaptionHeight
this.MinTrackSize = new Size(300, (200 + SystemInformation.CaptionHeight) );
this.AutoScroll = true;
this.MaximizeBox = false;
this.Controls.Add(label1);
this.Click += new EventHandler(clicking);
}
public void clicking(object ob, EventArgs e)
{
MessageBox.Show("Click will change the Form Color", "Title_JAYANT");
this.BackColor = Color.Red;
}
public static void Main()
{
Application.Run(new MyForm());
}
}
/*
To Compile make a batch File in Dos Mode as compile.bat
csc /r:System.dll /r:System.Drawing.dll /r:System.WinForms.dll
/r:Microsoft.Win32.InterOp.dll /out:MyForm7.exe MyForm7.cs
*/

OutPut:

Source Code:

//MyForm8.cs
//This Tutorial will Teach Mouse clicking Events and
using System;
using System.Drawing;
using System.WinForms;
class MyForm : System.WinForms.Form
{
Label label1;
TextBox txtbx1;
Button btn1;
Button exit;
public MyForm()
{
label1 = new Label();
txtbx1 = new TextBox();
btn1 = new Button();
exit = new Button();
label1.UseMnemonic = true;
label1.Text = "First &Name:";
label1.Location = new Point(15,15);
label1.BackColor = Color.Pink;
label1.ForeColor = Color.Maroon;
label1.BorderStyle = System.WinForms.BorderStyle.FixedSingle;
label1.Size = new Size (label1.PreferredWidth, label1.PreferredHeight + 2);
txtbx1.Text = "Enter Your Name";
txtbx1.Location = new Point(15+label1.PreferredWidth+5, 15);
txtbx1.BorderStyle = System.WinForms.BorderStyle.FixedSingle;
txtbx1.BackColor = Color.LightGray;
txtbx1.ForeColor = Color.Maroon;
txtbx1.Size = new Size (90, 20);
btn1.Text = "&OK";
btn1.Location = new Point(15+txtbx1.Location.X+txtbx1.Size.Width,15);
btn1.Size = new Size (50, 20);
exit.Text = "Exit";
exit.Location = new Point(150,150);
exit.Size = new Size (90, 20);
exit.BackColor = Color.Maroon;
exit.ForeColor = Color.White;
//Text to be Displayed in the Caption-Title Bar
this.Text = "Form Tutorial No.8 From JAYANT";
this.StartPosition = FormStartPosition.CenterScreen;
this.AutoScaleBaseSize = new Size(5,13);
this.ClientSize = new Size(300, 200); //Size except the Title Bar-CaptionHeight
this.MinTrackSize = new Size(300, (200 + SystemInformation.CaptionHeight) );
this.AutoScroll = true;
this.MaximizeBox = false;
this.Controls.Add(label1);
this.Controls.Add(txtbx1);
this.Controls.Add(btn1);
this.Controls.Add(exit);
btn1.Click += new EventHandler(Btn_Clicked);
exit.Click += new EventHandler(Ext_Clicked);
}
public void Btn_Clicked(object ob, EventArgs e)
{
if(txtbx1.Text == "Enter Your Name")
MessageBox.Show("You Have'nt Entered Your Name","Title_JAYANT");
else
MessageBox.Show("Hello!!! " + txtbx1.Text,"Title_JAYANT");
}
public void Ext_Clicked(object ob, EventArgs e)
{
Application.Exit();
MessageBox.Show("Successfully Closed","EXIT");//not Shown! Do you know Why?
}
public static void Main()
{
Application.Run(new MyForm());
}
}
/*
To Compile make a batch File in Dos Mode as compile.bat
csc /r:System.dll /r:System.Drawing.dll /r:System.WinForms.dll
/r:Microsoft.Win32.InterOp.dll /out:MyForm8.exe MyForm8.cs
*/

OutPut:

CSharp and Working with Data

2010-02-17T00:59:00.001-08:00

This article introduces SQL, shows how to use ADO.NET Datasets, and connect to SQL Server and Microsoft Access databases. It introduces data binding and shows how to build your own SQL Query program that works with Access databases.

Working with Data

Database access is the perfect example of source code reuse. The basic operations are always the same—add, retrieve, update, and delete records. The only thing different is the structure of the data. Yet, each database system has its own native programming library that is not compatible with other databases, making it difficult to port applications to other database systems. So, it is not surprising that numerous database libraries have been developed over the years to encapsulate the implementation details of database operations.

In this article, we talk about how to access a database using ADO.NET—the set of classes that .NET provides for database access.

Databases

Most business applications need to access some kind of a database. That database could be a flat file, a directory of files, or it could be a server program that handles data requests from client programs. The later case is most common because database servers are optimized for managing large amounts of data and many concurrent connections. In the case of Microsoft Access, the tables are contained within a file with the MDB extension and the "server" is the JET database engine that your program communicates with using the classes that ADO.NET provides.

A database consists of a collection of tables. Each table is defined as a set of columns and a collection of rows. Each row has a field of data for each column in its table.

A relational database is a database that defines relationships between the tables. Consider the logical relationship between a Customer table and an Orders table. A customer can have many orders, but each order can belong to only one customer. This type of relationship is called one-to-many.

The Customer record can be thought of as the parent record of each Order record belonging to that customer. If you delete the Customer record while it still has orders in the Orders table, then those orders would be orphaned records. A relational database gives us the ability make that logical relationship a physical one by putting constraints or rules on the table, such as not allowing a Customer record to be deleted if it has any Order records, preserving the integrity of the database.

A database table usually defines a primary key to uniquely identify every record in the table. The primary key is normally a combination of one or more fields in the table. If a table contains child records that are linked back to a parent record, then the value of that parent’s primary key is usually stored in the child record. It is that field that provides the link to the parent record. When a table contains a field that stores a primary key from some other table, that field is called a foreign key.

Consider two tables that store Customers and Orders. The Customer table may be defined to hold customer information and a primary key. Table 15.1 shows what a Customer table might look like.

Table 15.1 - Definition of the Customer Table

Field Name
Data Type

CustomerID
int, auto counter, primary key

Name
string

Address
string

Phone
string

The Customer table is defined to store the Name, Address, and Phone of a Customer, as well as a CustomerID field that will uniquely identify a record in the table. The CustomerID field is the primary key.

The Customer and Orders table have a parent-child relationship, with Customers being the parent table. Each Customer can have one or more Orders, giving the tables a one-to-many relationship. The definition of the Orders table is below.

Table 15.2 - Definition of the Order Table

Field Name
Data Type

OrderID
int, auto counter, primary key

CustomerID
int, foreign key

OrderDate
DateTime

ShipDate
DateTime

The Orders table definition stores the OrderID as its primary key. It also stores the CustomerID as the foreign key to link it back to the customer record of the customer who placed the order.

The Northwind Trader Database

An example of a database is the Northwind Trader database, which you can install with Microsoft Access. The Northwind Trader database is a sample database that contains tables for Customers, Orders, Employees, and other data commonly used by businesses. We will use the Northwind Trader database in the examples that follow.

Figure 15.1

Introduction to SQL

Most databases use a language called SQL, Structured Query Language, to process their commands. While SQL (commonly pronounced "sequel") is a large topic, the basics are easily grasped by looking at a few statements. The basic operations for any database are to add, retrieve, update, and delete records. The SQL language supports these operations with the following four statements.

The INSERT Statement

The INSERT statement will add new records to a table. To insert a record, you must specify the name of the table and the values for the fields. The following statement inserts a new record into the Customers table of the Northwind Trader database.
INSERT INTO Customers ( CustomerID, CompanyName )
VALUES ('SUD100', 'Jeff Suddeth')
The INSERT statement takes the name of the table that you want to insert a record into. Then, in parentheses, you must specify the list of fields you are setting values to. After the VALUES keyword, there is another set of parentheses that include the list of values to be assigned to the fields. The statement above creates a new Customers record and sets the CustomerID field to "SUD100" and the CompanyName field to "Jeff Suddeth". All other fields will be null unless the field has a default value defined.

The SELECT Statement

Use the SELECT statement to retrieve a set of records based on the criteria you specify. The SELECT statement may return zero or more records depending on the conditions of your selection. The following statement does not specify any selection criteria. It will return the CustomerID and CompanyName fields from every row in the table.
SELECT CustomerID, CompanyName
FROM Customers
To add search criteria to the SELECT statement, you can use the WHERE clause. The WHERE clause takes a comma separated list of conditions. The following select statement will select the record we added above.
SELECT CustomerID, CompanyName
FROM Customers'''
The ADO.NET Classes

ADO.NET is the portion of the .NET library that deals with databases. Table 15.3 lists some of the common ADO.NET classes.

Table 15.3 – Classes of ADO.NET

Class
Description

DataSet
A set of database tables that can be filled from a database and used as a disconnected database

DataTable
A collection data rows and the columns that define their structure

DataRow
A database Record

DataView
A view of the data. Can be filtered for search criteria and sorted

DataRowView
A single row from a DataView

DataRelation
A parent-child relationship between tables

The classes in Table 15.3 organize the data into table structures. They are declared within the System.Data namespace. The DataSet class is one of the most useful classes in .NET; because, it encapsulates a collection of tables and the relationships between those tables. It is essentially a mini database that you can use in memory. You can also fill the DataSet with tables and data from some other database, giving you a local cache of data.

Roll Your Own Database

In this section, we use the ADO.NET classes from Table 15.3 to define a database of customer information. We will define the structure of the database by adding columns to a table named Customers. Then, we will load some sample data into the table and persist the data to an XML file. When the program runs again, we will load the database from the XML file and print the data that it contains. The complete listing is shown in Example15_1.cs.

Listing 15.1
// Example15_1.cs
using System;
using System.Text;
using System.Data;
using System.IO;

namespace csbook.ch15 {

 class CustomerDatabase {

    public void MakeFile() {
       DataSet ds = new DataSet();
       ds.DataSetName = "CustomerDatabase";

       DataTable custTable = new DataTable();
       custTable.TableName = "Customers";

       // this will be the primary key
       DataColumn custId = new DataColumn("CustID", typeof(int));

       custId.AutoIncrement = true;
       custId.AutoIncrementSeed = 101;
       custId.AutoIncrementStep = 1;
       custTable.Columns.Add(custId);

       // make this the primary key
       custTable.PrimaryKey = new DataColumn[] { custId };

       // add some fields for customer data
       custTable.Columns.Add(new DataColumn("Name", typeof(string)));

       custTable.Columns.Add(new DataColumn("Phone", typeof(string)));

       custTable.Columns.Add(new DataColumn("Email", typeof(string)));

       // add the table to the DataSet
       ds.Tables.Add(custTable);


       // add some records to the table
       DataRow row;
       row = custTable.NewRow();
       row["Name"] = "Evy";
       row["Phone"] = "123-555-9876";
       row["Email"] = "evy@evymail.com";
       custTable.Rows.Add(row);

       row = custTable.NewRow();
       row["Name"] = "Jon";
       row["Phone"] = "123-444-7384";
       row["Email"] = "jon@jonsmail.com";
       custTable.Rows.Add(row);

       row = custTable.NewRow();
       row["Name"] = "Eric";
       row["Phone"] = "123-666-7398";
       row["Email"] = "eric@ericsmail.com";
       custTable.Rows.Add(row);

       // dump to XML
       ds.WriteXml("customers.xml");

       Console.WriteLine("The file was created");
       }

    public void ReadFile() {
       DataSet ds = new DataSet();
       ds.ReadXml("customers.xml");

       foreach (DataRow row in ds.Tables[0].Rows) {
          // get the data
          string name = (string)row["Name"];
          string phone = (string)row["Phone"];
          string email = (string)row["Email"];

          // build the string
          StringBuilder builder = new StringBuilder();
          builder.AppendFormat
             ("Name: {0}\t Phone: {1}\t Email: {2}",
               name, phone, email);
          // write the string
          Console.WriteLine(builder.ToString());
          }
       }

    public void Test() {
       if (File.Exists("customers.xml")) {
          ReadFile();
          }
       else {
          MakeFile();
          }
       }

    static void Main(string[] args) {
       CustomerDatabase db = new CustomerDatabase();
       db.Test();
       }
    }
 }
Listing 15.1 defines the Customers table to have the structure shown below.

Table 15.4 – The Customers Table

Field Name
Data Type

CustID
int, auto increment, primary key

Name
string

Phone
string

Email
string

To define the table, we create a DataTable object and set its TableName property to "Customers". The DataTable has a property named Columns, which is a collection of DataColumn objects that define the columns of the table. Another important property of the DataTable is the PrimaryKey property. The PrimaryKey property is an array of DataColumn objects. You can set the primary key by creating an array of one or more DataColumns from the table and assigning a reference to that array in the PrimaryKey property.
The DataColumn class has many properties, many of which you won’t care about for the examples here. However, two important properties are the Name and DataType.
The Name property is a string value that names the field. When you access a column of a DataRow you can use this name as an index instead of an integer; so, you don’t have to remember the order of the columns.
The DataType property stores an instance of the Type class containing the type of data the column will store. The data are stored in the fields as object references so you can use any C# data type. If the DataType of a column is int, then you can set the column’s AutoIncrement property to true. If the AutoIncrement property is true, then the column’s value will be set automatically from a counter variable that is incremented every time a new row is created. This guarantees that the field will hold a unique value for each row in the table and makes the field a good candidate to use as a primary key.
Defining the Table Structure

The following code segment defines the Customer table structure. The CustID field is defined as an auto counter field and used as the primary key.
DataTable custTable = new DataTable();
custTable.TableName = "Customers";
// this will be the primary key DataColumn custId = new DataColumn("CustID", typeof(int)); custId.AutoIncrement = true;
custId.AutoIncrementSeed = 101;
custId.AutoIncrementStep = 1;
Columns.Add(custId);
// make this the primary key
custTable.PrimaryKey = new DataColumn[] { custId };
// add some fields for customer data custTable.Columns.Add(newDataColumn("Name", typeof(string)));
custTable.Columns.Add(new DataColumn("Phone", typeof(string))); custTable.Columns.Add(new DataColumn("Email", typeof(string)));
Reading Rows of Data

The DataTable also has a property named Rows that stores the rows of data. The rows are actually objects of the DataRow class. The DataRow stores a collection of values that you can read or write to using an index. You can either use an integer—if you know the order of the columns—or you can use the name of the field. The following code segment loops through the table’s rows and obtains references to the Name, Phone, and Email fields.
foreach (DataRow row in ds.Tables[0].Rows) {
 // get the data
 string name = (string)row["Name"];
 string phone = (string)row["Phone"];
 string email = (string)row["Email"];
 }
The DataRow stores the values as object references so the data must be cast to the appropriate type before we can use it. In this case, we used strings.
Adding Rows of Data

We obviously need to add new rows to the table, too. To create a DataRow object, we call the Table’s NewRow method. That method will instantiate a DataRow object and set its auto increment field for the primary key. Then, we can set the other values of the record and add the row into the Table’s Rows collection.
DataRow row  = custTable.NewRow();
row["Name"]  = "Evy";
row["Phone"] = "123-555-9876";
row["Email"] = "evy@evymail.com";
custTable.Rows.Add(row);
Storing the Data as XML

The DataSet stores a collection of DataTables in its Tables property. To dump the entire DataSet to an XML file, we need to call the DataSet’s WriteXml method, passing the name of the file as a string. Reading the file back in is just a matter of calling the ReadXml method.
ds.WriteXml("customers.xml");   // dump to XML
ds.ReadXml ("customers.xml");   // restore from XML
Filtering the Data with the DataView

The DataView class can be used to create a new view of the table that can be filtered or sorted without affecting the underlying table. The DataView is similar to a table in that it has a collection of rows but the objects in the DataView’s Rows collection are of type DataRowView. You use the DataRowView the same as you would use a DataRow. You use the name of the field as an index to get the value from the column. Once you have a DataView, you can filter or sort the data without affecting the actual table.
You create a DataView by passing a DataTable to the DataView constructor.
// create a view that can be filtered and sorted DataView view = new DataView(ds.Tables[0]); foreach (DataRowView drv in view) { Console.WriteLine(drv["Name"].ToString()); } // find the record for Rick view.RowFilter = "Name = 'Evy'"; foreach (DataRowView drv in view) { Console.WriteLine(drv["Name"].ToString()); }
In the code segment, we create a DataView for the first DataTable in the DataSet’s Tables collection. Then, we loop through the Rows collection, printing out the Name field as we go. Then, we filter the view so that view only contains records where the Name field is "Evy". The foreach loop iterates through each row in the view of "Evy" records and prints out the Name field.

Table 15.5 – OLEDB Database Classes

Class Description

OleDbConnection The physical database connection

OleDbCommand A command to execute on the database

OleDbDataAdapter Moves data between the DataSet and the physical Database using a connection and a command

OleDbDataReader Can iterate results returned from a command

Now that you have been introduced to the ADO.NET classes, it is time to write some real code. The example in the next section connects to the Microsoft Access Northwind Traders database using the OleDb classes.
Connecting to Access using OLE DB

In this section, we will use the Northwind Trader database that installs (optionally) with Microsoft Access. The program is a Console Application that simply loads a DataSet from the Customers table of the database. Then, we loop through the records, printing the CustomerName field to the screen.
Listing 15.2
// Example15_2.cs
using System;
using System.Data;
using System.Data.OleDb;

namespace csbook.ch15 {

 class Example15_2 {

    static void Main(string[] args) {
       string conString =
            @"Provider=Microsoft.JET.OLEDB.4.0;"
          + @"data source=c:\data\Northwind.mdb";

        
       // create an open the connection          
       OleDbConnection conn = new OleDbConnection(conString);
       conn.Open();

       // create the DataSet
       DataSet ds = new DataSet();

       // create the adapter and fill the DataSet
       OleDbDataAdapter adapter =
          new OleDbDataAdapter("Select * from Customers", conn);
       adapter.Fill(ds);

       // close the connection
       conn.Close();

       DataTable dt = ds.Tables[0];
       foreach (DataRow dr in dt.Rows) {
          Console.WriteLine(dr["CompanyName"].ToString());
          }
       }
    }
 }
The listing first creates a connection string that provides information to the OleDbConnection class. Specifically, the connection string contains the provider for the database engine that we want to connect to and the data source, which in this case is a Microsoft Access file. If the file were password protected, we would also specify a User ID and Password in the connection string. After creating the connection string, the program creates an OleDbConnection object, passing the connection string as the argument.
Next, the listing opens the database connection by calling the connection’s Open method. It also creates an empty DataSet that will later be filled from the database.
The OleDbAdapter class encapsulates the command to fill the DataSet. We create the adapter by passing a SQL query string and the database connection to its constructor. This query string will select all fields of all rows from the Customers table. The adapter’s Fill method will execute the query through the connection and load the results into the DataSet that we pass to it. The results include the data from the query as well as the metadata, defining its structure. When the call is complete, the DataSet will contain a table with all the Customer records from the database. At that point, we can close the database connection so that it can be used by some other application.
The tables within the DataSet are represented by the DataTable class. Each DataTable has a collection of DataRow objects storing the rows from the query. The foreach loop iterates through the DataRows, displaying the CompanyName field. The DataRow object uses the string "CompanyName" as an index to find the field of that name and retrieve its value. The value is returned as an object type. Calling the virtual ToString method will result in displaying the string value of the field.
Connecting to a SQL Server Database

The SQL Server versions of the connection, command, and adapter classes are listed below in Table 15.6. They are defined in the System.Data.SqlClient namespace.

Table 15.6 – SQL Server Database Classes

Class
Description

SqlConnection
The physical database connection

SqlDataCommand
A command to execute on the database

SqlDataAdapter
Moves data between the DataSet and the physical Database using a connection and a command

SqlDataReader
Can iterate results returned from a command

SQL Server also installs a copy of the Northwind Trader database. The next example is similar to the previous except that it uses the SQL Server versions of the connection and adapter.
While the previous listing used an adapter to execute a command internally and fill a DataSet, this example uses the command object directly. The program calls the SqlCommand object’s ExecuteReader method, which returns a SqlReader object. Then, it uses the SqlReader to loop through the records that have been returned.

Listing 15.3
// Example15_3.cs
using System;
using System.Data;
using System.Data.SqlClient;

namespace csbook.ch15 {

 class Example15_3 {
    static void Main(string[] args) {
       // create an open the connection
       SqlConnection conn =
          new SqlConnection("Data Source=DESKTOP;"
             + "Initial Catalog=Northwind;"
             + "Persist Security Info=True;"
             + "User ID=jeff;Password=password");

       conn.Open();

       // create a SqlCommand object for this connection
       SqlCommand command = conn.CreateCommand();
       command.CommandText = "Select * from Customers";
       command.CommandType = CommandType.Text;

       // execute the command that returns a SqlDataReader
       SqlDataReader reader = command.ExecuteReader();

       // display the results
       while (reader.Read()) {
          string output = reader["CompanyName"].ToString();
          Console.WriteLine(output);
          }

       // close the connection
       reader.Close();
       conn.Close();
       }
    }
 }
Data Binding

Window controls have the ability to bind their properties to the properties of other objects. When two properties are bound, a change in one is reflected in the other.
For example, consider the following listing for the Student class. The Student has two properties—the string value Name and the double value Gpa.
class Student { private string name; private double gpa; public string Name { get { return name; } set { name = value; } } public double Gpa { get { return gpa; } set { gpa = value; } } }
If we declare an instance of the Student as a member of a Windows Form, we can bind the Name and Gpa properties to the Text properties of a pair of TextBoxes.
// create the student student = new Student(); student.Name = "Jeff"; student.Gpa = 4.0; // bind the properties textBox1.DataBindings.Add(new Binding("Text", student, "Name")); textBox2.DataBindings.Add(new Binding("Text", student, "Gpa"));
We can also put a Button on the Form that displays the current values of the student’s Name and Gpa. This allows us to view the changes made to the object after we change the text in the TextBox.
private void testButton_Click(object sender, EventArgs e) { MessageBox.Show("Name: " + student.Name + " GPA: " + student.Gpa); }
Running the example, we can see that when the form first opens the initial values are displayed.

Figure 15.2

Then, we can change the text in the text boxes and click the Test Button. The message box displays the values of the student object, which have been changed to the new values in the TextBoxes.

Figure 15.3

This type of data binding is called simple data binding. We can also bind a ListBox control to an array or collection of data. Binding to a collection of data is called complex data binding. To bind the ListBox to a collection you set the ListBox’s DataSource property. The ListBox will display the first public property of each item in the collection in its list. The next example binds an array of strings to a ListBox.
public partial class Form1 : Form { string[] names = { "Jeff", "Rachel", "Katy", "Evy", "Ben" }; public Form1() { InitializeComponent(); } private void Form1_Load(object sender, EventArgs e) { listBox1.DataSource = names; } }
When the form is displayed, the names in the string array appear in the ListBox.

Figure 15.4

Using the DataGridView

The DataGridView is a control designed to be bound to database tables. You will find the DataGridView in the Data group on your Toolbox. In this section, we will use the DataGridView to build a SQL interface for the Northwind Trader database. This application is surprisingly simple using the classes provided by ADO.NET.

Figure 15.5

To create the user interface, place a TextBox on the form and set its Multiline property to true. Then, add two buttons, setting their Text properties to Query and Update. Finally, place a DataGridView component on the form. Your form might look something like the one in Figure 15.5.
Since we are going to connect to a Microsoft Access database, we need to use the OleDb classes. At the top of the file, you should add the following using statement to gain access to the System.Data.OleDb namespace.
using System.Data.OleDb;
The Form’s Load event should create an OleDbConnection object, an OleDbCommand object, and a DataSet object. Each of these objects should be stored as members of your Form class.
private void Form1_Load(object sender, EventArgs e) {
 // connect to the database
 string conString =
    @"Provider=Microsoft.JET.OLEDB.4.0;"
    + @"data source=c:\data\Northwind.mdb";

 // create an open the connection          
 conn = new OleDbConnection(conString);
 command = conn.CreateCommand();

 // create the DataSet
 DataSet ds = new DataSet();
 }
Next, you need to implement the select button’s Click handler. The method should start by clearing the DataSource property of the DataViewGrid and creating a fresh DataSet. Then, it should reopen the connection. Set the Command object’s CommandText property to the Text from the TextBox control. Then, create an adapter with the command and fill the new DataSet. Finally, set the DataGridView’s DataSource property to the first table in the DataSet’s Table collection.
private void button1_Click(object sender, EventArgs e) {
 // clear the grids data source
 dataGridView1.DataSource = null;

 // create a new DataSet
 ds = new DataSet();

 // open the connection
 conn.Open();

 // run the query
 command.CommandText = textBox1.Text;
 adapter = new OleDbDataAdapter(command);
 adapter.Fill(ds);

 // close the connection
 conn.Close();

 // set the grid's data source
 dataGridView1.DataSource = ds.Tables[0];
 }
The last step is to implement the Click event handler for the Update button.
private void button2_Click(object sender, EventArgs e) {
 // clear the grids data source
 dataGridView1.DataSource = null;

 // open the connection
 conn.Open();

 // run the query
 command.CommandText = textBox1.Text;

 int affected = command.ExecuteNonQuery();
 MessageBox.Show ("There were " + affected + " rows affected");

 // close the connection
 conn.Close();
 }
The update button sets the DataGridView’s DataSource property to null to clear the grid. Then, it reopens the connection and sets the command object’s CommandText property to whatever text is in the TextBox. This time the command is executed by the ExecuteNonQuery method. The ExecuteNonQuery method runs a command that updates or deletes records. It returns the number of rows affected by the command. Finally, the method displays a message box showing the number of rows affected and then closes the connection. Figure 15.6 shows a SELECT statement being executed on the database.

Figure 15.6

Figure 15.7 shows the update button being used to change the ContactTitle from Guru to Fool.

Figure 15.7

To verify that our update actually worked, we can run the query again.

Figure 15.8

C# – Static Members

2010-02-16T03:50:00.000-08:00

INTRODUCTION:

The object oriented programming will give the impression very unnatural to a programmer with a lot of procedural programming experience. In Object Oriented programming Encapsulation is the first pace. Encapsulation is the procedure of covering up of data and functions into a single unit (called class). An encapsulated object is often called an abstract data type. In this article let us see about it in a detailed manner.

NEED FOR ENCAPSULATION:

The need of encapsulation is to protect or prevent the code (data) from accidental corruption due to the sillylittle errors that we are all prone to make. In Object oriented programming data is treated as a critical element in the program development and data is packed closely to the functions that operate on it and protects it from accidental modification from outside functions.

Encapsulation provides a way to protect data from accidental corruption. Rather than defining the data in the form of public, we can declare those fields as private. The Private data are manipulated indirectly by two ways. Let us see some example programs inC# to demonstrate Encapsulation by those two methods. The first methodis using a pair of conventional accessor and mutator methods. Another one method is using a named property. Whatever be the method our aim is to use the data with out any damage or change.

ENCAPSULATION USING ACCESSORS AND MUTATORS:

Let us see an example of Department class. Tomanipulate the data in that class (String departname) we define anaccessor (get method) and mutator (set method).

using system;
public class Department
{
private string departname;
…….

// Accessor.
public string GetDepartname()
{
return departname;
}

// Mutator.
public void SetDepartname( string a)
{
departname=a;
}

}

Like the above way we can protect the privatedata from the outside world. Here we use two separate methods to assignand get the required data.

public static int Main(string[] args)
{
Department d = new Department();
d.SetDepartname("ELECTRONICS");
Console.WriteLine("The Department is :"+d.GetDepartname());
return 0;
}

In the above example we can't access theprivate data departname from an object instance. We manipulate the dataonly using those two methods.

ENCAPSULATION USING PROPERTIES:

Properties are a new language featureintroduced with C#. Only a few languages support this property.Properties in C# helps in protect a field in a class by reading andwriting to it. The first method itself is good but Encapsulation can beaccomplished much smoother with properties.Now let's see an example.

using system;
public class Department
{
private string departname;
public string Departname
{
get
{
return departname;
}
set
{
departname=value;
}
}
}
public class Departmentmain
{
public static int Main(string[] args)
{
Department d= new Department();
d.departname="Communication";
Console.WriteLine("The Department is :{0}",d.Departname);
return 0;
}
}

From the above example we see the usage ofEncapsulation by using properties. The property has two accessor getand set. The get accessor returns the value of the some property field.The set accessor sets the value of the some property field with thecontents of "value�. Properties can be made read-only. This isaccomplished by having only a get accessor in the propertyimplementation.

READ ONLY PROPERTY:

using system;
public class ReadDepartment
{
private string departname;
public ReadDepartment(string avalue)
{
departname=avalue;
}
public string Departname
{
get
{
return departname;
}
}
}
public class ReadDepartmain
{
public static int Main(string[] args)
{
ReadDepartment d= new ReadDepartment("COMPUTERSCIENCE");
Console.WriteLine("The Department is: {0}",d.Departname);
return 0;
}
}

In the above example we see how to implement aread-only property. The class ReadDepartment has a Departname propertythat only implements a get accessor. It leaves out the set accessor.This particular class has a constructor, which accepts a stringparameter. The Main method of the ReadDepartmain class creates a newobject named d. The instantiation of the d object uses the constructorof the ReadDepartment that takes a string parameter. Since the aboveprogram is read-only, we cannot set the value to the field departnameand we only read or get the value of the data from the field.Properties can be made also Write-only. This is accomplished by havingonly a set accessor in the property implementation.

WRITE ONLY PROPERTY:

using system;
public class WriteDepartment
{
private string departname;

public string Departname
{
set
{
departname=value;
Console.WriteLine("The Department is :{0}",departname);
}
}
}
public class WriteDepartmain
{
public static int Main(string[] args)
{
WriteDepartment d= new WriteDepartment();
d.departname="COMPUTERSCIENCE";
return 0;
}
}

In the above example we see how to implement aWrite-only property. The class WriteDepartment has now has a Departnameproperty that only implements a set accessor. It leaves out the getaccessor. The set accessor method is varied a little by it prints thevalue of the departname after it is assigned.

Conclusion:

The Encapsulation is the first footsteptowards the object-oriented programming. This article gives you alittle bit information about Encapsulation. Using accessor and mutatormethods we can make encapsulation. Another one method is using a namedproperty. The benefit of properties is that the users of your objectsare able to manipulate the internal data point using a single nameditem.

C# Encapsulation

2010-02-16T03:48:00.001-08:00

INTRODUCTION:

The object oriented programming will give theimpression very unnatural to a programmer with a lot of proceduralprogramming experience. In Object Oriented programming Encapsulation isthe first pace. Encapsulation is the procedure of covering up of dataand functions into a single unit (called class). An encapsulated objectis often called an abstract data type. In this article let us see aboutit in a detailed manner.

NEED FOR ENCAPSULATION:

The need of encapsulation is to protect orprevent the code (data) from accidental corruption due to the sillylittle errors that we are all prone to make. In Object orientedprogramming data is treated as a critical element in the programdevelopment and data is packed closely to the functions that operate onit and protects it from accidental modification from outside functions.

Encapsulation provides a way to protect datafrom accidental corruption. Rather than defining the data in the formof public, we can declare those fields as private. The Private data aremanipulated indirectly by two ways. Let us see some example programs inC# to demonstrate Encapsulation by those two methods. The first methodis using a pair of conventional accessor and mutator methods. Anotherone method is using a named property. Whatever be the method our aim isto use the data with out any damage or change.

ENCAPSULATION USING ACCESSORS AND MUTATORS:

Let us see an example of Department class. Tomanipulate the data in that class (String departname) we define anaccessor (get method) and mutator (set method).

using system;
public class Department
{
private string departname;
…….

// Accessor.
public string GetDepartname()
{
return departname;
}

// Mutator.
public void SetDepartname( string a)
{
departname=a;
}

}

Like the above way we can protect the privatedata from the outside world. Here we use two separate methods to assignand get the required data.

public static int Main(string[] args)
{
Department d = new Department();
d.SetDepartname("ELECTRONICS");
Console.WriteLine("The Department is :"+d.GetDepartname());
return 0;
}

In the above example we can't access theprivate data departname from an object instance. We manipulate the dataonly using those two methods.

ENCAPSULATION USING PROPERTIES:

READ ONLY PROPERTY:

WRITE ONLY PROPERTY:

using system;
public class WriteDepartment
{
private string departname;

Conclusion:

C# Interface Implementation

2010-02-16T03:46:00.001-08:00

Interface implementation can be confusing…

I see a feature in C# that can be very confusing. In theexample below we have a class (Test) that implements 2 interfaces(I1 and I2). So the logic says that we should have implementations in the classTest for both MyFunction() methods from I1 and I2. BUT!As you see in the example below everything works fine with only 1 implementation.This is not as correct as we expect, because we can't be sure which of the two interfacesis implemented in the MyFunction method in class Test.So the solution is in another example (EXAMPLE2).In Example2 MyFunction() is implemented in class Test for each interface, by using a different method. (I1.MyFunction() -> for I1, I2.MyFunction() -> for I2).So now everything is clear, isn't it?

//EXAMPLE 1
using System;

namespace PavelTsekov
{
interface I1
{
void MyFunction();
}
interface I2
{
void MyFunction();
}
class Test : I1,I2
{
public void MyFunction()
{
Console.WriteLine("Guess which interface I represent???!");
}
}
class AppClass
{
public static void Main(string[] args)
{
Test t=new Test();
I1 i1=(I1)t;
i1.MyFunction();
I2 i2=(I2)t;
i2.MyFunction();
}
}
}

//EXAMPLE 2
using System;

namespace PavelTsekov
{
interface I1
{
void MyFunction();
}
interface I2
{
void MyFunction();
}
class Test : I1,I2
{
void I1.MyFunction()
{
Console.WriteLine("Now I can say this here is I1 implemented!");
}
void I2.MyFunction()
{
Console.WriteLine("Now I can say this here is I2 implemented!");
}
}
class AppClass
{
public static void Main(string[] args)
{
Test t=new Test();
I1 i1=(I1)t;
i1.MyFunction();
I2 i2=(I2)t;
i2.MyFunction();
}
}
}

Is Object Class, the root of all hierarchies?

2010-02-16T03:44:00.001-08:00

Introduction
This might come as a surprise for many, to see me doubting theinformation presented in almost .NET books even MSDN library but as wedelve deeper into this topic, you will find yourself in the samepredicament as I am now.

What is an Object class?
For those who arenew to .NET, according to MSDN library – "Object is the ultimatesuperclass of all classes in the .NET Framework; it is the root of thetype hierarchy."

This is the class declaration of the object class
[Serializable]
[ClassInterface(ClassInterfaceType.AutoDual)]
public class object

All the classes are required to inherit fromthis Object class but they need not declare inheritance from itexplicitly as it is taken care internally. While all classes inheritfrom it, it doesn't inherit from any super class or interface.

So what's the problem?
This I will explain with a help of an example.
Let's define a class called Foo

Class Foo
{
void show() {}
static void main(string[] args)
{
Foo f=new Foo();
}
}

If you have Visual Studio IDE or any othereditor which supports intellisense, when you type f. you will get thefollowing methods
1. Equals
2. GetHashCode
3. ToString
4. GetType
5. show

Even though you have defined only one method show since Foo implicitly inherits from Object it gets the other four methods.Let's now define an interface called IFoo and make Foo class inherit from it.

Interface IFoo
{
void Ishow();
}
class Foo:IFoo
{
void show(){}
void IFoo.Ishow(){}
static void main(string[] args)
{
Foo f=new Foo();
IFoo ifoo=f;
}
}

Since we have inherited from IFoo, we need toimplement the Ishow method. When we type ifoo.show(), we get a compiletime error saying that the interface doesn't contain a definition forshow method. This is correct since an interface is allowed to accessonly methods declared by it even though the object it might bereferring has other methods.

The problem arises now when we typeifoo.equals(f), ideally this should give a compile time error (notruntime error) it is not declared by IFoo interface or none of itssuper interface but it doesn't. Nor does it give a compile time errorfor using any of the methods of Object class.

This is definitely a discrepancy from the factthat an interface is allowed to access only methods declared by it. Aninterface for sure can't inherit from a class so how then can weexplain for the four methods of Object which are available to anyinterface. The only possible solution can be that there must be a superinterface like IObject as declared below:

Interface IObject
{
public virtual bool equals(object);
public virtual int getHashCode();
public Type getType();
public virtual string toString();
}

and the Object class must have inherited fromthis interface and also that this IObject must be the super interfaceof all the interfaces just like Object is to other classes.

Conclusion
This is one of the issues whichMicrosoft should clarify so that the programmers can have a betterunderstanding of the language.

Name:C.Prashanth
Email Id:seeprash@hotmail.com
I am a MSc Software Engg student doing my final semester project atIntel Technologies, India. I am a fanatic follower of Indian cricketteam and try not to miss any match even if it means bunking college andoffice. I love reading War novels and listening to A.R.Rahman music.

C# Class Inheritance

2010-02-16T03:43:00.001-08:00

This Console-based C# code calculates theArea, perimeter, surface area and volume of the following polygons:square, rechtangle, parellelogram, trapezoid, triangle, circle, cube,prism (both rechtangular and triangular base), cylinder, cone, sphere,pyramid and rhombus. All the user does is to input the polygon'sdimensions and the code will produce the polygon's attributes.

polygons.cs

author : Martin Raphael.K
// email : mrkraj@officetiger.com
// Date : November 02, 2001

// This is the sample code for inheritence

// new is the keyword which is used to override the base(Parent) class
//members base is the keyword whichs is equal to super in java
using System;
public class Base
{
public string str;
public Base()
{
Console.WriteLine("Base class Constructor");
}
~Base()
{
Console.WriteLine("Base class Destructor");
}
public void getData()
{
Console.WriteLine("Base class GetData");
}
}
public class Derived:Base
{
public new string str;

public Derived()
{
Console.WriteLine("Derived class Constructor");
}
~Derived()
{
Console.WriteLine("Derived class Destructor");
}
public new void getData()
{
base.getData();
Console.WriteLine("Derived class GetData");
}
public void getValues()
{
base.str=Console.ReadLine();
this.str=Console.ReadLine();
}
public void printValues()
{
Console.WriteLine("Base class Str "+base.str);
Console.WriteLine("Derived class Str "+this.str);
}
}

class InheritenceDemo
{
public static void Main(string[] a)
{
Derived d=new Derived();
d.getData();
d.getValues();
d.printValues();
Console.WriteLine("———–");
// this is used to get the Base class getData Method
((Base)d).getData();
}
}

// send a feedback to mrkraj@officetiger.com

Explaining C# Abstraction, Inheritence and Polymorphism

2010-02-16T03:41:00.000-08:00

Far too often, fundamental programming concepts like inheritance and polymorphism are taught using vague examples, like class "AA" and class "BB". Let's get away from that; they're far too abstract to offer a proper explanation. We'll use a workshop as our example instead.

Say you have a program to simulate a workshop, and you want to create a class for each possible tool you can use… hammers, power saws, screwdrivers, etc. Pretty much every tool class you create is going to have common methods, like Use() and PutAway(), regardless of what it actually is. Inheritance allows you to enforce this common ground between tools, and reap some very useful benefits in the process. Take the following "base" class:

public abstract class Tool()
{

private double _price;
public double GetPrice()
{
return _price;
}

public abstract void Use();
public abstract void PutAway();

}

This class doesn't do much of anything on it's own, but it provides a common interface for all of the other tools you create.

Every class that inherits from Tool will automatically have a _price, a method called "GetPrice()", and two other methods called Use() and PutAway(). Because we've already written code for GetPrice(), any other Tool class we write can take advantage of it right away.

Use() and PutAway() are a little different. Because we've declared Use() and PutAway() as abstract methods, any class we write that inherits from Tool [i]must[/i] have its own Use() and PutAway() methods. You might ask, "then why bother putting them in the base Tool class in the first place, if you have to rewrite them in all the inherited classes, anyway"? The reason is because these abstract methods [i]guarantee[/i] to our program that any tool it ever deals with will have these methods, 100% certain. We'll see the benefits of this in a minute, but first let's take a quick look at two classes that inherit from Tool (in place of specific code, I'll just add some comments):

public class ScrewDriver: Tool
{

public override void Use()
{
// Insert into screw head and rotate
}

public override void PutAway()
{
// Find correct drawer in toolbench and place inside
}

}

public class PowerSaw: Tool
{

public override void Use()
{
// Flip "on" switch and apply blade to wood surface
}

public override void PutAway()
{
// Flip "off" switch and place on shelf
}

public void ReplaceBatteries()
{
// Remove old batteries, and insert new ones
}

}

Both ScrewDriver and PowerSaw inherit the Use() and PutAway() methods from Tool, but in addition to this they can implement their own unique methods, as well. For example, PowerSaw has a ReplaceBatteries() method, which would be pointless on a screwdriver, but important on a power tool. And that's a critical point: that's why we didn't put a ReplaceBatteries() method in the tool class… because not [i]every[/i] tool needs a ReplaceBatteries() method. Instead, we placed it in the class that would actually need it. Use() and PutAway(), however, are needed by every tool, and so those methods are in the base class.

Note also that, although you can't see it, both ScrewDriver and PowerSaw also have _price and GetPrice(), because they inherited it from "Tool". For example, the following code is, in theory, perfectly legal:

ScrewDriver myScrewDriver;
myScrewDriver.GetPrice();

What about Use() and PutAway()? Those are actually written in ScrewDriver and PowerSaw, so why do we even care that they're included in Tool? For one thing, it guarantees that you won't forget to add those methods to your inherited classes. For another thing, you can do stuff like this:

Tool[] myArrayOfTools = new Tool[2];
tool[0] = new ScrewDriver();
tool[1] = new PowerSaw();

foreach( Tool myTool in myArrayOfTools )
{
myTool.Use();
myTool.PutAway();
}

And that will be perfectly legal, even though element 0 and element 1 in that array are totally different types! One is a ScrewDriver, and one is a PowerSaw, but because they are both tools, we can call their Use() and PutAway() methods regardless of their specific type.

A few closing points…

1) The "abstract" in "public abstract class Tool()" just means that we can't create instances of our Tool class… which is good, because the actual base Tool class doesn't do anything. We don't want people creating copies of it by accident, they should stick to ScrewDrivers and PowerSaws that can actually do stuff.

2) If we want to write code for Use() in the base class, but still allow it to be overridden by an inheritence class, use "virtual" instead of "abstract":

public virtual void Use()
{
// Generic instructions for using a tool
}

Be aware that, although all inherited classes still have access to virtual methods, they are not required to override them.

3) You don't have to use only one base class. You could create two additional base classes, PowerTool and HandTool that inherit from Tool, and then have your specific tools inherit from either PowerTool or HandTool. PowerTool would have specific methods that all power tools need, and HandTool would have specific methods that all hand tools need. Think of inheritance as a family tree, where in this case, "Tool" is the trunk, "PowerTool" and "HandTool" are both branches, and "ScrewDriver" and "PowerSaw" are twigs.

4) For the record, the ability to use all inherited tools as a normal tool (ie, using a ScrewDriver as a Tool), is called "polymorphism".

5) There are also some really neat things called "Interfaces", which you may want to look into once you're comfortable with inheritance.

Objects & Classes in C#

2010-02-16T03:34:00.001-08:00

In this article we will understand some of the concepts of object-oriented programming in C# like objects and classes. To read this article you must have C# programming basics.

NOTE: read the whole article because there aresome concepts you may will not get the best of it until you finish the article.And we will revisit all the concepts more than one time when I see it’sappropriate in future articles so don’t worry at all.

Introduction:

OOP stands for Object-Oriented Programming. OOP isrelatively a new way to program computer applications. Before OOP programmersused to creating computer applications using procedural-programming (orstructure-programming) but when OOP solved a lot of the problems of theprocedural-programming so almost all of the programmers and developers beganusing OOP languages. In procedural- programming all the program functionalitywritten in a few modules of code or maybe one module (depending on the program)and these modules depend on one another and maybe if you change a line of codeyou will have to rewrite the whole module again and maybe the whole program butin Object-Oriented Programming programmers write independent parts of a programcalled classes each class represent a part of the program functionality andthese classes can be assembled to form a program and when you need to changesome of the program functionality all what you have to do is to replace thetarget class which may contain a problem. So in OOP applications create by theuse of classes and these applications can contain any number of classes. Thatwill get us to discuss the Class and Object concept.

Classes and objects:

You may find it not easy to understand the class and objectstory but I will try to do my best explaining it. Actually the class and objectconcept is related to each other and some beginners don’t care aboutunderstanding it clear so I think they will have a hard times learning C#.

Object-Oriented concept takes the most of its functionalityfrom the real-life concepts. For example, I will discuss the concept of Classesand Objects of the world first and then you will understand the computer’sClasses and Objects before I even write anything about it.

World’s Classes and Objects:

In our world we have a classes and objects for thoseclasses. Everything in our world considered to be an object. For example,people are objects, animals are objects too, minerals are objects, everythingin the world are objects. Easy right ? but what about classes. In our world wehave to differentiate between objects that we are living with. So we mustunderstand that there are a classifications (this is how they get the nameand the concepts of the Class) for all of those objects. For example, I’man object, David is object too, Maria is another object so we are from apeople class (or type). I have a dog called Ricky so it’s an object, Myfriend’s dog called Doby is also an object so they are from a Dogs class (ortype). A third example, I have a computer Pentium III this is object, Myfriend have a computer Pentium IIII so this is another object and they are froma Computers class (or type). Now I think you got the concept of theClass and Object but let me crystallize it for you. In our world we have aclassifications for objects and every object must be from some classification.so a Class is a way for describing some properties and functionalities orbehaviors of a group of objects. In other words, The class considered to be atemplate for some objects. So maybe I will create a class called person so thisis a template of the functionality and the properties of persons. I explainedit by more than a way so wait until you see the first example and I think youwill grasp it completely.

Computer’s Classes and Objects:

Computer’s Classes discussion is similar to what you graspfrom the last section with some modifications to become computerized.

A C# Class Considered being the primary building block ofthe language. What I mean by the primary building block of the language is thatevery time you work with C# you will create Classes to form a program. We useClasses as a template to put the properties and functionalities or behaviors inone building block for some group of objects and after that we use thattemplate to create the objects we need. For example, We need to have personsobjects in our program so the first thing to do here is to create a Classcalled Person that contains all the functionalities or behaviors and propertiesof any person and after that we will use that Class or template to create asmany objects as we need. Creating object of a specific class type called”instance of the class”. Don’t worry if you didn’t grasp it 100% anddon’t worry if you don’t know what’s the Class and Object’s properties andfunctionalities or behaviors because we still in the beginning and until now Ididn’t give any code examples. So let’s take a brief of what’s the Class andwhat’s an object ?

The Class : Is abuilding block that contains the properties and functionalities that
describesome group of objects, We can create a class Person that contains:

1- The properties of any normal person on the earth like :Hair Color, Age, Height, Weight, Eyes Color.

2- The functionalities or behaviors of any normal person onthe earth like : Drink water, Eat, Go to the work and later we will see how wecan implement the functionalities or behaviors and properties.

There are 2 kinds of classes : The built-it classes thatcome with the .NET Framework and called Framework Class Library. And theprogrammer defined-classes which we create it.

The class contains data (in the form of variables andproperties) and behaviors (in the form of methods to process these data). Wewill understand this concept more later in the article.

When we declare a variable in a class we call it membervariables or instance variables. The name instance come from the fact that whenwe create an object we instance a class to create that object so instance of aclass means object of that class and instance variable means variable thatexists in that class.

The Object : It’s objectof some classification (or class, or type. All means the same thing) and whenyou create the object you can specify the properties of that object. What Imean here is me as an object can have a different properties (Hair Color, Age,Height, Weight) of you as another object. For example, I have a brown eyes andyou have a green eyes so when I create 2 objects I will specify a browncolor for my object’s Eyes Color property and I will specify a green color foryour object’s Eyes Color property.

So to complete my introduction to Classes we must discussProperties and Variables.

Properties and Variables:

Variables declared in a class store the data for eachinstance, What that means ? means that when you instantiate this class (thatis, When you create an object of this class) the object will allocate a memorylocations to store the data of its variables. Let’s take an example tounderstand it well.

class Person
{
public int Age;
public string HairColor;
}

This is our simple class which contains 2 variables. Don’tworry about public keyword now because we willtalk about it later . Now we will instantiate this class (that is, When youcreate an object of this class).

static void Main(string[]args)
{
Person Michael = newPerson();
Person Mary = new Person();

// Specify some values for the instance variables
Michael.Age = 20;
Michael.HairColor = “Brown”;
Mary.Age = 25;
Mary.HairColor = “Black”;
// print the console’s screen someof the variable’s values
Console.WriteLine(“Michael’s age = {0}, and Mary’s age= {1}”,Michael.Age,
Mary.Age);
Console.ReadLine();
}

So we begin our Main method by creating 2 objects of Persontype. After creating the 2 objects we initialize the instance variables forobject Michael and then for object Mary. Finally we print some values to theconsole. here when you create Michael object C# compiler allocate a memorylocation for the 2 instance variables to put the values there. Also the samething with Mary object the compiler will create 2 variables in the memory forMary object. So each object now contains a different data. Note that wedirectly accessed the variables and we put any values we want, Right ? so maybesomeone doesn’t like me will put in my object’s variable Age value of 120 yearsso I will not get any kind of jobs. But wait there are a solution for thisproblem. We will use properties.

Properties:

Properties is a way to access the variables of the class ina secure manner. Let’s see the same example using properties.

class Person
{
private int age;
private string hairColor;
public int Age
{
get
{
returnage;
}
set
{
if(value <= 65 && value >= 18)
{
age = value;
}
else
age = 18;
}
}
public string HairColor
{
get
{
return hairColor;
}
set
{
hairColor = value;
}
}
}

I made some modifications but please just care about the new2 properties that I created it here. So the property consists of 2 accessor.The get accessor which is responsibleof retrieving the variable value, And the set accessor which is responsible of modifying the variable’svalue. So The get accessor code is very simple wejust use the keyword return withthe variable name to return its value. so the following code:

get
{
return hairColor;
}

return the value stored in hairColor.

Note :the keyword value isa reserved keyword by C# (that is, reserved keywords means that these keywordsown only by C# and you can’t create it for other purpose. For example, Youcan’t create a variable called value .Ifyou did that C# compiler will generate an error and to make things easierVisual Studio.NET will color the reserved keywords to blue.)

Let’s put this code at work and after that discuss theset accessor.

static void Main(string[]args)
{
Person Michael = newPerson();
Person Mary = new Person()
;

// Specify some values for the instance variables
Michael.Age = 20;
Michael.HairColor = “Brown”;
Mary.Age = 25;
Mary.HairColor = “Black”;

// print the console’s screen some of the variable’s values
Console.WriteLine(“Michael’s age = {0}, and Mary’s age= {1}”,Michael.Age,
Mary.Age);
Console.ReadLine();
}

Here I created the same objects from last example themodifications that I used only properties to access the variable instead ofaccess it directly. Look at the following line of code

Michael.Age = 20;

When you assign a value to the property like that C# willuse the set accessor. The great thing withthe set accessor is that we can controlthe assigned value and test it and maybe change to in some cases. When youassign a value to a property C# change the value in a variable and you canaccess the variable’s value using the reserved keyword value exactly as I did in the example. Let’s see it again here.

set
{
if(value <= 65 && value >= 18)
{
age = value;
}
else
age = 18;
}

Here in the code I used if statement to test the assigned value because for some reasonI want any object of type Person to be in age between 18 and 65. Here I testthe value and if it in the range then simply I will store it in the variableage and it it’s not in the range I will put 18 as a value to age. It was just asimple example for the properties but there is a complete article about propertiessoon.

How we create objects and classes ?

We create classes by define it like that:

using the keyword class followedby the class name like that

class Person

then we open a left brace “{” and after we writeour methods and properties we close it by a right brace “}”. That’show we create a class. Let’s see how we create an instance of that class.

In the same way as we declare a variable of type int we create an object variable of Person type with some modifications:

int age;
Person Michael = new Person();

In the first line of code we specified integer variablecalled age. In the second line we specified first the type of Object we need tocreate followed by the object’s name followed by a reserved operator called new and we end by typing the class name again followed byparenthesis “()”.

Let’s understand it step-by-step. Specifying the class nameat the beginning tell the C# Compiler to allocate a memory location for thattype (C# compiler knows all the variables and properties and methods of theclass so it will allocate the right amount of memory). Then we followed theclass name by out object variable name that we want it. The rest of the code”=new Person();” callthe object’s constructor. We will talk about constructor later but for nowunderstand that the constructor is a way to initialize your object’s variablewhile you are creating it not after you create it. For example, The Michaelobject we created it in the last section can be written as following :

Person Michael = new Person(20, “Brown”);

here I specified the variable’s values in the parameter listso I initialized the variables while I’m creating the object. But for this codeto work we will need to specify the constructor in the Person class and I willnot do that here because constructor section will come in later articles. Ithink you got a good introduction about Classes and Objects not I will completein in my next article and I will talk about constructors and building blockscoping. I hope you got a new thing from my article.

About the Author:

Michael Youssef is 20 years old and he’sworking with Microsoft technologies since he was 17. He is working with VB,VB.NET, C#,ASP, ASP. NET, XML Web services, COM+, SQL Server 2000, Windows 2000Server, Active Directory, Networks design. He is MCSD.NET, MCDBA, MCSE, MCSAand he’s working now as a .NET Trainer in Egypt. Michael can be reached atmichaellabibat@hotmail.com .

C# Tutorial For Beginners

2010-02-16T03:26:00.000-08:00

So you just install .NET framework and want to start using C# but you don't know where to start ? well…

First you could download this complete tutorial here. There is a directory for each tutorial with a build.bat to build the tutorial and a run.bat to run the program. And every example is already compiled, just in case…

First tutorial

You should first open a DOS command shell. (If you don't know what it is, clic on the Start menu then run (at the bottom) and type, in the text field: "cmd".
exercise: there is an easiest way to do that, try to find it.)
You should begin to work in an empty directory for this. let call it "C:\learncs". Type in the shell:

> md C:\learncs
> cd C:\learncs
> C:

Now you should create your first C# program, type "notepad hello.cs" and type (in the notepad)

using System;

public class Hello
{
public static void Main()
{
Console.WriteLine("Hello C# World ");
}
}

the using keyword just let you write Console at line 7, instead of System.Console. It's very usefull shortcut when you use a lot of "class" define in System.
Save the file.
Now you could compile. Type in the DOS Shell again and type:
csc /nologo /out:hello.exe hello.cs
You probaly have some errors, correct them, compile again, and now you have a working hello.exe program… type hello, see…

Second tutorial

Congratulation you've done the most difficult, let increase the difficulty. and create an object instance. in the DOS shell create a new directory:

> md ..\learncs2
> cd ..\learncs2
> notepad hello.cs

and then type, in the notepad

using System;

public class Echo
{
string myString;

public Echo(string aString)
{
myString = aString;
}

public void Tell()
{
Console.WriteLine(myString);
}
}

public class Hello
{
public static void Main()
{
Echo h = new Echo("Hello my 1st C# object !");
h.Tell();
}
}

Wouah, 25 lines! That's a program! Save it, compile it, run it…
What happened? csc look for a Main() function in your program, it should find one (and only one) and it will be the entry point of your program.
In this tutorial we create 2 classes: Echo & Hello. In the Main() method you create an Echo object (an instance of the Echo class) with the keyword new
Then we called the instance method "Tell()".
the upper case letter on class or Method is just a MS convention, do as it pleased you.
public is a visibility access, method wich are not public could not be seen from outside, there is also other visibility keywords, to learn more, clic on Start menu-> Programs -> Microsoft .NET Framework SDK -> Documentation there is a search window, an index window, etc… try to learn more about public private protected.

Third tutorial

Now you become to be pretty confident, I guess, so we could start using multiple file, and even a dll ? go into an other directory (or stay in this one, I won't mind) and create 2 file:

hello.cs

using System;

public class Hello
{
public static void Main()
{
HelloUtil.Echo h = new HelloUtil.Echo("Hello my 1st C# object !");
h.Tell();
}
}

echo.cs

using System;

namespace HelloUtil
{
public class Echo
{
string myString;

public Echo(string aString)
{
myString = aString;
}

public void Tell()
{
Console.WriteLine(myString);
}
}
}

Note in hello.cs I have used the syntax "HelloUtil.Echo" it's because Echo is in the namespace HelloUtil, you could have typed (at he start of the file) using HelloUtil and avoid HelloUtil., that's the way namespace work.

Now you could compile both in one .exe with
> csc /nologo /out:hello.exe *.cs
But it's not my intention, no.
Well.
(Have you tried?)
Let's go building a DLL:
> csc /nologo /t:library /out:echo.dll echo.cs
that's it (dir will confirm).
Now we could use it …
> csc /out:hello.exe /r:echo.dll hello.cs
if you typed "hello" it will worked as usual…, but if you delete "echo.dll" the program will now crash: it use the DLL. You could also change Echo.cs, rebuild the DLL and see… that's the advantage of DLL!

You could also put your DLL in the global assembly cache (GAC), and any program would be able to access it, even if the DLL is not in its directory!
to put it in the GAC, I sugest you read MS doc but here are the unexplained step:

create your assembly key, create it once and use it for every version. you create it with:
sn -k myKeyName.snk
the .snk file should be in your compilation directory (the one where your run csc)

create a strong asssembly title by adding in any .cs source file the following directive at top level: using System.Reflection;
using System.Runtime.CompilerServices;
[assembly: AssemblyTitle("My Lib Title")]
[assembly: AssemblyVersion("1.2.3.4")]
[assembly: AssemblyKeyFile("myKeyName.snk")]

now add it to the GAC:
> gacutil.exe /if myLib.dll

By the way, did I tell you ? when I referenced the hello.dll while compiling, remember? csc /out:hello.exe /r:echo.dll hello.cs, it could have been any assembly, even a .exe !!!

Fourth tutorial

Congratulation you would soon be able to hack CsGL but there is one last step you should understand : interop (with C code).
You will need a C compiler, I advise gcc for windows called MinGW, it's free, it's good, it's GCC!
We will create 3 file:
echo.c

#include

#define DLLOBJECT __declspec(dllexport)

DLLOBJECT void writeln(char* s)
{
printf("%s\
n", s);
}

echo.cs

using System;
using System.Runtime.InteropServices;

namespace HelloUtil
{
public class Echo
{
[DllImport("echo.native.dll", CallingConvention=CallingConvention.Cdecl)]
static extern void writeln(string s);

string myString;

public Echo(string aString)
{
myString = aString;
}

public void Tell()
{
writeln(myString);
}
}
}

hello.cs

using System;
using HelloUtil;

public class Hello
{
public static void Main()
{
Echo h = new Echo("Hello my 1st interop code !");
h.Tell();
}
}

Hehe, here you discover a completly new thing, Attribute.
"[DllImport(.." is an attribute.
You could tag any method/field/class with any number of attribute.
They generate extra information that could be used by anyone who could understand them.
This DllImport attribute is understand by the compiler and told him that the function below is in fact in a DLL whose name is "echo.native.dll". I add a calling convention parameter as the default .NET calling convention is __stdcall whereas, in C, it's __cdecl.
By the way, if you look for DllImport in the documentation, look for DllImportAttribute, because you remove "Attribute" to attribute classname when using them, it's like this.

And now let's compile this!

> csc /nologo /t:library /out:echo.dll echo.cs
> csc /nologo /out:hello.exe /r:echo.dll hello.cs
>
> rem "if the following line don't work, read bellow.."
> gcc -shared -o echo.native.dll echo.c
> strip echo.native.dll

the 2 last line (the gcc & strip command) are for building the "C-DLL".
If they don't work maybe gcc is not in a directory listed in your path environment variable ? check with:
%lt; echo %PATH%
Well it's probably not,anyway, so type, assumin mingc is in C:\MinGW:
set PATH=C:\MinGW;%PATH%
And try again… you sure it's not a syntax error ?
If it compile test it now: hello
Great isn't it ?

Now I should admit I didn't tell you all the truth. echo.dll and echo.native.dll are not the same kind of DLL. It's not just the language (C / C#) the C one is a plain executable full of, probably, x86 instruction, whereas the C# one is what MS call a portable executable.. anyway they are different.
If you install echo.dll in the GAC it wont work because it won't find echo.native.dll except if you put in into the PATH (like C:\Windows\System32).
In the same manner when you add the reference in VS.NET echo.native.dll is overlooked and your program won't work….
So either put the native one in your path or copy it in the debug/release directory of VS.NET.
Or do everything by hand (makefile? build.bat?) and put all your dll in you build directory, and everything work fine..

And now..

Well, first forget about notepad. It's good to learn, but so painfull to use regularly.., try to find real developer friendly small text editor (like JFE) or a complete IDE like SharpDevelop.

Now you are ready to understand, I could tell you all the truth:
csgl.dll is a C# assembly and csgl.native.dll is just a dll compiled by GCC, upon which csgl.dll depends…

TCS Interviews

2010-02-14T09:45:00.001-08:00

February 04, 2010 Category : Training & Placements

After the online written test, the next day was the technical round.My friends and I prepared hard for it. Actually, I would like to thank my friends Sonam and Prachi to help me brush up the things i studied in my past semisters. We all reached the venue by 1pm and I got the chance to be interviewed around 7:45 in the evening. Whole day we all were revising the subjects we mentioned in our resumee. But this only dosent work you hav to be done with all your core subjects!!!!

In the technical round i was asked questions on my training both major and minor. Then on C and C++.Also on the subject I mentioned, especially, on Dtata Structure. Major Projects questions were also asked like how would u approach to it.

The technical results were out after some 2 hrs and uptill then i was completely stressed out on seeing the vast no. of rejections in the technical round!! But when i heard my name in the next round qualifying candidates list, all my apprehensions were lost.

Next day we had to report at 9am, it was more stressful,u sleep at 12:30 in the night n report at 9 in the morning. But we all had to do that!! That day wewere scheduled with 2 rounds 1st the managerial round and on qualifying that the next n final was the HR round.

In MR the panel, which i was assigned on, got the record of maximum no. of rejections. This increased my tensions more but i tried to be calm.When my no. came to go in I made myself very very confident. The interviewer made me comfortable in a minute and it increased my confidence level even more. Then he gave me my 1st situation and saw my approach on it. The next question was on my hobbies, to which i replied Dancing and Writing. I was elaborating my Dancing when he asked me to show few steps. I was bit surprised but he went on saying that people generally claim the hobbies which arent there's. I didnt showed any surprised expressions and i stood up to dance. He then urged that if i m not comfortable then no need to do it. But i refused to accept that and danced on Beedi Jalaile. He was impressed by this and also on learning tht i prepared it from TV!!! Then he gave me another situation where i am dancing on the stage on same song and suddenly a group of people in the backside of the audience start throwing eggs on me, how would i handle that situation.To this I answered and he framed questions on my answers, At the end he was very much impressed on my approach.

MR was the round i enjoyed very much!!! There were group of 7 people,who I know, incuding me, out of which only 3 gotselected and i was 1 of them!!! :)

Next was the HR round and in that also i was full of confidence. He asked me about my MR and i gave the appropriate answers and then some general HR questions.

After the final HR round We all were waiting for our results. This was again stressful. But uptill 9:30 we were told our results and I landed in TCS!!! :)

HR Interview Questions For Freshers

2010-02-14T09:36:00.000-08:00

1. Tell me about yourself?
I am down-to-earth, sweet, smart, creative, industrious, and thorough.

2. How has your experience prepared you for your career?
Coursework:
Aside from the discipline and engineering foundation learning that I have gained from my courses, I think the design projects, reports, and presentations have prepared me most for my career.
Work Experience:
Through internships, I have gained self-esteem, confidence, and problem-solving skills. I also refined my technical writing and learned to prepare professional documents for clients.
Student Organizations:
By working on multiple projects for different student organizations while keeping up my grades, I've built time management and efficiency skills. Additionally, I've developed leadership, communication, and teamwork abilities.
Life Experience:
In general, life has taught me determination and the importance of maintaining my ethical standards.

3. Describe the ideal job.
Ideally, I would like to work in a fun, warm environment with individuals working independently towards team goals or individual goals. I am not concerned about minor elements, such as dress codes, cubicles, and the level of formality. Most important to me is an atmosphere that fosters attention to quality, honesty, and integrity.

4. What type of supervisor have you found to be the best?
I have been fortunate enough to work under wonderful supervisors who have provided limited supervision, while answering thoughtful questions and guiding learning. In my experience, the best supervisors give positive feedback and tactful criticism.

5. What do you plan to be doing in five years' time?
Taking the PE exam and serving in supervisory/leadership roles both at work and in professional/community organization(s).

6. What contributions could you make in this organization that would help you to stand out from other applicants?
In previous internships, my industriousness and ability to teach myself have been valuable assets to the company. My self-teaching abilities will minimize overhead costs, and my industriousness at targeting needs without prompting will set me apart from others. Additionally, one thing that has always set me apart from my scientific/engineering peers are my broad interests and strong writing abilities. I am not your typical "left-brained" engineer, and with my broad talents, I am likely to provide diverse viewpoints.

7. What sort of criteria are you using to decide the organization you will work for?
Most importantly, I am looking for a company that values quality, ethics, and teamwork. I would like to work for a company that hires overachievers.

8. What made you choose your major?
My academic interests are broad, so I sought civil engineering to achieve a great balance of mathematics, chemistry, biology, physics, and writing.

9. Have your university and major met your expectations?
The College of Engineering at MSU has exceeded my expectations by providing group activities, career resources, individual attention, and professors with genuine interest in teaching.
My major has met my expectations by about 90%. I would have enjoyed more choices in environmental courses, and would have preferred more calculus-based learning.

10. What made you choose this college?

I chose this college for the following reasons: my budget limited me to in-state schools, I was seeking an area with dog-friendly apartments, the MSU web site impressed me, I saw active student groups, and the people were very friendly.

11. List 2-3 of your greatest achievements since you've been in college and why? Receiving the SWE Outstanding Member Award and College of Engineering Student Service Award
I got involved with student activities to overcome my debilitating shyness. Receiving these awards signified that I had accomplished a transition from dragging myself to participate to feeling energized by it.
Receiving the SWE Web Site Award
Without training in web design, I competed against not only the other student sections, but professional sections around the nation. Despite competing with more HTML-experienced people, I brought this award to my section. After getting so much from SWE, I was able to give something back.
Earning the highest grade in an organic chemistry class of ~200 people
I worked very hard for this grade and loved the subject, so it was a great feeling to see that the hard work paid off.

12. Which subjects have you enjoyed studying the most and why?
I have enjoyed hydrology, fluids, solid & hazardous waste management, water and wastewater treatment, and oceanography because I love water and environmental topics.
Calculus and linear algebra excite me because I love logic.
I enjoyed the writing and analysis in economic history.
Business law thrilled me because I have a strong interest in legal matters.

13. Which subjects did you dislike and why?
Introductory soil elicited little interest in me, most likely because the professor was inexperienced, the book was ineffective, and I had little spare time that semester to look into other resources.

14. Do you have plans to continue your education?
Yes, but not immediately. I plan to continue part time with either an MBA or an environmental engineering masters, depending on which will be more beneficial to my work.

15. How would a professor who knows you well describe you? One who does not know you well?
A professor who knows me well would likely describe my personal qualities: sweet, down-to-earth, smart, hard-working, and conscientious.
As specific examples of those who did not know me well, my soils professor and soils teaching assistant each considered me smart and respectful, and both thought that I must have enjoyed the class a lot, due to my performance.

16. Given the chance, how would you alter your education?
Knowing now what I like the most, I would have used my electives for extra math and psychology classes, since I tend to be well-rounded enough that a variety of classes are unnecessary; my personal reading is diverse enough. I have found that mathematics and psychology are helpful to all career and life paths.

17. Which part-time job did you enjoy the most and why?
Working for PM Environmental was most enjoyable to me, since I felt like I was significantly contributing to the company, and I enjoyed learning on my own.

18. Interests:
Some of my interests include dogs, hiking, snow-shoeing, water sports, writing, reading (especially Charles Dickens' novels), skiing, drawing, crafts, and computers.

19. What are your strengths?
My strongest strength is the ability to teach myself difficult material, regardless of the subject (with the exception of theater and drawing blood from dogs, which I have no talent for). Additionally, I have always excelled verbally and look forward to writing opportunities.

20. What are your weaknesses?
I tend to try to do too many things, leaving little time for myself. I have worked on balancing myself for the last several months. I am also working on improving my public speaking skills.

21. What sort of serious problems have you experienced, and how have you handled them?
My apartment building burned down at the end of January during one of my semesters at MSU. Before the fire got too bad, I was able to rescue my pets and the neighbor's dog, as well as my textbooks and backpack, but I lost most of my mementos and possessions. While the firemen were preparing their hoses, I drove to school (with the animals in the car) to meet my lab partners, who were waiting for me. I explained the situation, emailed my professors, and rushed back to the apartment.
Fortunately, I had renter's insurance. I missed about a week of school to deal with the insurance matters and find a new place to live. In order to salvage my grades and sanity, I dropped a course and honored my existing student group and research commitments. Staying active socially and keeping myself well-rounded were the best healing tools for me. Within a few weeks, I was caught up and had recovered reasonably from the loss of sentimental items.

22. Do you or have you in the past experimented with illegal drugs?
No. My only addictions are caffeine and sugar.

23. Would you be willing to take a drug test?
Of course.

24. Do you drink alcohol socially?
No, but I enjoy Shirley Temples quite a bit.

Human Resource Interview Tips

2010-02-14T09:30:00.000-08:00

Human Resource Interview Tips

The interview is an opportunity for both, the interviewer and the candidate to market themselves. The employer is selling the organization to you, and you are marketing your skills, knowledge, and personality to the employer. Remember that interviews are varied and so they cannot therefore be easily categorized.
Following are some human resource interview tips:

Be prepared
Preparation increases confidence. Practice with your friends or relatives. Remember that everyone who is interviewing is not necessarily a good interviewer.
You may prepare by reviewing magazine and newspaper articles. You may check out their web site. Read your resume before your interview. It will keep your answers fresh.

Location and punctuality
Find out the location of organization. Make sure you have a map or directions as well as information of the nearest railway station.
Arrive 5-10 minutes early. Arriving early will give you the opportunity to read some information on the company in the reception area.

Be professional
Professional look always helps for good impression. Be careful about your dressing. Be aware of the company culture and ensure you dress to impress. Decide what you are going to wear the night before to avoid making the wrong choices.

Be polite
Don't interrupt to the interviewer. Listen very carefully. Poor listening skills are responsible for the bad impression.
If the interview is being conducted in a restaurant, mind your table manners. If the interviewers are serious and soft-spoken, then you should be same as interviewer. Avoid loud laughter during the interviewer.

Be positive
Keep in mind that there is only one chance to make a first impression. Every company wants employees who are goal-oriented, career-driven, enthusiastic and motivated. Be the employee as they want. End the interview on a positive note. The hiring official needs to know that you are interested, enthusiastic and excited about the position and the company.

Be practical
If you are experienced then the interviewer already knows your current salary and benefits package. When the topic of salary comes up state that you know they will make a fair offer.
If you are offered the position during the interviewing process and you want the job then accept it. If the offer is not acceptable for any reason, ask for time to consider the offer.

Human resource interview tips - Do's

Have a firm handshake.

Be sincere and direct.

Introduce yourself in a courteous manner.

Read company materials while you wait.

You have to prepare for questions and listen carefully to the interviewer.

Ask about the next step in the process.

Thank the interviewer.

Learn about the Human Resources Analyst Program and understand the different facets of human resources.

You never know what the interviewer will ask you about, so be prepared to talk about anything you have included on your resume. You should be truthful about your experiences and skills.

Human resource interview tips - Don'ts

Don't show depression or discouragement.

Don't start the topics like salary, benefits or working hours.

Don't look at your watch.

Don't take extensive notes.

Don't be too serious.

Follow up
Always write a thank you note immediately after the interview. If there are number of interviewers then send a copy of thank you letter to each person. Summarize your qualifications and how they meet the expectations of the position.

Design Pattern

2010-02-04T23:18:00.000-08:00

Introduction

Hi friends, please do not think you get an architecture position by reading interview questions. But yes there should be some kind of reference which will help you quickly revise what are the definition. Just by reading these answers you get to a position where you are aware of the fundamentals. But if you have not really worked you will surely fail with scenario based questions. So use this as a quick revision rather than a shot cut.

(B) What are design patterns ?

Design patterns are documented tried and tested solutions for recurring problems in a given context. So basically you have a problem context and the proposed solution for the same. Design patterns existed in some or other form right from the inception stage of software development. Let's say if you want to implement a sorting algorithm the first thing comes to mind is bubble sort. So the problem is sorting and solution is bubble sort. Same holds true for design patterns.

(I) Which are the three main categories of design patterns ?

There are three basic classifications of patterns Creational, Structural, and Behavioral patterns.

Creational Patterns

Abstract Factory : Creates an instance of several families of classes
Builder : Separates object construction from its representation
Factory Method : Creates an instance of several derived classes
Prototype : A fully initialized instance to be copied or cloned
Singleton : A class in which only a single instance can exist

Note : The best way to remember Creational pattern is by remembering ABFPS (Abraham Became First President of States).

Structural Patterns

Adapter : Match interfaces of different classes .
Bridge : Separates an object's abstraction from its implementation.
Composite : A tree structure of simple and composite objects.
Decorator : Add responsibilities to objects dynamically.
Flyweight : A fine-grained instance used for efficient sharing.
Proxy : An object representing another object.

Note : To remember structural pattern best is (ABCDFFP)

Behavioral Patterns

Mediator : Defines simplified communication between classes.
Memento : Capture and restore an object's internal state.
Interpreter : A way to include language elements in a program.
Iterator : Sequentially access the elements of a collection.
Chain of Resp : A way of passing a request between a chain of objects.
Command : Encapsulate a command request as an object.
State : Alter an object's behavior when its state changes.
Strategy : Encapsulates an algorithm inside a class.
Observer : A way of notifying change to a number of classes.
Template Method : Defer the exact steps of an algorithm to a subclass.
Visitor : Defines a new operation to a class without change.

Note: Just remember Music....... 2 MICS On TV (MMIICCSSOTV).

Note : In the further section we will be covering all the above design patterns in a more detail manner.

(A) Can you explain factory pattern ?

Factory pattern is one of the types of creational patterns. You can make out from the name factory itself it's meant to construct and create something. In software architecture world factory pattern is meant to centralize creation of objects. Below is a code snippet of a client which has different types of invoices. These invoices are created depending on the invoice type specified by the client. There are two issues with the code below :

First we have lots of 'new' keyword scattered in the client. In other ways the client is loaded with lot of object creational activities which can make the client logic very complicated.

Second issue is that the client needs to be aware of all types of invoices. So if we are adding one more invoice class type called as 'InvoiceWithFooter' we need to reference the new class in the client and recompile the client also.

Figure 1. Different types of invoice

Taking these issues as our base we will now look in to how factory pattern can help us solve the same. Below figure 'Factory Pattern' shows two concrete classes 'ClsInvoiceWithHeader' and 'ClsInvoiceWithOutHeader'.

The first issue was that these classes are in direct contact with client which leads to lot of 'new' keyword scattered in the client code. This is removed by introducing a new class 'ClsFactoryInvoice' which does all the creation of objects.

The second issue was that the client code is aware of both the concrete classes i.e. 'ClsInvoiceWithHeader' and 'ClsInvoiceWithOutHeader'. This leads to recompiling of the client code when we add new invoice types. For instance if we add 'ClsInvoiceWithFooter' client code needs to be changed and recompiled accordingly. To remove this issue we have introduced a common interface 'IInvoice'. Both the concrete classes 'ClsInvoiceWithHeader' and 'ClsInvoiceWithOutHeader' inherit and implement the 'IInvoice' interface.

The client references only the 'IInvoice' interface which results in zero connection between client and the concrete classes ( 'ClsInvoiceWithHeader' and 'ClsInvoiceWithOutHeader'). So now if we add new concrete invoice class we do not need to change any thing at the client side.

In one line the creation of objects is taken care by 'ClsFactoryInvoice' and the client disconnection from the concrete classes is taken care by 'IInvoice' interface.

Figure 2. Factory pattern

Below are the code snippets of how actually factory pattern can be implemented in C#. In order to avoid recompiling the client we have introduced the invoice interface 'IInvoice'. Both the concrete classes 'ClsInvoiceWithOutHeaders' and 'ClsInvoiceWithHeader' inherit and implement the 'IInvoice' interface.

Figure 3. Interface and concrete classes

We have also introduced an extra class 'ClsFactoryInvoice' with a function 'getInvoice()' which will generate objects of both the invoices depending on 'intInvoiceType' value. In short we have centralized the logic of object creation in the 'ClsFactoryInvoice'. The client calls the 'getInvoice' function to generate the invoice classes. One of the most important points to be noted is that client only refers to 'IInvoice' type and the factory class 'ClsFactoryInvoice' also gives the same type of reference. This helps the client to be complete detached from the concrete classes, so now when we add new classes and invoice types we do not need to recompile the client.

Figure 4. Factory class which generates objects

Note : The above example is given in C# . Even if you are from some other technology you can still map the concept accordingly. You can get source code from the CD in 'FactoryPattern' folder.

Can you explain abstract factory pattern ?

Abstract factory expands on the basic factory pattern. Abstract factory helps us to unite similar factory pattern classes in to one unified interface. So basically all the common factory patterns now inherit from a common abstract factory class which unifies them in a common class. All other things related to factory pattern remain same as discussed in the previous question.

A factory class helps us to centralize the creation of classes and types. Abstract factory helps us to bring uniformity between related factory patterns which leads more simplified interface for the client.

Figure 5. Abstract factory unifies related factory patterns

Now that we know the basic lets try to understand the details of how abstract factory patterns are actually implemented. As said previously we have the factory pattern classes (factory1 and factory2) tied up to a common abstract factory (AbstractFactory Interface) via inheritance. Factory classes stand on the top of concrete classes which are again derived from common interface. For instance in figure 'Implementation of abstract factory' both the concrete classes 'product1' and 'product2' inherits from one interface i.e. 'common'. The client who wants to use the concrete class will only interact with the abstract factory and the common interface from which the concrete classes inherit.

Figure 6. Implementation of abstract factory

Now let's have a look at how we can practically implement abstract factory in actual code. We have scenario where we have UI creational activities for textboxes and buttons through their own centralized factory classes 'ClsFactoryButton' and 'ClsFactoryText'. Both these classes inherit from common interface 'InterfaceRender'. Both the factories 'ClsFactoryButton' and 'ClsFactoryText' inherits from the common factory 'ClsAbstractFactory'. Figure 'Example for AbstractFactory' shows how these classes are arranged and the client code for the same. One of the important points to be noted about the client code is that it does not interact with the concrete classes. For object creation it uses the abstract factory ( ClsAbstractFactory ) and for calling the concrete class implementation it calls the methods via the interface 'InterfaceRender'. So the 'ClsAbstractFactory' class provides a common interface for both factories 'ClsFactoryButton' and 'ClsFactoryText'.

Figure 7. Example for abstract factory

Note: We have provided a code sample in C# in the 'AbstractFactory' folder. People who are from different technology can compare easily the implementation in their own language.

We will just run through the sample code for abstract factory. Below code snippet 'Abstract factory and factory code snippet' shows how the factory pattern classes inherit from abstract factory.

Figure 8. Abstract factory and factory code snippet

Figure 'Common Interface for concrete classes' how the concrete classes inherits from a common interface 'InterFaceRender' which enforces the method 'render' in all the concrete classes.

Figure 9. Common interface for concrete classes

The final thing is the client code which uses the interface 'InterfaceRender' and abstract factory 'ClsAbstractFactory' to call and create the objects. One of the important points about the code is that it is completely isolated from the concrete classes. Due to this any changes in concrete classes like adding and removing concrete classes does not need client level changes.

Figure 10. Client, interface and abstract factory

Can you explain builder pattern?

Builder falls under the type of creational pattern category. Builder pattern helps us to separate the construction of a complex object from its representation so that the same construction process can create different representations. Builder pattern is useful when the construction of the object is very complex. The main objective is to separate the construction of objects and their representations. If we are able to separate the construction and representation, we can then get many representations from the same construction.

Figure 11. Builder concept

To understand what we mean by construction and representation lets take the example of the below 'Tea preparation' sequence.

You can see from the figure 'Tea preparation' from the same preparation steps we can get three representation of tea's (i.e. Tea with out sugar, tea with sugar / milk and tea with out milk).

Figure 12. Tea preparation

Now let's take a real time example in software world to see how builder can separate the complex creation and its representation. Consider we have application where we need the same report to be displayed in either 'PDF' or 'EXCEL' format. Figure 'Request a report' shows the series of steps to achieve the same. Depending on report type a new report is created, report type is set, headers and footers of the report are set and finally we get the report for display.

Figure 13. Request a report

Now let's take a different view of the problem as shown in figure 'Different View'. The same flow defined in 'Request a report' is now analyzed in representations and common construction. The construction process is same for both the types of reports but they result in different representations.

Figure 14. Different View

We will take the same report problem and try to solve the same using builder patterns. There are three main parts when you want to implement builder patterns.

Builder : Builder is responsible for defining the construction process for individual parts. Builder has those individual processes to initialize and configure the product.
Director : Director takes those individual processes from the builder and defines the sequence to build the product.
Product : Product is the final object which is produced from the builder and director coordination.

First let's have a look at the builder class hierarchy. We have a abstract class called as 'ReportBuilder' from which custom builders like 'ReportPDF' builder and 'ReportEXCEL' builder will be built.

Figure 15. Builder class hierarchy

Figure 'Builder classes in actual code' shows the methods of the classes. To generate report we need to first Create a new report, set the report type (to EXCEL or PDF) , set report headers , set the report footers and finally get the report. We have defined two custom builders one for 'PDF' (ReportPDF) and other for 'EXCEL' (ReportExcel). These two custom builders define there own process according to the report type.

Figure 16. Builder classes in actual code

Now let's understand how director will work. Class 'clsDirector' takes the builder and calls the individual method process in a sequential manner. So director is like a driver who takes all the individual processes and calls them in sequential manner to generate the final product, which is the report in this case. Figure 'Director in action' shows how the method 'MakeReport' calls the individual process to generate the report product by PDF or EXCEL.

Figure 17. Director in action

The third component in the builder is the product which is nothing but the report class in this case.

Figure 18. The report class

Now let's take a top view of the builder project. Figure 'Client,builder,director and product' shows how they work to achieve the builder pattern. Client creates the object of the director class and passes the appropriate builder to initialize the product. Depending on the builder the product is initialized/created and finally sent to the client.

Figure 19. Client, builder, director and product

The output is something like this. We can see two report types displayed with their headers according to the builder.

Figure 20. Final output of builder

Can you explain prototype pattern ?

Prototype pattern falls in the section of creational pattern. It gives us a way to create new objects from the existing instance of the object. In one sentence we clone the existing object with its data. By cloning any changes to the cloned object does not affect the original object value. If you are thinking by just setting objects we can get a clone then you have mistaken it. By setting one object to other object we set the reference of object BYREF. So changing the new object also changed the original object. To understand the BYREF fundamental more clearly consider the figure 'BYREF' below. Following is the sequence of the below code:

In the first step we have created the first object i.e. obj1 from class1.
In the second step we have created the second object i.e. obj2 from class1.
In the third step we set the values of the old object i.e. obj1 to 'old value'.
In the fourth step we set the obj1 to obj2.
In the fifth step we change the obj2 value.
Now we display both the values and we have found that both the objects have the new value.

Figure 21. BYREf

The conclusion of the above example is that objects when set to other objects are set BYREF. So changing new object values also changes the old object value.

There are many instances when we want the new copy object changes should not affect the old object. The answer to this is prototype patterns.

Lets look how we can achieve the same using C#. In the below figure 'Prototype in action' we have the customer class 'ClsCustomer' which needs to be cloned. This can be achieved in C# my using the 'MemberWiseClone' method. In JAVA we have the 'Clone' method to achieve the same. In the same code we have also shown the client code. We have created two objects of the customer class 'obj1' and 'obj2'. Any changes to 'obj2' will not affect 'obj1' as it's a complete cloned copy.

Figure 22. Prototype in action

Note : You can get the above sample in the CD in 'Prototype' folder. In C# we use the 'MemberWiseClone' function while in JAVA we have the 'Clone' function to achieve the same.

(A) Can you explain shallow copy and deep copy in prototype patterns ?

There are two types of cloning for prototype patterns. One is the shallow cloning which you have just read in the first question. In shallow copy only that object is cloned, any objects containing in that object is not cloned. For instance consider the figure 'Deep cloning in action' we have a customer class and we have an address class aggregated inside the customer class. 'MemberWiseClone' will only clone the customer class 'ClsCustomer' but not the 'ClsAddress' class. So we added the 'MemberWiseClone' function in the address class also. Now when we call the 'getClone' function we call the parent cloning function and also the child cloning function, which leads to cloning of the complete object. When the parent objects are cloned with their containing objects it's called as deep cloning and when only the parent is clones its termed as shallow cloning.

Figure 23. Deep cloning in action

(B) Can you explain singleton pattern ?

There are situations in a project where we want only one instance of the object to be created and shared between the clients. No client can create an instance of the object from outside. There is only one instance of the class which is shared across the clients. Below are the steps to make a singleton pattern :-

Define the constructor as private.
Define the instances and methods as static.

Below is a code snippet of a singleton in C#. We have defined the constructor as private, defined all the instance and methods using the static keyword as shown in the below code snippet figure 'Singleton in action'. The static keyword ensures that you only one instance of the object is created and you can all the methods of the class with out creating the object. As we have made the constructor private, we need to call the class directly.

Figure 24. Singleton in action

Note : In JAVA to create singleton classes we use the STATIC keyword , so its same as in C#. You can get a sample C# code for singleton in the 'singleton' folder.

Can you explain command patterns?

Command pattern allows a request to exist as an object. Ok let's understand what it means. Consider the figure 'Menu and Commands' we have different actions depending on which menu is clicked. So depending on which menu is clicked we have passed a string which will have the action text in the action string. Depending on the action string we will execute the action. The bad thing about the code is it has lot of 'IF' condition which makes the coding more cryptic.

Figure 25. Menu and Commands

Command pattern moves the above action in to objects. These objects when executed actually execute the command.

As said previously every command is an object. We first prepare individual classes for every action i.e. exit, open, file and print. Al l the above actions are wrapped in to classes like Exit action is wrapped in 'clsExecuteExit' , open action is wrapped in 'clsExecuteOpen', print action is wrapped in 'clsExecutePrint' and so on. All these classes are inherited from a common interface 'IExecute'.

Figure 26. Objects and Command

Using all the action classes we can now make the invoker. The main work of invoker is to map the action with the classes which have the action.

So we have added all the actions in one collection i.e. the arraylist. We have exposed a method 'getCommand' which takes a string and gives back the abstract object 'IExecute'. The client code is now neat and clean. All the 'IF' conditions are now moved to the 'clsInvoker' class.

Figure 27. Invoker and the clean client

Prototype pattern

2010-02-04T03:59:00.000-08:00

Prototype

Specify the kinds of objects to create using a prototypical instance, and create new objects by copying that prototype.

A prototype pattern is used in software development when the type of objects to create is determined by a prototypical instance, which is cloned to produce new objects. This pattern is used for example when the inherent cost of creating a new object in the standard way (e.g., using the 'new' keyword) is prohibitively expensive for a given application.

Implementation: Declare an abstract base class that specifies a pure virtual clone() method. Any class that needs a "polymorphic constructor" capability derives itself from the abstract base class, and implements the clone() operation.

Here the client code first invokes the factory method. This factory method, depending on the parameter, finds out concrete class. On this concrete class call to the Clone() method is called and the object is returned by the factory method.

This is sample code which is a sample implementation of Prototype method. We have the detailed description of all the components here.
- "Record" class which is a pure virtual class which is having pure virtual method "Clone()".
- "CarRecord", "BikeRecord" and "PersonRecord" as concrete implementation of "Record" class.
- An enum RECORD_TYPE_en as one to one mapping of each concrete implementation of "Record" class.
- "RecordFactory" class which is having Factory method "CreateRecord(...)". This method requires an enum RECORD_TYPE_en as parameter and depending on this parameter it returns the concrete implementation of "Record" class.

  /**

  * Implementation of Prototype Method

  **/

 #include 

 #include 



 using namespace std;



 enum RECORD_TYPE_en

 {

   CAR,

   BIKE,

   PERSON

 };



 /**

  * Record is the Prototype

  */



 class Record

 {

   public :



     Record() {}



     ~Record() {}



     Record* Clone()=0;



     virtual void Print()=0;

 };



 /**

  * CarRecord is Concrete Prototype

  */



 class CarRecord : public Record

 {

   private :

     string m_oStrCarName;



     u_int32_t m_ui32ID;



   public :



     CarRecord(string _oStrCarName,u_int32_t _ui32ID)

       : Record(), m_oStrCarName(_oStrCarName),

         m_ui32ID(_ui32ID)

     {

     }



     CarRecord(CarRecord& _oCarRecord)

       : Record()

     {

       m_oStrCarName = _oCarRecord.m_oStrCarName;

       m_ui32ID = _oCarRecord.m_ui32ID;

     }



     ~CarRecord() {}



     Record* Clone()

     {

       return new CarRecord(*this);

     }



     void Print()

     {

       cout << "Car Record" << endl

         << "Name  : " << m_oStrCarName << endl

         << "Number: " << m_ui32ID << endl << endl;

     }

 };





 /**

  * BikeRecord is the Concrete Prototype

  */



 class BikeRecord : public Record

 {

   private :

     string m_oStrBikeName;



     u_int32_t m_ui32ID;



   public :

     BikeRecord(string _oStrBikeName,u_int32_t _ui32ID)

       : Record(), m_oStrBikeName(_oStrBikeName),

         m_ui32ID(_ui32ID)

     {

     }



     BikeRecord(BikeRecord& _oBikeRecord)

       : Record()

     {

       m_oStrBikeName = _oBikeRecord.m_oStrBikeName;

       m_ui32ID = _oBikeRecord.m_ui32ID;

     }



     ~BikeRecord() {}



     Record* Clone()

     {

       return new BikeRecord(*this);

     }



     void Print()

     {

       cout << "Bike Record" << endl

         << "Name  : " << m_oStrBikeName << endl

         << "Number: " << m_ui32ID << endl << endl;

     }

 };





 /**

  * PersonRecord is the Concrete Prototype

  */



 class PersonRecord : public Record

 {

   private :

     string m_oStrPersonName;



     u_int32_t m_ui32Age;



   public :

     PersonRecord(string _oStrPersonName, u_int32_t _ui32Age)

       : Record(), m_oStrPersonName(_oStrPersonName),

         m_ui32Age(_ui32Age)

     {

     }



     PersonRecord(PersonRecord& _oPersonRecord)

       : Record()

     {

       m_oStrPersonName = _oPersonRecord.m_oStrPersonName;

       m_ui32Age = _oPersonRecord.m_ui32Age;

     }



     ~PersonRecord() {}



     Record* Clone()

     {

       return new PersonRecord(*this);

   }



   void Print()

   {

     cout << "Person Record" << endl

       << "Name : " << m_oStrPersonName << endl

       << "Age  : " << m_ui32Age << endl << endl ;

   }

 };





 /**

  * RecordFactory is the client

  */



 class RecordFactory

 {

   private :

     map<RECORD_TYPE_en, Record* > m_oMapRecordReference;



   public :

     RecordFactory()

     {

       m_oMapRecordReference[CAR]  = new CarRecord("Ferrari", 5050);

       m_oMapRecordReference[BIKE] = new BikeRecord("Yamaha", 2525);

     m_oMapRecordReference[PERSON] = new PersonRecord("Tom", 25);

     }



     ~RecordFactory()

     {

       delete m_oMapRecordReference[CAR];

       delete m_oMapRecordReference[BIKE];

       delete m_oMapRecordReference[PERSON];

     }



     Record* CreateRecord(RECORD_TYPE_en enType)

     {

       return m_oMapRecordReference[enType]->Clone();

     }

 };



 int main()

 {

   RecordFactory* poRecordFactory = new RecordFactory();



   Record* poRecord;

   poRecord = poRecordFactory->CreateRecord(CAR);

   poRecord->Print();

   delete poRecord;



   poRecord = poRecordFactory->CreateRecord(BIKE);

   poRecord->Print();

   delete poRecord;



   poRecord = poRecordFactory->CreateRecord(PERSON);

   poRecord->Print();

   delete poRecord;



   delete poRecordFactory;

   return 0;

 }

Another example:

To implement the pattern, declare an abstract base class that specifies a pure virtual clone() member function. Any class that needs a "polymorphic constructor" capability derives itself from the abstract base class, and implements the clone() operation.

The client, instead of writing code that invokes the "new" operator on a hard-wired class name, calls the clone() member function on the prototype, calls a factory member function with a parameter designating the particular concrete derived class desired, or invokes the clone() member function through some mechanism provided by another design pattern.

 class CPrototypeMonster

{

protected:           

    CString           _name;

public:

    CPrototypeMonster();

    CPrototypeMonster( const CPrototypeMonster& copy );

    ~CPrototypeMonster();



    virtual CPrototypeMonster*    Clone() const=0; // This forces every derived class to provide an overload for this function.

    void        Name( CString name );

    CString    Name() const;

};



class CGreenMonster : public CPrototypeMonster

{

protected:

    int         _numberOfArms;

    double      _slimeAvailable;

public:

    CGreenMonster();

    CGreenMonster( const CGreenMonster& copy );

    ~CGreenMonster();



    virtual CPrototypeMonster*    Clone() const;

    void  NumberOfArms( int numberOfArms );

    void  SlimeAvailable( double slimeAvailable );



    int         NumberOfArms() const;

    double      SlimeAvailable() const;

};



class CPurpleMonster : public CPrototypeMonster

{

protected:

    int         _intensityOfBadBreath;

    double      _lengthOfWhiplikeAntenna;

public:

    CPurpleMonster();

    CPurpleMonster( const CPurpleMonster& copy );

    ~CPurpleMonster();



    virtual CPrototypeMonster*    Clone() const;



    void  IntensityOfBadBreath( int intensityOfBadBreath );

    void  LengthOfWhiplikeAntenna( double lengthOfWhiplikeAntenna );



    int       IntensityOfBadBreath() const;

    double    LengthOfWhiplikeAntenna() const;

};



class CBellyMonster : public CPrototypeMonster

{

protected:

    double      _roomAvailableInBelly;

public:

    CBellyMonster();

    CBellyMonster( const CBellyMonster& copy );

    ~CBellyMonster();



    virtual CPrototypeMonster*    Clone() const;



    void       RoomAvailableInBelly( double roomAvailableInBelly );

    double     RoomAvailableInBelly() const;

};



CPrototypeMonster* CGreenMonster::Clone() const

{

    return new CGreenMonster(*this);

}



CPrototypeMonster* CPurpleMonster::Clone() const

{

    return new CPurpleMonster(*this);

}



CPrototypeMonster* CBellyMonster::Clone() const

{

    return new CBellyMonster(*this);

}

A client of one of the concrete monster classes only needs a reference (pointer) to a CPrototypeMonster class object to be able to call the ‘Clone’ function and create copies of that object. The function below demonstrates this concept:

 void DoSomeStuffWithAMonster( const CPrototypeMonster* originalMonster )

{

    CPrototypeMonster* newMonster = originalMonster->Clone();

    ASSERT( newMonster );



    newMonster->Name("MyOwnMoster");

    // Add code doing all sorts of cool stuff with the monster.

    delete newMonster;

}

Now originalMonster can be passed as a pointer to CGreenMonster, CPurpleMonster or CBellyMonster.

Design Pattern

2010-02-04T03:19:00.000-08:00

Introduction

Hi friends, please do not think you get an architecture position by reading interview questions. But yes there should be some kind of reference which will help you quickly revise what are the definition. Just by reading these answers you get to a position where you are aware of the fundamentals. But if you have not really worked you will surely fail with scenario based questions. So use this as a quick revision rather than a shot cut.

(B) What are design patterns ?

Design patterns are documented tried and tested solutions for recurring problems in a given context. So basically you have a problem context and the proposed solution for the same. Design patterns existed in some or other form right from the inception stage of software development. Let's say if you want to implement a sorting algorithm the first thing comes to mind is bubble sort. So the problem is sorting and solution is bubble sort. Same holds true for design patterns.

(I) Which are the three main categories of design patterns ?

There are three basic classifications of patterns Creational, Structural, and Behavioral patterns.

Creational Patterns

Abstract Factory : Creates an instance of several families of classes
Builder : Separates object construction from its representation
Factory Method : Creates an instance of several derived classes
Prototype : A fully initialized instance to be copied or cloned
Singleton : A class in which only a single instance can exist

Note : The best way to remember Creational pattern is by remembering ABFPS (Abraham Became First President of States).

Structural Patterns

Adapter : Match interfaces of different classes .
Bridge : Separates an object's abstraction from its implementation.
Composite : A tree structure of simple and composite objects.
Decorator : Add responsibilities to objects dynamically.
Flyweight : A fine-grained instance used for efficient sharing.
Proxy : An object representing another object.

Note : To remember structural pattern best is (ABCDFFP)

Behavioral Patterns

Mediator : Defines simplified communication between classes.
Memento : Capture and restore an object's internal state.
Interpreter : A way to include language elements in a program.
Iterator : Sequentially access the elements of a collection.
Chain of Resp : A way of passing a request between a chain of objects.
Command : Encapsulate a command request as an object.
State : Alter an object's behavior when its state changes.
Strategy : Encapsulates an algorithm inside a class.
Observer : A way of notifying change to a number of classes.
Template Method : Defer the exact steps of an algorithm to a subclass.
Visitor : Defines a new operation to a class without change.

Note: Just remember Music....... 2 MICS On TV (MMIICCSSOTV).

Note : In the further section we will be covering all the above design patterns in a more detail manner.

(A) Can you explain factory pattern ?

Factory pattern is one of the types of creational patterns. You can make out from the name factory itself it's meant to construct and create something. In software architecture world factory pattern is meant to centralize creation of objects. Below is a code snippet of a client which has different types of invoices. These invoices are created depending on the invoice type specified by the client. There are two issues with the code below :

First we have lots of 'new' keyword scattered in the client. In other ways the client is loaded with lot of object creational activities which can make the client logic very complicated.

Second issue is that the client needs to be aware of all types of invoices. So if we are adding one more invoice class type called as 'InvoiceWithFooter' we need to reference the new class in the client and recompile the client also
\
Figure 1. Different types of invoice

Taking these issues as our base we will now look in to how factory pattern can help us solve the same. Below figure 'Factory Pattern' shows two concrete classes 'ClsInvoiceWithHeader' and 'ClsInvoiceWithOutHeader'.

The first issue was that these classes are in direct contact with client which leads to lot of 'new' keyword scattered in the client code. This is removed by introducing a new class 'ClsFactoryInvoice' which does all the creation of objects.

The second issue was that the client code is aware of both the concrete classes i.e. 'ClsInvoiceWithHeader' and 'ClsInvoiceWithOutHeader'. This leads to recompiling of the client code when we add new invoice types. For instance if we add 'ClsInvoiceWithFooter' client code needs to be changed and recompiled accordingly. To remove this issue we have introduced a common interface 'IInvoice'. Both the concrete classes 'ClsInvoiceWithHeader' and 'ClsInvoiceWithOutHeader' inherit and implement the 'IInvoice' interface.

The client references only the 'IInvoice' interface which results in zero connection between client and the concrete classes ( 'ClsInvoiceWithHeader' and 'ClsInvoiceWithOutHeader'). So now if we add new concrete invoice class we do not need to change any thing at the client side.

In one line the creation of objects is taken care by 'ClsFactoryInvoice' and the client disconnection from the concrete classes is taken care by 'IInvoice' interface.

Figure 2. Factory pattern

Below are the code snippets of how actually factory pattern can be implemented in C#. In order to avoid recompiling the client we have introduced the invoice interface 'IInvoice'. Both the concrete classes 'ClsInvoiceWithOutHeaders' and 'ClsInvoiceWithHeader' inherit and implement the 'IInvoice' interface.

Figure 3. Interface and concrete classes

We have also introduced an extra class 'ClsFactoryInvoice' with a function 'getInvoice()' which will generate objects of both the invoices depending on 'intInvoiceType' value. In short we have centralized the logic of object creation in the 'ClsFactoryInvoice'. The client calls the 'getInvoice' function to generate the invoice classes. One of the most important points to be noted is that client only refers to 'IInvoice' type and the factory class 'ClsFactoryInvoice' also gives the same type of reference. This helps the client to be complete detached from the concrete classes, so now when we add new classes and invoice types we do not need to recompile the client.

Figure 4. Factory class which generates objects

Note : The above example is given in C# . Even if you are from some other technology you can still map the concept accordingly. You can get source code from the CD in 'FactoryPattern' folder.

Can you explain abstract factory pattern ?

Abstract factory expands on the basic factory pattern. Abstract factory helps us to unite similar factory pattern classes in to one unified interface. So basically all the common factory patterns now inherit from a common abstract factory class which unifies them in a common class. All other things related to factory pattern remain same as discussed in the previous question.

A factory class helps us to centralize the creation of classes and types. Abstract factory helps us to bring uniformity between related factory patterns which leads more simplified interface for the client.

Figure 5. Abstract factory unifies related factory patterns

Now that we know the basic lets try to understand the details of how abstract factory patterns are actually implemented. As said previously we have the factory pattern classes (factory1 and factory2) tied up to a common abstract factory (AbstractFactory Interface) via inheritance. Factory classes stand on the top of concrete classes which are again derived from common interface. For instance in figure 'Implementation of abstract factory' both the concrete classes 'product1' and 'product2' inherits from one interface i.e. 'common'. The client who wants to use the concrete class will only interact with the abstract factory and the common interface from which the concrete classes inherit.

Figure 6. Implementation of abstract factory

Now let's have a look at how we can practically implement abstract factory in actual code. We have scenario where we have UI creational activities for textboxes and buttons through their own centralized factory classes 'ClsFactoryButton' and 'ClsFactoryText'. Both these classes inherit from common interface 'InterfaceRender'. Both the factories 'ClsFactoryButton' and 'ClsFactoryText' inherits from the common factory 'ClsAbstractFactory'. Figure 'Example for AbstractFactory' shows how these classes are arranged and the client code for the same. One of the important points to be noted about the client code is that it does not interact with the concrete classes. For object creation it uses the abstract factory ( ClsAbstractFactory ) and for calling the concrete class implementation it calls the methods via the interface 'InterfaceRender'. So the 'ClsAbstractFactory' class provides a common interface for both factories 'ClsFactoryButton' and 'ClsFactoryText'.

Figure 7. Example for abstract factory

Note: We have provided a code sample in C# in the 'AbstractFactory' folder. People who are from different technology can compare easily the implementation in their own language.

We will just run through the sample code for abstract factory. Below code snippet 'Abstract factory and factory code snippet' shows how the factory pattern classes inherit from abstract factory.

Figure 8. Abstract factory and factory code snippet

Figure 'Common Interface for concrete classes' how the concrete classes inherits from a common interface 'InterFaceRender' which enforces the method 'render' in all the concrete classes.

Figure 9. Common interface for concrete classes

The final thing is the client code which uses the interface 'InterfaceRender' and abstract factory 'ClsAbstractFactory' to call and create the objects. One of the important points about the code is that it is completely isolated from the concrete classes. Due to this any changes in concrete classes like adding and removing concrete classes does not need client level changes.

Figure 10. Client, interface and abstract factory

Can you explain builder pattern?

Builder falls under the type of creational pattern category. Builder pattern helps us to separate the construction of a complex object from its representation so that the same construction process can create different representations. Builder pattern is useful when the construction of the object is very complex. The main objective is to separate the construction of objects and their representations. If we are able to separate the construction and representation, we can then get many representations from the same construction.

Figure 11. Builder concept

To understand what we mean by construction and representation lets take the example of the below 'Tea preparation' sequence.

You can see from the figure 'Tea preparation' from the same preparation steps we can get three representation of tea's (i.e. Tea with out sugar, tea with sugar / milk and tea with out milk).

Figure 12. Tea preparation

Now let's take a real time example in software world to see how builder can separate the complex creation and its representation. Consider we have application where we need the same report to be displayed in either 'PDF' or 'EXCEL' format. Figure 'Request a report' shows the series of steps to achieve the same. Depending on report type a new report is created, report type is set, headers and footers of the report are set and finally we get the report for display.

Figure 13. Request a report

Now let's take a different view of the problem as shown in figure 'Different View'. The same flow defined in 'Request a report' is now analyzed in representations and common construction. The construction process is same for both the types of reports but they result in different representations.

Figure 14. Different View

We will take the same report problem and try to solve the same using builder patterns. There are three main parts when you want to implement builder patterns.

Builder : Builder is responsible for defining the construction process for individual parts. Builder has those individual processes to initialize and configure the product.
Director : Director takes those individual processes from the builder and defines the sequence to build the product.
Product : Product is the final object which is produced from the builder and director coordination.

First let's have a look at the builder class hierarchy. We have a abstract class called as 'ReportBuilder' from which custom builders like 'ReportPDF' builder and 'ReportEXCEL' builder will be built.

Figure 15. Builder class hierarchy

Figure 'Builder classes in actual code' shows the methods of the classes. To generate report we need to first Create a new report, set the report type (to EXCEL or PDF) , set report headers , set the report footers and finally get the report. We have defined two custom builders one for 'PDF' (ReportPDF) and other for 'EXCEL' (ReportExcel). These two custom builders define there own process according to the report type.

Figure 16. Builder classes in actual code

Now let's understand how director will work. Class 'clsDirector' takes the builder and calls the individual method process in a sequential manner. So director is like a driver who takes all the individual processes and calls them in sequential manner to generate the final product, which is the report in this case. Figure 'Director in action' shows how the method 'MakeReport' calls the individual process to generate the report product by PDF or EXCEL.

Figure 17. Director in action

The third component in the builder is the product which is nothing but the report class in this case.

Figure 18. The report class

Now let's take a top view of the builder project. Figure 'Client,builder,director and product' shows how they work to achieve the builder pattern. Client creates the object of the director class and passes the appropriate builder to initialize the product. Depending on the builder the product is initialized/created and finally sent to the client.

Figure 19. Client, builder, director and product

The output is something like this. We can see two report types displayed with their headers according to the builder.

Figure 20. Final output of builder

Can you explain prototype pattern ?

Prototype pattern falls in the section of creational pattern. It gives us a way to create new objects from the existing instance of the object. In one sentence we clone the existing object with its data. By cloning any changes to the cloned object does not affect the original object value. If you are thinking by just setting objects we can get a clone then you have mistaken it. By setting one object to other object we set the reference of object BYREF. So changing the new object also changed the original object. To understand the BYREF fundamental more clearly consider the figure 'BYREF' below. Following is the sequence of the below code:

In the first step we have created the first object i.e. obj1 from class1.

In the second step we have created the second object i.e. obj2 from class1.

In the third step we set the values of the old object i.e. obj1 to 'old value'.

In the fourth step we set the obj1 to obj2.

In the fifth step we change the obj2 value.

Now we display both the values and we have found that both the objects have the new value.

Figure 21. BYREf

The conclusion of the above example is that objects when set to other objects are set BYREF. So changing new object values also changes the old object value.

There are many instances when we want the new copy object changes should not affect the old object. The answer to this is prototype patterns.

Lets look how we can achieve the same using C#. In the below figure 'Prototype in action' we have the customer class 'ClsCustomer' which needs to be cloned. This can be achieved in C# my using the 'MemberWiseClone' method. In JAVA we have the 'Clone' method to achieve the same. In the same code we have also shown the client code. We have created two objects of the customer class 'obj1' and 'obj2'. Any changes to 'obj2' will not affect 'obj1' as it's a complete cloned copy.

Figure 22. Prototype in action

Note : You can get the above sample in the CD in 'Prototype' folder. In C# we use the 'MemberWiseClone' function while in JAVA we have the 'Clone' function to achieve the same.

(A) Can you explain shallow copy and deep copy in prototype patterns ?

There are two types of cloning for prototype patterns. One is the shallow cloning which you have just read in the first question. In shallow copy only that object is cloned, any objects containing in that object is not cloned. For instance consider the figure 'Deep cloning in action' we have a customer class and we have an address class aggregated inside the customer class. 'MemberWiseClone' will only clone the customer class 'ClsCustomer' but not the 'ClsAddress' class. So we added the 'MemberWiseClone' function in the address class also. Now when we call the 'getClone' function we call the parent cloning function and also the child cloning function, which leads to cloning of the complete object. When the parent objects are cloned with their containing objects it's called as deep cloning and when only the parent is clones its termed as shallow cloning.

Figure 23. Deep cloning in action

(B) Can you explain singleton pattern ?

There are situations in a project where we want only one instance of the object to be created and shared between the clients. No client can create an instance of the object from outside. There is only one instance of the class which is shared across the clients. Below are the steps to make a singleton pattern :-

Define the constructor as private.

Define the instances and methods as static.

composition and aggregation

2010-02-04T03:12:00.000-08:00

Introduction:

Apart from programming, a lot of my spare time sat at the computer is spent reading group, blog postings, etc from other developers. One particular posting that caught my eye recently provoked a lot of response and mixed answers to a question posed by a poster. This question was, 'What is the difference between composition and aggregation and how would I express it in my programs'?

Reading the responses to the post, I had a mixed reaction, many of the responses reflected my understanding of the difference, others turned my understanding right around and explained composition as my understanding of aggregation.

This short article will put forward my understanding of composition and aggregation and how I would express it in C# code.

Composition:

As we know, inheritance gives us an 'is-a' relationship. To make the understanding of composition easier, we can say that composition gives us a 'part-of' relationship. Composition is shown on a UML diagram as a filled diamond (see Figure 1).

If we were going to model a car, it would make sense to say that an engine is part-of a car. Within composition, the lifetime of the part (Engine) is managed by the whole (Car), in other words, when Car is destroyed, Engine is destroyed along with it. So how do we express this in C#?

public class Engine
{
. . .
}

public class Car

{

Engine e = new Engine();

.......

}

As you can see in the example code above, Car manages the lifetime of Engine.

Aggregation:

If inheritance gives us 'is-a' and composition gives us 'part-of', we could argue that aggregation gives us a 'has-a' relationship. Within aggregation, the lifetime of the part is not managed by the whole. To make this clearer, we need an example. For the past 12+ months I have been involved with the implementation of a CRM system, so I am going to use part of this as an example.

The CRM system has a database of customers and a separate database that holds all addresses within a geographic area. Aggregation would make sense in this situation, as a Customer 'has-a' Address. It wouldn't make sense to say that an Address is 'part-of' the Customer, because it isn't. Consider it this way, if the customer ceases to exist, does the address? I would argue that it does not cease to exist. Aggregation is shown on a UML diagram as an unfilled diamond (see Figure 2).

So how do we express the concept of aggregation in C#? Well, it's a little different to composition. Consider the following code:

public class Address
{
. . .
}

public class Person

{

private Address address;

public Person(Address address)

{

this.address = address;

}

. . .

}

Person would then be used as follows:

Address address = new Address();
Person person = new Person(address);

Person person = new Person( new Address() );

As you can see, Person does not manage the lifetime of Address. If Person is destroyed, the Address still exists. This scenario does map quite nicely to the real world.

Conclusion:

As I said at the beginning of the article, this is my take on composition and aggregation. Making the decision on whether to use composition or aggregation should not be a tricky. When object modelling, it should be a matter of saying is this 'part-of' or does it 'have-a'?

Visual Studio 2005 Installation Problems

2010-01-20T12:09:00.000-08:00

The installer has encountered an unexpected error installing this package. This may indicate a problem with this package. The error code is 2908

OK, I just ended up having to burn one of my MSDN incidents :( because I could not get Visual Studio 2005 to install correctly, so I figured I'd blog the solution so someone else could benefit from it.

The Error

The error message I got simply said that Document Explorer 2005 failed to install. Tracing the event log I got the following:

Product: Microsoft Document Explorer 2005 -- The installer has encountered an unexpected error installing this package. This may indicate a problem with this package. The error code is 2908. The arguments are: {FAA7C2AC-4205-4228-BEB6-6E647CCA9FD2}, ,

followed by:

Product: Microsoft Document Explorer 2005 -- Error 1935.An error occurred during the installation of assembly 'Microsoft.MSXML,Version="8.0.0.0",PublicKeyToken="b03f5f7f11d50a3a",Culture="neutral",FileVersion="8.0.50727.42",ProcessorArchitecture="MSIL"'. Please refer to Help and Support for more information. HRESULT: 0x80131700. assembly interface: , function: CreateAssemblyNameObject, component: {B1BE189C-054D-4195-9C26-49D28C20DE94}

The Solution

The problem was solved by following these steps:

Uninstall .NET 2.0.

Click "Start". The Windows Start Menu pops up.
Click "Control Panel". The Control Panel windows opens.
Double Click "Add/Remove Programs". The Add/Remove Programs window opens and after some period of scanning for applications, presents you with a list of installed applications.
Select the ".NET Framework 2.0" application and select to remove it.

Delete temp files.

Click "Start". The Windows Start Menu pops up.
Click "Run". The Run command window opens.
Enter "%temp%" and click OK. This will open your Temp folder.
Press Ctrl+A. This will select all the files in the folder.
Press Shift+Del to delete all files listed that are not locked. The delete process may abort on error several times stating that a particular file could not be deleted. Simply unselect that given file by holding down the Ctrl key and clicking the file and continue the deletion. In my case there were 2 files that could not be deleted in the end.

Add registry key.

Click "Start". The Windows Start Menu pops up.
Click "Run". The Run command window opens.
Enter "regedit" and click OK. This will open RegEdit.
Navigate down to HKLM\Software\Policies\Microsoft\Windows\Installer.
Right click in the right hand pane. A popup menu with one option, "New" appears.
Click "New". A new popup menu with several options appears.
Click "String Value".
Change the "New Value #1" text to "Logging".
Double click the "Logging" entry. The value edit window opens.
Change the value of the key to "VoiceWarmup" & click OK.
Close RegEdit.

Install the .NET Framework 2.0.

Open Windows Explorer.
Navigate to "D:\wcu\dotNetFramework".
Double click "dotnetfx.exe" to install the framework.

Install the Microsoft Document Explorer 2005.

In Windows Explorer, navigate to "D:\wcu\DExplore".
Double click "DExplore.exe" to install the Document Explorer.

Install Visual Studio 2005 as per normal from here.

That worked for me... hopefully, it will work for you too! :)

Fruit juices - adding colour and health to your life

2010-01-05T02:03:00.000-08:00

Fruit juices - adding colour and health to your life

Easy to prepare, a good friend of your taste buds, a hit all through the year and good for your health – that’s a glass of fresh juice, which can also add glow and energy to your life. Fresh juice is healthy and we all know that drinking the real thing is better than the sugary alternatives that are packed months before they reach the consumers. Fresh juices benefit us in the following ways:

* They provide minerals, vitamins, essential fatty acids, carbohydrates and proteins
* Help improve energy levels
* Good for the skin
* Strengthen the immune system
* Make the bones stronger

Despite all the benefits that fruit juices offer, there are certain things we need to know about fresh juice.

Is it OK to drink as much juice as we want daily?

No, water should be the main source of liquid and it is always better to have fruits in their natural form rather than as juice. Why? Because we all add sugar and salt to the fruit juice we make at home. This increases the amount of sugar in our diet and thus, the calorie load. But we don’t really perceive drinks to be food. Eating a whole pomegranate or having three or four oranges in a row is a cumbersome job. But we would gallop a big glass of juice in a few seconds and even forget to count them as calories. So, if you take two servings of fruit in a juice, ideally you should forego your evening snacks.

Should we drink juice daily?

Drinking juice is an easy way to have two fruit servings per day that is good for the daily quota of vitamins. But, keep a check on the sugar added to the juice. It’s best to have fresh juice without any sugar or salt. Though such juice might taste a bit bland and sometimes sour as in the case of orange juice, you would gradually develop a taste for them. The best choice for a daily habit of juice is carrot, apple and ginger, made with only one piece of fruit. Carrots are sweet but lower in calories and have about half the carbohydrates of fruits. Celery is also a nice low-calorie filler. Have a look at the amount of carbohydrates different fruits have.

* Orange –16 g
* Grapes – 28 g
* Pomegranates – 26 g
* Pineapple – 19 g
* Apple – 21 g

How to use the juicer?

Now the next thing is how to use the juicer at home to get the best juice. The foremost thing is to get a good quality juicer, preferably ISI marked. If you want the fibre benefits, then put all the vegetables and fruits into a blender and don’t use a juice extractor. While ordering fresh juice from outside, be sure about the hygiene and ensure that they are using a blender, not an extractor. Extractors make a smooth drink but they remove the all-important fibre from the juice.

Are juices good for children?

Replacing water with juice for children can cause diarrhoea. Having juice everyday can help to develop lifetime sweet tendencies in children. So, juices should be an occasional drink for children. Eating fruit in its natural form and relying on water, as the source of liquid, are better alternatives. Nevertheless, fruit juice is better than having aerated drinks.

Tips on getting best out of your juices

* Always wash fruit and vegetables – even organic produce could carry bacteria.
* Include the stems and leaves of vegetables because they have a high vitamin and mineral content.
* Drink a juice within half an hour of preparing it, or it can get oxidised by exposure to air and develop a sour taste.
* If you must prepare juice early, keep it refrigerated with a tight lid. Or freeze in daily-serving-size containers immediately and drink it straight after thawing.
* Include the white inner skin of citrus fruits, as it is full of beneficial bioflavonoids.
* Add lemon juice to preserve the natural colour and reduce the oxidation of essential nutrients.
* If you want to lose weight, then drink vegetable juices, as they contain fewer calories than fruit juice.
* If you have a sensitive stomach or irritable bowel syndrome (IBS), ensure that you dilute juices with water (three parts of juice with one part of water).

Easy to make juice-based drinks

Watermelon drink

Ingredients - 3 cups watermelon (washed and cut into small pieces), sugar (as per taste), 3 tablespoon skimmed milk, ice cubes.

Method - Blend the ingredients in a blender and refrigerate. Pour the prepared drink into serving glass, add ice cubes and serve.

Nutritive value of the watermelon juice - Apart from providing energy, watermelon protects against age-related symptoms of vision loss, fights heart disease, reduces cancer risk and is loaded with anti-oxidants. So, a glass of watermelon drink everyday not only quenches your thirst but also offers a range of health benefits.

Carrot, celery and cabbage juice

Ingredients - 2 cucumbers, stalks of celery, a piece of ginger, a handful of parsley, piece of apple or citrus fruit.

Method - Wash all vegetables and juice them together. Serve it fresh.

A glass of fruit or vegetable juice takes very little digestion. It goes right into your body and is a very yummy way of getting instant energy. Fruit juices can energise your life.
( Wednesday , 16 September 2009)

Field Name		Data Type
`CustomerID`		`int, auto counter, primary key`
`Name`		`string`
`Address`		`string`
`Phone`		`string`

Field Name		Data Type
`OrderID`		`int, auto counter, primary key`
`CustomerID`		`int, foreign key`
`OrderDate`		`DateTime`
`ShipDate`		`DateTime`

Class		Description
`DataSet`		A set of database tables that can be filled from a database and used as a disconnected database
`DataTable`		A collection data rows and the columns that define their structure
`DataRow`		A database Record
`DataView`		A view of the data. Can be filtered for search criteria and sorted
`DataRowView`		A single row from a DataView
`DataRelation`		A parent-child relationship between tables

Field Name		Data Type
`CustID`		`int, auto increment, primary key`
`Name`		`string`
`Phone`		`string`
`Email`		`string`

Class	Description
`OleDbConnection`	The physical database connection
`OleDbCommand`	A command to execute on the database
`OleDbDataAdapter`	Moves data between the DataSet and the physical Database using a connection and a command
`OleDbDataReader`	Can iterate results returned from a command

Class		Description
`SqlConnection`		The physical database connection
`SqlDataCommand`		A command to execute on the database
`SqlDataAdapter`		Moves data between the DataSet and the physical Database using a connection and a command
`SqlDataReader`		Can iterate results returned from a command

Everything in a single blog

upcasting and downcasting

ICSE CBSE comparision : ICSE vs CBSE after 8th Standard and 10th standard

Powerful Leg & Knee Strengthening Exercises Using Your Body Weight

Knee Circles - Strengthen Your Knees & Ankles

C Sharp Window Forms

CSharp and Working with Data

Working with Data

Databases

Table 15.1 - Definition of the Customer Table

Table 15.2 - Definition of the Order Table

The Northwind Trader Database

Figure 15.1

Introduction to SQL

The INSERT Statement

The SELECT Statement

The ADO.NET Classes

Table 15.3 – Classes of ADO.NET

Roll Your Own Database

Listing 15.1

Table 15.4 – The Customers Table

Defining the Table Structure

Reading Rows of Data

Adding Rows of Data

Storing the Data as XML

Filtering the Data with the DataView

Table 15.5 – OLEDB Database Classes

Connecting to Access using OLE DB

Connecting to a SQL Server Database

Table 15.6 – SQL Server Database Classes

Listing 15.3

Data Binding

Figure 15.2

Figure 15.3

Figure 15.4

Using the DataGridView

Figure 15.5

Figure 15.6

Figure 15.7

Figure 15.8

C# – Static Members

Related Articles :

C# Encapsulation

Related Articles :

C# Interface Implementation

Related Articles :

Is Object Class, the root of all hierarchies?

Related Articles :

C# Class Inheritance

author : Martin Raphael.K// email : mrkraj@officetiger.com// Date : November 02, 2001

Related Articles :

Explaining C# Abstraction, Inheritence and Polymorphism

Objects & Classes in C#

Related Articles :

C# Tutorial For Beginners

First tutorial

Second tutorial

Third tutorial

Fourth tutorial

And now..

Most Commented Articles :

TCS Interviews

HR Interview Questions For Freshers

Human Resource Interview Tips

Design Pattern

Prototype pattern

Prototype

Design Pattern

composition and aggregation

Visual Studio 2005 Installation Problems

The installer has encountered an unexpected error installing this package. This may indicate a problem with this package. The error code is 2908

Fruit juices - adding colour and health to your life

The `INSERT` Statement

The `SELECT` Statement

Using the `DataGridView`

author : Martin Raphael.K
// email : mrkraj@officetiger.com
// Date : November 02, 2001