C# 4 and .NET 4

Workflows ❘ 1329
Here, an instance of the WorkflowServiceHost class is constructed, and the workflow it exposes is
provided by the GetPropertyWorkflow method call. You can use a code based workflow, as we have done
with this example, or an XAML-based workflow. We then add an endpoint and specify a basic HTTP
binding, and then enable metadata publishing so that a client can point svcutil.exe at this endpoint to
download the service definition. Once that’s done, it is simply a matter of calling Open on the service host
class, and we’re then ready to receive incoming calls.
ensuring That a Workflow Can Be Created
The first activity within the workflow is a Receive, and it has been defined with the CanCreateInstance
property set to True. This is important, as it notifies the host that, if a caller calls this operation, a new
workflow instance will be constructed based on that call. What is happening under the covers is that
the WorkflowServiceHost is probing the workflow definition looking for Receive activities, and it will
construct a service contract based on these activities. It’s also looking for any such activities with True set
for CanCreateInstance, as then it knows what to do when it receives a message.
The sample code contains a client application that creates a new workflow instance by calling
UploadPropertyInformation; it then uploads information about three rooms using the
UploadRoomInformation operation, and finally it calls DetailsComplete. This sets the Finished flag
used by the While activity, and this completes that workflow.
The workflow code is fairly complex, as there’s a lot going on under the covers. Knowing how it works,
though, is instructive, so we’ll go through some of it here.
The first activity within the workflow is defined as follows:
Variable address = new Variable();
Variable owner = new Variable();
Variable askingPrice = new Variable();
// Initial receive - this kicks off the workflow
Receive receive = new Receive
{
CanCreateInstance = true,
OperationName = "UploadPropertyInformation",
ServiceContractName = XName.Get("IProperty", ns),
Content = new ReceiveParametersContent
{
Parameters =
{
{"address", new OutArgument(address)},
{"owner", new OutArgument(owner)},
{"askingPrice", new OutArgument(askingPrice)}
}
}
};
This Receive has the CanCreateInstance flag set to true, and it defines both operation and
service contract names. The ServiceContractName includes a namespace (in the example set to
http://pro-csharp/) so as to uniquely identify this service. The Content property defines what is
expected to be passed up from the client when the operation is called — in this instance we’re passing
up address, owner, and asking price values. The service operation is completely defined here by this
code — and the metadata exported uses this code to construct the operation definition.
The arguments received from this operation are bound to variables defined by the workflow. This is how we
pass arguments from the outside world into a workflow hosted by WCF.
Inside the workflow, we then create the unique ID that will be used when calling back to this workflow
instance. In order to do this, we need to define a workflow variable and assign its value — in the code that
follows, we’ve used an Assign activity to do this.
www.it-ebooks.info