C#.Net Tutorials

Multi Document Interface

2014-02-25T23:48:00.002+05:30

Multi Document interfaceu

While designing an application with multiple forms init, we are setting the startup form under the program class, but as we don’t provide source code to client, When we develop a application, he doesn’t have chance to edit the class program and specify his startup Form. In that case we use Mdi Approach.

- In this approach we will be having only one form as a startup form, so client doesn’t required to change it each time. Rest of the form in application will be under the control of Main Form or start up Form.

- Here we will be having two parts:

- MDI Parent

- MDI Child

- The form which is going to be the startup form is MDI parent and to make it as Mdi parent we need to set the IsMdiProperty of form as true.

Note – An application can have only one MdiParent, all the other forms should be child of parent, which comes and sits under parent;

Eg. Visual Studio is an MdiParent which launches all the remaining form under it as Childs.

- To launch a form as child of parent, create object of form class we want to launch, set its MdiParent property with parent forms reference and then call show method.

Layout: -

When we have more than one child form to be launched under parent the way how child form gets arranged in parent can be set with a layout, which has 4 options like:

Cascade (D): - child forms are arranged one on the top of the other

ii. Tile Vertical: - child forms are arranged one beside the other

iii. Tile Horizontal: - child forms are arranged one blow the other

iv. ArrangeIcons: - all child icone are arranged with in the parent.

Way to define a project with one MdiParent and its child: -

- Take a new form on the project and sets its IsMdiContainer property as true, so that it becomes as MdiParent and also set the windowstate property as maximize, so that the form gets launched to the full size of the screen.

- Place a menu strip control on a form and add two menus on it.

1. Forms,

2. Arrange

- Under Form menu add separator menu item for each form we want to launch

E.g. Form1, Form2, Form3 etc.

- Under Arrange menu add the menu items – ArrangeIcons, Cascade, vertical and Horizontal.

- Now write the following code:

Under Each Forms Menu Item:

Form1 f = new Form1();

f.MdiParent = this;

f.Show();

Under arrange icons menu Strip:

this.LayoutMdi(MdiLayout.ArrangeIcons);

Under Cascade menu Strip:

this.LayoutMdi(MdiLayout.Casecade);

Under Vertical menu Strip:

this.LayoutMdi(MdiLayout.TileVertical);

Under Horizontal menu Strip:

this.LayoutMdi(MdiLayout.TileHorizontal);

User Control

User Control These are controls that are created or developed by the programmers. To consume under your application there are of two types –

Creating a new control from existing controls.
Inherited or Extended Controls.

- In the first case, we create new controls making use of existing controls, so to design the control first we need to define a class inheriting from the predefined class i.e. user control, which provide the container required for designing.

** Image con not be displayed

Syntax

public class StopClock : UserControl

{

// Design the control

// write behavior for the control

}

- In the second case without designing any control we only copy the design of an existing control and add functionalities or behavior to the control.

In this case, we define a class inheriting from the control class and we have to add new behavior.

public class NumericTextBox : TextBox

{

// write the code for accepting only numeric’s

}

Note – To create a control in the first process we need to add an item template of the type user control, which provide a class inheriting from UserControl class.

Where as in the second case we need to add a item template of type class and than

Inherit from the control class we want to extend.

Developing a Control

- People working on controls or classified into two Categories:

1. Component Developer

2. Component Consumer

- The person who develops a control is a component developer and who consume the controls is a component consumer.

While developing component the developer of the control should define all the behavior required for the control and also defined any required properties, methods and event to the control.

- Properties are defined to provide access for any value of the control to consumers.

Eg: Text property for of TextBox, Checked property of CheckBox etc.

- Method is defined so that the controls can perform actions whenever required.

Eg: Clear(), Focus(), Methods of textbox

Close() method of Form etc.

- Events

While developing a control the developer of the control may not know what action has to be performed at the specific time period.

Eg: the developer of the control is not aware what should happen when button is clicked, what happen when button is clicked will be decided by component consumer even if decided by consumer, it is the responsibility of developer to execute the code written by consumer even if these two persons never come together to work.

To resolve the above problem developer must first define an event under their controls and then asked the consumer to write code under an event procedure which should be bound with the event, So whenever the event occur, event procedure gets executed.

Define an event:

[ < modifier >] event < delegate > <name>

As we know that events takes the help of delegates to execute an event procedure, so while defining an events we must also specified which delegate will execute the event.

So first we need to define a delegate and then the event

public delegate void EventHandler(object sender EventArgs e);

public event EventHandler click;

- All delegates that are predefined in BCL are defined with two parameters:

1. Object sender

2. EventArgs e

- That is the reason why all our event procedure are also taking the same two parameters ( we are already aware that I/O parameter of delegate should be same ass the I/O prams of method it has to call)

Note à While defining our own event to our controls we can define delegates with or without parameters so that the event procedure that are generated will also come with or without parameters respectively.

Create a StopClock control:

à Open a new project of type windows Forms Control library and name it as controls project.

à By default the project comes with a class userControl1 that is inherited from user control

à Open the Solution explorer and rename the file UserControl1.cs as StopClock.cs and design it as following.

Now goto the properties of Mask TextBox à select Mask property à click on the button beside it à select time à click ok à and also set text as “0000”

Place a timer control and set its interval property as 1000

** Image Can not be displayed..

Now write the following code in code view

** Code Can not be displayed..

Now open the solution explorer à right click on the project à select built, which compile the project and generated an assembly controlsProject.dll

Consuming the Controls è To consume the controls à goto our old project à open the toolbox à right click on it à and select add tab, which adds a new tab à enter the name as csharp4 controls.

Now right click on the new tab and select choose items, which opens a dialog box à click on the browser button and select controlsProject.dll from its physical location.

c:\csharp4\controlsProject\Bin\Debug\controlsProject.dll

After selecting the assembly à click on the OK button, which adds StopClock control under the new tab we have added, which can be place on any Form and consume it.

PictureBox Control & Timer

2014-02-25T23:35:00.001+05:30

ComboBox

Goto properties of ComboBox: - Select items property used under it and enter the list of countries

SelectedIndexChanged – It is the default event of all the above three controls, which gets raised immediately once a value is selected.

PictureBox Control: - It is used for displaying images in an application.

To display an image, the image has to be bound with the control using any of these properties:

PictureBox

ImageLocation = < Path of the image>
Image = Image.FromFile (< Path of the image >)
Image = Image.FromStream ( stream stream)

Step1 – By default pictureBox control doesn’t have any border. If we want to give a border to the control, we need to set the BorderStyle Property either as a fixed single or fixed 3D.

Step2 – By default the image is bigger than the pictureBox so it will not display the complete image. To place or handle the image placement under the control we use the size mode property, which can be set with values like- Starched image, outsize and center image, default is normal.

Timer: -

This control is used for execution of code for specified interval regularly i.e. once the specified frequency gets allows.

Timer provided Four members init that are-

Interval Property: - Used for specifying the frequency for execution of the code, which should be given in millisecond.
Tick Event: - The code which should be executed by the timer should be written under his event
Start : - It’s a method which starts the execution of timer.
Stop : - It’s a method which stops the execution of timer.

ComboBox, ListBox and CheckListBox

2014-02-25T23:29:00.005+05:30

** Image con not be displayed

-Goto property of fees Text box and change its name as TxtFees and set readonly property as true, so that it becomes non editable and also set Text as zero(0).

- For every CheckBox and radio button provide a tag value, which should be the fees amount corresponding to course. Now for normal radio button use tag as zero.

Note – Tag property is also similar to text property, whereas, Tag is not visible to the end user, but both text and tag can be accessed in code by a programmer using text and tag properties.

- Now define a checked change event procedure for one CheckBox and bind this event procedure with all the other checkboxes.

- In the same way do it for radio button control also.

- Now write the following code under code view:

** Text con not be displayed

ComboBox, ListBox and CheckListBox: - we are using this control also for users to select from a list of available values.

ComboBox

it is allowing only single selection, but also allow the user to enter a new value in Run time.

ListBox

It is by default allows single selection but can be customized into multi selection.

CheckListBox

Is always by-default allows multi selection.

Adding values to the control: -

If we want to add values to the control, we have various mechanisms:

Under the properties of the control  select items property and click on the button beside it, which opens a window and under it enter your required values.
Using Items.Add method a value can be added to the control at any time.

< Control >. Items.Add ( object values )
Using the Items.AddRange method of thee control, an array of values can be at a time bound to them.

Eg:

< control > . Items.AddRange ( object [] values )
. Using the data source property of the control, a data table can be bounded to the control, but again using display member property, we need to specify which column of the table has to be display.

Eg:

< Control > .DataSource = < data table >

<control > DisplayMember = < Col name >

Multiple selection under ListBox

As discussed earlier a ListBox control allows only single selection, If we want to go for multi selection, we need to set the selection mode property of the control either as MultiSimple (only mouse click) or MultiExtended (ctrl + Mouse click).

Identify selected values from the controls: -

ComboBox:

- Text	String
- SelectedItem	object
SelectedIndex	int

ListBox

- SelectedItem	object
- SelectedItems	object []
-SelectedIndex	int
- SelectedIndices	int []

CheckListBox

- CheckedItems	object []
- CheckedIndices	int []

Radio Button and CheckBox

2014-02-25T23:23:00.003+05:30

Radio Button and CheckBox

Radio Button and CheckBox: - These two controls are used when we want, the user select the values from a list of avilabel values.

Radio Button allows single selection and CheckBox allows multiple selections.

Note – Because radio button allows only single selection, when we want to use them under multiple questions, we require to group the radio buttons, that are used under the particular question.

To group them we need to place them on different container controls like- Panel and GroupBox etc.

- Both radio button and CheckBox controls has a property checked, to identify whether the control has been selected or not, which returns true if selected or else return false.

- Under Button1 click:

{

if (radioButton1.Checked)

MessageBox.Show("Radio Button 1 is Selected");

else if (radioButton2.Checked)

MessageBox.Show("Radio Button 2 is Selected");

else if (radioButton3.Checked)

MessageBox.Show("Radio Button 3 is Selected");

}

- Under Button2 click:

{

if (checkBox1.Checked)

MessageBox.Show("Check Box1 is selected");

if (checkBox2.Checked)

MessageBox.Show("Check Box2 is selected");

if (checkBox3.Checked)

MessageBox.Show("Check Box3 is selected");

}

Checked Change event: - It is the default event of both the above two controls, which gets raised when the control is selected as well as deselected also.

Creating Menu in Windows Application

2014-02-25T23:20:00.001+05:30

Creating Menu in Windows Application

- Not all events but some events have properties under them. If we want to access the propertied of an event, under its event procedure we can make use of the parameter e, which refers to properties of current executing event.

- In the above case, cancel is a property of validation event when set as true will not allow the focus to leave the control.

- If we want to close the Form even from mandatory field --> Goto properties of cancel button and set causes validation property as false, So that when we click on the button, the code under its click event gets executed before execution of textbox’s validation event.

- Now under the cancel button write the following code

{

txtUser.causesValidation = false;

txtPwd.causesValidation = false;

this.close();

}

- When we set the causes validation property of txtBox as false, validation event of txtBox will not occur, so the form gets closed.

- Now, under the login button write the following code:

if(txtUser.Text.Trim() == “Admin” && txtPwd.Text.Trim() == “Admin”)

MessageBox.Show(“Login successful”);

else

MessageBox.Show(“Login failed”);

- Now under reset button:

txtUser.Text = “”;

txtPwd.Clear();

txtUser.focus();

Creating Menu in Windows application

To create a menu  add menu strip control to form, which sets on top of it.

- To add a menu on menu strip  click on Left hand site corner of it, which opens a textbox to type here  Enter a name in it  which adds a menu, repeat the same process for adding multiple menus.

- To add a menu item, under a menu  click on the menu  which opens the text box blow assigning to type here  enter a name init, which adds a menu item, repeat the same process for adding multiple menu items.

Note – A menu and menu item are object of the class toolStripMenu item.

If we want menus to be responding for alt keys of key board, prefix with “&” before the character which should response for alt.

Eg: &File, &Edit, Format etc..

- To create a short cut for menu item so that it response to key board actions  Goto properties of menu item  Select short cut keys property  click on drop down beside it that displays a window. In it choose a modifier ctrl or alt or shift and then choose a key for ComboBox blow.

- TO group related menu item, under a menu we can add separators between menu item, to do it  Right click on menu item and select insert separator, which adds a separator on top of the menu item.

Note - same as we inserted separator, we can also insert a menu item if required in the middle.

- If we want to display an Image, beside a menu item  Right click on it and select the set image, Which opens a window  select local resource  and click on import button  which opens a DilogBlox , Using it select an image from your hard disk.

- Some times, we find check marks beside menu item to identify a property is on or off. Eg: Word Wrap under notepad. To create check mark beside a menu item --> right click on it and select checked.

Note – To check or uncheck the item in run time we need to write code explicitly under its click event as following

if ( < Control >.Checked == true)

< Control >.Checked = false;

else

< Control >.Checked = true;

Dialog Control

These are used for displaying a list of system values from which the users can select; we have five different dialog controls like:

ColorDialog, FolderBrowserDialog, FontDialog, OpenFileDialog and SaveFileDialog

- None of the dialog controls are visible on a form even after click in them. TO make them visible we need to call method ShowDialog explicitly, which is common for all the five controls.

- Dialog controls never perform any actions; they are only responsible for returning the values that has been chosen by the users. It was the programmer responsibility to capture those values and perform a necessary action.

To capture the values chosen use following properties

ColorDialog	Color
FolderBrowserDialog	Select Path
FontDialog	Font
OpenFileDialog	FileName
SaveFileDialog.	File name

New Login Form and Controls

2014-02-25T23:14:00.003+05:30

Setting tabs order of a form controls

While working with a windows application, we navigate between controls using tab key of key board. By default tab key navigate the focus b/w controls in the same order how to. If we want to set the sequence of tab on our own, it can be done by setting the tab order. To do this goto view menu and select tab order, which shows the current tab sequence. Now click on each control sequentially, in the way we want to move the tabs again goto view menu and select tab order

AcceptButton and CancelButton properties of Form:-

Form control has the above two properties, which allow us to map button on a form with Keyboard keys.

- AcceptButton property if set with a button that button gets clicked, whenever we press enter key of keyboard.

- CancelButton property is set with a button that button gets clicked, whenever we press ESC key of keyboard.

- Procedure to set these two properties --> open the property window of form and under accept button choose the button btnLogin and under CancelButton choose the button btnCancel.

- In the above form, perform the following validation.

Check username and password text box are mandatory field.
Password should be ranging b/w 5 – 10 character.
Allow the users to close the form even without entering any data.

- To do the above validation go to the form properties of password text box and set its max length property as 10, so that it will not allow more then 10 character.

- Now define a validation event procedure for user name text box and bind the event procedure as pwdTextBox also, and then write the following code under the event procedure.

TextBox tb = sender as TextBox;

if (tb.Text.Trim().Length == 0)

{

MessageBox.Show(“Can not Leave empty”);

e.Cancel = true;

return;

}

if (tb.Name == “txtPwd”)

{

if (tb.Text.Trim().Length < 5)

{

MessageBox.Show(“Pwd should be ranging between 5-10 char”);

e.Cancel = true;

}

- Validation event fires when the control is leaving its focus to validate the content of the control.

Designing a Form In VS

2014-02-25T23:11:00.000+05:30

Que. How does a Form gets created?

Ans. When a form is added to the project internally following things takes place :-

--> Creates a class inheriting from the predefined class Form, so that the new class is also a form

eg. public partial class Form1 :Form

--> Sets some initialization properties like name, text etc., under the method initialize component

Eg:

this.Name = “Form1”;

this.Text = “ Form1”;

Que. How does a control gets placed on the form?

Ans. When control is placed on a form following things take place:-

I. Create object of appropriate control class.

Button button1 = new Button();

TextBox textBox1 = new TextBox();

. Set some initialization properties that are required like – name, text, side, location etc.

Eg:

button.Name = “button1”;

button.Text = “button1”;

button1.Location = new Size(width,height);

Now the control get added to form by calling Controls. Add a method on current form:

Eg:

this.Controls.Add(button1);

Note - VS will generate all the above code, under the Method Initialized component.

- Under a windows application code is of two types:-

1. Designer code

2. Business logic

- Code, which is responsible for construction of the form, known as Designer code, & code, which is responsible for execution of the form, known as Business form.

- Designer code is generated by VS under the method InitializedComponent and Business logic is defined by programmers in the form of Event procedure.

- Before .net 2.0, Designer code and business logic were define in a class present under a file.

Before 2.0

Form1.cs :-

public class Form1 : Form

{

- Designer Code

- Business logic

}

- From .net 2.0 with introduction of partial classes designer code and business logic are separated into 2 different files but of the same class only.

From 2.0

Form1.cs:-

public partial class Form1 : Form

{

- Business Logic

}

Form1.Desiger.cs:

partial class form1

{

- Designer Code

}

Default Events

As we are aware every controls has events under it but one event will be its default. To write code under default event double click on the control which take to its mapping event procedure.

Control	Default Event
Form	Load
Button	Click
TextBox	TextChanged
Check Box and RadioButton	CheckedChanged
TreeView	AfterSelect
Timer	Tick
ListView, ListBox, ComboBox & CheckedListBox	SelectedIndexChanged

Controls :- different types of controls :

Button – It is used for taking acceptance from user to perform an action.
Label – it is used for displacing static text on the UI (user interface)
TextBox – It is used for taking text input from the user. This control can be used in Three different ways –

TextBox (single line input)

TextArea (Multiline input)

Password Field

- By default the control takes input in single line. If we want multiline input , change the multiline property as true. In multiline format we required scroll bass to navigate up and down as well as left and right but it doesn’t provide you scroll bars by default you. To gets scroll bars set the property scrollbar with any value like vertical or horizontal or both.

Note – By default the word-wrap property of control in true. So we not get horizontal scrollbar until we make it false.

- To make the control in password field – set the password Char property with star(*).

Placing Controls In a Windows Form

2014-02-25T23:03:00.002+05:30

Add a new form in a project:

- IF we want one more form in the project we can add it from the add new item window, choosing the item template Windows Form. Once a new form is added to run the form we need to specify the form class name, under Application.Run method with in the class program.

EG:

Application.Run(new Form2());

-Binding an event procedure with multiple events of a control under VS.

- In the new form asses --> goto properties of it and double click on load event, which defines an event procedure Form2_Load --> Now again Goto events of form select Click event and choose Form2_Load event procedure under it.

- Now write the following code under event procedure, which gets executed for both Load and Click events.

Eg:

MessageBox.Show(“Bound with multiple events of a control”)

- Now add a new form, Form3 in project.

Placing controls on a form:-

We have provided with number of controls for developing our application, where each control is define as a class.
These controls are avilabel under the tool box window arranged as groups (tabs).
To place a control of the form either choose your control and double click on it or select a control and place on the form so that the control is placed at that location.

Note – use the layout tool bar for aligning of the controls.

- In form Form3 under project place three buttons on it.

- Goto events of button one double click on click event, which defines button1_Click event procedure, bind the event procedure with click event of button2, button3 and Form also.

- Then tried the following code under button1_Click event procedure.

if (sender.GetType().Name == "Button")

{

Button b = (Button)sender;

if (b.Name=="button1")

MessageBox.Show("Button1 is clisked");

else if (b.Name=="button2")

MessageBox.Show("Button2 is clisked");

else if (b.Name=="button3")

MessageBox.Show("Button3 is clisked");

}

else

MessageBox.Show("Form is clicked");

Note - Goto the notes of inheritance , read the 2,3 and 4 rule , you can understand clearly , what we are doing.

- When a event procedure is bound with multiple controls, the object of the control, which has raised the event is sent to event procedure in run time and that get captured under sender parameter of event procedure.

- As a sender is of type object it can hold instance (or object) of any control that has raised the event which is sent to the event procedure in run time as following

- in the above case we have bound the event procedure with diff type of controls (button and form) so first to identify the type of control it was used the get type method of object class and recognize the type of control (button or form), raised in the event.

- after recognizing the type of control it was if there are multiple controls of same type then we need to convert sender into the appropriate control type to identify the name of each control, because “sender” is of parent type it can not referred to members of it child class(button now).

- Converting sender into appropriate control type can be done in two ways as following:

Button b = (Button)sender;

Button b = sender as Button;

Properties & Events in Windows Application

2014-02-25T22:57:00.001+05:30

Properties

As we are aware that every control has Properties, Method & Events to them. To access the properties of event Visual Studio provides property window, which will list all the properties and events corresponding to a control. To open it select the control and press F4, which will by default list the properties of the control, change any property you want like left, right, width, height, back color etc. for which you can see the impact immediately.

- To view events of control select events option on top of the property window.

- Methods of a control can be accessed only in CODE view.

- Whenever we set a value to any property of the control VS will internally write the necessary code referring to each property of control by assigning values, what we specify in property window. That code will be present in initialize component method, which is called from the constructor.

Eg:

this.Text = “ First Form”;

this.BackColor = Color.Pink;

this.Size = new Size(350,350);

Note – To view the code under initialize component method right click on it --> select got definition, which takes you to a partial class, under witch the method was defines (Form1.Designer.cs)

Events

These are time periods which tells when an action has to be performed i.e. when we want to perform any action at a specific time period choose an appropriate event , that occurs at the required time in the property window and dabble click on it . That will take you to code view and provide a method under which we need to write the code.

In the project we have opened --> got properties of form --> select events and double click on load event --> and write the following code under form1_load method generated in code view.

- MessageBox.Show(“Welcome to windows app”)

Again go to design view select events and double click on click event, the write following code under the method Form1_click

- MessageBox.Show(“you have click on form”)

Que. What is the method under which we are writing the code corresponding to an event?

Ans. The method under which we are writing the code corresponding to an event has a special name i.e. event procedure, which is a block of code i.e. bound with an event of control and gets executed whenever the event occur or rises . The code written under an event procedure will be internally executed by the event whenever it occurs or rises with the help of a delegate.

- In the above case whenever the event occurs or rises will call the delegate, which then executes the event procedure i.e. bound with event.

Que. How does an event, delegate and event procedure gets linked with each other?

Ans. Events and delegates are predefined under BCL (events are defined in control classes and delegates are defined under system namespace) , what we defined here is only an event procedure. After defining an event procedure in form class to link the event, delegate and event procedure VS write a mapping statement as following:

Syntax : < control >.< event >+= < delegates > ( < event procedure > )

Eg:

this.Load += new EventHandler(Form1_Click);

button1.Click += new EventHandler(button1_click);

textBox1.keyPress += new KeyPressEventHnandler(textBox1_KeyPress);

Multiple events can used the same delegate but all events will not use the same delegate. Different event may used different delegates to execute an event procedure.

Note- we can see the above code under the method InitializedComponent.

Que. How can we define an event procedure manually.

Ans. We can define event procedures manually as following:

Syntax:

[ < Modifier > ] void < name > ( object sender, Event Args e)

{

< stmts >;

}

- Events procedure are non value returning methods.

- We can give any name to a Event procedure, but VS follows a convention wile naming them:

< Control name > _ < event >

Eg: Form_Load,

Button1_Click,

textBox1_keypress

- Every event procedure should take to mandatory parameters:

1. Object sender.

2. EventArgs e

- Write the blow code in a Notepad and execute:

// I don't know why it shows error but main thing is the concept.

// So don’t copy & past this , and if you are able to run , then please give me this solution

using System;

using System.Drawing;

using System.Windows.Forms;

public class MyForm : Form

{

public MyForm2()

{

InitializeComponent();

}

private void InitializeComponent();

{

this.Text =”My Form”;

this.BackColor = Color.Pink;

this.Size = new Size(350,350);

this.Load += new Eventhandler(Test);

this.Click += new Eventhandler(Test);

}

private void Test(object sender, EventArgs e)

{

MessageBox.Show(“Procedure written manually”);

}

static void Main()

{

Application.Run(new MyForm2());;

}

Note- This concept of events & event procedure’s has been derived from classical VB , but them an event procedures can be bound only single event of single control, whereas in .net it can be bound with multiple events of a single control os well as with multiple control also.

Windows Application - Part - 2

2014-02-25T22:49:00.002+05:30

Whatever the control it was every control has 3 things in common.

1. Property: - these are attributes of a control which have their impact on look of the control. Eg: Width, Height, Back Color, for color etc.

2. Method: - these are action performed by the controls eg: Clear(), Focus(), Close() etc.

3. Events: - these are time period which specify when an action has to be perform. Eg: Click Load, Keypress, mouse over etc.

Note – All the controls we are going to work with or derived from a default parent i.e. class control, which contains the properties methods and events which are common for all the controls like: Form, Button, TextBox etc.

Que. How to develop a windows application?

Ans. if we want to develop a windows application, the base control which has to be created first is – Form. To create it we follow the blow process.

Step 1: Define a class inheriting from the predefined class form so that the new class is also a form.

Step 2: now to run the form we have created, create an object of it and passed it as parameter to the rum method of application class, which is responsible in execution of a windows application.

Que. from where can we develop a windows application.

Ans. we can develop a windows application in two different ways:

I. Using notepad following the above process.

II. Using windows forms application project template, under Visual Studio.

Developing windows application under notepad: - open notepad  write the following code init then save, compile and execute

using System;

using System.windows.forms;

public class MyForm : Form

{

static void Main()

{

MyForm f = new MyForm ();

Application. Run(f);

}

. Developing windows application under Visual Studio:- To develop a windows application under visual studio,

Open new project window  select windows form application project templates  and specify the name to the project, eg- WindowsProject.
By default the project comes with two class’s init.
Program.cs
Form1.cs
The execution of windows application starts from the static class program, under this class we find a main method creating the object of Form class that has to be executed.

Eg: Application. Run(new Form1());

Form1.cs is the file in which the class Form1 is defined inheriting from pre-defined class Form and this is the class that has to be executed.

eg: public partial class Form1 : Form

Windows application develops under Visual studio has two places to work with.

Design view

Code view

Design view is the place where we design the application; this is accessible to both programmers and end users.
Code view is the place where we write the code for execution of application, this is accessible only to programmer.

Note- because of the design view, what VS provides it is known as WYSIWYG editor- (What You See Is What You Get)

Exception & WINDOWS PROGRAMMING

2014-02-25T22:42:00.002+05:30

Que. How can we raise the exception?

Ans. If we want to raise an exception follow the blow process –

Create an object of exception class.
Throw that object using Throw object.
Syntax – throw <object>
When we want to raise an exception explicitly, we can adopt to different approach

a. Where we want to raise an exception than create an object of class ApplicationException by passing an error massage as a parameter to its constructor

ApplicationException (string error massage)

Eg:-

ApplicationException obj = new ApplicationException (“< error massage>”)

throw obj;

throw new ApplicationException (“< error massage>”)

. b. First define a user define exception class as par your requirement and use that class in the place of application exception class same as the above.

Q. How to define an Exception class?

Ans. to define our own exception classes about the blow process-

Define a class inheriting from the pre-defined class Exception so that the new class also becomes an Exception class.
Now override the virtual readonly property of Exception class under your new class as par your requirement.

- Add a class ThrowDemo.cs and write the following

class OddNumberException : Exception

{

public override string Message

{

get

{

return "odd number can't be used as Divisor";

}

class ThrowDemo

{

static void Main()

{

try

{

int x, y, z;

Console.Write("Enter x Value :");

x = int.Parse(Console.ReadLine());

Console.Write("Enter y Value :");

y = int.Parse(Console.ReadLine());

z = x / y;

if (y % 2 > 0)

{

//throw new ApplicationException("divisor can't be odd number");

throw new OddNumberException();

}

Console.WriteLine(z);

}

catch (Exception ex)

{

Console.WriteLine(ex.Message);

}

Console.WriteLine("End the Program");

Console.ReadLine();

}

Partial Class

It’s a new approach that came into picture from C# 2.0 which allows splitting a class into multiple files i.e. one class can be defined with in more than one file

-To define ‘partial class’ we need to prefix the class with “partial” modifier.

- If we want to inherit a partial class from any other class it is enough to inheriting any single file but not all.

- Partial class is allowing multiple programmers to work on the same class at same time but on different files.

- Partial classes are used for physical separation of related code into different file, but logically they will be under the same class.

- Add a class Part1.cs and write the following:

using System;

namespace oopsProject

{

public partial class Parts

{

public void Method1()

{

Console.WriteLine("Method 1");

}

public void Method2()

{

Console.WriteLine("Method 2");

}

- Add a class Part2.cs and write the following:

using System;

namespace oopsProject

{

public partial class Parts

{

public void Method3()

{

Console.WriteLine("Method 3");

}

public void Method4()

{

Console.WriteLine("Method 4");

}

- Add a class TestParts.cs and write the following:

using System;

namespace oopsProject

{

class TestParts

{

static void Main()

{

Parts p = new Parts();

p.Method1(); p.Method2(); p.Method3(); p.Method4();

Console.ReadLine();

}

WINDOWS PROGRAMMING

In development of any application we have required a user interface (UI) to communicate with end user. We have two different types of User Interface

CUI ( Character User Interface)
GUI ( Graphical User Interface)

- Traditionally we have CUI eg: dos, UNIX, os etc. This application suffers from little criticism like:

1. They are not user-friendly. As we need to learn the commands first to use them.

2. They do not allow navigating from one place to other place.

- To solve the above problems in early 90’s GUI applications are introduced by Microsoft with its windows operation system, which has a beautiful feature known as “Look & Feel “ To develop them Microsoft has introduced an language also into the market in 90’s i.e. VB , letter when .net was introduced the support for GUI has been given in all .net languages.

- To develop windows application we required a set of component known as controls provided as classes to us, with in the namespace system.windows.forms

- Controls are categorized into 2:

1. Container Controls: - these controls are capable of holding other controls on them eg: Form, Panel, GroupBox, SplitContainer, TabControl etc.

2. Non-Container Controls: - These controls are not capable of holding any controls on them moreover they can be used only after being placed on a container. Eg: Button, Label, TextBox, CombBox, ChekBox, TreeView, ListView, DataGridView etc.

Rules of inheritance

2014-02-25T20:51:00.000+05:30

-Add a class Class1.cs and write the following :

class Class1

{

public Class1()

{

Console.WriteLine("class1 constructor");

}

public void test1()

{

Console.WriteLine("Method one");

}

public void test2()

{

Console.WriteLine("Method two");

}

-Add a class Class2.cs and write the following :

class Class2:Class1

{

public Class2()

{

Console.WriteLine("class2 constructor");

}

public void test3()

{

Console.WriteLine("Method three");

}

static void Main()

{

Class2 obj = new Class2();

obj.test1(); obj.test2();

obj.test3();

Console.ReadLine();

}

Rules to be considered while working with inheritance:

In inheritance the execution of child class starts by invoking default constructor of parent class. So parent class’s default constructor should be accessible to child class, otherwise inheritance cannot be performed.
In inheritance child classes can access members of its parent classes whereas the parent class cannot access child class members moreover a parent never knows about its children.

To test this rewrite the code under main method of child class Class2 as following-

static void Main()

{

Class1 obj = new Class1();

obj.test1(); obj.test2();

// obj.test3(); // invalid

Console.ReadLine();

}

Earlier we have discussed object of a class can be assign to the variable of the same class to make it as a reference in the same way object of a child class can be assigned to the variable of its parent to make it as a reference, so that both object and reference will be pointing to the same memory but in this situation also parent class reference cannot be used for invoking child class members.

To test this rewrites the code under main method of Class2 as following-

static void Main()

{

Class2 c = new Class2();

Class1 p = c; //valid

p.test1(); p.test2();

//p.test3(); //invalid

Console.ReadLine();

}

Note – if required reference of a parent class i.e. created from object of the child class can be converted back into child class reference but this required ‘explicit conversion ’ which can be done as blow.

Class2 c = new Class2();

- creating reference of parent using object of child:

Class1 p = c; //valid

- converting parent reference back into child reference:

Class2 c2 = (Class2)P ;

Class2 c2 = p as Class2 ;

Each and every class in .NET languages has the default parent value i.e. a class object present under system name space. This always stands at top of the hierarchy becoming a parent for every class directly or indirectly.

The members which are defined in the class object can be accessed from any of the class in .NET languages.

eg. GetType() , ToString() etc.

Types of INHERITANCE

as par the standers of object oriented programming we have two different type of inheritance-

Single inheritance
Multiple inheritance

If a class has one immediate parent class to it we call it as single inheritance

If a class has more than one immediate parent class we call it as multiple Inheritances

Traditional C++ language supports both single and multiple and multiple inheritance whereas modern object oriented languages like JAVA .Nat doesn’t provide the support for multiple inheritance through classes because because it suffers from the problem of antiquity i.e. a same member may be defined in multiple parents of a class in the same hierarchy

Exception Handling

2011-10-13T22:44:00.002+05:30

Exception Handling

try

{

- stmts which will cause a exception

- stmts which will not be executed when exception occurs

}

catch (<exception><var>)

{

- stmts which should be executed only when an exception occurs

}

Multiple Catch Blocks

when we enclosed the code under try and catch blocks, the execution of the program will be as following:

If all the statement in try is executed successfully without executing the catch block from the last stmt of try the control directly jumps to the stmt which is present after catch blocks.
If any of the stmt in try comes rises or causes an exception from that line of code without executing any stmts in try control jumps to catch block searching for a matching catch block. If a matching catch block is avilabel executes the stmts under that catch block and than jumps to the stmt after all the catch blocks, if the matching catch block is not avilabel abnormal termination occurs again.

- Add a class ExcepDemo.cs and write the following

class ExcepDemo

{

static void Main()

{

int x, y, z;

try

{

Console.Write("enter x value : ");

x = int.Parse(Console.ReadLine());

Console.Write("enter y value : ");

y = int.Parse(Console.ReadLine());

z = x / y;

Console.WriteLine(z);

}

catch (DivideByZeroException ex1)

{

Console.WriteLine(" Divisor can't be zero");

}

catch (FormatException ex2)

{

Console.WriteLine("Input must be integer");

}

catch (Exception ex3)

{

Console.WriteLine(" error occurred ");

}

Console.WriteLine("end of program");

Console.ReadLine();

}

};

}

Finally Block

(V. imp):- in a block of code which gets executed both the times when an exception occur or did not occur also.

using System;

namespace oopsProject

{

class FinDemo

{

static void Main()

{

int x, y, z;

try

{

Console.Write("enter x value : ");

x = int.Parse(Console.ReadLine());

Console.Write("enter y value : ");

y = int.Parse(Console.ReadLine());

if (y == 1)

return;

z = x / y;

Console.WriteLine(z);

}

catch (Exception ex)

{

Console.WriteLine(ex.Message);

}

finally

{

Console.WriteLine("finally block");

}

Console.WriteLine("end of program");

Console.ReadLine();

}

- In the above program if at all the value to the deviser is given as 1 the execution of the program stops their because we are using return to jump out of the method but all this happens only after executing finally block, because once the control enters into try without executing finally we cannot stop the program execution.

Note – Massage is a property of the exception class which returns the predefined error massage associated with the currently occur exception.

- Massage is a virtual property of class exception which is overridden under all the child exception classes according to their recurrent, so the reference of the exception class holding object of its child class (Currently occur Exception) was able to access property massage of its child class and display the relevant error massage.

Try catch and finally statement can be used in three different combinations:

Try and Catch – in this case abnormal termination of the program stops as we are handling the exception.
Try Catch and Finally – Execution will be same as above as well as all the stmts in finally gets executed at any cast.
Try and Finally – In this case abnormal termination will not stop because we are not handling the exception using catch, but all the stmts is finally will be executed.

Exceptions are two types

System exception.
Application exception.

- An exception which gets raised implicitly on some pre-defined error conditions is a system exception. Eg: Format exception divides by zero exception etc.

- An exception which gets raised explicitly on user defined condition is an application exception can also be called as user defined exception.

Exception and Exception Error:-

2011-10-13T22:43:00.002+05:30

Exception and Exception Error

Program may come across two different types of error in it.

Compile-Time Error.
Run-Time Error.

An error which comes into picture at the time of compilation of the program is a compile time error. This error may come due to syntactical mistakes and moreover these are not dangerous.

An error which comes into picture while execution of a program is going on is referred as a run-time error, which may come into picture due to various reason like-

Wrong implementation of logic.
Wrong input supply to program.
Missing of required resources of an application etc.

These errors are what we call as Exception also.

Whenever a run-time error or exception occurs with a program, the program terminate abnormally without executing the next line of code in the program, even if that code is no way related with the error occurred and also displayed an error massage telling the reason for abnormal termination.

- As a programmer an exception is a class which is responsible in abnormal termination of the program. Within a program we may be coming across various types of runtimes error, mating with the scenario we have been provided with a separate exception class for each runtime error.

FormaleException
DivideByZeroException
IndexOutOfRangeException
NullReferanceException
SqlException etc.

- These exception classes are predefined under the system Namespace and each class is responsible for abnormal termination as well as displaying of an error massage related with the error.

- Implementation of Exception classes has been done as following

Exception Handling: -

As we discussed whenever an exception comes into picture the program terminate abnormally without executing the next lines of code even if the code is no way related with the exception, so if we want to stop the abnormal termination of program and still execute the code which is not related with the exception being occurred we need the make use of exception handballing.

- To handle an exception we must enclosed the code under some spatial block known as try-Catch blocks.

Indexers , Delegates

2011-10-13T22:42:00.003+05:30

Indexers

These are near similar to Properties that are used for providing access to an array outside of the class. Once an Indexer is defined on a class the object of that class will work like an array providing access to the values of array i.e. defined inside it.

- Add a class IndexerDemo.cs and write the following:

using System;

namespace oopsProject

{

public class IndexerDemo

{

//Private array declaretion

string[] arr;

public IndexerDemo(int size)

{

// initializing array with a size

arr = new string[size];

// Assigning the default value to array

for (int i = 0; i < size; i++)

arr[i] = "empty";

}

// defining an indexer to access the array out of the class

public string this[int index]

{

get { return arr[index]; }

set { arr[index] = value; }

}

Add a class TestIndexer.cs and write the following:

using System;

namespace oopsProject

{

class TestIndexer

{

static void Main()

{

IndexerDemo obj = new IndexerDemo(6);

for (int i = 0; i < 6; i++) ;

Console.Write(obj[i] +" ");

Console.WriteLine();

obj[1] = "red"; obj[3] = "blue"; obj[5] = "green";

for (int i = 0; i < 6; i++) ;

Console.Write( obj[i] + " ");

Console.ReadLine();

}

public static int i { get; set; }

}

Delegates

These are similar to function pointers, which are avilabel in our traditional languages like C and C++ which provides an option to invoke a function with them, which will be faster in execution.
These function pointers are provided under .net languages in a form of Delegates which can be referred as pointer to the method.
Invocation of a method can be done in Two different ways –

I. We can invoke a method directly using object of the class.

II. We can invoke a method without object of a class using a Delegate, which is faster in execution when compared with first process.

Note – A Delegate is also a type (Reference type).

Using Delegates: - To use a delegate adopt blow process.

Step 1:

Delegate Declearetion: - Here we need to declare a delegate for invoking the method where IO parameters for the Delegate should matched with IO parameters of Method it has to call.

Syntax –

[<modifiers>] delegate <void |type> <name> [<param def’s>]

Eg:-

public void Add (int x, int y)

{

Console.WriteLine(x +y);

}

public delegate void AddDel( int x, int y);

Eg:-2

public string SayHello (string name)

{

return “Hello “ + name;

}

public delegate string SayDel(string name);

Step 2:

Creating Object of Delegate: - as a delegate is also a type, to consume it we need to create object of it. While creating the object we need to pass the method as a parameter to its constructor, which we want to call using the delegate.

AddDel ad = new AddDel(Add);

SayDel sd = new SayDel(SayHello);

Step 3:

Invoking the Delegate to Execute the Method: - Now we can call the delegate for any number of times so that the method gets executed, where each delegate uses a separate Stack to execute the method for any number of times.

ad (100,50) ; ad (1046,54) ; ad (237,265) ;

sd (“xxx”); sd (“yyy”); sd (“zzz”);

Note – A delegate can be declared either within a namespace or within a class also.

Add a class DelClass.cs and write the following:

using System;

namespace oopsProject

{

class DelClass

{

public string SayHello(String name)

{

return "Hello " + name;

}

public delegate string SayDel(string name);

static void Main()

{

DelClass obj = new DelClass();

SayDel sd = new SayDel(obj.SayHello);

Console.WriteLine(sd("prabhu"));

Console.WriteLine(sd("nitya"));

Console.WriteLine(sd("choure"));

Console.ReadLine();

}

Delegetes are of two types

Uni-cast or Single-Cast delegates
Multi- Cast delegates

- If a delegate is used for invoking only a single method, it is a single cast delegate.

- If we can use a delegate for invoking more than one method also i.e. a multi-cast delegate, but if we want to invoke multiple methods using a single delegate then all the method should have the same io parameters.

- Add a class MultiDel.cs and write the following

using System;

namespace oopsProject

{

class MultiDel

{

public void Add(int x, int y)

{

Console.WriteLine("Add : " + (x + y));

}

public void sub(int x, int y)

{

Console.WriteLine("sub : " + (x - y));

}

public void mul(int x, int y)

{

Console.WriteLine("mul : " + (x * y));

}

public void div(int x, int y)

{

Console.WriteLine("div : " + (x / y));

}

static void Main()

{

MultiDel obj = new MultiDel();

Math m = new Math(obj.Add);

m += obj.sub; m += obj.mul; m += obj.div;

m(100, 50);

Console.WriteLine();

m(1844, 5230);

Console.WriteLine();

m -= obj.mul;

m(1023, 523);

Console.WriteLine();

Console.ReadLine();

}

Note – The advantage with multicast delegate is, a single delegate call will execute all the method that is bound to it at a time.

Enumerated Property

2011-10-13T22:42:00.000+05:30

Add a class Customer.cs and write the following code:

using System;

namespace oopsProject

{

public enum cities { Bangalore, Hyderabad, Mumbai, Kolkata, NewDelhi, Chennai };

public class Customer

{

int _custid;

string _cname, _state;

double _balance;

bool _status;

cities _city;

public Customer(int _custid)

{

this._custid = _custid;

//Get all other values from DB basing on given ID:

_cname = "prabhu";

_balance = 5000;

_status = false ;

_city = 0;

_state = "karnataka";

Country = "India";

}

//Read only Property

public int Custid

{

get { return _custid; }

}

//Read write Property

public string Cname

{

get { return _cname; }

set { _cname = value; }

}

//Read write Property

public bool Status

{

get { return _status; }

set { _status= value; }

}

//Read write Property with a condition

public double Balance

{

get

{

(_status)

return _balance;

else return 0;

}

set

{

if (value >= 500)

_balance = value;

}

// enumerated property

public cities city

{

get{return _city;}

set{_city = value;}

}

// setting scope of property Accessor independently (2.0)

public string state

{

get { return _state;}

protected set { _state = value;}

}

//Automatic Properties 3.0

public string Country

{

get;

private set;

}

Enumerated Property – These are property which is defined with a list of constants to choose from. to define these type of properties first we need to declare all the constants under a type known as “enum” .An enum is a collection of constants, which should be declared as following.

Syntax –

[<modifiers>] enum <name> {<list of values >};

Eg:-

public enum Days {Monday, Tuesday, Wednesday, Thursday, Friday};

If this enum is used as a type for any property we call it as enumerated property.

- Declaring a variable of enum type

Days weekday = 0;

Days weekday = Days.Wednesday ;

Now for the variable weekday we can define a property as Following:

public Days weekday

{

get {return weekday;}

set { weekday = value;}

}

New Features to Properties:-

 In C# 2.0, there are given an option to define a property setting the scope of each property Accessor independently.

Eg: State property we have defined under customer class.

 In C# 3.0, we were given with an option automatic properties, which allows us to define a property without any variable declaration for the property, So set and get blocks doesn’t contain any code in them, but it is must to define both get and set blocks.

Eg: Country Property in above customer class.

Consuming the Properties:-

- Add a class TestCustomer.cs and write the following

using System;

namespace oopsProject

{

class TestCustomer

{

static void Main()

{

Customer obj = new Customer(101);

Console.WriteLine(obj.Custid);

//Assignment i not possible as property is read only

//obj.Custid = 102;

Console.WriteLine(obj.Cname);

obj.Cname = "xyz";

Console.WriteLine(obj.Cname);

Console.WriteLine(obj.Status );

//Balance will be zero here as status is inactive

Console.WriteLine(obj.Balance);

obj.Status = true;

Console.WriteLine(obj.Status);

// now it returns balance as status is active

Console.WriteLine(obj.Balance);

obj.Balance = 400; //assignment fails

// here as it is less than 500

obj.Balance = 400;

Console.WriteLine(obj.Balance);

// assignment succeeds as it is greater than 500

obj.Balance = 600;

Console.WriteLine(obj.Balance);

Console.WriteLine(obj.city);

obj.city = cities.Hyderabad;

Console.WriteLine(obj.city);

Console.WriteLine(obj.state);

// Assigning value to the property is invalid as current

//class is not a child class of customer

//obj.state = "AP";

Console.WriteLine(obj.Country);

Console.ReadLine();

}

Note – Just like we have Abstract method and Virtual method, we can define Property also as abstract and virtual. So that we can override them under Child class.

Properties-

2011-10-13T22:41:00.002+05:30

Destructor are actually responsible for deallocation of memory used by objects but in managed languages deallocation is taken care by garbage collector for which destructor are not required, whereas in some situation we may be using any unmanaged resource like files, database etc. which will not be under control of garbage collector, in such scenario we use these destructors for managing those unmanaged resources.

Properties: - If at all a class contains any values in it that should be accessible outside of the class. Access to those values can be provided in two different ways –

By storing the value in public variable access to the value can be given where anyone can get the value or set with a new value.

public class Show

{

public int x = 100;

}

……………………….

Show obj = new Show ();

int a = obj x ; // Getting the value

int.x = 200; // Setting the value

By storing the value in a private variable also access to the value can be given by defining a property on that variable, where we can provide the access to the value in three different ways.

Both get and set access (read | write property)
only get access (Read only property)
only set access (Write only property)

Syntax

[<modifiers>]<type> <name>

{

[get {- stmts}] // get Accessor

[set {- stmts}] // Set Accessor

}

The code which is present in the Get block is executed whenever we try to capture the value of property

Eg:-

string str = “Hello”;

int len = str.Length;

The code under set box gets executed whenever we are trying to assign in new value to the property

Console.BackgroungColor = ConsoleColor.Blue;

- If the property is defined with both get and set blocks it is a read | write property.

- If defined only with get block, it is a read only property.

- If defined only with a set block it is a write only property.

Language Interoperability and Destructors:

2011-10-13T22:40:00.002+05:30

Open visual studio à go to file new Project à choose console application à name it as accessDeemo1 and name the solution as MySolution , by default we get a class in the project as program ,

write following code in it making the class as public

public class Program

{

private void Test1()

{

Console.WriteLine("Private Method");

}

internal void Test2()

{

Console.WriteLine("Internal Method");

}

protected void Test3()

{

Console.WriteLine("Protected Method");

}

protected internal void Test4()

{

Console.WriteLine("Protected Internal Method");

}

public void Test5()

{

Console.WriteLine("Public Method");

}

static void Main(string[] args)

{

Program p = new Program();

p.Test1(); p.Test2(); p.Test3(); p.Test4(); p.Test5();

Console.ReadLine();

}

Add a new class Two.cs in the project and write the following:

class Two : Program

{

static void Main()

{

Two obj = new Two();

obj.Test2(); obj.Test3(); obj.Test4(); obj.Test5();

Console.ReadLine();

}

Add a new class Three.cs in the project and write the following:

class Three

{

static void Main()

{

Program p = new Program();

p.Test2(); p.Test4(); p.Test5();

Console.ReadLine();

}

Add a new project under the solution of type console application à name it as AccessDemo2 and rename the default file Program.cs as Four.cs , so that class name also changes as Four à add the reference of AccessDemo1 assembly from its physical location to the current project & then write the following code

class Four : AccessDemo1.Program

{

static void Main()

{

Four obj = new Four();

obj.Test3(); obj.Test4(); obj.Test5();

Console.ReadLine();

}

Add a new class under the Project AccessDemo2 names it as Five.cs and write the following:

using AccessDemo1;

using System;

namespace AccessDemo2

{

class Five

{

static void Main()

{

Program p = new Program();

p.Test5();

Console.ReadLine();

}

Language Interoperability – As discussed earlier the code written in 1 .net language can be consumed from other , to test this add a new project under the MySolution by choosing the language as VB and template as class library which is collection of types that can only be consumed but not executed .

- The project comes with a default class Class1 in the file Class1.vb write the following code init.

Public Class Class1

Public Sub Add(ByVal x As Integer, ByVal y As Integer)

Console.WriteLine(x + y)

End Sub

Public Function Say(ByVal name As String) As String

Return "Hello" & " " & name

End Function

End Class

- Now to compile the project open solution explorer à right click on the VBproject à and select Built which compiles and generates an assembly.

- Now add a new class under AccessDemo2 project as TestVb.cs , add the reference of VBProject’s assembly from its physical location and write the following code

using VBDemo;

using System;

namespace AccessDemo2

{

class TestVB

{

static void Main()

{

Class1 obj = new Class1();

obj.Add(100,50);

Console.WriteLine(obj.Say("Prabhu"));

Console.ReadLine();

}

Members Of a Class – As we are aware a class is a collection of members which can be of various types like –

1. Fields (variables)

2. Methods

3. Constructor

4. Destructor

5. Properties

6. Indexers

7. Events

8. Delegates

9. Ename

Destructors : - These are also special methods, avilabel in a class similar to a constructor, whereas a constructor method gets executed whenever the object of the class is created and destructor method gets executed whenever the object of class is destroyed.

Both Constructor and Destructor will have the same name i.e. name of the class, but to distinguish between these two we use tilled operator (~) before of destructor.

class Test

{

Test()

{

//Constructor

}

~Test()

{

//Destructor

}

A constructor method can have modifiers as well as parameters also, whereas, a Destructor cannot have it.

-Add a class TestDemo.cs under OOPSProject and write the following:

using System;

namespace oopsProject

{

class DestDemo

{

public DestDemo()

{

Console.WriteLine(" object 1 created");

}

~DestDemo()

{

Console.WriteLine("object 1 distroyed");

}

class DestDemo2 : DestDemo

{

public DestDemo2()

{

Console.WriteLine(" object 2 created");

}

~DestDemo2()

{

Console.WriteLine("object 2 distroyed");

}

static void Main()

{

DestDemo2 obj = new DestDemo2();

//obj = null ; GC.Collect();

//Console.ReadLine();

}

As we are aware Garbage Collector is responsible for memory management i.e. allocation and dislocation, so it is only responsible to create an object and allocate the memory and destroy the object and de-allocates the memory.

- Garbage Collector comes into the picture for destroying the object of a class in different case like:

1. In the end of a programs execution, when the program gets executed successfully without any shortage of memory.

2. Sometimes it can also come into picture in the middle of a programs execution provided there is a memory shortage, which identifies all unused object to destroy them.

3. We can also explicitly call the Garbage Collector in to a program in the middle to perform the de-allocation process , but this is not advised because, whenever Garbage Collector comes into picture for performing de-allocation it suspends the execution of program for an unpredictable laps of time.

-Execute the above program using ctrl F5 and check the result. In this case we find both constructor and destructor getting called one after the other because the main method contains only single statement in it i.e. is creating object of class, so when object is created constructor is called and because that is end of execution of program object get destroyed and destructor gets called.

Note – When constructors are called in case of inheritance they adopt top to bottom approach, whereas in case of destructor it will be bottom to top approach.

- Now uncomment the ReadLine statement in main and execute the program again using ctrl + F5, now we can see only constructor getting called but not destructor because the program is still under execution at ReadLine statement , press enter which will end the program and invokes the destructors.

- Now uncomment the second statement also in Main and execute the program again , where we can see destructor getting called before program execution is completed only because we are explicitly calling the Garbage collector in to the program to destroyed unused object

Access Specifiers

2011-10-13T22:39:00.002+05:30

Access Specifiers – these are also modifiers used to define scope of a type (Class or Interface or Structure) as well as their members i.e. who can access them and who cannot.

C# has 5 different Specifiers those are

Private
Internal
Protected
Protected Internal
Public

Note – Members define in a type with any Specifiers (Scope) are always accessible within the type, all the restrictions comes in to the picture only when we try to access them outside of the type.

Private – Members declared as private under class or structure is not accessible outside of them in which they are defining. Default scope for members of a class and structure is private, but public in the case of interface. Interface cannot contain private member in it. A type can never be declared as private.
Protected – Members declared as protected under a class or interface can be accessed only from its children or within itself , an non – child class cannot consumed .Types cannot be declared as protected also.

Q – How to restrict a class not to be accessible from any other class?

Ans – This can be done by declaring constructors of classes private

Q – How to restrict a class not to be inherited for any other class?

Ans – This can be done by declaring class as Sealed.

Q – How to restrict a class not to be accessible for any other class to consume by creating its object?

Ans – This can be done by declaring constructor of a class is Private.

Internal - Members of types that are declared as internal are accessible only within the project both from child or non-child class the default Scope for only type in C# is internal only.
Protected internal – Members declared as Protected Internal enjoy dual scope i.e. within the project they behave as Internal providing access to others, outside the project they change protect and still provide access to child classes.

Publicu - A type or member of a type if declared as Public is global in scope that can be access from anywhere.

Cases	Private	Internal	Protected	Protected Internal	Public
case 1					
case 2	X				
case 3	X		X		
case 4	X	X			
case 5	X	X	X	X	

Case 1 – Accessing members with in the same class.

Case 2 - Accessing members with in child class of same project.

Case 3 - Accessing members with in non-child class of same project

Case 4 - Accessing members with in child class of other project.

Case 5 - Accessing members with in non-child class of other project.

Operator Overloading

2011-10-13T22:38:00.002+05:30

Operator Overloading - This is same as method overloading, where in method overloading we define multiple behaviors to a method but in the case of operator overloading we can define multiple behavior to an Operator.

Eg. - ‘+’ is overloaded operator which can be used for adding numeric’s and concatenating Strings.

In the some way we can overload any existing operator as per over requirement and use it. To overload an operator we need to define an operator method as following

[< method >] static <type> operator <opt> (<param def’s >)

{

- stmts

}

The operator method are always static, return type of an operator method will be the same type of parameters which are passed to the method.

Add a class Matrix.cs and write the following:

class Matrix

{

// variables for a 2*2 matrix

int a, b, c, d;

public Matrix(int a, int b, int c, int d)

{

this.a = a; this.b = b;

this.c = c; this.d = d;

}

// overload + operator to add Two matrixes

public static Matrix operator +( Matrix obj1, Matrix obj2)

{

Matrix m = new Matrix(obj1.a + obj2.a, obj1.b + obj2.b, obj1.c + obj2.c, obj1.d + obj2.d);

return m;

}

// overload - operator to add Two matrixes

public static Matrix operator - (Matrix obj1, Matrix obj2)

{

Matrix m = new Matrix(obj1.a - obj2.a, obj1.b - obj2.b, obj1.c - obj2.c, obj1.d - obj2.d);

return m;

}

// overloading ToString () method of object class to print value of matrix.

public override string ToString()

{

string str = string.Format("[a:{0},b:{1},c:{2},d:{3}]",a,b,c,d);

return str;

}

- Add a class TestMatrix.cs and write the following:

class TestMatrix

{

static void Main()

{

Matrix m1 = new Matrix(5, 6, 7, 8);

Matrix m2 = new Matrix(1, 2, 3, 4);

Matrix m3 = m1 + m2;

Matrix m4 = m1 - m2;

Console.WriteLine(m1);

Console.WriteLine(m2);

Console.WriteLine(m3);

Console.WriteLine(m4);

Console.ReadLine();

}

Structure

2011-10-13T22:36:00.003+05:30

Structure – It is also a user define similar to a class that can contain variables methods as well as constructor in it.

Differences between classes and structure – (v. imp)

CLASS	STRUCTURE
1. It reference type.	1. it is a value type
2. Memory allocation is done on managed heap, so gets the support of garbage collector follow Automatic memory management.	2. Memory allocation is done on stack which doesn’t have support of garbage collector for memory management, but faster in access.
3. Using new operator to create the object of class (reference type) is mandatory.	3. Using new operator to create the object of structure (value type) is only optional.
4. Can contain variable declaration as well as initialization.	4. Can contain variable declaration but cannot be initialized.
5. variable of the class can be initialized in three ways i.e. – - at the time of declaration or - under the constructor or - using the object.	5. variable of the Structure can be initialized only in two ways i.e. – - under the constructor or - using the object.
6. A class require a constructor for creating the object of it , which need not be a default constructor	6. A structure also requires a constructor for creating its object without using new operator and in this case it use default constructor only. So default constructor is mandatory for structure and will be defined implicitly, that cannot be defined by programmer explicitly...
7. If defined with Zero constructor after compilation there will be one constructor and if defined with ‘n’ constructors after compilation there will be ‘n’ constructors only	7. If define with Zero constructor after compilation there will be One constructor and define with ‘n’ after compilation there will be ‘n+1’ constructor , because there is implicit default constructor always
8. It supports both Implementation and Interface inheritance.	8. It supports only Interface Inheritance.

Note – All the predefine type which comes under the value type category are implemented as structure under namespace.

Eg – int32, single, Boolean etc,

Whereas all predefined data types which comes under refinance type category are implemented as Classes

Eg – string and object.

- Add a code file naming it as MyStruct.cs and write the following

using System;

namespace oopsProject

{

struct MyStruct

{

int x;

public MyStruct(int x)

{

this.x = x;

}

public void Display()

{

Console.WriteLine(" Method under struct :" + x);

}

static void Main()

{

MyStruct obj1; // using default constructor

obj1.x = 50; obj1.Display();

MyStruct obj2 = new MyStruct(150);

obj2.Display();

Console.ReadLine();

}

Add one more code file naming it as MyStruct2.cs and write the following:

using System;

namespace oopsProject

{

struct MyStruct2

{

static void Main()

{

MyStruct obj = new MyStruct(300);

obj.Display();

Console.ReadLine();

}

abstract class example and Interfaces

2011-10-05T21:20:00.000+05:30

In the above case figure is an abstract class that provides the attributes, which are required in common for multiple figure like – rectangle, circle, triangle, cone etc. so it provide reusability through inheritance.

The Figure class also contains two abstract methods which need to be implimented separately for each figure, without changing the signature of the method.

- Add a class Figure.cs and write the following

public abstract class Figure

{

public double width, height, radius;

public const float pi = 3.14f;

public abstract double GetArea();

public abstract double GetPerimeter();

}

- Add a class Rectangle.cs and write the following :

public class Rectangle : Figure

{

public Rectangle(double width, double height)

{

// here using base or this will be same

base.width = width;

this.height = height;

}

public override double GetArea()

{

return width * height;

}

public override double GetPerimeter()

{

return 2 * (height + width);

}

- Add a class Circle.cs and write the following :

class Circle: Figure

{

public Circle (double radius)

{

base.radius = radius;

}

public override double GetArea()

{

return pi * radius * radius;

}

public override double GetPerimeter()

{

return 2 * pi *radius;

}

- To consume the Figures add a class TestFigure.cs and write the following:

class TestFigure

{

static void Main()

{

Rectangle r = new Rectangle(12.9, 23.87);

Console.WriteLine(r.GetArea());

Console.WriteLine(r.GetPerimeter());

Circle c = new Circle (229.32);

Console.WriteLine(c.GetArea());

Console.WriteLine(c.GetPerimeter());

Console.ReadLine();

}

INTERFACES - These are also types just like a class but can contain only abstract members init.

Non abstract class –

- only non abstract members

Abstract class –

- abstract members

- non abstract members

Interfaces –

- only abstract members

Note – whatever rules and regulations we have discussed in case of abstract classes applies to interfaces also.

Interfaces are used in the development of distributed applications Clint sever technology.

Interfaces also provide support for multiple inheritances i.e. a class can inherit from any number of Interfaces but can have only one class as its parent.

SEALED CLASS AND ABSTRACT CLASS

2011-10-05T21:18:00.000+05:30

Sealed Class – a class which can’t be inherited by any other class is referred as a Sealed Class. To make a class Sealed we need to apply sealed modifier on it.

Syntax -

sealed class Class1

{

- members

}

class Class2 : Class1 // invalid

Note – a sealed class if required can be consumed from other classes by creating its object.

Sealed Methods –

A method which cannot be overridden under a child class is referred as a sealed method. By default every method is sealed method because overriding a method is not possible unless it was declared as virtual.

If at all a method is declared as virtual within a class any of its child class in the linear hierarchy has a chance to override the method.

Eg.

class Class1

public virtual void Display()

class Class2 : Class1

public override void Display()

class Class3 : Class2

public override void Display()

A virtual method of a class can be sealed by its child class so that further overriding of the method by Childs of child class will not be possible.

class Class1

public virtual void Display()

class Class2 : Class1

public sealed override void Display()

class Class3 : Class2

public override void Display() // invalid

Abstract Methods and Abstract Class –

Abstract Method - A method without any method body is referred as an abstract method, what it has, is only Declearetion of the method. We need to use abstract modifier to declare an abstract method.

Abstract Class - the class under which these abstract methods are declared is referred as abstract class. Need to declare the class also using abstract modifier.

Ex-

abstract class Example

{

public abstract void Add (int x , int y)

}

the concept of abstract methods is near similar to the concept of method overriding, where in overriding if at all a class declared a method as virtual it can be re implemented by its child classes using the override modifier, which is only optional for a child class, whereas if any class declared a method as abstract implementation of the method has to be provided by its child classes using overrode modifier only, which is mandatory for child classes to provide the implementation

An abstract class can contain abstract and non- abstract members in it, if at all a class contains abstract members in it until and unless the abstract members are implemented under the childe class, childe class cannot consume non-abstract members of parent

Note – An abstract class is never useable to itself because we cannot create the object of an abstract class.

- Add a class AbsParent.cs and write the following code:

abstract class AbsParent

{

public void Add(int x, int y)

{

Console.WriteLine(x + y);

}

public void sub(int x, int y)

{

Console.WriteLine(x - y);

}

public abstract void Mul(int x, int y);

public abstract void Div(int x, int y);

}

- Add a class AbsChild.cs and write the following code:

class AbsChild : AbsParent

{

public override void Mul(int x, int y)

{

Console.WriteLine(x * y);

}

public override void Div(int x, int y)

{

Console.WriteLine(x / y);

}

static void Main()

{

AbsChild obj = new AbsChild();

obj.Add(100, 50); obj.sub(20, 10);

obj.Mul(57, 29); obj.Div(1200, 600);

Console.ReadLine();

}

- To test this rewrite the code under main method of class AbsChild.cs as following:

{

AbsChild obj = new AbsChild();

AbsParent p = obj;

p.Add(100, 50); p.sub(20, 10);

p.Mul(57, 29); p.Div(1200, 600);

Console.ReadLine();

}

How to override the method in Polymorphism

2011-10-05T08:06:00.002+05:30

How to override the method –

If we want to override a method first under the parent class the method should be declared using virtual modifier, now the child class gets the permission to override the method which can be overridden by the child class using override modifier, but overriding the method is only optional for the child class.

eg – LoadParent

public virtual void test1(int x)

LoadChild : LoadParent

public override void test1(int x)

Overriding is an option which allows to change the behavior of the parent class method under child class according to its requirement. To change the behavior parent class is giving the permission by declaring the method as virtual.

- To test this goes into the Class LoadParent and rewrite the Test method as following

public virtual void test1(int x)

{

Console.WriteLine("method test1");

}

Now run the child class and check the result which also prove overriding is only optional.

- Add a new method under the class LoadChild as following

public override void test1(int x)

{

Console.WriteLine("Method test 3");

}

Now again run the child class and check the difference in result , where in the place of virtual method the overridden method gets executed, Because object of the child class gives First preference to Local methods .

After the child class is overriding a virtual method of its parent if required the child class has a chance to invoke virtual methods of Parent Class also, which can be done in two different ways –

By creating the object of parent class child class can invoke Parent class’s virtual method.

- To test this rewrites the code under main method of class LoadChild as following –

{

LoadParent p = new LoadParent();

LoadChild c = new LoadChild();

p.test1(10); // Invoke parent class method

c.test1(10); //Invoke child class method

Console.ReadLine();

}

Note – Earlier we have discussed references of parent class that are created using object of child class cannot invoke child class members but we have an assumption in overriding i.e. these references can invoke the overridden methods under child class because overriding is performed with the permission of parent.

To test this rewrites the code under main method of class LoadChild as following –

{

LoadChild c = new LoadChild();

LoadParent p = c;

p.test1(10); // Invokes child class method only

c.test1(10); //Invokes child class method

Console.ReadLine();

}

. using ‘base ‘keyword also from child class from child class we can invoke virtual methods of parent but using of “base and this key words” from a static block is invalid

To test the process add new method under child class as following –

public void Ptest(int x)

{

base.test1(x);

}

Now in the main method of Child class rewrite the code as following –

{

LoadChild c = new LoadChild();

c.Ptest(10); // Invokes Parent class method

c.test1(10); //Invokes child class method

Console.ReadLine();

}

Q. How to re-define a parent class method under child class –

Ans – A parent class method can be re- defined under its child class using two different approaches

Method overriding
Method Hiding

In the first case parent class gives the permission for child class to re-define its method by declaring it as virtual, now he child class can re-define the method using override modifier.
In the second case parent class doesn’t give any permission to re-define its method to the child class, but still the child class can re-define it without any permission of its parent.

LoadParent

public void show()

public virtual void test (int x)

LoadChild : LoadParent

public new void show() // method hiding

public override void test (int x) // method overriding

To test this add new method under the class load child as following-

public new void show ()

{

Console.WriteLine("Method show 2");

}

All the rules we have discussed in case of overriding applies to method hiding also accept reference of parent class created from object of Child can invoke overridden methods of child but not the methods which are re-implemented using method hiding approach.

To check this rewrite the code under main method of class load child as following-

{

LoadChild c = new LoadChild();

LoadParent p = c;

p.show(); // Invokes parent method because this is method hiding

c.test(10); //Invokes child method because this is method overriding

Console.ReadLine();

}

Polymorphism is of two types –

Static or compile time polymorphism.
Dynamic or run time polymorphism.

In the first case the object of class recognizes which Polymorphic method it has to call at the time of compilation of the program only, which is possible in overloading.

In the second case the object of a class recognizes which Polymorphic method it has to call at run time of while executing the program, this happen in case of method overriding and method hiding.

POLYMORPHISM:

2011-10-05T08:05:00.002+05:30

POLYMORPHISM:-

. Entities behaving in different ways depending upon the input it receives is known as polymorphism i.e. whenever the input changes the output or behavior of entity also changes , this can be implemented with an approach known as-

overloading and
overriding

Overloading –

It is an approach which allows defining multiple methods with the same name with in a class, but signature of the method should be different. Signature in the sense we can either change the type of parameter being pass to the method or number of parameter being pass to the method or order of parameter being pass to the method.

public void show()

public void show(int x)

public void show(string s)

public void show(int x , string s)

public void show(string s, int x)

Note – Change in the return type of method is not taken into consideration in overloading.

-Add a class LoadDemo.cs and write the following:

class LoadDemo

{

public void show()

{

Console.WriteLine(1);

}

public void show(int x)

{

Console.WriteLine(2);

}

public void show(string s)

{

Console.WriteLine(3);

}

public void show(int x, string s)

{

Console.WriteLine(4);

}

public void show(string s, int x)

{

Console.WriteLine(5);

}

static void Main()

{

LoadDemo d = new LoadDemo();

d.show(); d.show(10); d.show("Hello");

d.show(10, "hello"); d.show("hello", 10);

Console.ReadLine();

}

As discussed earlier whenever you changed the type of input applied to a method automatically a different method get executed that matches with the given type performing a different action.

Overloading is an approach which allows you to provide multiple behaviors to a methodexample – the WriteLine method that is defined with 19 different behaviors which can print any type of value i.e. supplies to it.

Constructor Overloading – Just like we can overload methods in the same way constructors of a class also can be overloaded, when a class contain multiple constructor in it we can use any constructor to create object of that class.

-Add a class LoadCon.cs and write the following:

using System;

namespace oopsProject

{

class LoadCons

{

int x;

public LoadCons()

{

this.x = x;

}

public LoadCons(int x)

{

x = 100;

}

public void Display()

{

Console.WriteLine();

}

static void Main()

{

LoadCons c1 = new LoadCons();

LoadCons c2 = new LoadCons(100);

c1.Display(); c2.Display();

Console.ReadLine();

}

We overload constructors of a class so that the variables of class can be initialized with either default values or by a given value supplied to the constructor as in our above example......

Inheritance Based overloading –

If at all a method which is declared under parent class is overloaded in the child class we called it as inheritance based overloading.

-Add a class LoadParent.cs and write the following:

using System;

namespace oopsProject

{

class LoadParent

{

public void show()

{

Console.WriteLine("Method Show1");

}

public void test1(int x)

{

Console.WriteLine("method test1");

}

-Add a class Class1.cs and write the following:

class LoadChild : LoadParent

{

public void test2(string s)

{

Console.WriteLine("Method test2");

}

static void Main()

{

LoadChild c = new LoadChild();

c.show(); c.test1(10); c.test2("hello");

Console.ReadLine();

}

Method overriding –

If at all a parent class method is redefined under the child class with the same signature we call it as method overriding.

Differences between overloading and overriding

overloading	overriding
it’s an approach of defining multiple methods with same name changing their signature	 It’s an approach of defining multiple methods with same name same signature.
this can be done with in class as well as within the child class also	This can be done only on the child class.
To overload a parent class method under child we don’t required any perdition from parent.	To override a parent class method under child we required an explicit permission from parent.