Happy New year 2010

Hay All Of my Friends Thanks For Wish me and This is Gift For You...

HAPPY NEW YEAR 2@1@

Thank You
[ About My Details ]

What Is an Object?

An object is merely a collection of related information and functionality. An object can be something that has a corresponding real-world manifestation (such as an employee object), something that has some virtual meaning (such as a window on the screen), or just some convenient abstraction within a program (a list of work to be done, for example).

An object is composed of the data that describes the object and the operations that can be performed on the object. Information stored in an employee object, for example, might be various identification information (name, address), work information (job title, salary), and so on. The operations performed might include creating an employee paycheck or promoting an employee. When creating an object-oriented design, the first step is to determine what the objects are. When dealing with real-life objects, this is often straightforward, but when dealing with the virtual world, the boundaries become less clear. That’s where the art of good design shows up, and it’s why good architects are in such demand.

Note that an object is just a special kind of data. An object has properties and methods.

Robust and Durable Software

Garbage collection takes the burden of memory management away from the programmer,[1] and the problems of writing versionable components are eased by definable versioning semantics and the ability to separate the interface from the implementation. Numerical operations can be checked to ensure that they don’t overflow, and arrays support bounds checking. C# also provides an environment that is simple, safe, and straightforward. Error handling is not an
afterthought, with exception handling being present throughout the environment. The language is type-safe, and it protects against the use of variables that have not been initialized, unsafe casts, and other common programming errors.

C# Design Goals

When the C++ language first came out, it caused quite a stir. Here was a language for creating object-oriented software that didn’t require C programmers to abandon their skills or their investment in software. It wasn’t fully object-oriented in the way a language like Eiffel is, but it had enough object-oriented features to offer great benefits.

C# provides a similar opportunity. In cooperation with the .NET Common Language Runtime, it provides a language to use for component-oriented soft- ware, without forcing programmers to abandon their investment in C, C++, or COM code.

C# is designed for building robust and durable components to handle real- world situations.

Gift

This is gift For U

My Profile

Engr. Md. Siddiq Bin Nur

Telephone
_________



[E m a i l]
_________


Research Interest
Software Engineering, Computer Networks, Bioinformatics, Robotics, Data Mining, Cluster Computing, Wireless LAN

Academic Background

BUET



Selected Publicationshttp://siddiqbinnur.blogspot.com/2009/12/my-profile.html
Please let me know if I can help you in any other way

Constructors Question and Answer

█. Is the constructor mandatory for a class?

► Yes, it is mandatory to have the constructor in the class and that too should be accessible for the object i.e., it should have a proper access modifier. Say, for example, we have only private constructor(s) in the class and if we are interested in instantiating the class, i.e., want to create an object of the class, then having only private constructor will not be sufficient and in fact it will raise an error. So, proper access modifies should be provided to the constructors.

█. What if I do not write the constructor?

► In such case, the compiler will try to supply the no parameter constructor for your class, behind the scene. Compiler will attempt this only if you do not write the constructor for the class. If you provide any constructor (with or without parameters), then compiler will not make any such attempt.

█. What if I have the constructor public myDerivedClass(), but not the public myBaseClass()?

► It will raise an error. If either the no parameter constructor is absent or it is in-accessible (say it is private), it will raise an error. You will have to take the precaution here.

█. Can we access static members from the non-static (normal) constructors?

► Yes, we can. There is no such restriction on non-static constructors. But there is one on static constructors that it can access only static members.

Thanks

Intro to Constructors in C#

Broadly speaking, it is a method in the class which gets executed when its object is created. Usually we put the initialization code in the constructor. Writing a constructor in the class is damn simple, have a look at the following sample :

public class mySampleClass
{
public mySampleClass()
{
// This is the constructor method.
}
// rest of the class members goes here.
}

When the object of this class is instantiated this constructor will be executed. Something like this :
mySampleClass obj = new mySampleClass()
// At this time the code in the constructor will // be executed


Constructor Overloading :

C# supports overloading of constructors, that means we can have constructors with different set of parameters. So our class can be like this :

public class mySampleClass
{
public mySampleClass()
{
// This is the no parameter constructor method.
// First Constructor
}

public mySampleClass(int Age)
{
// This is the constructor with one parameter.
// Second Constructor

}

public mySampleClass(int Age, string Name)
{
// This is the constructor with two parameters.
// Third Constructor
}

// rest of the class members goes here.
}

Well, note here that call to the constructor now depends on the way you instantiate the object. For example :
mySampleClass obj = new mySampleClass()
// At this time the code of no parameter
// constructor (First Constructor)will be executed

mySampleClass obj = new mySampleClass(12)
// At this time the code of one parameter
// constructor(Second Constructor)will be
// executed.

The call to the constructors is completely governed by the rules of the overloading here.

Calling Constructor from another Constructor:

You can always make the call to one constructor from within the other. Say for example :

public class mySampleClass
{
public mySampleClass(): this(10)
{
// This is the no parameter constructor method.
// First Constructor
}

public mySampleClass(int Age)
{
// This is the constructor with one parameter.
// Second Constructor
}
}

Very first of all let us see what is this syntax :
public mySampleClass(): this(10)

Here this refers to same class, so when we say this(10), we actually mean execute the public mySampleClass(int Age) method. The above way of calling the method is called initializer. We can have at the most one initializer in this way in the method.

Another thing which we must know is the execution sequence i.e., which method will be executed when. Here if I instantiate the object as


mySampleClass obj = new mySampleClass()


Then the code of public mySampleClass(int Age) will be executed before the code of mySampleClass(). So practically the definition of the method :

public mySampleClass(): this(10)
{
// This is the no parameter constructor method.
// First Constructor
}

is equivalent to
public mySampleClass()
{
mySampleClass(10)
// This is the no parameter constructor method.
// First Constructor
}

Note that only this and base (we will see it further) keywords are allowed in initializers, other method calls will raise the error.

This is sometimes called Constructor chaining.

Huff… Simple thing made tough, but this is how it is. Anyway, let us proceed further.

Behavior of Constructors in Inheritance :

Let us first create the inherited class.

public class myBaseClass
{
public myBaseClass()
{
// Code for First Base class Constructor
}

public myBaseClass(int Age)
{
// Code for Second Base class Constructor
}

// Other class members goes here

}

public class myDerivedClass : myBaseClass
// Note that I am inheriting the class here.
{
public myDerivedClass()
{
// Code for the First myDerivedClass Constructor.
}

public myDerivedClass(int Age):base(Age)
{
// Code for the Second myDerivedClass Constructor.
}

// Other class members goes here
}

Now what will be the execution sequence here :
If I create the object of the Derived class as
myDerivedClass obj = new myDerivedClass()

Then the sequence of execution will be
1. public myBaseClass() method.
2. and then public myDerivedClass() method.

Note: If we do not provide initializer referring to the base class constructor then it executes the no parameter constructor of the base class.

Note one thing here : We are not making any explicit call to the constructor of base class neither by initializer nor by the base() keyword, but it is still executing. This is the normal behavior of the constructor.

If I create the object of the Derived class as
myDerivedClass obj = new myDerivedClass(15)

Then the sequence of execution will be
1. public myBaseClass(int Age) method.
2. and then public myDerivedClass(int Age) method.

Here the new keyword base has come into picture. This refers to the base class of the current class. So, here it refers to the myBaseClass. And base(10) refers to the call to myBaseClass(int Age) method.

Also note the usage of Age variable in the syntax : public myDerivedClass(int Age):base(Age). [ Understanding it is left to the reader. ]

Phew… lost… Anything left in constructors. Yes, Static Constructors. Ha!! Now what are they ? Let us see..

Static Constructors :
This is a new concept introduced in C#. By new here I mean that it was not available for the C++ developers. This is a special constructor and gets called before the first object is created of the class. The time of execution cannot be determined, but it is definitely before the first object creation - could be at the time of loading the assembly.

The syntax of writing the static constructors is also damn simple. Here it is :
public class myClass
{
static myClass()
{
// Initialization code goes here.
// Can only access static members here.
}
// Other class methods goes here
}

Notes for Static Constructors :
1. There can be only one static constructor in the class.
2. The static constructor should be without parameters.
3. It can only access the static members of the class.
4. There should be no access modifier in static constructor definition.

Ok fine, all the above points are fine but why is it like that? Let us go step by step here.

Firstly, the call to the static method is made by the CLR and not by the object, so we do not need to have the access modifier to it.

Secondly, it is going to be called by CLR, who can pass the parameters to it, if required, No one, so we cannot have parameterized static constructor.

Thirdly, Non-static members in the class are specific to the object instance so static constructor, if allowed to work on non-static members, will reflect the changes in all the object instances, which is impractical. So static constructor can access only static members of the class.

Fourthly, Overloading needs the two methods to be different in terms to methods definition, which you cannot do with Static Constructors, so you can have at the most one static constructor in the class.


Now, one question raises here, can we have the two constructors as


public class myClass
{
static myClass()
{
// Initialization code goes here.
// Can only access static members here.
}
public myClass()
{
// Code for the First myDerivedClass Constructor.
}

// Other class methods goes here
}

This is perfectly valid, though doesn’t seem to be in accordance with overloading concepts. But why? Because the time of execution of the two method are different. One is at the time of loading the assembly and one is at the time of object creation.


FAQs Regd. Constructors :
1. Is the Constructor mandatory for the class ?
Yes, It is mandatory to have the constructor in the class and that too should be accessible for the object i.e., it should have a proper access modifier. Say for example we have the private constructor in the class then it is of no use as it cannot be accessed by the object, so practically it is no available for the object. In such conditions it will raise an error.

2. What if I do not write the constructor ?
In such case the compiler will try to supply the no parameter constructor for your class behind the scene. Compiler will attempt this only if you do not write the constructor for the class. If you provide any constructor ( with or without parameters ), then compiler will not make any such attempt.

3. What if I have the constructor public myDerivedClass() but not the public myBaseClass() ?
It will raise an error. If either the no parameter constructor is absent or it is in-accessible ( say it is private ), it will raise an error. You will have to take the precaution here.

4. Can we access static members from the non-static ( normal ) constructors ?
Yes, We can. There is no such restriction on non-static constructors. But there is one on static constructors that it can access only static members.

Classes and Objects

Classes and Objects

In VB.NET, a class is that chunk of code mentioned earlier. You've been using Classes all the time during this course. The Form you've started out with is a Class. If you look right at the top of the code window for a Form, you'll see:

Public Class Form1

The word "Public" means that other code can see it. Form1 is the name of the Class

If you look at the bottom of the coding window, you'll see End Class, signifying the end of the code for the Class.

When you place a Button or a textbox on the Form, you're really adding it to the Form Class.

When you start the Form, VB does something called instantiation. This basically means that your Form is being turned into an Object, and all the things needed for the creation of the Form are being set up for you (Your controls are being added, variables are being set up an initialised, etc).

And that's the basic difference between a Class and an Object: A Class is the code itself; the code becomes an Object when you start using it.

Note that an object is just a special kind of data. An object has properties and methods.