The following code demonstrates how to create an Expression that can then participate in tracking.

public class TrackResult<T> : CodeActivity<T>
 {
 public InArgument<T> Expression { get; set; }
 
 protected override T Execute(CodeActivityContext context)
 {
 T result = context.Get(Expression);
 // Either explicitly call context.Track here, or just set up a tracking profile on TrackResult.Expression
 return result;
 }
 }
 

Note that in order to use a custom activity for the Condition property of a FlowDecision activity, the workflow must be created in code rather than using the designer. The following code snippet (from the Flowchart with Fault Handling sample) demonstrates how to create a flowchart in code.

private static Activity CreateFlowchartWithFaults(string promoCode, int numKids)
 {
 Variable<string> promo = new Variable<string> { Default = promoCode };
 Variable<int> numberOfKids = new Variable<int> { Default = numKids };
 Variable<double> discount = new Variable<double>();
 DelegateInArgument<DivideByZeroException> ex = new DelegateInArgument<DivideByZeroException>();
 
 FlowStep discountNotApplied = new FlowStep
 {
 Action = new WriteLine 
 { 
 DisplayName = "WriteLine: Discount not applied", 
 Text = "Discount not applied" 
 },
 Next = null
 };
 
 FlowStep discountApplied = new FlowStep
 {
 Action = new WriteLine 
 {
 DisplayName = "WriteLine: Discount applied",
 Text = "Discount applied " 
 },
 Next = null
 };
 
 FlowDecision flowDecision = new FlowDecision 
 {
 Condition = ExpressionServices.Convert<bool>((ctx) => discount.Get(ctx) > 0),
 True = discountApplied,
 False = discountNotApplied
 };
 
 FlowStep singleStep = new FlowStep
 {
 Action = new Assign
 {
 DisplayName = "discount = 10.0",
 To = new OutArgument<double> (discount),
 Value = new InArgument<double> (10.0)
 },
 Next = flowDecision
 };
 
 FlowStep mnkStep = new FlowStep
 {
 Action = new Assign
 {
 DisplayName = "discount = 15.0",
 To = new OutArgument<double> (discount),
 Value = new InArgument<double> (15.0)
 },
 Next = flowDecision
 };
 
 FlowStep mwkStep = new FlowStep
 {
 Action = new TryCatch
 {
 DisplayName = "Try/Catch for Divide By Zero Exception",
 Try = new Assign
 {
 DisplayName = "discount = 15 + (1 - 1/numberOfKids)*10",
 To = new OutArgument<double>(discount),
 Value = new InArgument<double>((ctx) => (15 + (1 - 1 / numberOfKids.Get(ctx)) * 10))
 },
 Catches = 
 {
 new Catch<System.DivideByZeroException>
 {
 Action = new ActivityAction<System.DivideByZeroException>
 {
 Argument = ex,
 DisplayName = "ActivityAction - DivideByZeroException",
 Handler =
 new Sequence
 {
 DisplayName = "Divide by Zero Exception Workflow",
 Activities =
 {
 new WriteLine() 
 { 
 DisplayName = "WriteLine: DivideByZeroException",
 Text = "DivideByZeroException: Promo code is MWK - but number of kids = 0" 
 },
 new Assign<double>
 {
 DisplayName = "Exception - discount = 0", 
 To = discount,
 Value = new InArgument<double>(0)
 }
 }
 }
 }
 }
 }
 },
 Next = flowDecision
 };
 
 FlowStep discountDefault = new FlowStep
 {
 Action = new Assign<double>
 {
 DisplayName = "Default discount assignment: discount = 0",
 To = discount,
 Value = new InArgument<double>(0)
 },
 Next = flowDecision
 };
 
 FlowSwitch<string> promoCodeSwitch = new FlowSwitch<string>
 {
 Expression = promo,
 Cases =
 {
 { "Single", singleStep },
 { "MNK", mnkStep },
 { "MWK", mwkStep }
 },
 Default = discountDefault
 };
 
 Flowchart flowChart = new Flowchart
 {
 DisplayName = "Promotional Discount Calculation",
 Variables = {discount, promo, numberOfKids},
 StartNode = promoCodeSwitch,
 Nodes = 
 { 
 promoCodeSwitch, 
 singleStep, 
 mnkStep, 
 mwkStep, 
 discountDefault, 
 flowDecision, 
 discountApplied, 
 discountNotApplied
 }
 };
 return flowChart;
 }
 

public class ReadOnlyStringEditor : PropertyValueEditor

{

    public ReadOnlyStringEditor()

    {

        FrameworkElementFactory factory = new FrameworkElementFactory(typeof(TextBlock));

        factory.SetBinding(TextBlock.TextProperty, new Binding("Value"));

        this.InlineEditorTemplate = new DataTemplate();

        this.InlineEditorTemplate.VisualTree = factory;

    }

}

The following code demonstrates how to assign the custom property editor. This should be done in the constructor for the designer.\

// Add attribute onto MyCustomActivity.DisplayName

AttributeTableBuilder builder = new AttributeTableBuilder();

builder.AddCustomAttributes(typeof(Activity), "DisplayName", new EditorAttribute(typeof(ReadOnlyStringEditor), typeof(PropertyValueEditor)));

MetadataStore.AddAttributeTable(builder.CreateTable());

Finally, assign the display name in the custom activity's constructor.



this.DisplayName = "Custom Sequence Activity";

If the custom activity can only accept a single type, this can be implemented quite simply by setting the WorkflowItemPresenter.AllowedItemType or WorkflowItemsPresenter.AllowedItemType property. Here is an example of this:

<sap:WorkflowItemsPresenter HintText="Drop Activities Here"
Margin="5" MinHeight="100"
Items="{Binding Path=ModelItem.Activities}"
AllowedItemType="{x:Type TypeName=sa:WriteLine}">

Note that to use the above code, you'll need to add a namespace declaration to your designer:

xmlns:sa="clr-namespace:System.Activities.Statements;assembly=System.Activities"

If you need to restrict to a set of allowed activity types, rather than a single type, this can be done by adding a validation error to the validation errors collection during the CacheMetadata phase. The following example shows how to create a validation error when an activity is added to the Activities collection that is not of type WriteLine or Assign:

protected override void CacheMetadata(NativeActivityMetadata metadata)
{
    base.CacheMetadata(metadata);
    foreach (Activity a in Activities)
    {
        if ((a.GetType() != typeof(System.Activities.Statements.WriteLine)) && (a.GetType() != typeof(System.Activities.Statements.Assign)))
        {
            metadata.AddValidationError("Child activity is not of type WriteLine or Assign");
        }
    }
}

designer.Context.Services.GetService<ValidationSErvice>().ValidateWorkflow();

To handle resulting validation errors, publish an implementation of IValidationErrorService, which will expose the set of errors through ValidationService.NavigateTo(). For information on how to do this, see the following topic:

How to: Display Validation Errors in a Rehosted Designer

Hosting workflows in IIS with Windows AppFabric

Using IIS with AppFabric is the preferred host for workflows. The host application for workflows using AppFabric is Windows Activation Service, which removes the dependency on HTTP over IIS alone.

Hosting workflows in IIS

Using IIS alone is not recommended, as there are management and monitoring tools available with AppFabric that facilitate maintenance of running applications. Workflows should only be hosted in IIS alone if there are infrastructure concerns with moving to AppFabric.

Hosting a workflow in a custom Windows Service

Creating a custom workflow service to host the workflow will require the developer to duplicate a lot of the functionality provided out-of-box by AppFabric, but will allow for more flexibility with custom functionality. This option should only be considered if AppFabric proves to not be an option.

HttpContext.Current is one of the features in WCF that is not available when using NetTcpBinding.

"Error: The values provided for the root activity's arguments did not satisfy the root activity's requirements:                 'UserDefinedInputClass': Expected an input parameter value of type 'MyAssembly.UserDefinedClass'            for parameter named 'UDC'. Parameter name: rootArgumentValues"

Assembly.LoadFrom does not use the main application context; instead, a new context is used, so type checking fails with the above error.

• Properties that have a common name across all the selected activities
• Properties that are of type String or a value type.

The private implementation of activity '<activity>' has the following validation error: "An error occurred while attempting to extract the target object of type 'System.Activites.InArgument' from the method call expression <activity><property>.Get". Note that the expression determining the object of type 'System.Activities.InArgument' must not require the runtime context.
Error: The sub-expression for the object of type 'System.Activities.InArgument' resulted in a location reference that is not visible at this scope.

The cause for this error is that the default reflection logic that happens during CacheMetadata to tell the runtime about the signature of an activity only looks for arguments with generic types.

Two solutions for this problem are:

• Use the generic version of InArgument with the anticipated type
• Override CacheMetadata and add the InArgument to the activity signature explicitly, as in the following code snippet:

protected override void CacheMetadata(ActivityMetadata metadata)
{
    base.CacheMetadata(metadata);
    this.myValue = MyValue ?? new InArgument<object>();
    RuntimeArgument arg = new RuntimeArgument("MyValue", this.myValue.ArgumentType, ArgumentDirection.In);
    metadata.AddArgument(arg);
    metadata.Bind(this.myValue, arg);
}

In order to implement cancellation in a useful way, do the following:

• Call AsyncCodeActivityContext.MarkCanceled to mark the activity as canceled.
• In the Cancel method, check to see what work had already been done by the activity, and undo the work.
• Do not duplicate effort in the Cancel and the EndExecute methods in case of cancellation, since both methods will be called.

If no work needs to be rolled back when an AsyncCodeActivity is canceled, it is not necessary to override AsyncCodeActivity.Cancel.