3.1  Introducing Windows Forms


Windows Forms:

To write GUI applications in Microsoft .NET, Windows Forms are to be used. Windows Forms are a new style of application built around classes in the .NET Framework class library's System.Windows.Forms namespace. The programming model is cleaner, more robust, and more consistent than models based on the Win32 API or MFC, and runs in the managed environment of the .NET Common Language Runtime (CLR). For an old MFC (or Windows API) developer, Windows Forms are a great way to get started with the .NET Framework class library because they enable to write traditional GUI applications that create windows, process user input, and the like. Learning Windows Forms makes working with other parts of the .NET Framework easier, too.


The chief benefit of writing Windows-based applications the Windows Forms way is that Windows Forms homogenize the programming model and eliminate many of the bugs, quirks, and inconsistencies that plague the Windows API. For example, every experienced Windows-based programmer knows that certain window styles can only be applied to a window when that window is created. Windows Forms largely eliminate such inconsistencies. If you apply a style that's only meaningful at creation time to an existing window, Windows Forms will quietly destroy the window and recreate it with the specified style. In addition, the .NET Framework class library is much richer than the Windows API, and when writing applications using Windows Forms, the full power of the framework at the developer’s disposal. More often than not, applications written using Windows Forms require less code than applications that use the Windows API or MFC.


Another benefit of Windows Forms is that the same API is used, regardless of which programming language is chosen. In the past, the choice of programming language drove the choice of API. Programmers in Visual Basic used one API (the one embodied in the Visual Basic language), while C programmers used the Win32 API, and C++ programmers, by and large, used MFC. It was tough for an MFC programmer to switch to Visual Basic, or vice versa. All applications that use Windows Forms are written to one API—that of the .NET Framework class library. The knowledge of one API is sufficient to allow programmers to write applications in virtually any language they choose.


Windows Forms Programming Model:

A form is a bit of screen real estate, usually rectangular, that you can use to present information to the user and to accept input from the user. Forms can be standard windows, multiple document interface (MDI) windows, dialog boxes, or display surfaces for graphical routines. The term “form” means the top-level window in Windows Forms. An application's main window is a form. Any other top-level windows the application has are forms also. Dialog boxes are also considered forms. Despite their name, applications using Windows Forms don't have to look like forms. Like traditional Windows-based applications, applications exercise full control over what appears in their windows.


The easiest way to define the user interface for a form is by placing controls on its surface. Forms are objects that expose properties, which define their appearance, methods that define their behavior, and events that define their interaction with the user. By setting the properties of the form and writing code to respond to its events, you customize the object to meet the requirements of your application.

As with all objects in the .NET Framework, forms are instances of classes. The form that is created with the Windows Forms Designer is a class, and when displayed an instance of the form at run time, this class is the template used to create the form. The framework also allows you to inherit from existing forms to add functionality or modify existing behavior. When you add a form to your project, you can choose whether it inherits from the Form class provided by the framework, or from a form you have previously created. Additionally, forms are controls, because they inherit from the Control class.

Within a Windows Forms project, the form is the primary vehicle for user interaction. By combining different sets of controls and writing code, information could be elicited from the user and responded, work with existing stores of data, and query and write back to the file system and registry on the user's local computer. Although the form can be created entirely in the Code Editor, it is easier to use the Windows Forms Designer to create and modify forms.

Programmers see Microsoft .NET through the lens of the .NET Framework class library. Applications using Windows Forms rely heavily upon classes found in the System.Windows.Forms namespace. That namespace includes classes such as Form, which models the behavior of windows or forms; Menu, which represents menus; and Clipboard, which enables Windows Forms applications to access the clipboard. It also contains numerous classes representing controls with names like Button, TextBox, ListView, and MonthCalendar. These classes can be referred to using their class names only, or using fully qualified names such as System.Windows.Forms.Button.


At the heart of nearly every Windows Forms-based application is a class derived from System.Windows.Forms.Form. An instance of that class represents the application's main window. System.Windows.Forms.Form has scores of properties and methods that comprise a rich programmatic interface to forms. Windows Forms-based applications that use pushbuttons, listboxes, and other Windows control types rely on the control classes in System.Windows.Forms.


Another important building block of an application that uses Windows Forms is a System.Windows.Forms class named Application. That class contains a static method named Run that gets a Windows Forms-based application up and running by displaying a window and providing a message loop. Many classes have virtual methods that you can override to respond to paint messages, mouse messages, and the like. For example, System.Windows.Forms.Form contains a virtual method named OnPaint that's called when a form's client area needs updating. OnPaint is one of many virtual methods to override in a derived class to build interactive forms; OnMouseDown, OnKeyDown, and OnClosing are some of the others.


Another important facet of the Windows Forms programming model is the mechanism that forms use to respond to input from menus, controls, and other GUI application elements. Traditional Windows-based applications process WM_COMMAND and WM_NOTIFY messages using Windows Forms process events. In C# and in other languages that support the .NET Common Language Runtime (CLR), events are first-class type members on par with methods, fields, and properties. Virtually all Windows Forms control classes (and many non-control classes, too) fire events. For example, button controls—instances of System.Windows.Forms.Button—fire Click events when they're clicked. EventHandler is a delegate defined in the System namespace. A delegate is the CLR's equivalent of a type-safe function pointer. An EventHandler is wrapped around the method that handles an event and added to the list of event handlers called when the control fires the event.



A Simple Windows Forms Example:

In this example we will develop a very simple and standard “Hello World” application as a Windows Forms application in C# using VS.NET.

Step 1: Open the VS.NET, choose File->New->Project from the menu. The following dialog box appears:

·       Choose “Visual C# Projects” on the “Project Types” window,

·       Choose “Windows Application” on the “Templates” window,

·       Type the “Name” as “HelloWorld” and

·       Choose the path under which the application folder would be stored.

Click OK.




Step 2:

The following Forms Designer appears on the screen with an empty form “Form1.cs[Design]” as shown below. Some of the features of the VS.NET are described hereunder:


To view the code of the Form, right click on the “Form1.cs” in the “Solution Explorer”, choose “View Code”. The “Form1.cs” is now available as a tabbed window next to the “Form1.cs[Design]”.


On the “Properties Window”, set the “Name” property to “HelloWorldForm” and the “Text” property to “HELLO WORLD”.



                                                                        Properties Window

            Design View                                                                           Solution Explorer


Toolbox                       Code View


Step 3:

Move the mouse over the “Toolbox” on the upper left corner of the window. The toolbar slides out. Choose “Label” under “Windows Forms”, drag and drop it inside the form.


While the focus is on the “label”, make the following changes in the properties window:

·       Change the “Name” to hwlabel

·       Change the “Text” to “HELLO WORLD”

·       Change the “Text Align” to MiddleCenter


Step 4:

From the menu choose Build->Build (or Rebuild All). Choose Debug->Start Without Debugging to run the application. The following form appears as the output:



The code generated for the above application is hereunder:


using System;                                       // The root of the namespaces in the .NET framework

using System.Drawing;                          // The namespace for GUI in the .NET framework

using System.Collections;                       // The namespace for data structures

using System.ComponentModel;

using System.Windows.Forms;               // The namespace for Windows Forms Application

using System.Data;


namespace HelloWorld                          // The name of the project


      /// <summary>

      /// Summary description for Form1.

      /// </summary>

      public class HelloWorldForm : System.Windows.Forms.Form  // The form class


            private System.Windows.Forms.Label hwlabel; // The label declared

            /// <summary>

            /// Required designer variable.

            /// </summary>

            private System.ComponentModel.Container components = null;


            public HelloWorldForm()  // The constructor of the form



                  // Required for Windows Form Designer support


                  InitializeComponent(); // This method initializes all the components of the

                       // form with the properties specified in the properties window for each of them

                  // -------------TODO: Add any constructor code after InitializeComponent call


            /// <summary>

            /// Clean up any resources being used.

            /// </summary>

            protected override void Dispose( bool disposing )


                  if( disposing )


                        if (components != null)





                  base.Dispose( disposing );


            #region Windows Form Designer generated code

            /// <summary>

            /// Required method for Designer support - do not modify

            /// the contents of this method with the code editor.

            /// </summary>

            private void InitializeComponent()


                  this.hwlabel = new System.Windows.Forms.Label();


                  // -------------------------------------hwlabel

                  this.hwlabel.Anchor = System.Windows.Forms.AnchorStyles.None;

                  this.hwlabel.Name = "hwlabel";

                  this.hwlabel.Size = new System.Drawing.Size(296, 280);

                  this.hwlabel.TabIndex = 0;

                  this.hwlabel.Text = "HELLO WORLD";

                  this.hwlabel.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;

                  // ----------------------------------HelloWorldForm

                  this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);

                  this.ClientSize = new System.Drawing.Size(292, 273);

                  this.Controls.AddRange(new System.Windows.Forms.Control[] {


                  this.Name = "HelloWorldForm";

                  this.Text = "Hello World";




            /// <summary>

            /// The main entry point for the application.

            /// </summary>


            static void Main()           // The main method that starts up the form application


                  Application.Run(new HelloWorldForm());




3.2  The .NET Framework Classes for Windows Forms


As described earlier the namespace System.Windows.Forms contains the framework of classes that aid in developing Windows Forms applications in .NET. The following chart explains in detail the hierarchy of the classes in this namespace.










































The classes in the above hierarchy chart are explained in detail in the section “Controls in Windows Forms”.




3.3  Creating Windows Forms


The steps involved in creating a simple Windows Form using C# was depicted in the “Hello World” example in the first section of this chapter. While the example dealt with the creation of the form using VS.NET, the application can be developed on any text editor, by writing a class that derives from System.Windows.Forms.Form class of the .NET Framework’s class library.


Form is a container control that derives from System.Windows.Forms.Form class. A form can be derived from an existing form too, which is called “Visual Inheritance”. The purpose of a form is to present information to the user and to accept user input. Users interact with the controls on the form. The properties that a form exposes are discussed in the section “Working with Properties” and the events that correspond to forms are discussed in the section “Working with Events”. The following section explains in detail about the controls that can be added to a form. The example provided hereunder is the same “Hello World” application that was discussed earlier; this time developed using a notepad. The steps involved are provided in detail.


A Simple Windows Forms Example:

Type the following code in a notepad and save it as “simplehelloworld.cs”.


using System;


public class SimpleHelloWorld : System.Windows.Forms.Form {



        public static int Main(string[] args) {

            System.Windows.Forms.Application.Run(new SimpleHelloWorld());

            return 0;



        public SimpleHelloWorld() {

            this.Text = "Hello World";




To compile the above program, type the following in the MS-DOS prompt, in the directory under which the file exists:


csc simplehelloworld.cs


The above command produces simplehelloworld.exe, the executable that could be run to see the following output.



As we had not added any control to the form, except that we set the Form’s “Text” property, the output is as shown above.


Note that in order to compile and run the above code, the “path” should be set to the directory in which the “csc.exe” exists. Typically it would be under C:\WINNT\Microsoft.NET\Framework\v1.0.2914, and so the path should be set to this directory before the compile command is issued on the DOS prompt. To run the program, just say “simplehelloworld” at the prompt, as this is the name of the “.exe” file generated after compilation.



3.4  Controls in Windows Forms


This section explores the various controls available for the programmer in the .NET framework that could be used in Windows Forms applications. Controls are components that allow a user to interact with the application in various ways – for example a commonly used control is the push button. The .NET control types can be broadly classified into the following types:


Command Controls:

·       Button, LinkLabel, NotifyIcon and ToolBar


Text Controls:

·       TextBox, RichTextBox, Label and StatusBar


Option Controls:

·       Checkbox, RadioButton, CheckedListBox, ComboBox, DomainUpDown, NumericUpDown, ListBox, ListView and TreeView


Container Controls:

·       Panel, GroupBox, and TabControl


Graphic Controls:

·       PictureBox and ImageList


Menu Controls:

·       MainMenu and ContextMenu


Dialog Controls:

·       OpenFileDialog, SaveFileDialog, ColorDialog, FontDialog, PrintDialog, PrintPreviewDialog and PageSetupDialog


Other useful controls:

·       DateTimePicker and MonthCalendar

·       DataGrid

·       Splitter

·       HscrollBar and VscrollBar

·       TrackBar and ProgressBar

·       Tooltip and ErrorProvider

·       Timer


These controls are subclasses of  System.ComponentModel.Component.



Adding and Removing Controls:

To include a control in a Windows Form, we must add it to the form. To do this, we must first create an instance of the desired control and add it to the Windows Form. Adding controls to a Windows form could be done either by drawing the control on the Form when working on VS.NET or adding the control programmatically incase of developing an application without the IDE. These methods are explained hereunder:


In order to draw a control on a Windows Form,


If we desire to add controls using their default sizes that is provided by the framework, then,

Controls can also be added to a form using the Add() method as follows. In this example, a Textbox control is added at location (50,50) on the Form.


            Textbox tb = new Textbox();               // this creates the Textbox control

            tb.Location = new Point(50,50);         // this fixes the location at (50,50)

            this.Controls.Add(tb);                         // this adds the control to the form


Sometimes, it would be necessary to remove a control from a form when it is no longer required in the application. To do this, we can use the Remove() method as follows:


            this.Controls.Remove(tb);  // this removes the text box added above from the form



Responding to Controls:

Except for labels that are passive controls, all controls generate events when accessed by the user. An event is an action that you can respond to or "handle" in code. Events can be generated by a user action, such as clicking the mouse or pressing a key, by program code or by the system. Event-driven applications execute code in response to an event. Each form and control exposes a predefined set of events that could be programmed against. If one of these events occurs and there is code in the associated event handler, that code is invoked. An event handler is a method that is bound to an event. When the event is raised, the code within the event handler is executed.


For example, most objects will handle a Click event — if a user clicks a button, code in the button's Click event handler is executed. Many events could occur in conjunction with other events. For example, in the course of the Click event occurring, the MouseDown, MouseUp, and Click events occur. The concept of Event Handling and how events are handled in .NET are discussed in detail in the section 3.6 of this chapter. The various types of controls briefly described above are explained in detail in this section. The following section 3.5 explores the properties that can be set to different controls as well as the Form of a Windows Form application.


Command Controls - Button:


The most widely used control is the Button, a component that generates an event when pressed. It has a label on it displaying some message to the user on its usage. This may be in the form of a text or in the form of images. The Button allows the user to click on it to perform some actions. When clicked it looks as if it has been pressed and generates the Click event. If code exists for Click event handling method of the button exists then it is executed.


To demonstrate the usage of a Button in a Windows Form Application, let us consider a very simple example:


This example has three buttons on a form and a label that displays an appropriate message on the click of each button.



The project is created and an empty Windows Form appears on the Forms Designer. On the “Properties Window” of the Form,


·       Set the form Name as “btnForm”

·       Set the form Text as “DEMO FOR BUTTON CONTROL”

·       Choose the “Button Control” on the Toolbox and drag and drop it thrice side by side onto the Form.

·       Set the properties of each button as follows:

Button1 – Name : btnAccept

                 Text   : ACCEPT

Button2 – Name : btnReject

                 Text   : REJECT

Button3 – Name : btnUD

                 Text   : UNDECIDED


Now that we have designed our form, we can add events to each of the three buttons. Double clicking the mouse on each of the buttons takes us to the event handler method for the button.

private void btnAccept_Click(object sender, System.EventArgs e)


                                             lblChoice.Text = "You chose ACCEPT as your option";


private void btnReject_Click(object sender, System.EventArgs e)


                                             lblChoice.Text = "You chose REJECT as your option";



                              private void btnUD_Click(object sender, System.EventArgs e)


                                             lblChoice.Text = "You chose UNDECIDED as your option";



As we could see from the above code, we are just setting the Text of the label that we added to the form to display a message indicating which option has been chosen, when each of the buttons is clicked by the user.



The following screen appears:




Click on each of the buttons to find the message displayed.







Creating an Access Key for a Button:

We can also give the option of selecting a button to the user in the form of typing the ALT key + any character in the text displayed on the button, by adding an ampersand in front of the letter to be made as the access key. For example, in the above example, the ACCEPT button could also be made to access by the ALT+A key if the btnAccept.Text property is set as “&ACCEPT” instead of “ACCEPT”. Now, let us change the Text of each of the buttons in the example as follows:

            ACCEPT as &ACCEPT

            REJECT as &REJECT


Now compile and run the application to see the results using the ALT+key options. Choosing ALT+A displays the following:




Command Controls - LinkLabel:

A LinkLabel control is very similar to a Label control except that it is used to display hyper-links on a Windows Form. Clicking the hyper-link would perform a specified task, for example display a web site in the Internet Explorer, as the code in the LinkClicked event handler method would specify. A LinkLabel could be made to display multiple hyper-links as each of the links is an item in the LinkCollection of the control. Also, links can be added and removed from the LinkCollection using the Add and Remove methods respectively. Alternatively, the LinkArea property could be used to specify the link in the LinkLabel. The LinkLabel.Links.Add method enables to convert text within the LinkLabel control to a link that can be clicked on by the user to perform tasks similar to a Button control.


The LinkLabel provides a number of properties that enable you to define the display appearance of hyperlinks in the control. The ActiveLinkColor, DisabledLinkColor, LinkColor and VisitedLinkColor properties define the colors used when displaying a hyperlink in various states. The LinkBehavior property defines the display of the underline that is associated with a hyperlink.


Let us consider an example that has a hyper-link, clicking which would take the user to the page “www.msn.com”.


Name : lnklblMSN

Text : Click here to reach to MSN


We can see that the entire Text is shown as a hyper-link on the form. This is because by default the entire text is added to the LinkCollection class of the control.



Now we can see that only “here” is shown as hyperlink.



private void lnklblMSN_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)


               // Determine which link was clicked within the LinkLabel.

               lnklblMSN.Links[lnklblMSN.Links.IndexOf(e.Link)].Visited = true;

// Display the appropriate link based on the value of the LinkData property of the Link //object.

               System.Diagnostics.Process.Start(e.Link.LinkData.ToString()); // starts IE





// TODO: Add any constructor code after InitializeComponent call


lnklblMSN.Links.Add(6,4,"www.msn.com");  // sets link for here in Click here to reach MSN



We can see that when the hyperlink is clicked, we are connected to the MSN homepage. This explains the usage of a LinkLabel control in an application.


You can set multiple hyperlinks to a single link by making different parts of the text property of the label link to point to different web sites. For example,  by adding the following two lines in the constructor, Click (in Click here to reach MSN) will point to msn site and to will point to yahoo site:






Command Controls - ToolBar:

A ToolBar control is one that is used to display a set of ToolBarButon controls, that would act as short-cuts to any menu item in an application. The buttons can be of various styles like a standard button, toggle button and drop-down button. Images and Text can be added to the buttons to display any useful message about the button. ToolBarButton controls are added to the toolbar by using the Add or Insert methods on the Buttons property of the ToolBar. The event handler method ButtonClick is invoked when a button on a ToolBar is clicked.


Let us now consider a small example to understand the usage of a ToolBar and ToolbarButton control in a Windows Form application.



private void tbDemo_ButtonClick(object sender, ToolBarButtonClickEventArgs e)




                              case 0:

                                             lblMessage.Text = "Button 1 was clicked on the ToolBar";


                              case 1:

                                             lblMessage.Text = "Button 2 was clicked on the ToolBar";


                              case 2:

                                             lblMessage.Text = "Button 3 was clicked on the ToolBar";








Initial screen:                                               When Button 1 is clicked:



When Button 2 is clicked:                            When Button 3 is clicked:



The appearance and behavior of the ToolBarButton controls on the ToolBar can be set to different types and styles as desired by the developer. Also images can be added to the ToolBarButton controls and the text made to appear at different positions on the button controls. These are set using the properties of the ToolBarButton Collection and would be discussed in the section “Working with Properties”.



Text Controls – Label:


The easiest control that could be used in any Windows application is a “Label”. It contains a string that it displays. Labels are passive controls that do not support any interaction with the user. At any point of time, the string that is held by the Label control is accessed using its Text property. In the examples that we had seen so far, we had used label controls in almost all of them. We hope that the reader would have understood the usage of this control well through those examples and hence a separate example for this control is not provided here.


Text Controls – TextBox:


A TextBox control is used whenever user input in an application is required. Typically a TextBox control is used to accept single-line input from the user, but by setting certain properties it could be modified to accept multi-line input and also to accept passwords that would not appear as characters but as an asterix on the screen. Also Horizontal and Vertical Scroll bars could be activated incase of multi-line input.


The following example explains the usage of a single-line and a multi-line TextBox control in any Windows Application.

Set the properties of each of the TextBox controls as follows:


TextBox control 1 :

Name – tbName

Text – empty


TextBox control 2:

Name – tbComments

Text – empty

Multiline – true

Size – 270, 60

ScrollBars – Vertical


private void btnOK_Click(object sender, System.EventArgs e)


               string str = "";

               str += "Name entered is : " + tbName.Text + "\n";

               str += "Your comment is : " + "\n";

               str += tbComments.Text;





This explains the usage of TextBox controls, single-line and multi-line in a Windows Application.


Initial screen in which user input in the TextBox controls are to be entered:



Message box displaying all information entered, to demonstrate that input through text boxes could be read in the application and manipulated using relevant code.




Text Controls -  RichTextBox:


The RichTextBox control allows the user to enter and edit text just as a TextBox control, but it provides more advanced formatting features than the standard TextBox control. This control is typically used to provide text manipulation and display features similar to word processing applications such as Microsoft Word. A list of features offered by the RichTextBox control are summarized as follows:


As the usage of a RichTextBox control is similar to that of a TextBox control explained in the previous section, we skip a separate demo of this control’s usage.


Text Controls – StatusBar:


A StatusBar control is generally added to a Form to display certain useful tips and messages to the user when the application is running. It is added by default to the bottom of the Form as the DockStyle.Bottom is used in the constructor of the StatusBar control.


To exhibit the use of a StatusBar control, let us add a StatusBar to the TextBoxDemo application that was developed before.

Name  - sbDemo

Text – empty

private void tbName_TextChanged(object sender, System.EventArgs e)


               sbDemo.Text = "User typing name";



private void tbComments_TextChanged(object sender, System.EventArgs e)


               sbDemo.Text = "User typing comments";



When name is entered:                                 When comments are entered:                                                  



Status bar displaying the messages


Option Controls – CheckBox:


A CheckBox control is one that is used to give the user an option such as yes or no. It is a combination of a small box and an associated label or image or both that describes the option represented by the CheckBox control. The box can either contain a check mark or not depending on whether the option is turned on or off respectively. The user can change the state of a CheckBox control by clicking on it. A CheckBox control is usually used in places where the user is asked to choose a combination of options from a list. The Checked property of the CheckBox control is used to get or set its value.


To demonstrate the use of CheckBox controls let us consider a simple Windows Form application hereunder:



private void btnOK_Click(object sender, System.EventArgs e)


               string str = "Chosen fruits:\n";

               if(cb1.Checked == true) str += cb1.Text + "\n";

               if(cb2.Checked == true) str += cb2.Text + "\n";

               if(cb3.Checked == true) str += cb3.Text + "\n";

               if(cb4.Checked == true) str += cb4.Text + "\n";




The above example describes the usage of CheckBox controls in Windows Form applications.


Initial screen :




Message Box that appears on OK:




Option Controls – RadioButton:


RadioButton and CheckBox controls have a similar function: they offer choices a user can select or clear. The difference is that multiple CheckBox controls can be selected at the same time, but radio buttons are mutually exclusive. That is only one of the set of radio buttons can be chosen as the option by the user. Radio buttons are to be defined as a group of which one would be chosen. When the user selects one radio button within a group, the others clear automatically.


The following example explains the usage of radio buttons in an application.


private void btnOK_Click(object sender, System.EventArgs e)


                              string str = "";

                              if(rb1.Checked == true) str = "You are very likely to attend the meet";

                              if(rb2.Checked == true) str = "You are likely to attend the meet";

                              if(rb3.Checked == true) str = "You are not likely to attend the meet";

                              if(rb4.Checked == true) str = "You will definitely not attend the meet";




The above example describes the usage of RadioButton controls in Windows Form applications.

Initial screen:                                                             

Message on OK:




Option Controls – ListBox:


A ListBox control provides the user with a compact, single or multiple choice, scrollable selection list. The SelectionMode property has three modes single, simple multiple (selects all items clicked) and extended multiple (SHIFT and CTRL keys activated) options. It also has properties when set, would avoid scrolling and display the items in the ListBox in multiple columns. The ListBox class supports three types of Collections that enable us to access the items in the ListBox. They are briefly explained hereunder:


ListBox.ObjectCollection:                            Contains all the items in the ListBox control. The Add method of this class is used to add items to the ListBox control.


ListBox.SelectedObjectCollection:             This contains the objects that have been selected in the ObjectCollection of the ListBox. It represents a subset of the entire set of items in the ObjectCollection, those items that are selected from the list.


ListBox.SelectedIndexCollection:                Contains a collection of the selected indices, which is a subset of the indices of the ListBox.ObjectCollection. These indices specify items that are selected.


The following example explains the usage of ListBox controls in Windows Form applications.


ListBox control 1:

Name – lbColors

SelectionMode – MultiSimple

Click on the Collection of the Items property that displays a dialog. Type in some colors one per line and click OK.

Adjust the size of ListBox control lbColors to display only three colors and the rest scrollable.


ListBox control 2:

Name – lbPaint

SelectionMode – MultiExtended

Click on the Collection of the Items property that displays a dialog. Type in some paint types – Oil paint, Cement paint, Emulsions, Plastic coats etc. one per line and click OK.

Adjust the size of ListBox control lbPaint to display only three paint types and the rest scrollable.



private void btnOK_Click(object sender, System.EventArgs e)


               string str = "Selected Colors :\n";

               foreach (object item in lbColors.SelectedItems)


                              str += item.ToString() + "\n";


               str += "\nSelected Paint Types :\n";

               foreach (object item in lbPaint.SelectedItems)


                              str += item.ToString() + "\n";






Initial Screen:


When items are selected:


Message box on OK:


Option Controls – CheckedListBox:


A CheckedListBox control is very similar to a ListBox control, except that each item in the list has a check box associated with it that the user can check or uncheck by clicking on it. Also the user can move through the items in the list either using the scroll bars or the keyboard.


Similar to the ListBox control’s Collection types, a CheckListBox control is also associated with three types of collection classes –

CheckedListBox.ObjectCollection, CheckedListBox.CheckedItemCollection and CheckedListBox.CheckedIndexCollection - that accomplish the same tasks as the collection classes of the ListBox.


The following example explains the usage of a CheckedListBox control.



Name - clbStates

Click on the Collection of the Items property that displays a dialog. Type in some name of US states one per line and click OK.

Adjust the size of CheckedListBox control clbStates to display only three states and the rest scrollable.



private void btnOK_Click(object sender, System.EventArgs e)


               string str = "You would like to visit:\n";

               foreach (object item in clbStates.CheckedItems)


                              str += item.ToString() + "\n";





Initial Screen:                                                     When some states are selected:



Message Box on OK:



Option Controls – ComboBox:


The ComboBox control is used to create a drop-down list of items from which the user may choose one. When inactive, the control takes the space of displaying one item only that is currently selected. When the user clicks on the arrow of the control, the entire list drops down, from which a new selection could be made. Items could also be added to the list at runtime using the AddRange (multiple items) and the Add (single item) methods.


The following example explains the usage of a ComboBox control.


Name - cbbAge

Click on the Collection of the Items property that displays a dialog. Type in the ranges of ages as shown below and click OK.



private void btnOK_Click(object sender, System.EventArgs e)


               string str = "You selected the range : " + cbbAge.SelectedItem.ToString() + "\n";

               str += "The index of this range is : " + cbbAge.SelectedIndex;

               lblMessage.Text = str;





Initial Screen:                                               When some age range is selected: