One of the most exciting features included in SharePoint 2007 is workflow support and the possibility of developing our own custom workflows (for more information about workflow development in the SharePoint 2007 platform please click here).

While it is possible to develop workflows to automate a series of activities without any human intervention, the full power of workflows in the SharePoint platform can only be achieved with human-oriented workflows. These workflows are characterized by creating and assigning tasks to users that must complete them in order to fulfill the purpose of the workflow. Some examples of out of the box human-oriented workflows that are included with MOSS 2007 are Approval, Collect Feedback and Issue Tracking.

In the SharePoint world, the most common usage of human-oriented workflows is in the context of document libraries, to perform some work when a new document is uploaded into a document library. Typically, in such scenario, tasks are created and assigned to users throughout the workflow lifetime that will complete them until the workflow purpose has been fulfilled. Having the workflow goal to be achieved is the desired and most common scenario, but unexpected actions may occur before the end of the workflow such as a user to delete the document. The following example will show you how to handle this situation in a custom workflow by using the OnWorkflowItemDeleted activity.

Example

The OnWorkflowItemDeleted activity can be used within a custom workflow to handle an item deletion in any SharePoint list. In this example, this activity will be used to delete all uncompleted tasks associated with the deleted item. After dragging and dropping the OnWorkflowItemDeleted activity into the workflow designer, the Invoke property must be set to the event handler that will perform the work.

For the purpose of this example, please consider the simple approval workflow in the following image:

In this workflow, a parallel activity with two branches is used. One contains the main workflow logic while the other contains a OnWorkflowItemDeleted activity that will handle the item deletion. The Invoke event property was set to be handled by an event handler method called OnWorkflowItemDeleted_Invoked. Let’s take a look at the code:

public sealed partial class ApprovalWorkflow : SequentialWorkflowActivity
{
    /// <summary>
    /// Handles the workflow item deleted event.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void OnWorkflowItemDeleted_Invoked(object sender, ExternalDataEventArgs e)
    {
        //delete uncompleted tasks when 
        //an item is deleted
        SPWorkflow workflowInstance = 
            workflowProperties.Workflow;
        SPWorkflowTaskCollection taskCollection = 
            GetWorkflowTasks(workflowInstance);
        for (int i = taskCollection.Count; i > 0; i--)
        {
            SPWorkflowTask task = 
                taskCollection[i - 1];
            using (SPWeb web = 
                workflowProperties.Web)
            {
                if (task[SPBuiltInFieldId.TaskStatus]
                    .ToString() != SPResource.GetString
                    (new CultureInfo((int)web.Language, false),
                    "WorkflowTaskStatusComplete", new object[0]))
                {
                    task.Delete();
                }
            }
        }
    }

    /// <summary>
    /// Reads the workflow tasks. This method 
    /// is implemented because the Tasks property
    /// of the SPWorkflow instance takes a 
    /// while to be populated.
    /// </summary>
    public static SPWorkflowTaskCollection 
        GetWorkflowTasks(SPWorkflow workflowInstance)
    {
        SPWorkflowTaskCollection taskCollection = null;
        bool tasksPopulated = false;
        while (!tasksPopulated)
        {
            try
            {
                taskCollection = workflowInstance.Tasks;
                tasksPopulated = true;
            }
            catch { }
        }

        return taskCollection;
    }
}

In the previous example, the following actions are being performed:

• In the OnWorkflowItemDeleted_Invoked event handler, the workflow instance task collection is obtained by calling the GetWorkflowTasks method;
• The task collection is iterated and the each task status is checked to verify if it is still uncompleted;
• If so, the task is deleted.

The post SharePoint 2007 Workflow – Using the OnWorkflowItemDeleted activity appeared first on Blog IT.

This blog post will show you how to check if a certain workflow instance is completed in a SharePoint list. In this example, let’s assume that the default “Documents” document library in a team site is configured with a Collect Feedback workflow and that a new instance is started every time a new document is added to the library. The workflow is configured with 2 reviewers. My purpose is to start a custom workflow (associated with a custom workflow) on each document every time all reviewers have reviewed them, i.e., every time a Collect Feedback workflow instance is completed.

Example

The following example shows how the previously described scenario can be implemented. One first note is that when a workflow instance gets completed on a list item (thus changing the workflow status of the item), the item is not updated. This means that the obvious solution that would be to have an event handler running on the document library to detect the completion of the workflow for each document can’t be implemented. The following example uses an alternative approach that makes use of an event handler associated with the “Task” content type, that is used on workflow tasks lists. The event handler will run every time a task is updated and will get the task associated list item (the document) and start a custom workflow on the document when its Collect Feedback workflow instance gets completed. Let’s take a look at the code:

/// <summary>
/// Event handler associated with the "Task" content types.
/// </summary>
public class WorkflowCompletionCheckerEventReceiver : SPItemEventReceiver
{
    //custom content type name
    private const string CUSTOM_CONTENT_TYPE_NAME = 
        "My Custom Content Type";
    //task list workflow list id field
    public const string TASK_LIST_WORKFLOW_LIST_ID_FIELD_NAME = 
        "ows_WorkflowListId";
    //task list workflow item id field
    public const string TASK_LIST_WORKFLOW_ITEM_ID_FIELD_NAME = 
        "ows_WorkflowItemId";
    //collect feedback workflow id
    public const string COLLECT_FEEDBACK_WORKFLOW_ID = 
        "46c389a4-6e18-476c-aa17-289b0c79fb8f";
    //custom workflow id
    public const string CUSTOM_WORKFLOW_ID = 
        "96be29b0-1be4-4b99-a703-656e5470962b";

    /// <summary>
    /// Event handler for item updated event.
    /// </summary>
    /// <param name="properties"></param>
    public override void ItemUpdated(SPItemEventProperties properties)
    {
        //start a custom workflow on a list item when a 
        //collect feedback workflow gets completed
        StartCustomWorkflowOnTaskItemCompletion(properties);
    }

    /// <summary>
    /// Checks if the "Collect Feedback" workflow 
    /// instance on an item is completed. This method checkes a 
    /// workflow task and verifies if they have been created by a 
    /// "Collect Feedback" workflow and if the associated item is of 
    /// my custom content type. If yes, it verifies if the workflow has 
    /// been completed and if complete, starts a custom workflow 
    /// on the associated item.
    /// </summary>
    /// <param name="properties"></param>
    private void StartCustomWorkflowOnTaskItemCompletion
        (SPItemEventProperties properties)
    {
        
        //get the task item
        SPListItem listItem = properties.ListItem;
        if (listItem != null)
        {
            //get associated item id and associated list id

            //list id - ows_WorkflowListId field
            object associatedWorkflowListId = 
                listItem[TASK_LIST_WORKFLOW_LIST_ID_FIELD_NAME];
            //item id - ows_WorkflowItemId field
            object associatedWorkflowItemId = 
                listItem[TASK_LIST_WORKFLOW_ITEM_ID_FIELD_NAME];

            //get associated item
            if (associatedWorkflowItemId != null 
                && associatedWorkflowListId != null)
            {
                //get task associated list item using 
                //its list id and item id
                SPListItem associatedListItem = listItem.Web.Lists
                 .GetList(new Guid(associatedWorkflowListId.ToString()), false)
                 .GetItemById(int.Parse(associatedWorkflowItemId.ToString()));

                //check if item is of my custom content type
                if (associatedListItem.ContentType.Name
                    .Equals(CUSTOM_CONTENT_TYPE_NAME))
                {
                    //check if item has any workflow association
                    if (associatedListItem.Workflows.Count > 0)
                    {
                        //iterate workflow associations and lookup 
                        //the collect feedback association
                        foreach (SPWorkflow workflow in 
                            associatedListItem.Workflows)
                        {
                            Guid collectFeedbackWorkflowId = 
                                new Guid(COLLECT_FEEDBACK_WORKFLOW_ID);
                            //check if collect feedback workflow 
                            //instance is completed
                            if (workflow.ParentAssociation.BaseId 
                                == collectFeedbackWorkflowId
                                && workflow.InternalState 
                                == SPWorkflowState.Completed)
                            {
                                //if collect feedback workflow instance is 
                                //completed, start custom workflow that is 
                                //associated with the item
                                StartContentTypeWorkflow(associatedListItem, 
                                    CUSTOM_WORKFLOW_ID);
                            }
                        }
                    }
                }
            }
        }
    }

    /// <summary>
    /// Starts a workflow associated to a content type programmatically.
    /// </summary>
    /// <param name="properties"></param>
    public static void StartContentTypeWorkflow(SPListItem listItem,
        string workflowId)
    {
        //start specified workflow that is associated with the item
        SPWorkflowManager manager = listItem.Web.Site.WorkflowManager;
        //get list item content type
        SPContentType contentType = listItem.ContentType;
        //get list item workflow associations
        SPWorkflowAssociationCollection associationCollection = 
            contentType.WorkflowAssociations;
        //iterate all item workflow associations
        foreach (SPWorkflowAssociation association in associationCollection)
        {
            Guid workflowGuid = new Guid(workflowId);
            //check if current workflow association matches 
            //the specified workflow
            if (association.BaseId == workflowGuid)
            {
                string data = association.AssociationData;

                //start workflow
                SPWorkflow wf = manager.StartWorkflow(listItem, association, 
                    data, false);
            }
        }
    }
}

In the previous example, the following actions are being performed:

• The ItemUpdated event in the event handler is being handled;
• In the event handler, a reference to the task is obtained;
• The associated list item is obtained using two columns of the task list item:
  • “ows_WorkflowListId” – holds the id of the list where the associated list item is created;
  • “ows_WorkflowItemId” – holds the id of the associated list item;
• The content type of the associated list item is checked for a match to my custom content type;
• If there is a match, the list item workflow associations are checked for a match with the Collect Feedback workflow;
• If there is a match and the workflow instance is completed, the custom workflow is started.

Related Articles

To learn why your business should migrate to SharePoint Online and Office 365, click here and here.

If you want to convert your tenant’s root classic site into a modern SharePoint site, click here.

If you are a SharePoint administrator or a SharePoint developer who
wants to learn more about how to install a SharePoint farm in an automated way using PowerShell, I invite you to click here and here. The articles use AutoSPInstaller with a SharePoint 2016 farm but AutoSPInstaller support for SharePoint 2019 was already announced!

If you want to learn how to upgrade a SharePoint 2013 farm to SharePoint 2019, click here and here.

If you want to learn all the steps and precautions necessary to successfully keep your SharePoint farm updated and be ready to start your move to the cloud, click here.

If you learn how to greatly speed up your SharePoint farm update process to ensure your SharePoint farm keeps updated and you stay one step closer to start your move to the cloud, click here.

If you want to learn how to upgrade a SharePoint 2010 farm to SharePoint 2016, click here and here.

If you are new to SharePoint and Office 365 and want to learn all about it, take a look at these learning resources.

If you are work in a large organization who is using Office 365 or thinking to move to Office 365 and is considering between a single or multiple Office 365 tenants, I invite you to read this article.

If you or your customers are not ready to move entirely to the Cloud and Office 365, a hybrid scenario could be an interesting scenario and SharePoint 2019 RTM was recently announced with improved hybrid support! To learn all about SharePoint 2019 and all its features, click here.

If you want to know all about the latest SharePoint and Office 365 announcements from SharePoint Conference 2019, click here and here.

Happy SharePointing!

The post SharePoint 2007 – Checking if a Workflow Instance is Completed appeared first on Blog IT.

If you happen to be at any of the events and want to meet, contact me using the form on the blog.

You just gotta love technology… 🙂 See you there.

The post PDC08 + TechEd Emea 2008 appeared first on Blog IT.

"Businesses start and fail in the United States at an increasingly staggering rate. Every year, over a million people in this country start a business of some sort. Statistics tell us that by the end of the first year at least 40 percent of them will be out of business. Within five years, more than 80 percent of them will have failed.  […] And more than 80 percent of the small businesses that survive the the first five years fail in the second five."

Create It is now over 7 years old, and 16 people strong.  It makes me proud to be in the small percentage of companies that do make it (although we are still 3 years away from the danger zone). 🙂

Meanwhile, on the technical side, I've been trying out the new BizTalk Services R12 release, which includes (hosted) Workflow support. It's limited in the sense that there are not many activities included, and there's not yet rich and integrated tooling, but it's an interesting start nonetheless. Well worth exploring. And on another track, I've been looking into BizTalk Server R3. The new features do look interesting, although clearly in the "evolution" side of things.

Finally, I've been getting ready for the PDC2008, in October, where it's interesting to note that the topic "Cloud Services" is the one with most sessions. If you want to learn more about this topic, I recommend you subscribe to the Cloud Computing group hosted at Google Groups (but not specifically Google-related or sponsored). Interesting discussions there.

The post “The E-Myth Revisited” and The World After Summer appeared first on Blog IT.

To solve the problem, all you have to do is to set the workflow association to “Allow” and new instances of the workflow can again be created.

Related Articles

To learn why your business should migrate to SharePoint Online and Office 365, click here and here.

If you want to convert your tenant’s root classic site into a modern SharePoint site, click here.

If you are a SharePoint administrator or a SharePoint developer who wants to learn more about how to install a SharePoint farm in an automated way using PowerShell, I invite you to click here and here. The articles use AutoSPInstaller with a SharePoint 2016 farm but AutoSPInstaller support for SharePoint 2019 was already announced!

If you want to learn how to upgrade a SharePoint 2013 farm to SharePoint 2019, click here and here.

If you want to learn all the steps and precautions necessary to successfully keep your SharePoint farm updated and be ready to start your move to the cloud, click here.

If you learn how to greatly speed up your SharePoint farm update process to ensure your SharePoint farm keeps updated and you stay one step closer to start your move to the cloud, click here.

If you want to learn how to upgrade a SharePoint 2010 farm to SharePoint 2016, click here and here.

If you are new to SharePoint and Office 365 and want to learn all about it, take a look at these learning resources.

If you are work in a large organization who is using Office 365 or thinking to move to Office 365 and is considering between a single or multiple Office 365 tenants, I invite you to read this article.

If you or your customers are not ready to move entirely to the Cloud and Office 365, a hybrid scenario could be an interesting scenario and SharePoint 2019 RTM was recently announced with improved hybrid support! To learn all about SharePoint 2019 and all its features, click here.

If you want to know all about the latest SharePoint and Office 365 announcements from SharePoint Conference 2019, click here and here.

Happy SharePointing!

The post SharePoint 2007 – New instances of this workflow template are currently disallowed appeared first on Blog IT.

This blog post will show you how to start a workflow programmatically every time an item is updated in a SharePoint list. For those who don’t know, Windows Workflow Foundation (WF) is the new engine for building custom workflows (you can find more information about WF on the official web site). It was released as part of the .NET Framework 3.0 along with Windows Presentation Foundation (WPF) and Windows Communication Foundation (WCF). In the SharePoint world, workflows can be associated both to a list and to a content type. Both options are valid and the choice for one or the other option depends on your needs:

• If you want to run a workflow in a list, independently of the content type of each list item, you should associate the workflow to a list. If you have more than one content type associated to the list, care should be taken in the workflow implementation since each content type can have different columns that may not be present in the other content types;
• If you want to run the workflow on all items of a specific content type, you should associate the workflow to a content type. The workflow will be associated to all list items from that content type in all lists across a site or the whole site collection (depending on the scope of the workflow, typically defined in its deployment feature) that are associated with the content type.

Example

The following example shows how both options can be addressed. This example uses an event handler and starts a workflow every time an item is updated in a SharePoint list.

public class ProgrammaticWorkflowInitiationEventReceiver : SPItemEventReceiver
{
    /// <summary>
    /// Event handler for item updated event.
    /// </summary>
    /// <param name="properties"></param>
    public override void ItemUpdated(SPItemEventProperties properties)
    {
        //use this method if the workflow is associated to a list
        StartListWorkflow(properties);

        //use this method if the workflow is associated to a content type
        StartContentTypeWorkflow(properties);
    }

    /// <summary>
    /// Starts a workflow associated to a list programmatically.
    /// </summary>
    /// <param name="properties"></param>
    private void StartListWorkflow(SPItemEventProperties properties)
    {
        //get list item from event handler properties
        SPListItem listItem = properties.ListItem;

        using (SPWeb web = listItem.Web)
        {
            using (SPSite site = web.Site)
            {
                //obtain an instance of SPWorkflowManager 
                //which will be later used to start the workflow
                SPWorkflowManager manager = site.WorkflowManager;
                //get item's parent list
                SPList parentList = listItem.ParentList;
                //get all workflows that are associated with the list
                SPWorkflowAssociationCollection associationCollection = 
                    parentList.WorkflowAssociations;
                //lookup and start the worflow
                LookupAndStartWorkflow(listItem, manager,
                    associationCollection, "FDEDCC37-4D8A-44ba-8E22-57B2669A887C");
            }
        }
    }

    /// <summary>
    /// Starts a workflow associated to a content type programmatically.
    /// </summary>
    /// <param name="properties"></param>
    private void StartContentTypeWorkflow(SPItemEventProperties properties)
    {
        //get list item from event handler properties
        SPListItem listItem = properties.ListItem;

        using (SPWeb web = listItem.Web)
        {
            using (SPSite site = web.Site)
            {
                //obtain an instance of SPWorkflowManager 
                //which will be later used to start the workflow
                SPWorkflowManager manager = site.WorkflowManager;
                //get item's content type
                SPContentType contentType = listItem.ContentType;
                //get all workflows that are associated with the content type
                SPWorkflowAssociationCollection associationCollection = 
                    contentType.WorkflowAssociations;
                //lookup and start the worflow
                LookupAndStartWorkflow(listItem, manager,
                    associationCollection, "FDEDCC37-4D8A-44ba-8E22-57B2669A887C");
            }
        }
    }

    /// <summary>
    /// Lookup and start the workflow.
    /// </summary>
    /// <param name="listItem"></param>
    /// <param name="manager"></param>
    /// <param name="associationCollection"></param>
    /// <param name="workflowId"></param>
    private static void LookupAndStartWorkflow(SPListItem listItem, 
        SPWorkflowManager manager, 
        SPWorkflowAssociationCollection associationCollection, 
        string workflowId)
    {
        //iterate workflow associations and lookup the workflow to be started
        foreach (SPWorkflowAssociation association in associationCollection)
        {
            //if the workflow association matches the workflow we are looking for,
            //get its association data and start the workflow
            Guid workflowGuid = new Guid(workflowId);
            if (association.BaseId == workflowGuid)
            {
                //get workflow association data
                string data = association.AssociationData;

                //start workflow
                SPWorkflow wf = manager.StartWorkflow(listItem, association, data);
            }
        }
    }
}

In the previous example, the following actions are being performed:

• The ItemUpdated event in the event handler is being handled. For demonstration purposes, I am assuming that two workflow associations were created, one to a list and another to a content type;
• A call is made to the StartListWorkflow method, which starts the workflow associated with a list;
• A call is made to the StartContentTypeWorkflow method, which starts the workflow associated with a content type.

Related Articles

To learn why your business should migrate to SharePoint Online and Office 365, click here and here.

If you want to convert your tenant’s root classic site into a modern SharePoint site, click here.

If you are a SharePoint administrator or a SharePoint developer who wants to learn more about how to install a SharePoint farm in an automated way using PowerShell, I invite you to click here and here. The articles use AutoSPInstaller with a SharePoint 2016 farm but AutoSPInstaller support for SharePoint 2019 was already announced!

If you want to learn how to upgrade a SharePoint 2013 farm to SharePoint 2019, click here and here.

If you want to learn all the steps and precautions necessary to successfully keep your SharePoint farm updated and be ready to start your move to the cloud, click here.

If you learn how to greatly speed up your SharePoint farm update process to ensure your SharePoint farm keeps updated and you stay one step closer to start your move to the cloud, click here.

If you want to learn how to upgrade a SharePoint 2010 farm to SharePoint 2016, click here and here.

If you are new to SharePoint and Office 365 and want to learn all about it, take a look at these learning resources.

If you are work in a large organization who is using Office 365 or thinking to move to Office 365 and is considering between a single or multiple Office 365 tenants, I invite you to read this article.

If you or your customers are not ready to move entirely to the Cloud and Office 365, a hybrid scenario could be an interesting scenario and SharePoint 2019 RTM was recently announced with improved hybrid support! To learn all about SharePoint 2019 and all its features, click here.

If you want to know all about the latest SharePoint and Office 365 announcements from SharePoint Conference 2019, click here and here.

Happy SharePointing!

The post SharePoint 2007 – Start a Workflow Programmatically appeared first on Blog IT.

Adding a validator to a custom activity involves two steps:

1. Create a class that derives from ActivityValidator class and override Validate method;
2. Add a ActivityValidator attribute with the validator type to the custom activity;

As an example, i'm going to show a validator creation that verifies if a specific property is set.

I have already created a custom activity that is called Hello and have a property that receives the user name. To validate if the activity proprety is set, i'm going to create a validator. 

ActivityValidator class creation:

As said early, to create a validator i have to create a class that derives from ActivityValidator. To perform the validation i have to override the validate method and set the validation code.

using System;

using
System.Text.RegularExpressions;

using
System.Workflow.ComponentModel.Compiler;

The ListenActivity as its name suggests listens for incoming wake-up calls on the workflow. This activity idles the workflow, and waits for something to happen on one of its branches.

When this activity is dropped into the workflow designer two branches are automatically created (child activities), and these two are the minimum number of branches required to be defined.

On each branch we can only have EventDriven activities, because they are used to handle events; typically they can be raised from the host or by the runtime in response to a delay timer expiring.

Resume:

This activity is mostly used on scenarios where we want to wait for more than one event at the same time, or we want to set a timeout while waiting for some event to get raised.

Each branch is waiting for some event to occur before it can continue with the other activities on the branch. The first occurring event will be the one to run its branch activities first. All other branches cancel and stop listening for events. Basically, the ListenActivity blocks till one branch completes.

Example:

This example is based on a simple Sequential Workflow Console Application. As you can see in the following image, there are two branches on the Listen activity:

• The one on the left has a HandleExternalEvent activity (for more information about this activity please click here) that is waiting for an external event to be raised (In this case for user to write its name on the console), and below is a Code activity that will display the user name and the current user number.
• The right branch has a Delay activity that in this case will wait 15 seconds before raising a timeout event. If no external events are raised during the 15 seconds period, the right branch will be executed and a timeout message will be written.

The following image shows an output where the following occurs:

• A first event is raised for a user named Lucas and the Code activity (Display_UserInput) on the left branch was executed;
• A second event is raised for a user named Pipas and the Code activity on the left branch was executed again;
• A timeout occurs. No events were raised for a period of 15 seconds and the Code activity (Display_Timeout_Msg) on the right branch was executed;
• A third event is raised for a user named Miguel and the left branch activities were executed.

Note:

The ListenActivity cannot be used in state machine workflows.

The post Windows Workflow – Using the ListenActivity appeared first on Blog IT.

Local Service Communication allows workflows to communicate with an external service that resides within the Host.

Using this activity involves 4 phases:

1.    Contract interface creation;

2.    Workflow CallExternalMethod activity configuration with the contract interface, the parameter(s) and return properties (if applies);

3.    Contract implementation creation;

4.    Using ExternalDataExchangeService class at the Host, to register the Contract implementation

We can optionally set the input properties and read the return data.

Example:

In this example I'm going to show the execution of a simple method that returns the 2 input parameters concatenation.

1.    Contract interface creation

    In the contract interface you have only to create the interface contract definition used by the Workflow.

    You're going to create an Interface named "IContract", which defines the Concatenate method.

    All interfaces must have the ExternalDataExchange attribute defined that marks the interface as a local service interface.

       [ExternalDataExchange]
    public interface IContract 
    {
        string Concatenate(string parameter1, string parameter2);
       }

2.    Workflow CallExternalMethodActivity configuration

    Add the CallExternalMethodActivity to the Workflow.

    The Workflow will appear like this:

    Then you will create three properties that correspond to the two input parameters to concatenate and the return concatenation.

    public string Parameter1ToConcat { get; set; }

    public string Parameter2ToConcat { get; set; }

    public string ConcatenateReturn { get; set; }

    Configure the CallExternalMethodActivity properties like this:

3.    Contract implementation creation

    At the contract implementation creation, you have to create a class that implements IContract defined at the first step.

  public class ContractImplementation : IContract
  { 
      public string Concatenate(string parameter1, string parameter2)                      
      { 
          return parameter1 + parameter2; 
           }            
   }

4.    Host configuration

    At the Host, the contract implementation is registered by using the ExternalDataExchangeService class.

    The input properties can be set by using the second parameter from the CreateWorkflow method.

    The return parameter can be retrieved using the OutputParameters property from the WorkflowCompletedEventArgs class, at the WorkflowCompleted event.

using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{ 
  …  
  workflowRuntime.WorkflowCompleted += delegate(
          object sender, WorkflowCompletedEventArgs e) 
    {
      // this is where we can get the return value 
      Console.Write((string)e.OutputParameters["ConcatenateReturn"]); 
      waitHandle.Set();
    } 
  … 
  ExternalDataExchangeService externalDataExchangeService = new ExternalDataExchangeService();  

  // add the external data exchange service to the runtime 
  workflowRuntime.AddService(externalDataExchangeService); 

  // add the external method implementation to the local services 
  // this is where we add the object(that implements IContract)
  // that is going to be invoked by the CallExternalMethodActivity 
  externalDataExchangeService.AddService(new ContractProject.ContractImplementation()); 

  Dictionary<string, object> parameters = new Dictionary<string, object>(); 

  // add both paramenters  
  parameters.Add("Parameter1ToConcat", "1"); 
  parameters.Add("Parameter1ToConcat", "2"); 

  WorkflowInstance instance = workflowRuntime.CreateWorkflow(
              typeof(WorkflowConsoleApplication1.Workflow1), parameters); 
  instance.Start(); 
  waitHandle.WaitOne();
} 

The post Using WF CallExternalMethod activity in Windows Workflow appeared first on Blog IT.

This is the first in a series of blog posts dedicated to Windows Workflow. For those who don’t know, Windows Workflow Foundation (WF) is the new engine for building custom workflows (you can find more information about WF on the official web site). It was released as part of the .NET Framework 3.0 along with Windows Presentation Foundation (WPF) and Windows Communication Foundation (WCF).

Local Service Communication

Workflows are not isolated entities and most of the times need to communicate with the outside world in order to perform some task. There are several ways of communicating with external entities/services, being one of them External Data Exchange and Local Service Communication. Local Service Communication basically allows workflows to communicate with an external service that resides within the workflow host. There are two main activities inside WF that allow communication between a workflow and an external service using Local Service Communication:

• CallExternalMethodActivity – Allows a workflow to call a method from an external service. The workflow and the host establish a contract (using an interface) that defines the way they communicate with each other. Basically the workflow calls a method of a service residing within the host that implements the contract interface. For more details about this activity, click here.
• HandleExternalEventActivity – Besides allowing the workflow to call an external method, it is also possible for the host to send an event to the workflow in order for it to perform some task. This is achieved using the HandleExternalEventActivity that will put the workflow on an idle state until an external event is raised. Just as in CallExternalMethodActivity, the communication between the workflow and the external is based on a contract.

Summary

To build a workflow that uses HandleExternalEventActivity to communicate with a service using Local Service Communication, you’ll need to:

• Define a contract (interface);
• Implement a service based on the defined contract;
• Develop a workflow that uses HandleExternalEventActivity;
• Develop a host for the workflow;
• Add the service to the workflow runtime in the host;
• Start the workflow and handle the workflow WorkflowIdled event in the host;
• Raise the event.

Example

As already explained, the HandleExternalEventActivity allows communication between a workflow and an external service using Local Service Communication based on event notifications. Next, I will present a simple demo that will show a very basic usage of this activity. The demo is based on a simple Approval State Machine Workflow Console Application. The console application will ask the user if he/she wants to approve and based on the answer it will pass the corresponding answer to the workflow through the raise of an event. This is how the workflow looks like:

This workflow will basically handle the external event inside the StartState activity and set the approved or rejected state according to the information supplied by the host in the event. The interface of the service is defined like this:

[ExternalDataExchange]
public interface IApprovalEventService
{
    void RaiseSetStateEvent(Guid instanceId, bool approve);

    event EventHandler<ApprovalExternalDataEventArgs> ExternalDataEvent;
    
}

The interface uses the ExternalDataExchange attribute which allows the workflow to use it to communicate with the host using Local Service Communication. The interface defines the event, whose arguments are of type ApprovalExternalDataEventArgs, a type derived from ExternalEventArgs. It also defines a RaiseSetStateEvent method that will be used by the host to raise the event. This method defines an additional Boolean parameter named approve in order to pass the approval information to the workflow. This is how the ApprovalExternalDataEventArgs class looks like:

[Serializable]
public class ApprovalExternalDataEventArgs : ExternalDataEventArgs
{
    private bool _result;

    public bool Result {
        set {
            _result = value; 
        }
        get {
            return _result;
        }
    }

    public ApprovalExternalDataEventArgs(Guid instanceId, bool approve)
        : base(instanceId) {
        Result = approve;
    }
}

In the constructor, a Boolean approve parameter is used. This parameter is populated by the host when raising the event and is used to set the Result property that will be used later by the workflow. The other parameter used in the constructor is instanceId, which is used to correlate the event with the right workflow instance.

The HandleExternalEventActivity is defined inside the StartState activity and is named handleSetState. Here are the details of the StartState activity:

As shown in the image above, the external event is handled by the HandleExternalEventActivity handleSetState. Then, based on the value that was supplied by the host, approval or rejected activities will be executed (in this case a simple message will be written to the application console). The properties for the HandleExternalEventActivity handleSetState look like this:

There are three properties worth mentioning here:

• e – It will hold the event arguments for the workflow instance. In this case it is set to ExternalDataEvent, a public property in the workflow of type ApprovalExternalDataEventArgs.
• EventName – name of the event that will be handled. Also set to ExternalDataEvent.
• InterfaceType – name of the interface. Set to IApprovalEventService.

The IfElseActivity defined after the HandleExternalEventActivity will evaluate a code condition to determine whether to execute the Approve or Reject activities.

The code condition is based on a CheckState method that will verify the Result property of the workflow ExternalDataEvent property.

// Code condition to evaluate whether to take the 1st branch, YesIfElseBranch
// Since it always returns true, the 1st branch is always taken.
private void CheckState(object sender, ConditionalEventArgs e) {
    e.Result = ExternalDataEvent.Result;
}

The two remaining pieces of this demo are the service and the host console application. Here is the definition of the service:

class ApprovalEventService : IApprovalEventService
{
    #region IApprovalEventService Members

    public void RaiseSetStateEvent(Guid instanceId, bool approve)
    {
        // create event
        EventHandler<ApprovalExternalDataEventArgs> setStateEvent 
        = this.ExternalDataEvent;

        // launch event
        if (setStateEvent != null)
            setStateEvent(null, new ApprovalExternalDataEventArgs
                (instanceId, approve));
    }

    public event EventHandler<ApprovalExternalDataEventArgs> 
        ExternalDataEvent;
   

    #endregion
}

The console application code looks like this:

private static ApprovalEventService service;
private static Guid instanceId; 

/// <summary>
/// We've decorated the IEventService interface with the 
/// ExternalDataExchangeAttribute.
/// The event args class (ApprovalExternalDataEventArgs) 
/// derives from ExternalDataEventArgs.
/// The event args class (ApprovalExternalDataEventArgs) is serializable.
/// ApprovalEventService implements IEventService.
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
    using(WorkflowRuntime workflowRuntime = new WorkflowRuntime())
    {
        //add ApprovalEventService service to the workflow runtime
        AutoResetEvent waitHandle = new AutoResetEvent(false);
        ExternalDataExchangeService dataExchange = 
        new ExternalDataExchangeService();
        workflowRuntime.AddService(dataExchange);
        service = new ApprovalEventService();
        dataExchange.AddService(service);
        
        workflowRuntime.WorkflowCompleted += 
        delegate(object sender, WorkflowCompletedEventArgs e) 
        {
            //display workflow completion message
            Console.WriteLine("Workflow completed.");
            waitHandle.Set();
        };
        workflowRuntime.WorkflowTerminated += 
        delegate(object sender, WorkflowTerminatedEventArgs e)
        {
            //display error message if an exception is raised
            Console.WriteLine(e.Exception.Message);
            waitHandle.Set();
        };
        workflowRuntime.WorkflowIdled += 
        delegate(object sender, WorkflowEventArgs e)
        {
            //read the input from keyboard (yes/no) and raise 
            //the event passing the answer as a boolean parameter
            Console.WriteLine("Workflow idled.");
            Console.Write("Do you want to approve? (Y/N) ");
            string key = Console.ReadLine();
            bool approved = key.ToLower() == "y" ? true : false;
            Console.WriteLine("Sending event to workflow.");
            service.RaiseSetStateEvent(instanceId, approved);
        };

        //start workflow
        WorkflowInstance instance = 
        workflowRuntime.CreateWorkflow(
        typeof(StateMachineCommunicationDemo.SimpleStateMachine));
        instanceId = instance.InstanceId;
        Console.WriteLine("Starting workflow.");
        instance.Start();

        //put workflow in an idle state
        waitHandle.WaitOne();

        //stop runtime
        workflowRuntime.StopRuntime();

        Console.WriteLine("Press any key.");
        Console.Read();
    }
}

In the code above, the following actions are performed:

• The service is added to the workflow runtime. In order for the service to be correctly added to runtime, two AddService methods must be executed and in the right order. First, an instance of ExternalDataExchangeService is added to the workflow runtime. Then, an instance of our service (ApprovalEventService) is added to the ExternalDataExchangeService instance.
• The workflow is started
• The workflow is placed in an idle state
• Several delegate functions are defined to handle workflow events. The most important one is the event handler for the WorkflowIdled event. The event handler will be trigger once the workflow is placed in an idle state. Then, the user will be asked the approval question and the event is raised which will cause the HandleExternalEventActivity in the workflow to be executed.

Here is the application’s output in case of approval:

And in case of rejection:

Another related activity is the ListenActivity. For more information, please click here.

Related Articles

To learn why your business should migrate to SharePoint Online and Office 365, click here and here.

If you want to convert your tenant’s root classic site into a modern SharePoint site, click here.

If you are a SharePoint administrator or a SharePoint developer who wants to learn more about how to install a SharePoint farm in an automated way using PowerShell, I invite you to click here and here. The articles use AutoSPInstaller with a SharePoint 2016 farm but AutoSPInstaller support for SharePoint 2019 was already announced!

If you want to learn how to upgrade a SharePoint 2013 farm to SharePoint 2019, click here and here.

If you want to learn all the steps and precautions necessary to successfully keep your SharePoint farm updated and be ready to start your move to the cloud, click here.

If you learn how to greatly speed up your SharePoint farm update process to ensure your SharePoint farm keeps updated and you stay one step closer to start your move to the cloud, click here.

If you want to learn how to upgrade a SharePoint 2010 farm to SharePoint 2016, click here and here.

If you are new to SharePoint and Office 365 and want to learn all about it, take a look at these learning resources.

If you are work in a large organization who is using Office 365 or thinking to move to Office 365 and is considering between a single or multiple Office 365 tenants, I invite you to read this article.

If you or your customers are not ready to move entirely to the Cloud and Office 365, a hybrid scenario could be an interesting scenario and SharePoint 2019 RTM was recently announced with improved hybrid support! To learn all about SharePoint 2019 and all its features, click here.

If you want to know all about the latest SharePoint and Office 365 announcements from SharePoint Conference 2019, click here and here.

Happy SharePointing!

The post Windows Workflow – Using the HandleExternalEventActivity appeared first on Blog IT.