• the use of instance variables and private;
• the form constructor;
• the use of library classes;
• the use of new;
• using methods and properties;
• the Random class;
• the TrackBar and Timer

Introduction

Here is an analogy: reading a book - whatever the book - involves opening it at the front, reading a page, then moving to the next page. We know what to do with a book. It is the same with objects. When you have used a few of them, you know what to look for when presented with a new one.

In general, the objects we will make use of are termed controls or components. The terms are really interchangeable, but C# uses 'control' for items which can be manipulated on a form (such as a button).

Instance variables

Here we introduce a simple program (Car Park1, figure 6.1) to assist in the running of a car park (or parking lot). It has two buttons: 'entering' and 'leaving'. The attendant clicks the appropriate button as a car enters or leaves. The program keeps a count of the number of cars in the park, and displays it in a label.

fig 1 -Screenshot of Car Park1

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

namespace carpark1
{
    /// 

    /// Summary description for Form1.
    /// 
    public class Form1 : System.Windows.Forms.Form
    {
        private int carCount = 0;

        // lots of code we have omitted here


        private void enterButton_Click(object sender,
            System.EventArgs e)
        {
            carCount = carCount + 1;
            countLabel.Text = Convert.ToString(carCount);
 
        }

        private void leaveButton_Click(object sender, 
            System.EventArgs e)
        {
            carCount = carCount - 1;
            countLabel.Text = Convert.ToString(carCount);
        }
    }
}

The point at issue here is the declaring of the carCount variable, but before considering this, we need to overview the code as a whole, and identify the different sections. As you will see when looking at the screen, a large amount of code has been generated by the IDE, and we must leave most of it unaltered. However, there are times when we need to insert our own instructions into the middle of this created code. Here is its structure, which is basically similar for all programs:

• Locate the using items at the top of the program. These are used to incorporate groups of pre-written library classes into our program. Sometimes we need to add our own using items here, as we mention later in this chapter. For the printed listings in this book we will not always show the using items, because they are identical in most cases.
• Locate the namespace item. This is an advanced feature, which we will not cover here. In our printed code listings, we will strip off the namespace and its accompanying opening and closing curly brackets. This leaves us with the following:

  
  public class Form1 : System.Windows.Forms.Form
  {
      private int carCount = 0;
      
      //lots of code we have omitted here
  
      private void enterButton_Click(object sender, System.EventArgs e)
      {
  
      }
  
      private void leaveButton_Click(object sender, System.EventArgs e)
      {
  
      }
  }
  

  Though we will not always show the using items and the namespace, they must always be there in your programs. Do not delete them!
• Finally, we get to the class, which contains a number of private and public variables and methods. Identify the public class line, and its following opening {. Below this is where we can place private variable declarations.

• The variable carCount is declared outside the methods, but inside the class Form1. It can be used by any method in Form1.
• It has been declared as private, meaning that any other classes we might have cannot use it. The variable is encapsulated or sealed up inside Form1 i.e. it is for the use of the methods and properties of Form1 only.
• carCount is an example of an instance variable. It belongs to an instance of a class, rather than to one method. Another term is 'class- level' variable.
• carCount is said to have class scope. The scope of an item is the area of the program in which it can be used. The other type of scope we have seen is local scope used with local variables.
• The preferred style for instance variables is to declare them as private.
• The C# convention is not to capitalize the first letter of an instance variable.

public class Form1 : System.Windows.Forms.Form
{
    private int n = 8;


    private void MyMethod()
    {
        int n;
        n = 3;         //which n?
    }
}

Instance variables are essential, but you should not ignore locals. For example, if a variable is used inside one method only, and need not keep its value between method calls, make it local.

The form constructor

It is common for the initial values of controls to depend on variables and on other controls. We could attempt to set up this situation at design-time, but for several controls this is error-prone, and does not express the dependencies. It is better if we set up related initial values in code. Fortunately C# provides a special area of the program for such once-only initialisation. Look at the second version: Car Park2.

public class Form1 : System.Windows.Forms.Form
{
    private int carCount = 0;
    private System.Windows.Forms.Button enterButton;
    private System.Windows.Forms.Button leaveButton;
    private System.Windows.Forms.Label countLabel;
    private System.Windows.Forms.Label label1;
    /// 

    /// Required designer variable.
    /// 
    private System.ComponentModel.Container components = null;

    public Form1()
    {
        //
        // Required for Windows Form Designer support
        //
        InitializeComponent();
        countLabel.Text = Convert.ToString(carCount);

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

    private void enterButton_Click(object sender,
        System.EventArgs e)
    {
        carCount = carCount + 1;
        countLabel.Text = Convert.ToString(carCount);

    }

    private void leaveButton_Click(object sender, 
        System.EventArgs e)
    {
        carCount = carCount - 1;
        countLabel.Text = Convert.ToString(carCount);

    }
}

Recall that we normally omit the using lines at the top of the program, and the namespace with its { and }.

Locate the section headed:

public Form1()
{
    

When the C# system runs your program, the first thing it does is to call the constructor for the form. The role of the constructor is to build the form, and initialise it. (Note that because the constructor is called from outside the class, it is declared as public rather than private).

If you look at the code created for the constructor, you will see that it is mainly comments, aside from a method call:

InitializeComponent();

private int carCount = 0;

Note that the created code also identifies this area by a comment:

// TODO: Add any constructor code after InitializeComponent call

In this improved version of the program, we have no need to set the Text of the label at design time - instead, we have inserted code to do this task in the constructor, so the Text is guaranteed to be the same as carCount.

public Form1()
{
    ...etc

    label1.Text = "38";
    InitializeComponent();
}

In the above example, we modified the constructor, but did not call it ourselves. Later in this chapter, we will create new objects by explicitly calling the constructor of their class.

The TrackBar class

The track bar is not used for precise settings such as entering your age, where the range might be large. i.e. 10 to 100. It is used for more informal settings, such as setting the volume of a loudspeaker.

Here we look at a program (Oval Shape) which allows the user to modify the width and the height of an ellipse. The current dimensions are displayed on the form in labels. Figure 6.2 shows a screenshot, and here is the code:

public class Form1 : System.Windows.Forms.Form
{
    private Graphics paper;

    public Form1()
    {
        //
        // Required for Windows Form Designer support
        //
        InitializeComponent();
        paper = pictureBox1.CreateGraphics();
        vertTrackBar.Minimum = 0;
        vertTrackBar.Maximum = pictureBox1.Height;
        vertLabel.Text = Convert.ToString(vertTrackBar.Value);

        horizTrackBar.Minimum = 0;
        horizTrackBar.Maximum = pictureBox1.Width;
        horizLabel.Text = Convert.ToString(horizTrackBar.Value);
        //
        // TODO: Add any constructor code after 
        //       InitializeComponent call
        //

    } 



    private void vertTrackBar_Scroll(object sender,
        System.EventArgs e)
    {
        SolidBrush myBrush = new SolidBrush(Color.Black);
        vertLabel.Text = Convert.ToString(vertTrackBar.Value);
        paper.Clear(Color.White);
        paper.FillEllipse(myBrush, 0, 0, horizTrackBar.Value,
            vertTrackBar.Value);

    }

    private void horizTrackBar_Scroll(object sender,
        System.EventArgs e)
    {
        SolidBrush myBrush = new SolidBrush(Color.Black);
        horizLabel.Text = Convert.ToString(horizTrackBar.Value);
        paper.Clear(Color.White);
        paper.FillEllipse(myBrush, 0, 0, horizTrackBar.Value,
            vertTrackBar.Value);

    }
}

fig 2 - Screenshot of Oval Shape

• The track bars have been renamed as horizTrackBar and vertTrackBar.
• A track bar can be positioned vertically, by setting its Orientation property to Vertical.
• The labels have been renamed as horizLabel and vertLabel.
• We set the picture box to a size of 100, 100.

• We set the Minimum property of the track bars to 0, and the Maximum properties to the height and width of the picture box.
• The initial value of the Text property of horizLabel - which displays the current track bar value - is set to horizTrackBar.Value, and vertTrackbar is initialized in a similar way.

• The track bar's event method (Scroll) is called when we move it to a new position.
• The track bar's Value property gives us the current setting. We use this to control the size of an imaginary rectangle enclosing the oval.
• The drawing area is used by two methods, so it must be declared as an instance variable at class-level, above the methods.

using and namespaces

Because there are thousands of classes, they are sub-divided into groups known as namespaces. To use a class, we must ensure that it has been imported into our program with the using keyword. However, there are two possibilities, because some of the most frequently-used namespaces are automatically imported into any Windows application. These namespaces are:

System
System.Drawing
System.Collections
System.ComponentModel
System.Windows.Forms
System.Data

• if the class we require is in one of the above namespaces, we can use it with no further action;
• if the class we require is not in one of the above namespaces, we should put a using at the top of our program.

// declare a StreamReader object, named myStream
StreamReader myStream; 

using System.IO;

There are two points to note:

• the using instructions do not work in a hierarchical way. Importing the System namespace does not automatically import every namespace which starts with System. Every namespace must be imported explicitly.
• using merely provides us with a shorthand. For example, we could use the StreamReader class without importing, but we would have to put:

  System.IO.StreamReader myStream;
  

To summarise, the vast library of C# classes is organised into namespaces, which can be imported into any program. When you have imported your class, you need to know how to create a new instance, and how to use its properties and methods. We shall look at these areas in a range of examples.

Members, methods, and properties

Properties can be used in a similar manner to variables: we can place a new value in them, and access their current value. As an example, here is how the Width and Height properties of a label might be manipulated:

//set a new value in a property:
label1.Height = 30;
label1.Height = Convert.ToString(textBox1.Text);

//get current value of property:
int a;
a = label1.Height;
a = label1.Height * label1.Width;

int a;
a = label1.Width * label1.Height;
label1.Height = label1.Width;

The Random class

public class Form1 : System.Windows.Forms.Form
{
    private Random ageGuesser = new Random();
    private int tries = 0;

    public Form1()
    {
        //
        // Required for Windows Form Designer support
        //
        InitializeComponent();
        guessLabel.Text = 
            Convert.ToString(ageGuesser.Next(5, 110));

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


    private void correctButton_Click(object sender,
        System.EventArgs e)
    {
        tries = tries + 1;
        MessageBox.Show("Number of tries was: " + 
            Convert.ToString(tries));
        tries = 0;
        guessLabel.Text = 
            Convert.ToString(ageGuesser.Next(5, 110));
    }

    private void button1_Click(object sender, 
        System.EventArgs e)
    {
        guessLabel.Text = 
            Convert.ToString(ageGuesser.Next(5, 110));
        tries = tries + 1;
    }
}

fig 3 - Screenshot of Guesser

We must then declare and initialise an instance of our class. This can be done in two ways. Firstly we can use one statement, as in

private Random ageGuesser = new Random();

• we chose the name ageGuesser for our instance.
• The statement calls the constructor of the Random class, which always has the same name as the class itself. The constructor is basically a method.
• the word new precedes the use of the constructor. new creates a new instance of a class in RAM.
• constructors may be overloaded, so you need to choose the most convenient constructor. Random has two constructors, and the one with no parameters is suitable here.
• you can consider the statement to be in two parts:

  private Random ageGuesser...
  

  and

  ...  = new Random();
  

  The first part declares ageGuesser as a variable of class Random, but it does not yet have a concrete instance (containing methods and property values) associated with it. The second part calls the constructor of the Random class to complete the task of declaring and initialisation.

public  class Form1 : System.Windows.Forms.Form
{
    private Random ageGuesser;

...

    ageGuesser = new Random();

• The declaration establishes the class of the instance. Here it is an instance of Random.
• The declaration establishes the scope of the object. Here, ageGuesser has class scope - it can be used by any method of the Form1 class, rather than being local to a method.
• ageGuesser is private. It cannot be used by other classes outside our Form1 class. Normally we make all such variables private.
• The initialization must be within the form's constructor or a within another method.
• when it is possible to use the single-statement form of declaration and initialisation, do so.

In this case, we would put the initialisation code inside a method (or perhaps the constructor of the form). We cannot put the declaration within the method, as this would declare the item as local to the method.

Let us return to the Random program. So far, we have created an instance of the Random class, named ageGuesser. We have yet to create any actual random numbers.

Once an object has been created with new, we can use its properties and methods. The documentation tells us that there are several methods which provide us with a random number, and we chose to use the method which lets us specify the range of the numbers. The method is named Next (in the sense of fetching the next random number from a sequence of numbers). In our program, we put:

guessLabel.Text = 
    Convert.ToString(ageGuesser.Next(5, 110));

int guess;
guess = ageGuesser.Next(5, 110);
guessLabel.Text = Convert.ToString(guess);

The Timer class

• those from the toolbox - such as the button. They have a design-time representation on the form (e.g. they can be re-sized). They bring event- handling code templates with them, and code to call their constructors will automatically be placed in your code. Their initial properties can be set at design-time.
• Those from the libraries, without a visual representation - such as Random. They do not appear at design time, and we have to explicitly code up a call to its constructor. Properties can only be set at run-time.

Here are the main timer facilities:

• The timer creates ticks at regular intervals. Each tick is an event which calls the Tick method.
• the Interval property can be set to an integer value, representing the time between ticks in milliseconds.
• we can start and stop a timer with Start and Stop methods.
• we can put any number of timers in a program, each with a different interval.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       
public class Form1 : System.Windows.Forms.Form
{
    private Random randomNumber = new Random();
    private Graphics paper;

    public Form1()
    {
        //
        // Required for Windows Form Designer support
        //
        InitializeComponent();
        paper = pictureBox1.CreateGraphics();
        gapLabel.Text = Convert.ToString(trackBar1.Value);

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


    private void startButton_Click(object sender, 
        System.EventArgs e)
    {
        timer1.Start();
    }

    private void stopButton_Click(object sender,
        System.EventArgs e)
    {
        timer1.Stop();
    }

    private void clearButton_Click(object sender, 
        System.EventArgs e)
    {
        paper.Clear(Color.White);
    }

    private void trackBar1_Scroll(object sender, 
        System.EventArgs e)
    {
        int timeGap = trackBar1.Value;
        gapLabel.Text = Convert.ToString(timeGap);
    }

    private void timer1_Tick(object sender,
        System.EventArgs e)
    {
        int x, y, size;
        Brush myBrush = new SolidBrush(Color.Black);

        x = randomNumber.Next(0, pictureBox1.Width);
        y = randomNumber.Next(0, pictureBox1.Height);
        size = randomNumber.Next(1, 20);
        paper.FillEllipse(myBrush, x, y, size, size);

        // set new interval for timer
        timer1.Stop();
        timer1.Interval =
            randomNumber.Next(1, trackBar1.Value);
        timer1.Start();
    }
}

fig 4 - Screenshot of Raindrops

public class Form1 : ...
{
    private int secondCount = 0;

    private void timer1_Tick(...)
    {
       secondCount = secondCount + 1;
       label1.Text = Convert.ToString(secondCount / 60);
    }
}

Programming principles

As well as making use of existing components, C# can be used to write GUI components for use by others. Such components are simple to incorporate: they are added to a project by a menu action. From then on, they appear on the toolbox like any other control, and provide event-handling method headers and properties that can be set at design time. In practical terms, it is well worth searching for an existing control which meets your requirements, rather than re-inventing the wheel by coding from scratch.

Programming pitfalls

Grammar spot

• Instance variables are declared outside methods, using private, as in:

  private int yourVariable;
  private Random myVariable = new Random();                       
  

• Instance variables can be initialised at declaration time, or inside a constructor or method.
• Properties can be manipulated in a similar manner to variables: we can get and set their values.

New language elements

• Private instance variables
• Using new for initialisation
• using to import namespaces
• The TrackBar, Random, and Timer classes

New IDE facilities

Summary

1. Place a track bar on a form, together with two text boxes and a button. When the button is clicked, the track bar's Minimum and Maximum properties should be set from numbers entered in the text boxes. When the track bar is scrolled, display its minimum and maximum properties in message boxes.

2. Write a program which initially displays the number 1 in a label. Clicking a button should increment the value. Make use of a private variable initialised to 1, and set up the label in the constructor.

3. Write a program which produces a random number between 200 and 400 each time a button is clicked. The program should display this number, and the sum and average of all the numbers so far. As you click again and again, the average should converge on 300. If it doesn't, we would suspect the random number generator - just as we would be suspicious of a coin that came out heads 100 times in a row!

4. (a) Write a program which converts degrees Celsius to degrees Fahrenheit. The Celsius value should be entered in a text box - use integer values. Clicking a button should cause the Fahrenheit value to be displayed in a label. The conversion formula is:

f = (c * 9) / 5 + 32;

(c) represent both the temperatures as long thin rectangles in a picture box.

5. Write a program which calculates the volume of a swimming pool, and which also displays its cross-section in a picture box. The width of the pool is fixed at 5 metres and the length is fixed at 20 metres. The program should have two track bars - one to adjust the depth of the deep end, and one to adjust the depth of the shallow end. The minimum depth of each end is 1 metre. Choose suitable values for the maximum and minimum track bar values at design time. The volume formula is:

v = averageDepth * width * length;

fig 5 - pool cross-section

6. Write a program which displays changing minutes and seconds, representing them by two long rectangles: make the maximum width of the rectangles equal to 600 pixels to simplify the arithmetic (10 pixels for each minute and each second). Re-draw the two rectangles every second. Figure 6.6 shows a representation of 30 minutes and 15 seconds

fig 6 - time display - for 30 mins 15 secs

7. This question guides you through the writing of a geometry game:
(a) Write a program with two track bars which control the horizontal and vertical position of a circle of 200 pixels diameter.

(b) add a third track bar to control the diameter of the circle.

(c) What follows is a game based on the mathematical fact that a circle can be drawn through any three points. The program should display 3 points (each is a small filled circle) when a 'Next Game' button is clicked. Good initial positions are (100,100), (200,200), (200,100) but you can add a small random number to them for variety. The player has to manipulate the circle until they judge that the circle goes through each point, they then click a 'Done' button.

(d) add a timer to display how long the task takes.