1. Open Visual Studio 2012 and create a new Project
2. Select the Workflow template to see a list of installed workflow templates.
3. Select workflow console application and name it Chapter5.FlowChart.
4. Rename the workflow console application to Exercise1. Delete the workflow that is included with the project and add a new activity named wfCustomerOrders.xaml.
5. Right-click on the solution and add new Visual C# class library. Name it Chapter5.DataModel. This project will handle all of the database plumbing used within the solution.
6. Rename the file Class1.cs that was added by default to Customer.cs.
7. Paste the following code into the Customer.cs file:

   using System;
    using System.Collections.ObjectModel;
    using System.Collections.Generic;
    using System.Text;
    using System.Threading.Tasks;
    using System.ComponentModel.DataAnnotations;
    namespace Chapter5 .DataModel
    {
        public class Customer
        {
            public Customer()
            {
                CustomerOrders =  new Collection <Order> ();
            }
            [Key]
            public int CustomerId { get; set; }
            public string CCNumber { get; set; }
            [Required]
            public string FirstName { get; set; }
            [Required]
            public string LastName { get; set; }
            public virtual ICollection <Order>  CustomerOrders { get; set; }
        }
        public class Customers : Collection <Customer>
        {
        }
    }

8. Add a new class to the Chapter5.DataModel and call it Order.cs. Paste the following code into the file:

   using System;
    using System.Collections.ObjectModel;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.ComponentModel.DataAnnotations;
    namespace Chapter5 .DataModel
    {
        public class Order
        {
            public Order()
            {
                LineItems =  new Collection <OrderLineItem> ();
            }
            [Key]
            public int OrderId { get; set; }
            [Required]
            public int CustomerId { get; set; }
            [Required]
            public DateTime DateOrdered { get; set; }
            [Required]
            public virtual ICollection <OrderLineItem>  LineItems { get; set; }
        }
    }

9. Add new class to the Chapter5.DataModel and call it OrderLineItem.cs. Paste the following code into the file:

   using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.ComponentModel.DataAnnotations;
    namespace Chapter5 .DataModel
    {
        public class OrderLineItem
        {
            [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
            public int LineItemId { get; set; }
            [Key]
            public int OrderId { get; set; }
    [Required]
            public string LineDescription { get; set; }
    [Required]
            public string SKU { get; set; }
    [Required]
            public Decimal? Price { get; set; }
        }
    }

   
   
   At this point you have built the Plain Old CLR Objects (POCO) that will be used to manage customers and their orders. The code that was pasted in might look different to developers who are not used to using Microsoft’s Entity Framework for object-relational mapping (ORM). However, later I will give a detailed description for what is going on within the POCO classes that were just added.
   
   Entity Framework (EF) has been around for a number of years now and is used for building and managing data layers within an application and the tables and relationships for data within SQL Server. EF’s Code First approach lets developers use code to handle the building of databases and application integration of an application and a SQL Server database. EF’s Code First approach may not be appropriate to use as a standard for all software projects, but huge benefits are gained within projects that are built from the ground up and when used within the initial stages for building architecture. The next steps will set up the code that will be used to build the database using EF’s Code First.
   
   The version of EF used in this exercise it Entity Framework 4.3, and if it is not already installed with Visual Studio 11, it can be downloaded via NuGet. NuGet is an extension to Visual Studio that assists in downloading companion frameworks for writing software within Visual Studio. By default Entity Framework 4.3 will use SQL Server 2008 R2 Express, which can be downloaded and installed from  www.microsoft.com/sqlserver/en/us/editions/express.aspx to build the database required in this exercise.
10. Add new class to the Chapter5.DataModel and call it Ordering.cs. Paste in the following code into the file:

    using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
     using System.Data.Entity;
     namespace Chapter5 .DataModel
     {
         public sealed class Ordering : DbContext
         {
             public DbSet <Order>  Orders { get; set; }
             public DbSet <Customer>  Customers { get; set; }
             protected override void OnModelCreating(DbModelBuilder modelBuilder)
         {
                 // Customer can have many Orders.
             modelBuilder.Entity <Customer> ()
                     .HasMany <Order> (customer =>  customer.CustomerOrders);
                 // Order can have many LineItems.
             modelBuilder.Entity <Order> ()
                     .HasMany <OrderLineItem> (order =>  order.LineItems);
                 // LineItems contains a composite key.
             modelBuilder.Entity <OrderLineItem> ()
                 .HasKey(p =>  new { p.OrderId, p.LineItemId });
             }
         }
     }

11. Add a new Unit Test project to the solution by right-clicking the solution and selecting New Project. Select the Test template that is represented under the Visual C# section (see Figure 5-11).

    

    Figure 5-11.  New Test Project

12. Rename the new test project as TestOrders. This project will test the EF Code First implementation and will also load customers and orders for the customers into the database.
13. By default the test project comes with a UnitTest1.cs file that has the stubs used for writing unit tests. Replace the existing file with the following code:

    using System;
     using System.Text;
     using System.Collections.ObjectModel;
     using System.Collections.Generic;
     using Microsoft.VisualStudio.TestTools.UnitTesting;
     using Chapter5 .DataModel;
     using System.Data.Entity;
     using System.Linq;
     namespace Chapter5 .Testing
     {
         [TestClass]
         public class UnitTest1
             {
             [TestMethod]
             public void TestGetOrders()
     {
                 using (var ordering =  new Ordering())
                 {
                     var custs =  from cust in ordering.Customers
                select cust;
                     var customers =  new Collection <Customer> ();
                     foreach (var c in custs)
                     {
                         customers.Add(c);
                     }
                 }
             }
             [TestMethod]
             public void TestCodeFirst()
             {
                 Database.SetInitializer(
                      new DropCreateDatabaseIfModelChanges <Ordering> ());
                 using (var ordering =  new Ordering())
                 {
                     ordering.Database.Initialize(false);
                     var customer =  new Customer
                     {
                         FirstName =  "John"
                         ,
                         LastName =  "Smith"
                     };
                     var order =
                         new Order
                         {
                             DateOrdered =  DateTime.Now
                         };
                     order.LineItems.Add(new OrderLineItem
                             {
                                 LineDescription =  "Widget 1",
                                 Price =  5.50m,
                                 SKU =  "fff-321-gfsf"
                             });
                     order.LineItems.Add(new OrderLineItem
                     {
                              LineDescription =  "Widget 2",
                              Price =  4.10m,
                              SKU =  "AAA-234-asdf"
                     });
                     order.LineItems.Add(new OrderLineItem
                     {
                         LineDescription =  "Widget 3",
                         Price =  10.10m,
                         SKU =  "BBB-321-j7df"
                     });                customer.CustomerOrders.Add(order);
                     ordering.Customers.Add(customer);
                     ordering.SaveChanges();
                 }
             }
         }
     }

14. Some references within the projects need to be made, so we can start by adding the references to the Chapter5.DataModel. Once NuGet is installed, check the project to make sure that Entity Framework 4.3 is installed. Figure 5-12 demonstrates how to right-click on the project and select “Manage NuGet Packages.”

    

    Figure 5-12.  Managing NuGet packages

    
    
    Check to see if Entity Framework 4.3 is installed by viewing the installed NuGet packages, illustrated in Figure 5-13. If it is not installed, an Install button can be pressed to download Entity Framework 4.3.

    

    Figure 5-13.  Checking if EntityFramework 4.3 is installed

15. Right-click References for the project and make sure to add references to System.ComponentModel.DataAnnotations, System.Data.DataSetExtensions, and System.Data.Entity. The reference list should look like Figure 5-14.

    

    Figure 5-14.  Chapter5.DataModel references

16. After adding the references, build the project by right-clicking on the project and selecting Build.
    
    Add a reference to the Entity Framework 4.3 within the test project TestOrders by either following the same steps for adding it via NuGet or adding it to the test project by using the file path for the EntityFramework referenced within the Chapter5.DataModel project, selecting References, and browsing to the same file path to add the reference to Entity Framework 4.3. The TestOrders reference list should look like Figure 5-15.

    

    Figure 5-15.  TestOrders references

17. Now that the references have been added, right-click the project and select Build.
18. After the project successfully builds, open up the UnitTest1.cs file within the TestOrders project.
19. Put the cursor on the test method TestCodeFirst() and then go to the top menu for visual studio and click on Test Run Tests in Current Context. This will run the test that will create the customer order and line items. To test that the records have been successfully created, you can either look at the database using SQL Server Management Studio or add a breakpoint by clicking the grey boundary of the code editor on the same line as the foreach statement within the test method TestGetOrders().
20. This time put the cursor on the test method TestGetOrders(), and then go to the top menu for Visual Studio and click on Test Debug Tests in Current Context. This will run the test method in debug mode, allowing the code to rest of the breakpoint. Press F10 to cycle through the ForEach statement, indicating that a customer has been loaded into the database.
    
    At this point, the data access layer is built and you can start building the workflow that is going to retrieve the customer order and line items, and build the logic for tallying up the total cost for the line items. To get the customer order, the workflow will rely on using a code activity that will implement the same code used to test that the customer record had been added to the database.
21. Right-click the workflow project Exercise1 and add a new folder called Activities. Right-click the folder and add a new class file. Name the file GetCustomeOrders.cs and replace the code with the following code:

    using System;
     using System.Activities;
     using System.Collections.Generic;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
     using Chapter5 .DataModel;
     using System.Collections.ObjectModel;
     namespace Exercise1.Activities
     {
         public class GetCustomerOrders:CodeActivity
         {
             [RequiredArgument]
             public OutArgument <Customers>  outCustomers { get; set; }
             protected override void Execute(CodeActivityContext context)
             {
                 using (var db =  new Ordering())
                 {
    	        db.Configuration.LazyLoadingEnabled =  false;
                     var custs =  db.Customers.Include("CustomerOrders.LineItems");
                     var customers =  new Customers();
                     foreach (var c in custs)
                     {
                         customers.Add(c);
                     }
                     // Reassign the argument.
                     context.SetValue(outCustomers,customers);
                 }
             }
         }
     }

22. There are two references that need to be made for the workflow project Exercise1. The first reference needs to add EntityFramework and the second is Chapter5.DataModel. Right-click on the Exercise1 project and select Build. After a successful build, the code activity GetCustomerOrders should appear in the Exercise1.Activties section of the toolbox.
23. Now the flowchart workflow is ready to be modeled. Double-click the Workflow1.xaml file to view the workflow designer. Next, drag a Flowchart activity from the toolbox onto the designer canvas. This sets the foundation for the flowchart workflow. While the workflow has focus and the Properites window is visible, check the ValidateUnconnectedNodes so all activity connections are validated.
24. Drag and drop the custom code activity GetCustomerOrders onto the designer canvas and while dragging the activity, lightly brush it close to the left side of the start activity on the workflow. This behavior will cause the nodes to appear on the start activity and will automatically connect the two activities once it is dropped. Figure 5-16 represents how the workflow should look at this point.

    

    Figure 5-16.  GetCustomerOrders

    
    
    GetCustomersOrders activity has an OutArgument called OutCustomers and because it is not set, the exception notification is visible on the activity. Viewing the Error List gives the details to the exception (that it must be set when using the activity within a workflow). A WF variable needs to be created to receive the collection of customers that the activity will return. See Figure 5-17.

    

    Figure 5-17.  Out argument required exception

25. Add a new WF variable for the workflow by clicking the Variable tab on the bottom left of the workflow. Set the name to varCustomers. The variable type is a custom type, Customers, and it is referenced in the Chapter5.DataModel project (see Figure 5-18). Click the drop-down box for the variable type and select Browse for Types.

    

    Figure 5-18.  Customers type

26. Select Customers for the variable type and set the default value for the variable to new Customers(). Make sure that the scope is set to Flowchart (see Figure 5-19).

    

    Figure 5-19.  Creating the variable to hold customers

27. Add the new WF variable varCustomers to the GetCustomersOrders by selecting the activity and viewing its properties within the Properties window. Select the button for outCustomers and type varCustomers into the textbox. After clicking OK, the exception notification for the activity will go away.
28. Drag a FlowDecision activity from the Flowchart section of the toolbox. And brush it close to the GetCustomersOrders activity so it can auto-connect the activities. While the FlowDecision activity has focus, make sure the Properties window is visible.
29. Set the Condition by pressing the button and adding varCustomers! = null&&varCustomers.Count> 0. This Condition will return a Boolean that will determine the flow for activity. Click OK.
30. Change the FalseLabel property to No Orders and the TrueLabel to Orders Exist.
31. Drag a WriteLine activity from the toolbox and brush the right side of the FlowDecision activity exposing the No orders node so it can auto-connect. Add There are no new customer orders inside the textbox for the WriteLine activity.
32. Drag the ForEach <T> activity from the toolbox and brush it to the left side of the FlowDecision activity to auto-connect the Orders Exist node with the ForEach <T> activity.
33. Click on the ForEach <t> activity to set configure its properties. Click the drop-down box for the TypeArgument property and select Browse for Types. Expand Chapter5.DataModel as illustrated in Figure 5-18 and select Customer as the argument type. At this point the workflow should resemble Figure 5-20.

    

    Figure 5-20.  Customer orders workflow

34. Double-click the ForEach activity, which will make the body for the activity accessible. There are two textboxes at the top of the activity. Add cust as the value for the textbox on the left and the LINQ expression from c in varCustomers select c for the value of the textbox on the right (see Figure 5-21).

    

    Figure 5-21.  Textbox value

35. Drag another ForEach <T> activity within the body of the existing ForEach <T> activity. Set the TypeArgument property to Chapter5.DataModel.Order. Add order as the value for the textbox on the left and cust.CustomerOrders for the value of the textbox on the right (see Figure 5-22).

    

    Figure 5-22.  Textbox value

36. Drag another ForEach <T> activity within the body of the last ForEach <T> activity that was added. Set the TypeArgument property to Chapter5.DataModel.OrderLineItem. Add lineItem as the value for the textbox on the left and order.LineItems for the value of the textbox on the right (see Figure 5-23).

    

    Figure 5-23.  Textbox value

37. Drag an Assign activity within the body of the ForEach <T> activity that was just added.
38. Drag a WriteLine activity just underneath the last ForEach <T> activity. The designer will automatically create a new Sequence activity so the WriteLine activity can be dropped.
39. Before the Assign activity can be configured, another WF variable needs to be added that has scope within the auto-generated Sequence activity.
40. Click on the Variable tab and add a WF variable named varTotalPrice. Select Browse for Types and set the VariableType to System.Decimal and set the scope to Sequence.
41. Click on the Assign activity and within the Properties window, set the To property to varTotalPrice and the Value property to varTotalPrice + lineItem.Price.value.
42. Click on the WriteLine activity and set the Text property to

    string.Format("Order for {0} has a total cost of {1}",←
    cust.FirstName + " " + cust.LastName,string.Format("{0:C}",varTotalPrice))

    At this point the composite activity built from steps 35–43 should look like Figure 5-24.

    

    Figure 5-24.  Nested ForEach <T> activities

43. Open up the Program.cs file and replace the existing code with the following code:

    using System;
     using System.Linq;
     using System.Activities;
     using System.Activities.Statements;
     namespace Exercise1
     {
        class Program
         {
             static void Main(string[] args)
             {
                 // Create and cache the workflow definition
                 Activity workflow1 =  new wfCustomerOrders();
                 WorkflowInvoker.Invoke(workflow1);
                 Console.ReadKey();
             }
         }
     }

Remember that you already created the test data that the workflow will use. There should be one order for John Smith with three line items within the order with the following prices:

Make sure that Exercise1 is set as the startup project and press F5 to run the solution. Once everything builds successfully and the workflow runs to completion, the results are displayed within the console window (see Figure 5-25).