program flow (loop)

Author: camielluijkx

LISTING 1-49 cancel a task/LISTING 1-49 cancel a task/Program.cs

@@ -49,4 +49,4 @@ Clock stopped.
             */
         }
     }
-}
+}

LISTING 1-50 cancel with exception/LISTING 1-50 cancel with exception/Program.cs

@@ -98,4 +98,4 @@ Clock task completed.
             */
         }
     }
-}
+}

LISTING 1-51 unsafe thread method/LISTING 1-51 unsafe thread method/Program.cs

@@ -34,4 +34,4 @@ static void Main(string[] args)
             */
         }
     }
-}
+}

LISTING 1-52 while loops/LISTING 1-52 while loops/Program.cs

@@ -1,11 +1,14 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace LISTING_1_52_while_loops
 {
+    /*
+    
+    The condition that controls the looping behavior is tested before the statements controlled by the loop are obeyed.    
+        
+    A while loop is very effective when creating a consumer of data.     
+
+    */
     class Program
     {
         static void Main(string[] args)
@@ -18,7 +21,7 @@ static void Main(string[] args)
             int count = 0;
             while(count < 10)
             {
-                Console.WriteLine("Hello {0}", count);
+                Console.WriteLine($"Hello {count}");
                 count = count + 1;
             }
 
@@ -28,4 +31,4 @@ static void Main(string[] args)
             }
         }
     }
-}
+}

LISTING 1-53 do while loops/LISTING 1-53 do while loops/Program.cs

@@ -2,6 +2,16 @@
 
 namespace LISTING_1_53_do_while_loops
 {
+    /*
+    
+    The important thing to note about this code is that although the logical expression contolling it is false, which 
+    means that the loop will never repeat, the message Hello will be printed once, since the printing takes place 
+    before the logical expression is tested.    
+
+    A do-while construction is useful when you want to create code that continuously fetches data until a(n) (in)valid 
+    value is entered.
+    
+    */
     class Program
     {
         static void Main(string[] args)
@@ -12,4 +22,4 @@ static void Main(string[] args)
             } while (false);
         }
     }
-}
+}

LISTING 1-54 for loops/LISTING 1-54 for loops/Program.cs

@@ -2,34 +2,43 @@
 
 namespace LISTING_1_54_for_loops
 {
+    /*
+    
+    A loop that is not infinite (one that should terminate at some point) can be made up of three things:
+
+        1. Initialization that is performed to set up the loop.
+        2. A test that will determine if the loop should continue.
+        3. An update to be performed each time the action of the loop has been performed.
+        
+    */
     class Program
     {
         static int counter;
 
         static void initalize()
         {
-            Console.WriteLine("Initialize called");
+            Console.WriteLine("Initialize called.");
             counter = 0;
         }
 
         static void update()
         {
-            Console.WriteLine("Update called");
+            Console.WriteLine("Update called.");
             counter = counter + 1;
         }
 
         static bool test()
         {
-            Console.WriteLine("Test called");
+            Console.WriteLine("Test called.");
             return counter < 5;
         }
         static void Main(string[] args)
         {
-            for(initalize(); test();  update())
+            for (initalize(); test(); update())
             {
-                Console.WriteLine("Hello {0}", counter);
+                Console.WriteLine($"Hello {counter}.");
             }
             Console.ReadKey();
         }
     }
-}
+}

LISTING 1-55 iterate with for/LISTING 1-55 iterate with for/Program.cs

@@ -9,9 +9,11 @@ static void Main(string[] args)
             string[] names = { "Rob", "Mary", "David", "Jenny", "Chris", "Imogen" };
 
             for (int index = 0; index < names.Length; index++)
+            {
                 Console.WriteLine(names[index]);
+            }
 
             Console.ReadKey();
         }
     }
-}
+}

LISTING 1-56 iterate with foreach/LISTING 1-56 iterate with foreach/Program.cs

@@ -1,23 +1,32 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace LISTING_1_56_iterate_with_foreach
 {
+    /*
+    
+    The iterating value must match the type of the items in the collection.
+    
+    It isn't possible for code in a foreach construction to modigfy the iterating value.
+
+    */
     class Program
     {
         static void Main(string[] args)
         {
             string[] names = { "Rob", "Mary", "David", "Jenny", "Chris", "Imogen" };
 
-            foreach(string name in names)
+            //foreach (int name in names) 
+            //Error CS0030  Cannot convert type 'string' to 'int'
+
+            foreach (string name in names)
             {
                 Console.WriteLine(name);
+
+                // Error CS1656  Cannot assign to 'name' because it is a 'foreach iteration variable'
+                //name = name.ToUpper();
             }
 
             Console.ReadKey();
         }
     }
-}
+}

LISTING 1-57 uppercase Person/LISTING 1-57 uppercase Person/Program.cs

@@ -1,11 +1,25 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace LISTING_1_57_uppercase_Person
 {
+    /*
+    
+    If the foreach loop is working on a list of references to objects, the objects on the ends of those references can 
+    be changed.
+
+    The foreach construction can iterate through any object which implements the IEnumerable interface. These objects
+    expose a method called GetIterator(). This method must return an object that implements the 
+    System.Collections.IEnumerator interface. This interface exposes methods that the foreach construction can use to 
+    get the next item from the enumerator and determine if there any more items in the collection. Many collection 
+    classes, including listst and dictionaries, implement the IEnumerable interface.
+
+    Note that the iteration can be implemented in a "lazy" way; the next item to be iterated only needs to be fetched
+    when requested. The result of database queries can be returned as objects that implement the IEnumerable interface
+    and then only fetch the actual data items when needed. It is important that the item being iterated is not changed
+    during iteration, if the iterating code tried to remove items from the list it was iteraqting through this would 
+    cause the program to throw an exception when it ran.
+    
+    */
     class Program
     {
         class Person
@@ -20,18 +34,24 @@ public Person(string name)
 
         static void Main(string[] args)
         {
-            Person[] people = new Person[] {
+            Person[] people = new Person[] 
+            {
                 new Person("Rob"), new Person("Mary"),
                 new Person("David"), new Person("Jenny"),
-                new Person("Chris"), new Person("Imogen") };
+                new Person("Chris"), new Person("Imogen")
+            };
 
             foreach (Person person in people)
+            {
                 person.Name = person.Name.ToUpper();
+            }
 
             foreach (Person person in people)
+            {
                 Console.WriteLine(person.Name);
+            }
 
             Console.ReadKey();
         }
     }
-}
+}

LISTING 1-58 using break/LISTING 1-58 using break/Program.cs

@@ -2,6 +2,11 @@
 
 namespace LISTING_1_58_using_break
 {
+    /*
+    
+    When the break statement is reached, the program immediatly exits the loop.
+    
+    */
     class Program
     {
         static void Main(string[] args)
@@ -12,10 +17,12 @@ static void Main(string[] args)
             {
                 Console.WriteLine(names[index]);
                 if (names[index] == "David")
+                {
                     break;
+                }
             }
 
             Console.ReadKey();
         }
     }
-}
+}

LISTING 1-59 using continue/LISTING 1-59 using continue/Program.cs

@@ -2,6 +2,12 @@
 
 namespace LISTING_1_59_using_continue
 {
+    /*
+    
+    The continue statement does not cause a loop to end. Instead, it ends the current pass through the code controlled
+    by the loop. The terminating condition is then tested to determine if the loop should continue.
+        
+    */
     class Program
     {
         static void Main(string[] args)
@@ -11,11 +17,13 @@ static void Main(string[] args)
             for (int index = 0; index < names.Length; index++)
             {
                 if (names[index] == "David")
+                {
                     continue;
+                }
 
                 Console.WriteLine(names[index]);
             }
             Console.ReadKey();
         }
     }
-}
+}