PERSISTING WITH WORKLFLOWAPPLICATION

The exercise will demonstrate how to use the WorkflowApplication host with the SqlWorkflowInstanceStore for persisting workflow instances. After workflow instances are created, the PersistableIdleAction will be changed between Unload and Persist and instance ownership will be demonstrated with how it reacts to the PersistableIdleAction being modified.

The scenario anticipates that persistence has already been created using the scripts discussed earlier; therefore this exercise will use the new persistence data store for persisting workflow instances with a simple equipment rental workflow that tracks when rentals should be returned. The goal is to keep track of the rentals and when equipment needs to be returned, even when the application goes down. Because the exercise uses the WorkflowApplication, each persisted workflow instance will need to be loaded manually, so I will show you how to use Entity Framework’s code first pattern to pull persisted records from the persistence store. Finally, I will demonstrate how to use extensions to communicate from the workflow back to the hosting application. Let’s get started.

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 a new Activity Library, and name it ApressChapter8.
4. Rename the Activity1.xaml that is included with the project to wfRentalEquipment.xaml.
5. Rename the project to Exercise1.
6. Right-click on the solution and add new Visual C# class library. Name it Rental.DataModel. This project will maintain the EquipmentRental entities that will be passed from the workflow hosting application to the workflow.
7. Rename the file Class1.cs that was added by default to Equipment.cs.
8. Paste the following code into the Equipment.cs file:

   using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.ComponentModel;
   
    namespace Rental.DataModel
    {
        public class Equipment
        {
            public int EquipmentId { get; set; }
            public string EquipmentName { get; set; }
            public decimal Price { get; set; }
            public DateTime DateRented { get; set; }
            public int RentalMinutes { get; set; }
            public DateTime ReturnedOn { get; set; }
        }
    }

9. Add another class to the Rental.DataModel project and name it EquipmentRental.cs.
10. Paste the following code into the Equipment.cs file:

    using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
    
     namespace Rental.DataModel
     {
         public class EquipmentRental
         {
             public int EquipmentId { get; set; }
             public int RentalId { get; set; }
             public Equipment RentedEquipment { get; set; }
         }
     }

11. Right-click on the solution and add new Visual C# class library. Name it WFPersistence.DataModel. This project will retrieve the workflow instances that have been persisted using the [System.Activities.DurableInstancing].Instances view that is standard with the persistence database that was generated.
12. Rename the file Class1.cs that was added by default to PersistedInstance.cs.
13. Paste the following code into the PersistedInstance.cs file:

    using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
     using System.ComponentModel.DataAnnotations;
     using System.Collections.ObjectModel;
    
     namespace WFPersistence.DataModel
     {
         public class Instance
         {
             public Guid InstanceId { get; set; }
             public DateTime? PendingTimer { get; set; }
             public DateTime? CreationTime { get; set; }
             public DateTime? LastUpdatedTime { get; set; }
             public int? ServiceDeploymentId { get; set; }
             public string SuspensionExceptionName { get; set; }
             public string SuspensionReason { get; set; }
             public string ActiveBookmarks { get; set; }
             public string CurrentMachine { get; set; }
             public string LastMachine { get; set; }
             public string ExecutionStatus { get; set; }
             public bool? IsInitialized { get; set; }
             public bool? IsSuspended { get; set; }
             public bool? IsCompleted { get; set; }
             public byte? EncodingOption { get; set; }
             public byte[] ReadWritePrimitiveDataProperties { get; set; }
             public byte[] WriteOnlyPrimitiveDataProperties { get; set; }
             public byte[] ReadWriteComplexDataProperties { get; set; }
             public byte[] WriteOnlyComplexDataProperties { get; set; }
             public string IdentityName { get; set; }
             public string IdentityPackage { get; set; }
             public long? Build { get; set; }
             public long? Major { get; set; }
             public long? Minor { get; set; }
             public long? Revision { get; set; }
         }
    
         public class Instances : Collection<Instance>
     {
         }
     }

14. Add another class to the WFPersistence.DataModel project and name it WFPersistence.cs.
15. Paste the following code into the WFPersistence.cs file:

    using System;
     using System.Collections.Generic;
     using System.Data.Entity;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
    
     namespace WFPersistence.DataModel
     {
         public class WFPersistenceStore : DbContext
         {
             public WFPersistenceStore()
                 : base("WFPersist")
             {
             }
    
             public DbSet<Instance> PersistedInstances { get; set; }
             protected override void OnModelCreating(DbModelBuilder modelBuilder)
             {
                 modelBuilder.Entity<Instance>().ToTable("System.Activities.DurableInstancing.Instances");
             }
         }
     }

    
    This snippet of code implements the code-first pattern for EF4.3 a little differently. Code-first indicates that code is written before the database, but in this case the persistence data store has already been created. Therefore, you can write code modeling the data structure you want to retrieve data from and use the class above as the  DbContext object for getting the records; in this case, the structure is a database view  System.Activities.DurableInstancing.Instances. Notice also that the constructor points to a  base description of  WFPersist. This tells EF code first that a database already exists so there is no need to modify it, and to use a  connectionstring within a  config file for connecting to the database.
    
    Creating a POCO object called  Instances will not work alone for retrieving records from the view because it does not match the view name, and surely creating an object called  System.Activities.DurableInstancing.Instances will not work, so instead the POCO  class Instance is mapped to the  System.Activities.DurableInstancing.Instances view .
16. Now that the classes are built, a reference to the EF4.3 needs to be added. Right-click on References for the WFPersistence.DataModel and select Manage NuGet Packages, as shown in Figure 8-10.

    

    Figure 8-10.  Manage NuGet Packages

17. Check to see if Entity Framework 4.3 is installed by checking to see if it has a green check, which is located in the upper right corner as indicated in Figure 8-11. If it is not installed, an Install button can be pressed to download Entity Framework 4.3.

    

    Figure 8-11.  Checking if EntityFramework 4.3 is installed

    
    
    As workflow instances are persisted, this project will be responsible for retrieving the persisted instances from the application hosting the workflows.
18. Open wfRentalEquipment.xaml within the Exercise1 project so it can be viewed within the workflow designer. This workflow is going to be a pretty simple one so there is no need for it to be anything other than a sequential workflow. It is a sequential workflow because it does not rely on a flowchart or state machine style.
19. Right-click on the Exercise1 project and select Add Reference to theRental.DataModel project by clicking the checkbox for the project.
20. Click the Arguments tab and add a new argument called argInRental. Set the Direction for the argument to In and select “Browse for Types.” Select Rental.DataModel located under <Referenced assemblies> for the Argument type EquipmentRental. This argument will accept a new equipment rental that will be used within the workflow.
21. Click the Variables tab and create a new variable called varDelayDuration. This variable will be used to calculate the duration for how long the workflow should wait until the equipment rental becomes overdue. Change the Variable type to TimeSpan and set the Default value for the variable to TimeSpan.FromMinutes(argInRentedEquipment.RentalMinutes). The variable will be set based on the number of minutes passed in through the argInRental argument.
22. Drag a Delay activity from the toolbox and place it on the designer canvas and set its Duration property to varDelayDuration.
23. Right-click the Exercise1 project and create a new folder called Activities.
24. Right-click the folder and add a new class file. Name the file NotifyHost.cs and replace the current code by pasting in the code that follows. This code will communicate with the hosting application when rental equipment has become overdue using a workflow extension.

    using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
     using System.Activities;
     using Rental.DataModel;
     namespace Apress Chapter8 .Activities
     {
         public class NotifyHost : CodeActivity
         {
             [RequiredArgument]
             public InArgument<EquipmentRental> inRental { get; set; }
             protected override void Execute(CodeActivityContext context)
             {
                 var rental = new EquipmentRental();
                 rental = context.GetValue(inRental);
                 INotifyHost host = context.GetExtension<INotifyHost>();
                 if (rental.RentedEquipment.DateRented.AddMinutes(rental.RentedEquipment.RentalMinutes)<DateTime.Now)
                     host.OverDueRental(string.Format("{0} rental is Overdue!",
                         rental.RentedEquipment.EquipmentName),
                         context.WorkflowInstanceId);
             }
         }
     }

25. A workflow extension in the form of a simple interface needs to be created so the NotifyHost activity knows how to communicate with the hosting application. Right-click the folder and add a new class file. Name the file INotifyHost.cs and replace the current code with the following code:

    using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
    
     namespace Apress Chapter8 .Activities
     {
         public interface INotifyHost
         {
             void OverDueRental(string RentalStatus, Guid InstanceId);
         }
     }

26. Right-click on Exercise1 and select Build to make sure the workflow and NotifyHost activity builds correctly. Once the Exercise1 project builds successfully, drag the new NotifyHost activity located at the top of the toolbox, under the AppressChapter8.Activities section, and add it beneath the Delay activity added earlier. A sequence activity will be created automatically and will serve as the container for both the Delay and NotifyHost activities (see Figure 8-12).

    

    Figure 8-12.  Delay and Notify activities

27. Set the inRental argument for the NotifyHost activity to the Inargument for the workflow, argInRental.
    
    At this point the workflow and the data models that will be used with the workflow have been created. The last step is setting up the workflow hosting application. Instead of using a WPF app, a simple WinForms app will be created.
28. Right-click on the ApressChapter8 solution and select Add and then New Project. Select the Windows template and add a new Windows Forms Application. Name the project RentalHost.
29. Add the solution references in Figure 8-13 to the new RentalHost project.

    

    Figure 8-13.  WFPersistence.DataModel references

30. Make sure to reference Entity Framework 4.3, and if not, use Nuget to install it.
31. Right-click on References and add the Framework references checked in Figure 8-14.

    

    Figure 8-14.  .NET Framework references

32. Open the default Form1.cs file so the form can be created. Figure 8-15 shows the basic user interface that needs to be created.

    

    Figure 8-15.  RentalHost form

33. Drag a ListView from the toolbox and place it at the top of the form. After it is added, click the Columns property and add following three columns (also shown in Figure 8-16):

    

    Figure 8-16.  Adding ListView columns

    
    Name:“RentalId” Text:“Rental Number”
    
    Name:“WorkflowState” Text:“ WorkflowState”
    
    Name:“Status” Text:“Status”
34. Drag a Label to the form and set the Text property to Equipment Rental. Use a font size of 12.
35. Drag another Label to the form and set the Text property to Equipment just below the first label.
36. Drag a Combobox and place it directly below the label above. Set the Id property to cboEquipment.
37. Click on the arrow located on the top right of the cboEquipment to add the default items (see Figure 8-17):

    -select-
     Backhoe
     Stump Grinder
     Compactor

    

    Figure 8-17.  Adding Equipment values

38. Drag another Label to the form and set the Text property to Rental Minutes just below the cboEquipment.
39. Drag another Combobox and place it directly below the previous label. Set the Id property to cboRentalMinutes and do the same thing as Step 35 for adding the items but instead use the following:

    -select-
    1
    2
    3

40. Drag a new Button from the toolbox and place it just below cboRentalMinutes. Set the Name property to cmdCreateRental and the Text value to Create Rental.
41. Drag another Button from the toolbox and place it in the far right corner of the form. Set its Name property to cmdUnloadInstances and the Text value to Release.
    
    Drag another Button from the toolbox and place it within far right corner but on the left-hand side from cmdUnloadInstances. Set its Name property to cmdCreateRental and the Text value to Create Rental.
42. Double-click each of the buttons to create their click events.
43. Right-click the Windows form, select View Code, and replace the code with the following:

    using System;
     using System.Collections.Generic;
     using System.ComponentModel;
     using System.Data;
     using System.Drawing;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
     using System.Windows.Forms;
     using System.Activities;
     using System.Threading;
     using System.Runtime.DurableInstancing;
     using System.Activities.DurableInstancing;
     using System.Xml.Linq;
     using WFPersistence.DataModel;
     using Rental.DataModel;
     using System.ServiceModel.Activities;
     using Apress Chapter8 .Activities;
    
     namespace RentalHost
     {
         public partial class Form1 : Form,INotifyHost
         {
             private WorkflowApplication _wfApp;
             private SqlWorkflowInstanceStore _instanceStore;
              public Form1()
             {
                 InitializeComponent();
                 listView1.View = View.Details;
                 CreatePersistenceStore();
                 CreateInstanceStoreOwner();
                 LoadInstancesIntoListView();
                 cmdSetOwner.Enabled = false;
             }
    
              private void LoadInstancesIntoListView()
              {
                  try
                  {
                      var instances =
                          GetPersistedInstances();
                      listView1.Items.Clear();
    
                      if (instances.Count> 0)
                      {
    
                          foreach (var instance in instances)
                          {
                              InitiateWorkflowRuntime();
                              _wfApp.Load(instance.InstanceId);
                              _wfApp.Run();
                              var item = new ListViewItem(
                              new string[3]
                                 {
                                     _wfApp.Id.ToString(),
                                     "Loaded",
                                     "Not Overdue"
    
                                 });
                              listView1.Items.Add(item);
                          }
                      }
                  }
                  catch (Exception ex)
                  {
                      throw;
                  }
              }
    
             private UnhandledExceptionAction OnUnhandledException(WorkflowApplicationUnhandledExceptionEventArgs uh)
             {
                 return UnhandledExceptionAction.Terminate;
             }
    
             private Instances GetPersistedInstances()
             {
                 var PersistedWFInstances = new Instances();
                 try
                 {
                     using (var PersistStore = new WFPersistenceStore())
                     {
                         var result = from t in PersistStore.PersistedInstances
                                      select t;
    
                         foreach (var instance in result)
                         {
                             PersistedWFInstances.Add(
                             new Instance
                             {
                                 InstanceId = instance.InstanceId,
                                 PendingTimer = instance.PendingTimer,
                                 CreationTime = instance.CreationTime,
                                 LastUpdatedTime = instance.LastUpdatedTime,
                                 ServiceDeploymentId = instance.ServiceDeploymentId,
                                 SuspensionExceptionName = instance.SuspensionExceptionName,
                                 SuspensionReason = instance.SuspensionReason,
                                 ActiveBookmarks = instance.ActiveBookmarks,
                                 CurrentMachine = instance.CurrentMachine,
                                 LastMachine = instance.LastMachine,
                                 ExecutionStatus = instance.ExecutionStatus,
                                 IsInitialized = instance.IsInitialized,
                                 IsSuspended = instance.IsSuspended,
                                 IsCompleted = instance.IsCompleted,
                                 EncodingOption = instance.EncodingOption,
                                 ReadWritePrimitiveDataProperties = instance.ReadWritePrimitiveDataProperties,
                                 WriteOnlyPrimitiveDataProperties = instance.WriteOnlyComplexDataProperties,
                                 ReadWriteComplexDataProperties = instance.ReadWriteComplexDataProperties,
                                 WriteOnlyComplexDataProperties = instance.WriteOnlyComplexDataProperties,
     IdentityName = instance.IdentityName,
                                 IdentityPackage = instance.IdentityPackage,
                                 Build = instance.Build,
                                 Major = instance.Major,
                                 Minor = instance.Minor,
                                 Revision = instance.Revision
                             });
    
                         }
                     }
                 }
                 catch (Exception ex)
                 {
                     throw ex;
                 }
                 return PersistedWFInstances;
             }
    
             /// <summary>
             /// The on workflow completed.
             /// </summary>
             /// <param name="wc">
             /// The event args
             /// </param>
             private void OnWorkflowIdle(WorkflowApplicationIdleEventArgs iw)
             {
    
             }
             /// <summary>
             /// The on workflow completed.
             /// </summary>
             /// <param name="wc">
             /// The event args
             /// </param>
             private void OnWorkflowCompleted(WorkflowApplicationCompletedEventArgs wc)
             {
                 foreach (ListViewItem item in listView1.Items)
                 {
                     if (item.Text == wc.InstanceId.ToString())
                         listView1.Items[item.Index].SubItems[1].Text = "Completed";
    
                 }
             }
    
             private PersistableIdleAction OnWorkflowPersitableIdle(WorkflowApplicationIdleEventArgs ia)
             {
                 return PersistableIdleAction.Unload;
             }
    
             private void InitiateWorkflowRuntime(Dictionary<string,object> WFArg=null)
             {
                 try
                 {
                     Activity rentalWorkflow = new Exercise1.wfRentalEquipment();
    
                     if(WFArg!=null)
                         _wfApp = new WorkflowApplication(rentalWorkflow, WFArg);
                     else
                         _wfApp = new WorkflowApplication(rentalWorkflow);
          _wfApp.SynchronizationContext = SynchronizationContext.Current;
                     _wfApp.OnUnhandledException = OnUnhandledException;
                     _wfApp.Completed = OnWorkflowCompleted;
                     _wfApp.Idle = OnWorkflowIdle;
                     _wfApp.PersistableIdle = OnWorkflowPersitableIdle;
                     _wfApp.InstanceStore = _instanceStore;
                     _wfApp.Extensions.Add(this);
                 }
                 catch (Exception ex)
                 {
                     throw ex;
                 }
             }
    
             private EquipmentRental BuildWorkflowArg()
             {
                 EquipmentRental rental = null;
                 try
                 {
                     if (cboEquipment.SelectedIndex> 0)
                     {
                         rental = new EquipmentRental();
                         rental.RentedEquipment =
                             new Equipment
                             {
                                 DateRented = DateTime.Now,
                                 EquipmentName = cboEquipment.SelectedItem.ToString(),
                                 RentalMinutes = Convert.ToInt32(cboRentalMinutes.SelectedItem)
                             };
                     }
                 }
                 catch (Exception)
                 {
                     throw;
                 }
                 return rental;
             }
    
             private void CreatePersistenceStore()
             {
                 try
                 {
                     _instanceStore = new SqlWorkflowInstanceStore();
                     _instanceStore.ConnectionString =
                         "Server=ServerName;Database=WFPersist;Trusted_Connection=yes";
                 }
                 catch (Exception)
                 {
                    
                     throw;
                 }
             }
             private void CreateInstanceStoreOwner()
             {
                 try
                 {
                    
          InstanceHandle handle = _instanceStore.CreateInstanceHandle();
                     InstanceView view = _instanceStore.Execute(handle,
                                                     new CreateWorkflowOwnerCommand(),
                                                     TimeSpan.FromSeconds(30));
    
                     handle.Free();
                     _instanceStore.DefaultInstanceOwner = view.InstanceOwner;
                 }
                 catch (Exception ex)
                 {
                     throw;
                 }
             }
             private void LoadNewRental()
             {
                 try
                 {
                     var DateAndTimeRented = DateTime.Now.ToShortDateString()+" "+DateTime.Now.ToShortTimeString();
                     var DateAndTimeDue = DateTime.Now.AddMinutes(Convert.ToInt32(cboRentalMinutes.SelectedItem));
                     var Due = DateAndTimeDue.ToShortDateString()+" "+DateAndTimeDue.ToShortTimeString();
          var item = new ListViewItem(
                     new string[3]
                     {
                         _wfApp.Id.ToString(),
                         "Started",
                         string.Format("Rented on {0} and due back by {1}"
                                     ,DateAndTimeRented
                                     ,Due)
                        
                     });
                     listView1.Items.Add(item);
                 }
                 catch (Exception ex)
                 {
                     throw ex;
                 }
             }
             private void cmdCreateRental_Click(object sender, EventArgs e)
             {
                 var rental = BuildWorkflowArg();
                 if (rental != null)
                 {
                     Dictionary<string, object> wfArg = new Dictionary<string, object>(){
                             {
                                 "argInRental",rental
                             }
                         };
    
                     InitiateWorkflowRuntime(wfArg);
                     _wfApp.Run();
                     LoadNewRental();
                 }
                
             }
             private void cmdUnloadInstances_Click(object sender, EventArgs e)
             {
                 try
                 {
                     InstanceHandle handle = _instanceStore.CreateInstanceHandle();
                
          InstanceView view = _instanceStore.Execute(handle,
                                                     new DeleteWorkflowOwnerCommand(),
                                                     TimeSpan.FromSeconds(30));
                     handle.Free();
                    
                     listView1.Items.Clear();
                     cmdUnloadInstances.Enabled = false;
                     cmdSetOwner.Enabled = true;
          
                 }
                 catch (Exception)
                 {
                    
                     throw;
                 }
             }
    
             public void OverDueRental(string RentalStatus,Guid InstanceId)
             {
                 foreach (ListViewItem item in listView1.Items)
     {
                     if (item.Text == InstanceId.ToString())
                     {
                         listView1.Items[item.Index].SubItems[2].Text = RentalStatus;
                     }
                 }
             }
    
             private void cmdSetOwner_Click(object sender, EventArgs e)
             {
                 try
                 {
                     CreatePersistenceStore();
                     CreateInstanceStoreOwner();
                     LoadInstancesIntoListView();
                     cmdSetOwner.Enabled = false;
                     cmdUnloadInstances.Enabled = true;
                 }
                 catch (Exception ex)
                 {
                     throw ex;
                 }
             }
    
         }
     }

44. Make sure the Connectionstring property is correct and matches the server and database name used to build the persistence store.

    Server=ServerName;Database=WFPersist;Trusted_Connection=yes;

45. Press F5 to run the application. Once the application starts, equipment can be selected from the drop-down box as well as a value for the minutes for how long it can be rented. Click Create Rental to add a new equipment rental.

As equipment is rented and the workflow goes idle, each workflow instance will be persisted and unloaded. To simulate a system failure, the application can be stopped and then restarted and each of the persisted instances will be loaded into memory. When the workflow is idle, it will then persist and unload from memory again. The Set Owner and Release buttons can be used to reload persisted workflow instances. Once the workflow instance completes the workflow, it will be removed from the persistence data store and will no longer be viewed within the application.

PERSISTENCE WITHOUT UNLOADING

This exercise makes a change to Exercise1 and demonstrates how to persist workflow instances without unloading them from memory and the behavior that takes place when the hosting application fails.

1. Open Exercise1 within Visual Studio 2012.
2. Open Microsoft SQL Server Management Studio and connect the persistence store database. Open up a query window that is connected to the persistence store database as well.
3. Add the following queries to the query window. The first query uses the view Instances to get all of the persisted instances. The second gets all of the owner locks for the persisted instances.

   SELECT TOP 1000 *
     FROM [WFPersist].[System.Activities.DurableInstancing].[Instances]
   
   SELECT TOP 1000 *
     FROM [WFPersist].[System.Activities.DurableInstancing].[LockOwnersTable]

4. Open Form1.cs to view the code. Find the OnWorkflowPersistedIdle function and replace
   
   return PersistableIdleAction.Unload;
   
   with
   
   return PersistableIdleAction.Persist;
5. Run the application. This will change the behavior of the workflow instances to NOT unload from memory after the workflow instance goes Idle.
   
   Select an equipment rental and 1 minute for the duration and then click Create Rental. You will notice that the WorkflowState column says Started.
6. Wait one minute and notice how the workflow instance information changes in the ListView (see Figure 8-18).

   

   Figure 8-18.  Persisted but not unloaded

   
   After a minute has passed and without interacting with the application, the equipment rental becomes overdue. Notice that the WorkflowState has changed from started to completed, which indicates that the workflow instance has completed the workflow. The status has also changed to indicate that the rental is overdue (see Figure 8-19).

   

   Figure 8-19.  Equipment rental is overdue

   
   Multiple rentals can now be added and given different rental durations. As each duration expires, the application updates the rental status (see Figure 8-20).

   

   Figure 8-20.  Multiple rentals

7. Click the Release button after adding a rental. This tells the WF runtime that the persisted workflow instance can be picked up by another application. If the rentals have become overdue, then the workflow has completed and it is removed from the persistence data store by default.
   Now let’s demonstrate how persisted workflow instances are locked from other hosts.
8. Select another equipment rental and 2 minutes for the duration, and then click Create Rental.
9. Click the Release button so the owner lock is removed and then shut down the application. Make sure the application is no longer within Visual Studio, too.
10. Start up the application to simulate a new hosing application. The workflow instance will be reloaded and this time simulated as a new hosting application. After 2 minutes the workflow will complete.
11. Select another equipment rental and 2 minutes for the duration, and then click Create Rental.
12. Now shut down the application, and make sure the application is no longer within Visual Studio, too.
13. Start up the application to simulate a new hosing application. The application will break with an error similar to that in Figure 8-21.

    

    Figure 8-21.  InstanceLockException

Exercise2 has demonstrated on top of Exercise1 how to persist workflows instead of unloading them and how to release ownership of workflow instances so other workflow hosts can access them. I also demonstrated what can happen if a persisted workflow instance is not released from a host while another host tries to access it.