﻿ Lesson 14: Details on Counting and Looping

Doing Something While a Condition is True

Introduction

The C# language supports various ways to keep checking a condition to take some action until a condition becomes false. In the previous lesson, we saw that one way to perform this operation is with the with keyword. We also saw that this with keyword by itself doesn't control the starting point of its operation. You need an external way to set that starting point. Fortunately, C# provides various options to address different issues related to counting and looping.

Practical Learning: Introducing Looping

1. Start Microsoft Visual Studio and create a new Console application (.NET Framework) named DoubleDecliningBalance1
2. Design the form as follows:

 Control (Name) Text TextAlign Label Machine Cost: TextBox txtMachineCost Right Label Estimated Life: TextBox txtEstimatedLife Right Label Years Button btnCalculate Calculate Label ____________ Label Declining Rate: TextBox txtDecliningRate Right Label % ListView lvwDepreciation ```View: Details GridLines: True FullRowSelect: True Anchor: Top, Bottom, Left, Right```

List View Columns

 (Name) Text TextAlign Width colYears Years 35 colBeginningOfYear Book Value at Beginning of Year Center 170 colDepreciationYear Depreciation for the Year Center 130 colEndOfYear Book Value at End of Year Center 140
3. On the form, double-click the Calculate button

do This while a Condition is True

Sometimes, before executing a repeating action, or before checking the condition for the first time, you may want to first execute a statement. In other words, you want to first execute a statement before checking its condition. To make this possible, the C-based languages, which includes C#, use a combination of the do and while keywords used in a formula as follows:

`do statement while (condition);`

If the statement includes more than one line of code, you must include the statement section in a body included inside curly brackets. The formula becomes:

```do {
statement
} while (condition);```

The body delimited by curly brackets can be used even it there is only one statement to exercute.

The do...while condition executes a statement first. After the first execution of the statement, the compiler examines the condition. If the condition is true, then it executes the statement again. It will keep executing the statement as long as the condition is true. Once the condition becomes false, the looping (the execution of the statement) will stop. This can be illustrated as follows:

If the statement is a short one, such as made of one line, you can write it after the do keyword. Like the if and the while statements, the condition being checked must be included between parentheses. The whole do...while statement must end with a semicolon. Here is an example:

If you are creating the condition in a method of a class, if the statement is long and should span more than one line, start it with an opening curly bracket "{" and end it with a closing curly bracket "}".

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
int number = 0;

do {
WriteLine("Make sure you review the time sheet before submitting it.");

number++;
} while (number <= 4);

WriteLine("==========================================================");
return 1_000;
}
};```

This would produce:

```Make sure you review the time sheet before submitting it.
Make sure you review the time sheet before submitting it.
Make sure you review the time sheet before submitting it.
Make sure you review the time sheet before submitting it.
Make sure you review the time sheet before submitting it.
==========================================================
Press any key to continue . . .```

Practical Learning: doing Something while a Condition is True

1. Change the document as follows:
```using System;
using System.Windows.Forms;

namespace DoubleDecliningBalance1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void btnCalculate_Click(object sender, EventArgs e)
{
int    estimatedLife;
double machineCost = 0.00;

try
{
machineCost = double.Parse(txtMachineCost.Text);
}
catch (FormatException)
{
MessageBox.Show("You must type a valid value that represents the " +
"cost of the machine. Since you don't provide a " +
"valid value, we will set the machine cost to 0.00.",
"Depreciation: Straight-Line Method");

txtMachineCost.Text = "0.00";
}

try
{
estimatedLife = int.Parse(txtEstimatedLife.Text);
}
catch (FormatException)
{
MessageBox.Show("You didn't enter a valid number of years for the life of " +
"the machine. Please correct it, otherwize, we will consider that this machine " +
"has no life, or a life of 0 years.",
"Depreciation: Straight-Line Method");

estimatedLife = 1;
txtEstimatedLife.Text = "1";
}

double decliningRate = (100.00 / estimatedLife) * 2.00;

double[] yearlyDepreciations = new double[estimatedLife];
double[] bookValuesEndOfYear = new double[estimatedLife];
double[] bookValuesBeginningOfYear = new double[estimatedLife];

int year = 1;
// Year 1
bookValuesBeginningOfYear[0] = machineCost;
yearlyDepreciations[0] = machineCost * decliningRate / 100;
bookValuesEndOfYear[0] = machineCost - yearlyDepreciations[0];

int i = 1;

// The other years
do
{
yearlyDepreciations[i] = bookValuesEndOfYear[i - 1] * decliningRate / 100;
bookValuesEndOfYear[i] = bookValuesEndOfYear[i - 1] - yearlyDepreciations[i];
bookValuesBeginningOfYear[i] = bookValuesEndOfYear[i - 1];
i++;
} while (i <= estimatedLife - 1);

i = 0;

ListViewItem lviDepreciation = null;

// Displaying the values
txtDecliningRate.Text = decliningRate.ToString("F");

lvwDepreciation.Items.Clear();

do
{
lviDepreciation = new ListViewItem(year.ToString());

i++;
year++;
} while (i <= estimatedLife - 1);
}
}
}```

3. Enter the following values:
```Machine Cost:  24680
Estimated Life 8```
4. Click the Calculate button:

6. Start a new Windows Forms App (.NET Framework) named CountriesStatistics2
7. Design the form as follows:

 Control (Name) Text TextAlign Label United Mexican States Font: Georgia, 20.25pt, style=Bold Label ____________________________________ ListView lvwStates ```View: Details GridLines: True FullRowSelect: True Anchor: Top, Bottom, Left, Right```

List View Columns

 (Name) Text TextAlign Width colNumber # 25 colStateName State Name 100 colCapital Capital 150 colAreaSqrKms Area (Sqr Kms) Right 90 colAreaSqrMiles Area (Sqr Ml) Right 80 colAdmissionToFederation Admission to Federation Center 130
8. Right-click the form and click View Code

Counting for a Loop

Introduction

Some operations require that you visit each item in a range, usually a range of numbers. To let you do this,the C-based languages, including C#, provide the for keyword. The primary formula to follow is:

`for(start; end; frequency) statement;`
• If you are writing your code in a method of a class and if the statement can fit on one line, you can follow the above formula
• If the statement(s) need many lines of code, in fact even if the statement is for one line of code, include it in curly brackets

The for loop is typically used to visit each number of a range. For this reason, it is divided in three parts. The first section specifies the starting point of the range. This start expression can be a variable assigned to the starting value. An example would be int count = 0;.

The second section sets the counting limit. This end expression is created as a Boolean expression that can be true or false. An example would be count < 5. This means that the counting would continue as long as the value of start is less than 5. When such a condition becomes false, the loop or counting would stop.

The last section determines how the counting should move from one value to another. If you want the loop to increment the value from start, you can apply the ++ operator to it. Here is an example:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
for (int number = 0; number <= 5; number++)
WriteLine("The time sheet was checked and this payroll has been approved.");

WriteLine("===============================================================");
return 15_000_101;
}
}```

This would produce:

```The time sheet was checked and this payroll has been approved.
The time sheet was checked and this payroll has been approved.
The time sheet was checked and this payroll has been approved.
The time sheet was checked and this payroll has been approved.
The time sheet was checked and this payroll has been approved.
The time sheet was checked and this payroll has been approved.
===============================================================
Press any key to continue . . .```

In the above example, we declared the variable in the for expression. You can use a variable from any source or declare a variable before the loop. Here is an example:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
int number;

for (number = 0; number <= 5; number++)
WriteLine("The time sheet was checked and this payroll has been approved.");

WriteLine("===============================================================");
return 15_000_101;
}
}```

In the above code, we first declared a variable, then initialized it in the loop. If you have a variable that has been initialize and want to use it in the loop, in the section of the loop where the variable is supposed to be initialized, leave it empty. Here is an example:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
span class="codered">int number = 0;

for (; number <= 5; number++)
WriteLine("The time sheet was checked and this payroll has been approved.");

WriteLine("===============================================================");
return 15_000_101;
}
}```

Practical Learning: Counting for a Loop

1. Change the document as follows:
```using System.Windows.Forms;

namespace CountriesStatistics3
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();

Show();
}

void Show()
{
string[] states = new string[31];

states[0]  = "Guanajuato";      states[1]  = "Tamaulipas";          states[2]  = "Michoacán";   states[3] = "Coahuila";
states[4]  = "Chihuahua";       states[5]  = "Baja California Sur"; states[6]  = "Nayarit";     states[7] = "Puebla";
states[8]  = "Oaxaca";          states[9]  = "Morelos";             states[10] = "Sonora";     states[11] = "Aguascalientes";
states[12] = "Baja California"; states[13] = "Tabasco";             states[14] = "Jalisco";    states[15] = "México";
states[16] = "Guerrero";        states[17] = "Colima";              states[18] = "Zacatecas";  states[19] = "Sinaloa";
states[20] = "Campeche";        states[21] = "Quintana Roo";        states[22] = "Nuevo León"; states[23] = "Hidalgo";
states[24] = "Tlaxcala";        states[25] = "Yucatán";             states[26] = "Querétaro";  states[27] = "Veracruz";
states[28] = "San Luis Potosí"; states[29] = "Durango";             states[30] = "Chiapas";

string[] capitals = new string[] { "Guanajuato",      "Ciudad Victoria",           "Morelia",
"Saltillo",        "Chihuahua",                 "La Paz",
"Tepic",           "Puebla de Zaragoza",        "Oaxaca de Juárez",
"Cuernavaca",      "Hermosillo",                "Aguascalientes",
"Toluca de Lerdo", "Chilpancingo de los Bravo", "Colima",
"Zacatecas",       "Culiacán",                  "San Francisco de Campeche",
"Chetumal",        "Monterrey",                 "Pachuca",
"Tlaxcala",        "Mérida",                    "Santiago de Querétaro",
"Xalapa",          "San Luis Potosí",           "Victoria de Durango", "Tuxtla Gutiérrez"};
int[] areasSqrKms = new int[]   {   30608, 80175, 58643, 151563, 247455,  73922, 27815, 34290, 93793,   4893,
179503,  5618, 71446,  24738,  78599,  22357, 63621,  5625, 75539,  57377,
57924, 42361, 64220,  20846,   3991,  39612, 11684, 71820, 60983, 123451,  73289 };
int[] areasSqrMiles = new int[] {   11818, 30956, 22642,  58519,  95543,  28541, 10739, 13240, 36214,   1889,
69306,  2169,  27585,  9551,  30347,   8632, 24564,  2172, 29166,  22153,
22365, 16356,  24800,  8049,   1541,  15294,  4511, 27730, 23546,  47665, 28297 };
int[] ordersOfAdmissionToFederation = new int[] {  2,  14,   5,  16,  18,  31,  28,   4,   3,  27,
12,  24,  29,  13,   9,   1,  21,  23,  10,  20,
25,  30,  15,  26,  22,   8,  11,   7,   6,  17,  19 };

ListViewItem lviState = null;

for(int i = 0; i < states.Length; i++)
{
lviState = new ListViewItem((i + 1).ToString());

}
}
}
}```

4. Start a new Windows Forms application (.NET Framework) named SumOfTheYearsDigits1
5. Design the form as follows:

 Control (Name) Text TextAlign Label Machine Cost: TextBox txtMachineCost Right Label Salvage Value: TextBox txtSalvageValue Right Label Estimated Life: TextBox txtEstimatedLife Right Label Years Button btnCalculate Calculate Label ____________ Label Depreciable Amount: TextBox txtDepreciableAmount Right Label % ListView lvwDepreciation ```View: Details GridLines: True FullRowSelect: True Anchor: Top, Bottom, Left, Right```

List View Columns

 (Name) Text TextAlign Width colYears Years colFraction Fraction Center 100 colDepreciation Depreciation Center 125
6. On the form, double-click the Calculate button

Reversing the Counting Direction

Instead of proceeding from a lower to a higher value in a loop, you can visit the values from the end of a list to the beginning. To do this, fir the first part of the loop, set the last value as the starting point. For the second part of the loop, specify the possible ending point as the first value. For its Boolean expression, you usually set a condition that would work backwards. This is usually done using the > or the >= operator. The last section usually applies the -- operator to the variable of the loop. The formula to follow can be the following:

`for(end; start; frequency) statement;`

Practical Learning: Reversing the Counting Direction

1. Change the counting as follows:
```using System;
using System.Windows.Forms;

namespace SumOfTheYearsDigits1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void btnCalculate_Click(object sender, EventArgs e)
{
int    estimatedLife;
double machineCost = 0.00;
double salvageValue = 0.00;

try
{
machineCost = double.Parse(txtMachineCost.Text);
}
catch (FormatException)
{
MessageBox.Show("You must type a valid value that represents the " +
"cost of the machine. Since you don't provide a " +
"valid value, we will set the machine cost to 0.00.",
"Depreciation: Straight-Line Method");

txtMachineCost.Text = "0.00";
}

try
{
salvageValue = double.Parse(txtSalvageValue.Text);
}
catch (FormatException)
{
MessageBox.Show("You must provide a value you estimate the machine  " +
"will have at the end of the cycle (or the end of its " +
"life cycle). If you don't enter a valid value, we will " +
"consider the estimated end value to 0.00.",
"Depreciation: Straight-Line Method");

txtSalvageValue.Text = "0.00";
}

try
{
estimatedLife = int.Parse(txtEstimatedLife.Text);
}
catch (FormatException)
{
MessageBox.Show("You didn't enter a valid number of years for the life of " +
"the machine. Please correct it, otherwize, we will consider " +
"that this machine has no life, or a life of 0 years.",
"Depreciation: Straight-Line Method");

estimatedLife = 1;
}

int year = 1;
int reverse = 0;
int sumOfYears = (estimatedLife * (estimatedLife + 1)) / 2;
double[] depreciations = new double[estimatedLife];
string[] fractions = new string[estimatedLife];

double depreciatiableAmount = machineCost - salvageValue;

txtDepreciatiableAmount.Text = depreciatiableAmount.ToString("F");

for (int i = estimatedLife - 1; i >= 0; i--)
{
fractions[reverse] = (i + 1) + "/" + sumOfYears;
depreciations[reverse] = (depreciatiableAmount * (i + 1)) / sumOfYears;
reverse++;
}

ListViewItem lviDepreciation = null;

lvwDepreciation.Items.Clear();

for (int i = 0; i <= @estimatedLife - 1; i++)
{
lviDepreciation = new ListViewItem(year.ToString());

year++;
}
}
}
}```

3. Enter the values as follows:
```Machine Cost: 6850
Salvage Value: 500
Estimated Life 8```

4. Click the Calculate button:

For Each Item In a List

Inseead of visiting the elements of a list by counting them, you may want to visit each item directly. To assist you with this, the C# language provides an operator named foreach. The formula to use it is:

```foreach(variable in list)
statement;```

The loop starts with the foreach keyword followed by parentheses. In the parentheses, enter the list that contains the elements you want. Precede that list with an operator named in. The foreach loop needs a variable that would represent an item from the list. Therefore, in the parentheses, start by declaring a variable before the in operator. Of course, the variable declared by a data type and a name. Outside the parentheses, create a statement of your choice. At a minimum, you can simply display the variable's value to the user. Here is an example:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
int[] numbers = new int[] { 102, 44, 525, 38, 6, 28, 24481, 327, 632, 104 };

foreach (int n in numbers)
WriteLine("Number: {0}", n);

WriteLine("===============================");
return 22_813_729;
}
}```

This would produce:

```Number: 102
Number: 44
Number: 525
Number: 38
Number: 6
Number: 28
Number: 24481
Number: 327
Number: 632
Number: 104
===============================
Press any key to continue . . .```

You can declare the variable with the var keyword. Here is an example:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
string[] provinces = new string[] { "Saskatchewan", "British Columbia",
"Ontario", "Alberta", "Manitoba" };

WriteLine("===============================");
return 22_813_729;
}
}```

You can include the statement inside curly brackets. This is especially useful if you to execute more than one statement.

Controlling a Loop

Loops and Conditional Statement Nesting

You can create a conditional statement in the body of a loop. This is referred to as a nesting. Here is an example:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
int number = 0;

while (number < 5)
{
WriteLine("Make sure you review the time sheet before submitting it.");

if (number == 2)

number++;
}

WriteLine("===============================================================");
return 15_000_101;
}
}```

This would produce:

```Make sure you review the time sheet before submitting it.
Make sure you review the time sheet before submitting it.
Make sure you review the time sheet before submitting it.
Make sure you review the time sheet before submitting it.
Make sure you review the time sheet before submitting it.
===============================================================
Press any key to continue . . .```

On the other hand, you can nest a loop in a conditional statement.

Breaking the Flow of a Loop

As mentioned in our introductions, a loop is supposed to navigate from a starting point to an ending value. Sometimes, for any reason, you want to stop that navigation before the end of the loop. To support this, the C-based languages, which include C#, provide the break keyword. The formula to use the break statement is:

`break;`

Although made of only one word, the break statement is a complete statement; therefore, it can (and should always) stay on its own line (this makes the program easy to read).

The break statement applies to the most previous conditional statement to it; provided that previous statement is applicable. The break statement can be used in a while condition, in a do...while, or a for loops to stop an ongoing operation. Here is an example that is used to count the levels of a house from 1 to 12 but it is asked to stop at 3:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
for (int number = 0; number <= 5; number++)
{
WriteLine("The time sheet was checked and this payroll has been approved.");

if (number == 2)
break;
}

WriteLine("===============================================================");
return 15_000_101;
}
}```

This would produce:

```The time sheet was checked and this payroll has been approved.
The time sheet was checked and this payroll has been approved.
The time sheet was checked and this payroll has been approved.
===============================================================
Press any key to continue . . .```

Continuing a Conditional Statement

Instead of stopping the flow of a loop, you may want to skip one of the values. To support this, the C-based languages such as C# provide the continue keyword. The formula to use it is:

`continue;`

When processing a loop, if the statement finds a false value, you can use the continue statement inside of a while, a do...while, or a for conditional statements to ignore the subsequent statement or to jump from a false Boolean value to the subsequent valid value, unlike the break statement that would exit the loop. Like the break statement, the continue keyword applies to the most previous conditional statement and should stay on its own line. Here is an example that is supposed to count the levels of a house from 1 to 6:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
string strNumbers = "";

for (int number = 0; number <= 5; number++)
{
if (number == 3)
continue;

strNumbers += number.ToString() + " ";

WriteLine("The list of numbers is {0}", strNumbers);
}

WriteLine("===========================================");
return 15_000_101;
}
}```

This would produce:

```The list of numbers is 0
The list of numbers is 0 1
The list of numbers is 0 1 2
The list of numbers is 0 1 2 4
The list of numbers is 0 1 2 4 5
===========================================
Press any key to continue . . .```

Notice that, when the compiler gets to 3, it ignores it.

Changing a Value in the Loop

Inside a loop, you may want to put a flag that would monitor the evolution of a piece of code so that, if a certain value is encountered, instead of skipping the looping by 1, you can make it jump to a valued range of your choice. To do this, in the loop, check the current value and if it gets to one you are looking for, change it. Here is an example where a loop is asked to count from 0 to 15:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
string strNumbers = "";

for (int number = 0; number < 15; number++)
{
if (number == 6)
number = 10;

strNumbers += number.ToString() + " ";
}

WriteLine("The list of numbers is {0}", strNumbers);
WriteLine("===========================================");
return 22_813_729;
}
}```

This would produce:

```The list of numbers is 0 1 2 3 4 5 10 11 12 13 14
===================================================
Press any key to continue . . .```

Selecting a Value From a List

Introduction

If you have a list, such as an array, made of too many values, at one time you may want to isolate only the first n members of the list, or the last m members of the list, or a range of members from an index i to an index j. Another operation you may be interested to perform is to find out if a certain value exists in the list. One more interesting operation would be to find out what members or how many members of the list respond to a certain criterion.

for Looping

Consider the following array:

```public class Exercise
{
public static int Main(string[] args)
{
int[] numbers = new[] { 102, 44, 525, 38, 6, 28, 24481, 327, 632, 104 };
}
}```

Imagine you want to access only the first n members of the array. To do this, you can use an if conditional statement nested in a for loop. Here is an example that produces the first 4 values of the array:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
int[] numbers = new int[] { 102, 44, 525, 38, 6, 28, 24481, 327, 632, 104 };

for (int i = 0; i < 10; i++)
if (i < 4)
WriteLine("Number: {0}", numbers[i]);

WriteLine("===============================");
return 22_813_729;
}
}```

This would produce:

```Number: 102
Number: 44
Number: 525
Number: 38
===============================
Press any key to continue . . .```

You can use the same technique to get the last m members of a list. You can also use a similar technique to get one or a few values inside of the list, based on a condition of your choice. Here is an example that gets the values that are multiple of 5 from the array:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
int[] numbers = new int[] { 102, 44, 525, 38, 6, 28, 24481, 327, 632, 104 };

for (int i = 0; i < 10; i++)
if (numbers[i] % 5 == 0)
WriteLine("Number: {0}", numbers[i]);

WriteLine("===============================");
return 22_813_729;
}
}```

This would produce:

```Number: 525
===============================
Press any key to continue . . .```

while(true)

For the different situations in which we used a while condition so far, we included a means of checking the condition. As an option, you can include juste the true Boolean constant in the parentheses of true. Here is an example:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
while (true)
WriteLine("Application development is fun!!!");

return 22_813_729;
}
}```

This type of statement is legal and would work fine, but it has no way to stop because it is telling the compiler "As long as 'this' is true, ...". The question is, what is "this"? As a result, the program would run for ever. Therefore, if you create a while(true) condition, in the body of the statement, you should (must) provide a way for the compiler to stop, that is, a way for the condition to be (or to become) false. This can be done by including an if condition. Here is an example:

```using static System.Console;

public class Exercise
{
public static int Main(string[] args)
{
int i = 0;

while (true)
{
if (i > 8)
break;

WriteLine("Application development is fun!!!");

i++;
}

WriteLine("===============================");
return 22_813_729;
}
}```

This would produce:

```Application development is fun!!!
Application development is fun!!!
Application development is fun!!!
Application development is fun!!!
Application development is fun!!!
Application development is fun!!!
Application development is fun!!!
Application development is fun!!!
Application development is fun!!!
===============================
Press any key to continue . . .```

Instead of using while(true), you can first declare and initialize a Boolean variable, or you can use a Boolean variable whose value is already known. The value can come from a method or by other means.

Practical Learning: Ending the Lesson