Apress-Visual CSharp 2010 Recipes A Problem Solution Approach_9

Chia sẻ: Thao Thao | Ngày: | Loại File: PDF | Số trang:95

Thêm vào BST

Báo xấu

60
lượt xem 6
download

Download Vui lòng tải xuống để xem tài liệu đầy đủ

requested became available—this example waits for all of the tasks to complete before obtaining the results. using System; using System.Threading; using System.Threading.Tasks; namespace Recipe15_03 { class Recipe15_03 { static void Main(string[] args) { Console.WriteLine("Press enter to start"); Console.ReadLine(); // Create Task Task Task the tasks. task1 = Task.Factory.StartNew(() = writeDays()); task2 = Task.Factory.StartNew(() = writeMonths()); task3 = Task.Factory.StartNew(() = writeCities()); // Wait for all of the tasks to complete. Task.WaitAll(task1, task2, task3); // Get the results and Console.WriteLine("{0} Console.WriteLine("{0} Console.WriteLine("{0} write them out. days were written", task1.Result); months were written", task2.Result); cities were written", task3.Result); ...

Chủ đề:

Bình luận(0) Đăng nhập để gửi bình luận!

Lưu

Nội dung Text: Apress-Visual CSharp 2010 Recipes A Problem Solution Approach_9

CHAPTER 15 ■ PARALLEL PROGRAMMING requested became available—this example waits for all of the tasks to complete before obtaining the results. using System; using System.Threading; using System.Threading.Tasks; namespace Recipe15_03 { class Recipe15_03 { static void Main(string[] args) { Console.WriteLine("Press enter to start"); Console.ReadLine(); // Create the tasks. Task task1 = Task.Factory.StartNew(() => writeDays()); Task task2 = Task.Factory.StartNew(() => writeMonths()); Task task3 = Task.Factory.StartNew(() => writeCities()); // Wait for all of the tasks to complete. Task.WaitAll(task1, task2, task3); // Get the results and write them out. Console.WriteLine("{0} days were written", task1.Result); Console.WriteLine("{0} months were written", task2.Result); Console.WriteLine("{0} cities were written", task3.Result); // Wait to continue. Console.WriteLine("\nMain method complete. Press Enter"); Console.ReadLine(); } static int writeDays() { string[] daysArray = { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" }; foreach (string day in daysArray) { Console.WriteLine("Day of the Week: {0}", day); Thread.Sleep(500); } return daysArray.Length; } 735
CHAPTER 15 ■ PARALLEL PROGRAMMING static int writeMonths() { string[] monthsArray = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; foreach (string month in monthsArray) { Console.WriteLine("Month: {0}", month); Thread.Sleep(500); } return monthsArray.Length; } static int writeCities() { string[] citiesArray = { "London", "New York", "Paris", "Tokyo", "Sydney" }; foreach (string city in citiesArray) { Console.WriteLine("City: {0}", city); Thread.Sleep(500); } return citiesArray.Length; } } } 15-4. Parallel Process a Collection Problem You need to parallel process each element in a collection. Solution Use the System.Threading.Parallel.ForEach method to create a new task to process each of the elements in a collection. Optionally, use System.Threading.ParallelOptions to limit the degree of parallelism that will be used. How It Works The static Parallel.ForEach method accepts a collection, a function delegate, and an optional instance of ParallelOptions as arguments. A new task is created to process each element in the collection using the function referenced by the delegate. The number of concurrent tasks is controlled by the ParallelOptions.MaxDegreeOfParallelism property—a value of -1 means that the degree of parallelism 736
CHAPTER 15 ■ PARALLEL PROGRAMMING will be determined by the runtime, whereas a value of 1 or more limits the number of tasks that will run at the same time (a value of 0 will throw an exception). The Code The following example creates tasks to process each element of a simple array using the printNumbers method. We have called Thread.Sleep in this method to slow down the processing so that the example is clearer. We use the MaxDegreeOfParallelism property of ParallelOptions to ensure that at most two tasks are performed simultaneously—when running the example, notice that the output from the first two tasks is intermingled and then followed by the output from the third task. using System; using System.Threading; using System.Threading.Tasks; namespace Recipe15_04 { class Recipe15_04 { static void Main(string[] args) { Console.WriteLine("Press enter to start"); Console.ReadLine(); // Define the data we want to process. int[] numbersArray = { 100, 200, 300 }; // Configure the options. ParallelOptions options = new ParallelOptions(); options.MaxDegreeOfParallelism = 2; // Process each data element in parallel. Parallel.ForEach(numbersArray, options, baseNumber => printNumbers(baseNumber)); Console.WriteLine("Tasks Completed. Press Enter"); Console.ReadLine(); } static void printNumbers(int baseNumber) { for (int i = baseNumber, j = baseNumber + 10; i < j; i++) { Console.WriteLine("Number: {0}", i); Thread.Sleep(100); } } } } 737
CHAPTER 15 ■ PARALLEL PROGRAMMING 15-5. Chain Tasks Together Problem You need to perform several tasks in sequence. Solution Create an instance of Task for the initial activity using the class constructors (as shown in the previous recipes in this chapter), and then call the ContinueWith method to create a Task instance representing the next activity in the sequence. When you have created all of the Task instances you require, call the Start method on the first in the sequence. How It Works The Task.ContinueWith and Task.ContinueWith methods create a new task that will continue upon completion of the Task instance on which they are invoked. The previous task (known as the antecedent) is provided as an input parameter to the lambda expression in the ContinueWith method—this can be used to check the states or get the result of the previous task, as shown in the following example. The Code The example for this recipe chains three tasks together. The first task adds some integer values. The second obtains the result from the first and prints it out, and the third task simply writes a message without reference to the previous tasks at all. using System; using System.Threading; using System.Threading.Tasks; namespace Recipe15_05 { class Recipe15_05 { static void Main(string[] args) { Console.WriteLine("Press enter to start"); Console.ReadLine(); // Create the set of tasks. Task firstTask = new Task(() => sumAndPrintNumbers(100)); Task secondTask = firstTask.ContinueWith(parent => printTotal(parent)); Task thirdTask = secondTask.ContinueWith(parent => printMessage()); 738
CHAPTER 15 ■ PARALLEL PROGRAMMING // Start the first task. firstTask.Start(); // Read a line to keep the process alive. Console.WriteLine("Press enter to finish"); Console.ReadLine(); } static int sumAndPrintNumbers(int baseNumber) { Console.WriteLine("sum&print called for {0}", baseNumber); int total = 0; for (int i = baseNumber, j = baseNumber + 10; i < j; i++) { Console.WriteLine("Number: {0}", i); total += i; } return total; } static void printTotal(Task parentTask) { Console.WriteLine("Total is {0}", parentTask.Result); } static void printMessage() { Console.WriteLine("Message from third task"); } } } 15-6. Write a Cooperative Algorithm Problem You need to write a parallel algorithm with multiple phases, each of which must be completed before the next can begin. Solution Create an instance of the System.Threading.Barrier class and call the SignalAndWait method from your Task code at the end of each algorithm phase. 739
CHAPTER 15 ■ PARALLEL PROGRAMMING How It Works The Barrier class allows you to wait for a set of tasks to complete one part of an algorithm before moving onto the next. This is useful when the overall results from the one phase are required by all tasks in order to complete a subsequent phase. When creating an instance of Barrier, you specify an integer as a constructor argument. In your Task code, you call the SignalAndWait method when you have reached the end of a phase—your Task will block until the specified number of Tasks is waiting, at which point the Barrier allows all of the waiting tasks to continue into the next phase. It is up to you to determine what constitutes each phase of your algorithm and to specify how many Tasks must reach the barrier before the next phase can begin. You can also specify an action to be performed when each phase is completed (i.e., after the required number of tasks have called the SignalAndWait method, but before the tasks are allowed to continue to the next phase—the example for this recipe demonstrates how to do this with a lambda function. ■ Note It is important to ensure that you set the Barrier instance to expect the correct number of tasks at each stage of your algorithm. If you tell the Barrier to expect too few tasks, one phase may not have completed before the next begins. If you tell the Barrier to expect too many tasks, a phase will never start, even though all of your tasks have completed the earlier phase. You can change the number of tasks a Barrier will wait for by using the AddParticipant, AddParticipants, RemoveParticipant, and RemoveParticipants methods. The Code The following example shows a simple two-phase cooperative algorithm, performed by three tasks. When all of the tasks reach the barrier at the end of each phase, the notifyPhaseEnd method is called. using System; using System.Threading; using System.Threading.Tasks; namespace Recipe15_06 { class Recipe15_06 { static void Main(string[] args) { // Create the barrier. Barrier myBarrier = new Barrier(3, (barrier) => notifyPhaseEnd(barrier)); Task task1 = Task.Factory.StartNew( () => cooperatingAlgorithm(1, myBarrier)); Task task2 = Task.Factory.StartNew( () => cooperatingAlgorithm(2, myBarrier)); 740
CHAPTER 15 ■ PARALLEL PROGRAMMING Task task3 = Task.Factory.StartNew( () => cooperatingAlgorithm(3, myBarrier)); // Wait for all of the tasks to complete. Task.WaitAll(task1, task2, task3); // Wait to continue. Console.WriteLine("\nMain method complete. Press Enter"); Console.ReadLine(); } static void cooperatingAlgorithm(int taskid, Barrier barrier) { Console.WriteLine("Running algorithm for task {0}", taskid); // Perform phase one and wait at the barrier. performPhase1(taskid); barrier.SignalAndWait(); // Perform phase two and wait at the barrier. performPhase2(taskid); barrier.SignalAndWait(); } static void performPhase1(int taskid) { Console.WriteLine("Phase one performed for task {0}", taskid); } static void performPhase2(int taskid) { Console.WriteLine("Phase two performed for task {0}", taskid); } static void notifyPhaseEnd(Barrier barrier) { Console.WriteLine("Phase has concluded"); } } } 15-7. Handle Exceptions in Tasks Problem You need to catch and process exceptions thrown by a Task. 741
CHAPTER 15 ■ PARALLEL PROGRAMMING Solution Call the Task.Wait or Task.WaitAll methods within a try...catch block to catch the System.AggregateException exception. Call the Handle method of AggregateException with a function delegate—the delegate will receive each exception that has been thrown by the Tasks. Your function should return true if the exception can be handled, and false otherwise. How It Works Catching AggregateException as it is thrown from Task.Wait or Task.WaitAll allows you to be notified of exceptions that are unhandled by your Task. If an error has occurred, then you will catch a single instance of System.AggregateException representing all of the exceptions that have been thrown. You process each individual exception by calling the AggregateException.Handle method, which accepts a function delegate (usually specified using a lambda expression)—the delegate will be called once for each exception that has been thrown by your task or tasks. Bear in mind that several threads may have encountered the same problem, and that you are likely to have to process the same exception type more than once. If you can handle the exception, your function delegate should return true— returning false will cause your application to terminate. ■ Tip If you do not catch exceptions from Wait or WaitAll, then any exception thrown by a Task will be considered unhandled and terminate your application. The Code The following example demonstrates how use the AggregateException.Handle method to implement a custom exception handler function: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; namespace Recipe15_07 { class Recipe15_07 { static void Main(string[] args) { // Create two tasks, one with a null param. Task goodTask = Task.Factory.StartNew(() => performTask("good")); Task badTask = Task.Factory.StartNew(() => performTask("bad")); 742
CHAPTER 15 ■ PARALLEL PROGRAMMING try { Task.WaitAll(goodTask, badTask); } catch (AggregateException aggex) { aggex.Handle(ex => handleException(ex)); } // Wait to continue. Console.WriteLine("\nMain method complete. Press Enter"); Console.ReadLine(); } static bool handleException(Exception exception) { Console.WriteLine("Processed Exception"); Console.WriteLine(exception); // Return true to indicate we have handled the exception. return true; } static void performTask(string label) { if (label == "bad") { Console.WriteLine("About to throw exception."); throw new ArgumentOutOfRangeException("label"); } else { Console.WriteLine("performTask for label: {0}", label); } } } } 15-8. Cancel a Task Problem You need to cancel a Task while it is running. Solution Create an instance of System.Threading.CancellationTokenSource and call the Token property to obtain a System.Threading.CancellationToken. Pass a function delegate that calls the Cancel method of your Task 743
CHAPTER 15 ■ PARALLEL PROGRAMMING to the Register method of CancellationToken. Cancel your Task by calling the Cancel method of CancellationTokenSource. How It Works The System.Threading.CancellationTokenSource class provides a mechanism to cancel one or more tasks. CancellationTokenSource is a factory for System.Threading.CancellationToken. CancallationToken has the property IsCancellationRequested, which returns true when the Cancel method is called on the CancellationTokenSource that produced the token. You can also use the Register method to specify one or more functions to be called when the Cancel method is called. The sequence for handling cancellation is as follows: 1. Create an instance of CancellationTokenSource. 2. Create one or more Tasks to handle your work, passing CancellationToken as a constructor parameter. 3. For each Task you have created, obtain a CancellationToken by calling Token on the CancellationTokenSource created in step 1. 4. Check the IsCancellationRequested property of the token in your Task body— if the property returns true, then release any resources and throw an instance of OperationCanceledException. 5. When you are ready to cancel, call the Cancel method on the CancellationTokenSource from step 1. Note that you must throw an instance of OperationCanceledException to acknowledge the task cancellation request. The Code The following example creates a CancellationToken that is used to create an instance of Task. A method to be called when the CancellationTokenSource is canceled is registered with the Register method. When CancellationTokenSource.Cancel is called, the Task is stopped and a message is written to the console. using System; using System.Threading; using System.Threading.Tasks; namespace Recipe15_08 { class Recipe15_08 { static void Main(string[] args) { // Create the token source. CancellationTokenSource tokenSource = new CancellationTokenSource(); // create the cancellation token CancellationToken token = tokenSource.Token; 744
CHAPTER 15 ■ PARALLEL PROGRAMMING // Create the task. Task task = Task.Factory.StartNew(() => printNumbers(token), token); // register the task with the token token.Register(() => notifyTaskCanceled ()); // Wait for the user to request cancellation. Console.WriteLine("Press enter to cancel token"); Console.ReadLine(); // Canceling. tokenSource.Cancel(); } static void notifyTaskCanceled() { Console.WriteLine("Task cancellation requested"); } static void printNumbers(CancellationToken token) { int i = 0; while (!token.IsCancellationRequested) { Console.WriteLine("Number {0}", i++); Thread.Sleep(500); } throw new OperationCanceledException(token); } } } 15-9. Share Data Between Tasks Problem You need to share data safely between Tasks. Solution Use the collection classes in the System.Collections.Concurrent namespace. How It Works One of the biggest problems when writing parallel or threaded code is ensuring that data is shared safely. Microsoft has introduced new classes in .NET 4.0 that are designed to be more efficient than using synchronization around the default collection classes, which we demonstrated in Chapter 4. The 745
CHAPTER 15 ■ PARALLEL PROGRAMMING techniques demonstrated in Chapter 4 will work with the .NET parallel programming model, but the new collection classes may be more efficient for large-scale applications. Table 15-1 lists the most useful classes from the System.Collections.Concurrent namespace. Table 15-1. Useful System.Collections.Concurrent Classes Class Description ConcurrentBag A thread-safe collection of objects where no typing or ordering is assumed ConcurrentDictionary A key/value pair collection ConcurrentQueue A first in, first out (FIFO) queue ConcurrentStack A last in, first out (LIFO) stack These new collections take care of managing data automatically—you do not have to use synchronization techniques in your code. The Code The following example creates a ConcurrentStack, which is then used by three Tasks. using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; using System.Collections.Concurrent; namespace Recipe15_9 { class Recipe15_9 { static void Main(string[] args) { // Create a concurrent collection. ConcurrentStack cStack = new ConcurrentStack(); // create tasks that will use the stack Task task1 = Task.Factory.StartNew( () => addNumbersToCollection(cStack)); Task task2 = Task.Factory.StartNew( () => addNumbersToCollection(cStack)); Task task3 = Task.Factory.StartNew( () => addNumbersToCollection(cStack)); 746
CHAPTER 15 ■ PARALLEL PROGRAMMING // Wait for all of the tasks to complete. Task.WaitAll(task1, task2, task3); // Report how many items there are in the stack. Console.WriteLine("There are {0} items in the collection", cStack.Count); // Wait to continue. Console.WriteLine("\nMain method complete. Press Enter"); Console.ReadLine(); } static void addNumbersToCollection(ConcurrentStack stack) { for (int i = 0; i < 1000; i++) { stack.Push(i); } } } } 747
C H A P T E R 16 ■■■ Using LINQ In some of the previous chapters, we illustrated how to use LINQ to perform queries on different types of data. Chapter 2 showed how to query collections and arrays, Chapter 6 to query XML trees, and Chapter 9 to query databases. This chapter shows you how to build on those simple examples to exploit the full flexibility of LINQ. One of the best features of LINQ is that you can perform the same kinds of queries whatever the data source is. Each of the recipes in this chapter uses an array or a collection as the data source, but the same techniques can be applied equally to XML or databases. The recipes in this chapter are all self-contained and illustrate different LINQ features—but part of the allure of LINQ is that you will be able to combine these techniques to create complex and powerful queries. The recipes in this chapter describe how to perform the following tasks: • Filter elements in a data source (recipes 16-1, 16-2, and 16-3) • Create anonymous types in results (recipe 16-4) • Work with multiple data sources in queries (recipes 16-6, 16-7, ad 16-8) • Grouping, sorting, comparing, and aggregating data (recipes 16-9 through to 16- 12) • Sharing interim results across query clauses (recipe 16-13) • Extending LINQ with custom extension methods (recipe 16-14) • Converting LINQ results into other types (recipe 16-15) 16-1. Perform a Simple LINQ Query Problem You need to select all items from a collection, database, or XML document. 749
CHAPTER 16 ■ USING LINQ Solution Use the from and select keywords. How It Works The most basic LINQ query selects all of the items contained in a data source. The most powerful aspect of LINQ is that you can apply the same query approach to any data source and get consistent, predictable results. Microsoft has embedded LINQ support throughout the .NET Framework so that you can use arrays, collections, XML documents and databases in the same way. To select all of the items in a data source is a simple two-step process 1. Start a new LINQ query using the from keyword, providing an element variable name that you will use to refer to elements that LINQ finds (for example, from e in datasource). 2. Indicate what will be added to the result set from each matching element using the select keyword. For the basic “select all” query used in this recipe, we simply define the element variable name in the first step and use it as the basis for the second step, as follows: IEnumerable myEnum = from e in datasource select e; The type that you use for the datasource reference must implement the System.Collections. Generic.IEnumerable interface. If you are using an array or a generic collection, then you can simply use the references to your instance as the data source because arrays and all standard generic collections implement IEnumerable, as follows: IEnumerable myEnum = from e in myarray select e; IEnumerable myEnum = from e in mycollection select e; If you are using an XML tree, you can get an IEnumerable from the root XElement by calling the Elements method; and for a DataTable, you can get an IEnumerable by calling the AsEnumerable method, as follows: IEnumerable myEnum = from e in root.Elements() select e; IEnumerable myEnum = from e in table.AsEnumerable() select e; Notice that the generic type of the result is dependent on the data source. For an array or collection, the result will be an IEnumerable of the data contained in the array—string for string[] and IList, for example. LINQ queries of DataTables return an IEnumerable, and queries of an XML tree return IEnumerable. If you want to select a value contained within a data source element (for example, if myType had a property called Name that returned a string), then you simply specify the value you want after the select keyword—for example: IEnumerable myEnum = from e in datasource select e.Name; 750
CHAPTER 16 ■ USING LINQ Notice that the generic type of the result has changed—we are querying a data source that contains myType instances, but selecting a string property—therefore, the result is an IEnumerable. IEnumerable can be used with a foreach loop to enumerate the results of a query, but because LINQ queries return instances of IEnumerable and LINQ data sources must implement IEnumerable, you can also use the result of one query as the data source for another. The Code The following example performs a basic LINQ query on a string array, a collection, an XML tree, and a DataTable, and prints out the results in each case: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Xml.Linq; using System.Data; namespace Apress.VisualCSharpRecipes.Chapter16 { class Recipe16_01 { static void Main(string[] args) { Console.WriteLine("Using an array source"); // Create the source. string[] array = createArray(); // Perform the query. IEnumerable arrayEnum = from e in array select e; // Write out the elements. foreach (string str in arrayEnum) { Console.WriteLine("Element {0}", str); } Console.WriteLine("\nUsing a collection source"); // Create the source. ICollection collection = createCollection(); // Perform the query. IEnumerable collEnum = from e in collection select e; // Write out the elements. foreach (string str in collEnum) { Console.WriteLine("Element {0}", str); } Console.WriteLine("\nUsing an xml source"); // Create the source. XElement xmltree = createXML(); 751
CHAPTER 16 ■ USING LINQ // Perform the query. IEnumerable xmlEnum = from e in xmltree.Elements() select e; // Write out the elements. foreach (string str in xmlEnum) { Console.WriteLine("Element {0}", str); } Console.WriteLine("\nUsing a data table source"); // Create the source. DataTable table = createDataTable(); // Perform the query. IEnumerable dtEnum = from e in table.AsEnumerable() select e.Field(0); // Write out the elements. foreach (string str in dtEnum) { Console.WriteLine("Element {0}", str); } // Wait to continue. Console.WriteLine("\nMain method complete. Press Enter"); Console.ReadLine(); } static string[] createArray() { return new string[] { "apple", "orange", "grape", "fig", "plum", "banana", "cherry" }; } static IList createCollection() { return new List() { "apple", "orange", "grape", "fig", "plum", "banana", "cherry" }; } static XElement createXML() { return new XElement("fruit", new XElement("name", "apple"), new XElement("name", "orange"), new XElement("name", "grape"), new XElement("name", "fig"), new XElement("name", "plum"), new XElement("name", "banana"), new XElement("name", "cherry") ); } 752
CHAPTER 16 ■ USING LINQ static DataTable createDataTable() { DataTable table = new DataTable(); table.Columns.Add("name", typeof(string)); string[] fruit = { "apple", "orange", "grape", "fig", "plum", "banana", "cherry" }; foreach (string name in fruit) { table.Rows.Add(name); } return table; } } } Running the example produces the following result: Using an array source Element apple Element orange Element grape Element fig Element plum Element banana Element cherry Using a collection source Element apple Element orange Element grape Element fig Element plum Element banana 753
CHAPTER 16 ■ USING LINQ Element cherry Using an xml source Element apple Element orange Element grape Element fig Element plum Element banana Element cherry Using a data table source Element apple Element orange Element grape Element fig Element plum Element banana Element cherry Main method complete. Press Enter 754