FlowChart.zip

public interface IOrderService

{

    string CreateOrder(string id);

    string UpdateOrder(string id);

    string ProcessOrder(string id);

    void CancelOrder(string id);

    string ShipOrder(string id);

    string GetOrderStatus();

}

To implement one of the methods add a WebServiceInputActivity, which is an IEventActivity, into an EventDriven on the state machine workflow or any of the states contained within it.  After setting the InterfaceType and the Method name the input parameters will appear in the property browser.  Bind them to workflow level variables so that you can use them across the workflow.  Add any activities needed to do the work for the method followed by a WebServiceOutputActivity.  After setting the InputActivityName the out parameters for the method are displayed so that you can bind to the variables containing the results.  After implementing all the methods you need right click on the project and choose Publish as Web Service to create the web service project.

In order to make multiple calls to the same web service you need to make sure that you have added a CookieContainer like below:

localhost.StateMachineWorkflow_WebService webservice = new localhost.StateMachineWorkflow_WebService();

webservice.CookieContainer = new CookieContainer();

After the host restarts If you want to send a web service method call to an already started instance you need the instance id for the workflow.  Then you add it to the cookie container like the folowing:

webservice.CookieContainer.Add(new Cookie("WF_WorkflowInstanceId", instanceId, "/", "localhost"));

If you are using other items in the cookie container serializing / deserializing the entire container would contain the required workflow instance id and you would not need to use the suggestion above.

Before running the example below make sure you follow the steps in the readme.txt file.

StateMachineWebServiceExample.exe

[DisplayName("Custom Activity Condition")]

public class CustomActivityCondition : ActivityCondition

{

    public override bool Evaluate(Activity activity, IServiceProvider provider)

    {

        return (this.customCondition.Equals("foo", StringComparison.CurrentCultureIgnoreCase));

    }

    private string customCondition = string.Empty;

    public string CustomCondition

    {

        get{ return this.customCondition; }

        set{ this.customCondition = value; }

    }

}

Next create a custom TypeConverter that will add your activity condition to the list of available activity conditions for your user to select like below:

public class CustomActivityConditionTypeConverter : TypeConverter

{

    private Hashtable conditionDecls = new Hashtable();

    public CustomActivityConditionTypeConverter()

    {

        AddTypeToHashTable(typeof(RuleConditionReference));

        AddTypeToHashTable(typeof(CodeCondition));

        AddTypeToHashTable(typeof(CustomActivityCondition));

    }

    private void AddTypeToHashTable(Type typeToAdd)

    {

        string key = typeToAdd.FullName;

        object[] attributes = typeToAdd.GetCustomAttributes(typeof(DisplayNameAttribute), false);

        if (attributes != null && attributes.Length > 0 && attributes[0] is DisplayNameAttribute)

            key = ((DisplayNameAttribute)attributes[0]).DisplayName;

        this.conditionDecls.Add(key, typeToAdd);

    }

    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)

    {

        if (sourceType == typeof(string))

            return true;

        return base.CanConvertFrom(context, sourceType);

    }

    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)

    {

        if (value is string)

        {

            if (((string)value).Length == 0 || ((string)value) == "(None)")

                return null;

            else

                return Activator.CreateInstance(this.conditionDecls[value] as Type);

        }

        return base.ConvertFrom(context, culture, value);

    }

    public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)

    {

        if (destinationType == typeof(string))

            return true;

        else

            return base.CanConvertTo(context, destinationType);

    }

    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)

    {

        if (value == null)

            return "(None)";

        object convertedValue = null;

        if (destinationType == typeof(string) && value is ActivityCondition)

        {

            foreach (DictionaryEntry conditionTypeEntry in this.conditionDecls)

            {

                if (value.GetType() == conditionTypeEntry.Value)

                {

                    convertedValue = conditionTypeEntry.Key;

                    break;

                }

            }

        }

        if (convertedValue == null)

            convertedValue = base.ConvertTo(context, culture, value, destinationType);

        return convertedValue;

    }

    public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)

    {

        ArrayList conditionDeclList = new ArrayList();

        conditionDeclList.Add(null);

        foreach (object key in this.conditionDecls.Keys)

        {

            Type declType = this.conditionDecls[key] as Type;

            conditionDeclList.Add(Activator.CreateInstance(declType));

        }

        return new StandardValuesCollection((ActivityCondition[])conditionDeclList.ToArray(typeof(ActivityCondition)));

    }

    public override bool GetStandardValuesSupported(ITypeDescriptorContext context)

    {

        return true;

    }

    public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)

    {

        return true;

    }

    public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)

    {

        PropertyDescriptorCollection props = new PropertyDescriptorCollection(new PropertyDescriptor[] { });

        TypeConverter typeConverter = TypeDescriptor.GetConverter(value.GetType());

        if (typeConverter != null && typeConverter.GetType() != GetType() && typeConverter.GetPropertiesSupported())

        {

            return typeConverter.GetProperties(context, value, attributes);

        }

        return props;

    }

    public override bool GetPropertiesSupported(ITypeDescriptorContext context)

    {

        return true;

    }   

}   

Then to use your custom type converter you just need to add the TypeConverterAttribute to any properties that are ActivityCondition like below:

[Browsable(true)]

[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]

[TypeConverter(typeof(CustomActivityConditionTypeConverter))]

public ActivityCondition MyCustomCondition

{

    get

    {

        return ((ActivityCondition)(base.GetValue(CustomActivityWithCustomActivityCondition.MyCustomConditionProperty)));

    }

    set

    {

        base.SetValue(CustomActivityWithCustomActivityCondition.MyCustomConditionProperty, value);

    }

}

To filter the types of ActivityCondition that can be used update the type converter’s constructor to add only the types you want to use like the following which will only display RuleConditionReference and the custom activity condition:

public CustomActivityConditionTypeConverter()

{

    AddTypeToHashTable(typeof(RuleConditionReference));

    AddTypeToHashTable(typeof(CustomActivityCondition));

}

CustomActivityConditionExample.exe

When you use have an attached property it will not be displayed in the property browser until you create an IExtenderProvider and implement the CanExtend method like the following:

bool IExtenderProvider.CanExtend(object extendee)

{

    return (extendee is Activity) && (((Activity)extendee).Parent is Switch);

} 

Along with the CanExtend method you also need to implement methods used for getting and setting the value of the property.  The naming convention that must be followed is the “Get” / “Set” followed by the name of the property.  For the switch activity I have the following:

[TypeConverter(typeof(ActivityBindTypeConverter))]

[CategoryAttribute("Switch"), ]

      [DescriptionAttribute("If any of the values in Cases equals the Switch's Expression then this activity will be run.")]

public object GetCases(Activity theActivity)

{

    object value = null;

    if (theActivity.Parent is Switch)

    {

        if (theActivity.IsBindingSet(Switch.CasesProperty))

            value = theActivity.GetBinding(Switch.CasesProperty) as object;

        else

            value = theActivity.GetValue(Switch.CasesProperty) as object;

    }

    return value;

}

public void SetCases(Activity theActivity, object value)

{

    if (theActivity.Parent is Switch)

    {

        if (value is ActivityBind)

            theActivity.SetBinding(Switch.CasesProperty, value as ActivityBind);

        else

            theActivity.SetValue(Switch.CasesProperty, value);

    }

}

Notice that any attribute that you would normally place on the property you will be adding above the GetPropertyName method.  Once you have the IExtenderProvider you link it up with the activity in the designer’s Initialize method:

protected override void Initialize(Activity activity)

{

    base.Initialize(activity);

    IExtenderListService extenderListService = (IExtenderListService)GetService(typeof(IExtenderListService));

    if (extenderListService != null)

    {

        bool foundExtender = false;

        foreach (IExtenderProvider extenderProvider in extenderListService.GetExtenderProviders())

        {

            if (extenderProvider.GetType() == typeof(CasesExtenderProvider))

                foundExtender = true;

        }

        if (!foundExtender)

        {

            IExtenderProviderService extenderProviderService = (IExtenderProviderService)GetService(typeof(IExtenderProviderService));

            if (extenderProviderService != null)

                extenderProviderService.AddExtenderProvider(new CasesExtenderProvider());

        }

    }

}

With attached properties you are also able to include a validator:

public static DependencyProperty CasesProperty = DependencyProperty.RegisterAttached("Cases", typeof(object), typeof(Switch), new PropertyMetadata(null), typeof(CasesValidator));

The validator in this case is validating that the Cases property is only set on a direct child of a Switch:

public class CasesValidator : Validator

{

    public override ValidationErrorCollection  Validate(ValidationManager manager, object obj)

    {

        ValidationErrorCollection errors = base.Validate(manager, obj);

        Activity activity = manager.Context[typeof(Activity)] as Activity;

        if (activity != null)

        {

            Switch switchAct = activity.Parent as Switch;

            if (switchAct == null)

                errors.Add(new ValidationError("The Cases property can only be set on a direct child of a Switch activity.", 123, false, "Cases"));

        }

        return errors;

    }

}

Since you can bind the Cases and Expression properties the value might not be set until runtime so validation of the values should be done in the Switch activity’s Initialize method.  If either are set to invalid values an exception is thrown to the user.  The current implementation only allows the properties to be set to a primitive, string or enum value.

SwitchActivity.exe

[Serializable()]

public class MyType

{

    string paramOne;

    string paramTwo;

    public MyType(string paramOne, string paramTwo)

    {

        ParamOne = paramOne;

        ParamTwo = paramTwo;

    }

    public string ParamOne

    {

        get { return paramOne; }

        set { paramOne = value; }

    }

    public string ParamTwo

    {

        get { return paramTwo; }

        set { paramTwo = value; }

    }

}

The default workflow serialization works pretty good for types that have a default constructor.  However, if your type is like the one above, which doesn’t, you aren’t going to get what you expect is you use the activity in a code only workflow.  If the property has a default value other than null in the designer.cs file you will see something like the following:

this.activity11.MyTypeProperty = ((MyType)(resources.GetObject("activity11.MyTypeProperty")));

And if you are using code separation it will look like the following:

<ns0:Activity1 x:Name="activity11">

      <ns0:Activity1.MyTypeProperty>

            <ns0:MyType ParamTwo="" ParamOne="" />

      </ns0:Activity1.MyTypeProperty>

</ns0:Activity1>

The code separation version looks good, but when you do anything that causes deserialization, like building or closing & reopening the workflow, you will end up with the following error message:

CreateInstance failed for type 'ActivityLibrary1.MyType'. No parameterless constructor defined for this object.

First, I will start with the code only workflow.  To get the proper serialization in the designer.cs file you need to have a CodeDomSerializer like the following:

public class MyTypeCodeDomSerializer : CodeDomSerializer

{

    public override object Serialize(IDesignerSerializationManager manager, object value)

    {

        MyType customType = value as MyType;

        return new CodeObjectCreateExpression(typeof(MyType), new CodeExpression[] { new CodePrimitiveExpression(customType.ParamOne), new CodePrimitiveExpression(customType.ParamTwo) });

    }

}

To link the serializer to the type use the following DesignerSerializerAttribute on the type:

[DesignerSerializer(typeof(MyTypeCodeDomSerializer), typeof(CodeDomSerializer))]

Now, below is what you will get in the designer.cs file:

this.activity11.MyTypeProperty = new ActivityLibrary1.MyType("", "");

For the code separation workflow issue you need to create a WorkflowMarkupSerializer to deserialize the custom type but you will also need to do the serialization.  Start by overriding the ToString method on your type.  For this example I have the following:

public override string ToString()

{

    return string.Format("ParamOne={0}, ParamTwo={1}", this.paramOne, this.paramTwo);

}

This will get your type serialized in a format that you know how to deal with and gives you the side benefit of having the property browser display the value of your type instead of its name.  The workflow markup serializer would look like the following:

public class MyTypeSerializer : WorkflowMarkupSerializer

{

    protected override bool CanSerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)

    {

        return true;

    }

    protected override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value)

    {

        MyType myType = null;

        if (!value.Contains("x:Null"))

        {

            string[] parameters = value.Split(new char[] { ',' }, 2);

            if (parameters.Length == 2)

            {

                string paramOneMatch = "ParamOne=";

                string paramTwoMatch = "ParamTwo=";

                string paramOneVal = parameters[0].Trim();

                string paramTwoVal = parameters[1].Trim();

                if (paramOneVal.StartsWith(paramOneMatch, StringComparison.OrdinalIgnoreCase)

                    && paramTwoVal.StartsWith(paramTwoMatch, StringComparison.OrdinalIgnoreCase))

                {

                    paramOneVal = paramOneVal.Substring(paramOneMatch.Length);

                    paramTwoVal = paramTwoVal.Substring(paramTwoMatch.Length);

                    myType = new MyType(paramOneVal, paramTwoVal);

                }           

            }

        }

        return myType;

    }

}

You link it to the type with the following attribute:

[DesignerSerializer(typeof(MyTypeSerializer), typeof(WorkflowMarkupSerializer))]

Now you should be able to add your custom activity to either a code only or seperated workflow and you should be able build without getting any errors, assuming you don’t have some other validation issue.

You can now add an activity with a custom type to a workflow and build it, but to set the value you have to edit the code or xoml file by manually.  The value displayed in the property browser isn’t editable so you can see what it is set to but not change it.  To allow the user to edit the value you need to add a TypeConverter.  I’ll start with making the string value of the type editable.  For this we need to override two sets of methods, one for converting to and one for from.  Because we aren’t going to supply a list of values we also need to say we don’t support standard values.  What we end up with is the following:

public class MyTypeTypeConverter : TypeConverter

{

    public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)

    {

        if (destinationType == typeof(MyType))

        {

            return true;

        }

        return base.CanConvertTo(context, destinationType);

    }

    public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)

    {

        if (context.PropertyDescriptor.PropertyType.IsAssignableFrom(typeof(MyType)) && destinationType == typeof(string))

        {

            if (value == null)

            {

                return string.Empty;

            }

            else

            {

                return (value as MyType).ToString();

            }

        }

        return base.ConvertTo(context, culture, value, destinationType);

    }

    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)

    {

        if (context.PropertyDescriptor.PropertyType == typeof(MyType))

        {

            return true;

        }

        return base.CanConvertFrom(context, sourceType);

    }

    public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)

    {

        if (context.PropertyDescriptor.PropertyType == typeof(MyType))

        {

            return Helper.Deserialize(value as string);

        }

        return base.ConvertFrom(context, culture, value);

    }

    public override bool GetStandardValuesSupported(ITypeDescriptorContext context)

    {

        return false;

    }

}

You link it to the type with the following attribute:

[TypeConverter(typeof(MyTypeTypeConverter))]

This is nice to be able to quickly edit here, but it isn’t the user experience that most people would expect.  If you have more than two or three properties making the property browser wider just isn’t going to work.  For this we need to create a separate line in the property browser for each property.  You do this my adding the following pair of methods:

public override bool GetPropertiesSupported(ITypeDescriptorContext context)

{

    return true;

}

public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)

{

    ArrayList properties = new ArrayList();

    MyType customType = value as MyType;

    if (customType != null && context != null)

    {

        PropertyDescriptorCollection props = TypeDescriptor.GetProperties(value, new Attribute[] { BrowsableAttribute.Yes });

        properties.Add(props["ParamOne"]);

        properties.Add(props["ParamTwo"]);

        return new PropertyDescriptorCollection((PropertyDescriptor[])properties.ToArray(typeof(PropertyDescriptor)));

    }

    return base.GetProperties(context, value, attributes);

}

What we have in place now works great if you have a default value that is not null.  However, if it is null your user would need to know the correct string format or they would still need to manually edit the code or xoml file. To fix this the final step is to create an editor. Start by creating add a Windows Form to you project that will allow users to set all the needed properties.  When you are done with that it is time to create a UITypeEditor and override the EditValue method.  This is where you will launch the form and return a new instance of your custom type.

WorkingWithCustomTypes.EXE

IStartWorkflow startWorkflow = executionContext.GetService(typeof(IStartWorkflow)) as IStartWorkflow;

Guid instanceId = startWorkflow.StartWorkflow(this.TargetWorkflow, this.Parameters);

Since the parameters won’t be known until runtime you can’t use the WorkflowParameterBindingsCollection because you wouldn’t be able to change in at runtime.  Instead I have have a parameters property that is type Dictionary<string, object>.

CustomInvokeWorkflowActivity.exe

ProcessActivity.EXE

PropertyDescriptor firstPropDescr = TypeDescriptor.GetProperties(this.activity)["FirstName"];

firstPropDescr.SetValue(this.activity, txtFirstName.Text);

Below is a link to a sample employee activity that when you double click in it a input form pops up to enter the first and last name.  Clicking the OK button sets the values on the activity.

InputActivity.exe

[ExternalDataExchange]

public interface IMyService

{

    event EventHandler<CompletedEventArgs> Completed;

}

In your workflow add a HandleExternalEventActivity and set its InterfaceType to the interface that contains the event delegate.  Next select the EventName for the event that you want to handle.  To raise the event from the host you need to implement the interface like the following:

public class MyService : IMyService

{

    public void RaiseEvent(CompletedEventArgs args)

    {

        EventHandler<CompletedEventArgs> completed = this.Completed;

        if (completed != null)

            completed(null, args);

    }

    public event EventHandler<CompletedEventArgs> Completed;

}

Then after creating the workflow runtime you need to add your custom service to the ExternalDataExchangeService and it needs to be added to the workflow runtime.

ExternalDataExchangeService dataExchange = new ExternalDataExchangeService();

workflowRuntime.AddService(dataExchange);

MyService myService = new MyService();

dataExchange.AddService(myService);

Below is a link to a simple sample that just traces out the string that is passed into the workflow.

SendDataToStateMachine.exe