summarizing examples ExamRef70-483#1

camielluijkx · camielluijkx · commit 2fe8fcff2d73 · 2019-05-16T16:44:46.000+02:00
diff --git a/All.sln b/All.sln
@@ -575,6 +575,11 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LISTING 1-31 Updating the
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LISTING 1-32 Using async", "LISTING 1-32 Using async\LISTING 1-32 Using async\LISTING 1-32 Using async.csproj", "{A9B754B1-55F5-46EE-943E-D0407EEB484A}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{79A31FC8-3FD2-4ACF-9C61-7F54B46F6854}"
+	ProjectSection(SolutionItems) = preProject
+		Summary.txt = Summary.txt
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Custom|Any CPU = Custom|Any CPU
diff --git a/LISTING 1-1 Parallel Invoke/LISTING 1-1 Parallel Invoke/Program.cs b/LISTING 1-1 Parallel Invoke/LISTING 1-1 Parallel Invoke/Program.cs
@@ -9,14 +9,15 @@ class Program
         static void Task1()
         {
             Console.WriteLine("Task 1 starting");
-            Thread.Sleep(2000);
-            //Thread.Sleep(1000);
+            //Thread.Sleep(2000);
+            Thread.Sleep(1000);
             Console.WriteLine("Task 1 ending");
         }
 
         static void Task2()
         {
             Console.WriteLine("Task 2 starting");
+            //Thread.Sleep(2000);
             Thread.Sleep(1000);
             Console.WriteLine("Task 2 ending");
         }
@@ -30,10 +31,19 @@ static void Main(string[] args)
             // An action delegate can be replaced with a lambda expression.
             // Note that you have no control over the order in which the tasks are started or which processor they are 
             // assigned to (e.g. Task1 might finish before Task2 and vice versa).
+
+            Action action1a = () => Task1();
+            Action action2a = () => Task2();
+            //Parallel.Invoke(action1a, action2a);
+
+            Action action1b = new Action(() => Task1());
+            Action action2b = new Action(() => Task2());
+            //Parallel.Invoke(action1b, action2b);
+
             Parallel.Invoke(() => Task1(), () => Task2());
 
             Console.WriteLine("Finished processing. Press a key to end.");
             Console.ReadKey();
         }
     }
-}
+}
diff --git a/LISTING 1-10 Exceptions in PLINQ/LISTING 1-10 Exceptions in PLINQ/Program.cs b/LISTING 1-10 Exceptions in PLINQ/LISTING 1-10 Exceptions in PLINQ/Program.cs
@@ -6,60 +6,57 @@ namespace LISTING_1_10_Exceptions_in_PLINQ
     class Program
     {
         public static bool CheckCity(string city)
-        {
-            if (city == "")
-                throw new ArgumentException(city);
-            return city == "Seattle";
-        }
-
-        public static bool CheckCity(string name, string city)
         {
             if (city == "")
             {
-                Console.WriteLine($"no city for {name}");
                 throw new ArgumentException(city);
             }
+
             return city == "Seattle";
         }
 
         class Person
         {
             public string Name { get; set; }
+
             public string City { get; set; }
         }
 
         static void Main(string[] args)
         {
-            Person[] people = new Person[] {
-                //new Person { Name = "Alan", City = "Hull" },
-                new Person { Name = "Alan", City = "" },
-                new Person { Name = "Beryl", City = "Seattle" },
-                new Person { Name = "Charles", City = "London" },
+            Person[] people = new Person[]
+            {
+                new Person { Name = "Alan", City = "Hull" },
+                new Person { Name = "Henry", City = "Seattle" },
+                new Person { Name = "Charles", City = "" },
+                new Person { Name = "Isaac", City = "Seattle" },
+                new Person { Name = "Gordon", City = "Hull" },
                 new Person { Name = "David", City = "Seattle" },
                 new Person { Name = "Eddy", City = "" },
                 new Person { Name = "Fred", City = "" },
-                new Person { Name = "Gordon", City = "Hull" },
-                new Person { Name = "Henry", City = "Seattle" },
-                new Person { Name = "Isaac", City = "Seattle" },
-                new Person { Name = "James", City = "London" }};
+                new Person { Name = "Beryl", City = "Seattle" },
+                new Person { Name = "James", City = "" }
+            };
 
             try
             {
                 // An AggregateException is thrown when all queries are completed if any query generates an exception.
-                var result = from person in
-                    people.AsParallel()
-                             //where CheckCity(person.City)
-                             where CheckCity(person.Name, person.City)
-                             select person;
-                result.ForAll(person => Console.WriteLine(person.Name));
+
+                Console.WriteLine("parallel query:");
+                var resultP = from person in people.AsParallel()
+                              where CheckCity(person.City)
+                              //orderby person.Name
+                              select person;
+
+                resultP.ForAll(person => Console.WriteLine(person.Name));
             }
             catch (AggregateException e)
             {
-                Console.WriteLine(e.InnerExceptions.Count + " exception(s)."); // might be > 1
+                Console.WriteLine(e.InnerExceptions.Count + " inner exception(s)."); // 1-3 runtime vs 4 when debugging, why?
             }
 
             Console.WriteLine("Finished processing. Press a key to end.");
             Console.ReadKey();
         }
     }
-}
+}
diff --git a/LISTING 1-11 Create a task/LISTING 1-11 Create a task/Program.cs b/LISTING 1-11 Create a task/LISTING 1-11 Create a task/Program.cs
@@ -16,6 +16,7 @@ public static void DoWork()
         static void Main(string[] args)
         {
             // Create a task, start it and wait for it to complete.
+
             Task newTask = new Task(() => DoWork());
             Console.WriteLine("Task start (begin)");
             newTask.Start();
@@ -24,6 +25,9 @@ static void Main(string[] args)
             newTask.Wait();
             Console.WriteLine("Task wait (end)");
 
+            Console.WriteLine("Finished processing. Press a key to end.");
+            Console.ReadKey();
+
             /*
             
             Task start (begin)
@@ -32,8 +36,9 @@ Task wait (begin)
             Work starting
             Work finished
             Task wait (end)
+            Finished processing. Press a key to end.
 
             */
         }
     }
-}
+}
diff --git a/LISTING 1-12 Run a task/LISTING 1-12 Run a task/Program.cs b/LISTING 1-12 Run a task/LISTING 1-12 Run a task/Program.cs
@@ -13,26 +13,32 @@ public static void DoWork()
             Console.WriteLine("Work finished");
         }
 
-        // Run a task (create and start) and wait for it to complete.
         static void Main(string[] args)
         {
-            Console.WriteLine("Task start (begin)");
+            // Run a task (create and start) and wait for it to complete.
+
+            Console.WriteLine("Task run (begin)");
             Task newTask = Task.Run(() => DoWork());
-            Console.WriteLine("Task start (end)");
+            Console.WriteLine("Task run (end)");
             Console.WriteLine("Task wait (begin)");
             newTask.Wait();
             Console.WriteLine("Task wait (end)");
 
+            Console.WriteLine("Finished processing. Press a key to end.");
+            Console.ReadKey();
+
             /*
              
-            Task start (begin)
-            Task start (end)
+            Task run (begin)
+            Task run (end)
             Task wait (begin)
             Work starting
             Work finished
             Task wait (end)
             
+            Finished processing. Press a key to end.
+
             */
         }
     }
-}
+}
diff --git a/LISTING 1-13 Task Factory/LISTING 1-13 Task Factory/Program.cs b/LISTING 1-13 Task Factory/LISTING 1-13 Task Factory/Program.cs
@@ -53,4 +53,4 @@ static void DoWork()
             Console.WriteLine("Result: " + total); // 12497500
         }
     }
-}
+}
diff --git a/LISTING 1-13 Task returning a value/LISTING 1-13 Task returning a value/Program.cs b/LISTING 1-13 Task returning a value/LISTING 1-13 Task returning a value/Program.cs
@@ -24,16 +24,30 @@ static void Main(string[] args)
             // You can create your own task scheduler or run a task scheduler in the synchronization context of another
             // processor. 
             // You can also create your own TaskFactory if you want to create a number of tasks with the same 
-            // configuration. 
+            // configuration.
+
+            Console.WriteLine("Task run (begin)");
             Task<int> task = Task.Run(() =>
             {
                 return CalculateResult();
             });
+            Console.WriteLine("Task run (end)");
 
-            Console.WriteLine(task.Result);
-
+            Console.WriteLine(task.Result); // await
+            
             Console.WriteLine("Finished processing. Press a key to end.");
             Console.ReadKey();
+
+            /*
+            
+            Task run (begin)
+            Task run (end)
+            Work starting
+            Work finished
+            99
+            Finished processing. Press a key to end.
+
+            */
         }
     }
-}
+}
diff --git a/LISTING 1-14 Task waitall/LISTING 1-14 Task waitall/Program.cs b/LISTING 1-14 Task waitall/LISTING 1-14 Task waitall/Program.cs
@@ -36,4 +36,4 @@ static void Main(string[] args)
             Console.ReadKey();
         }
     }
-}
+}
diff --git a/LISTING 1-15 Continuation tasks/LISTING 1-15 Continuation tasks/Program.cs b/LISTING 1-15 Continuation tasks/LISTING 1-15 Continuation tasks/Program.cs
@@ -24,16 +24,18 @@ static void Main(string[] args)
             // If the antecedent task produces a result, it can be supplied as an input to the continuation task.
             // Continuation tasks can be used to create a "pipeline" of operations, with each successive stage starting
             // when the preceding one ends.
+
             // A Task object exposes a ContinueWith method that can be used to specify a continuation task.
             // The lambda expression that executes the continuation task is provided with a reference to the antecedent
             // task, which it can use to determine if the antecedent completed successfully.
             // You can add continuation tasks to tasks that deliver a result, in which case the continuation task can
             // use the Result property of the antecedent task to obtain its input data.
+
             Task task = Task.Run(() => HelloTask());
-            task.ContinueWith( (prevTask) => WorldTask());
+            task.ContinueWith((prevTask) => WorldTask());
 
             Console.WriteLine("Finished processing. Press a key to end.");
             Console.ReadKey();
         }
     }
-}
+}
diff --git a/LISTING 1-16 Continuation options/LISTING 1-16 Continuation options/Program.cs b/LISTING 1-16 Continuation options/LISTING 1-16 Continuation options/Program.cs
@@ -39,4 +39,4 @@ static void Main(string[] args)
             Console.ReadKey();
         }
     }
-}
+}
diff --git a/LISTING 1-2 ParallelForEach in use/LISTING 1-2 ParallelForEach in use/Program.cs b/LISTING 1-2 ParallelForEach in use/LISTING 1-2 ParallelForEach in use/Program.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -16,20 +17,22 @@ static void WorkOnItem(object item)
 
         static void Main(string[] args)
         {
-            var items = Enumerable.Range(0, 500);
+            //var items = Enumerable.Range(0, 10);
+            IEnumerable<int> items = Enumerable.Range(0, 10);
 
             // The Parallel.ForEach method accepts two parameters.
             // The first parameter is an IEnumerable collection.
             // The second parameter provides the action to be performed on each item in the collection.
             // Note that the tasks are not completed in the same order that they were started.
-            Parallel.ForEach(items, item =>
-            {
-                WorkOnItem(item);
-            });
+
+            Action<int> itemAction = new Action<int>((item) => WorkOnItem(item));
+            //Parallel.ForEach(items, itemAction);
+
+            //Parallel.ForEach<int>(items, item => { WorkOnItem(item); });
+            Parallel.ForEach(items, item => { WorkOnItem(item); });
 
             Console.WriteLine("Finished processing. Press a key to end.");
             Console.ReadKey();
         }
-
     }
-}
+}
diff --git a/LISTING 1-3 ParallelFor in use/LISTING 1-3 ParallelFor in use/Program.cs b/LISTING 1-3 ParallelFor in use/LISTING 1-3 ParallelFor in use/Program.cs
@@ -16,19 +16,21 @@ static void WorkOnItem(object item)
 
         static void Main(string[] args)
         {
-            var items = Enumerable.Range(0, 500).ToArray();
+            //var items = Enumerable.Range(0, 10).ToArray();
+            int[] items = Enumerable.Range(0, 10).ToArray();
 
             // The Parallel.For method accepts three parameters.
             // The first and second parameter represent start and end index for iteration of the collection.
             // The third parameter represents the delegate that is invoked once per iteration.
             // Note that the tasks are not completed in the same order that they were started.
-            Parallel.For(0, items.Length, i =>
-            {
-                WorkOnItem(items[i]);
-            });
+
+            Action<int> itemAction = new Action<int>((item) => WorkOnItem(item));
+            //Parallel.For(0, items.Length, itemAction);
+
+            Parallel.For(0, items.Length, i => { WorkOnItem(items[i]); });
 
             Console.WriteLine("Finished processing. Press a key to end.");
             Console.ReadKey();
         }
     }
-}
+}
diff --git a/LISTING 1-4 Managing a parallel For loop/LISTING 1-4 Managing a parallel For loop/Program.cs b/LISTING 1-4 Managing a parallel For loop/LISTING 1-4 Managing a parallel For loop/Program.cs
diff --git a/LISTING 1-5 A parallel LINQ query/LISTING 1-5 A parallel LINQ query/Program.cs b/LISTING 1-5 A parallel LINQ query/LISTING 1-5 A parallel LINQ query/Program.cs
diff --git a/LISTING 1-6 A informing parallelization/LISTING 1-6 A informing parallelization/Program.cs b/LISTING 1-6 A informing parallelization/LISTING 1-6 A informing parallelization/Program.cs
diff --git a/LISTING 1-7 Using AsOrdered/LISTING 1-7 Using AsOrdered/Program.cs b/LISTING 1-7 Using AsOrdered/LISTING 1-7 Using AsOrdered/Program.cs
diff --git a/LISTING 1-8 Sequential elements/LISTING 1-8 Sequential elements/Program.cs b/LISTING 1-8 Sequential elements/LISTING 1-8 Sequential elements/Program.cs
diff --git a/LISTING 1-9 Using the ForAll method/LISTING 1-9 Using the ForAll method/Program.cs b/LISTING 1-9 Using the ForAll method/LISTING 1-9 Using the ForAll method/Program.cs

Original file line number	Diff line number	Diff line change
`@@ -53,4 +53,4 @@ static void DoWork()`
`53`	`53`	`Console.WriteLine("Result: " + total); // 12497500`
`54`	`54`	`}`
`55`	`55`	`}`
`56`		`-}`
	`56`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -36,4 +36,4 @@ static void Main(string[] args)`
`36`	`36`	`Console.ReadKey();`
`37`	`37`	`}`
`38`	`38`	`}`
`39`		`-}`
	`39`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -39,4 +39,4 @@ static void Main(string[] args)`
`39`	`39`	`Console.ReadKey();`
`40`	`40`	`}`
`41`	`41`	`}`
`42`		`-}`
	`42`	`+}`