Task 1: Enable Communication between the Client and Its Host

Article
03/05/2010

In this task, you will enable communication between your client and its host through the use of a WCF contract. The host application will invoke one operation on the client that is designed to start the client workflow and initialize it with a starting value.

Also, instead of creating another WCF contract through a new interface, in this task you will learn how to create a WCF contract programmatically through the workflow-first method.

Note

When the Visual Studio workflow designer is used to create or manage workflow services, it sometimes produces spurious validation errors. If you are able to successfully build your project, ignore the validation errors.

Procedures

To create the local host communication contract

Note When the Visual Studio workflow designer is used to create or manage workflow services, it sometimes produces spurious validation errors. If you are able to successfully build your project, ignore the validation errors.
Open the WorkflowServiceTutorial solution.
In the WorkflowServiceClient project node, open the workflow designer for that project.
Drag a ReceiveActivity activity onto the designer and place it above the first SendActivity activity so that the ReceiveActivity activity will be executed first in the workflow.

This activity will implement the operation defined in the local host communication contract.
Select the ReceiveActivity activity and in the Properties pane, under ServiceOperationInfo, click the ellipsis to open the Choose Operation dialog box.
You are going to be defining a new contract using the workflow-first authoring style, so click Add Contract in the upper-right corner and highlight Contract1.
In the Contract Name text box, name your contract ILocalHostContract.
Highlight the first operation under ILocalHostContract and rename it to StartClientWorkflow.
In the Parameters tab, click the Add symbol and add a new parameter named initialValue of type Int32 with a Direction of In and click OK.
Select the ReceiveActivity activity and under the Properties pane, bind initialValue to the global variable inputValue.
Also under the Properties pane, set the CanCreateInstance property to True.

A new contract named ILocalHostContract is now programmatically defined for you, but you still must alter a few files before you can use this contract to interact with your workflow service.
Open App.config in the WorkflowServiceClient project.

Add the following configuration code:

      <services>
        <service name="WorkflowServiceClient.ClientWorkflow" behaviorConfiguration="WorkflowServiceClient.ClientWorkflowBehavior">
          <host>
            <baseAddresses>
              <add baseAddress="https://localhost:8090/ClientWorkflow" />
            </baseAddresses>
          </host>
          <endpoint address=""
                    binding="wsHttpContextBinding"
                    contract="ILocalHostContract" />
          <endpoint address="mex"
                    binding="mexHttpBinding"
                    contract="IMetadataExchange" />
        </service>
      </services>
      <behaviors>
        <serviceBehaviors>
          <behavior name="WorkflowServiceClient.ClientWorkflowBehavior"  >
            <serviceMetadata httpGetEnabled="true" />
            <serviceDebug includeExceptionDetailInFaults="true" />
            <serviceCredentials>
              <windowsAuthentication
                  allowAnonymousLogons="false"
                  includeWindowsGroups="true" />
            </serviceCredentials>
          </behavior>
        </serviceBehaviors>
      </behaviors>

You have now defined the endpoint address for your local host communication contract. The client you have used throughout this tutorial will also implement this new contract.

To set up the local host communication

Open Program.cs and add the following using statements to the top of the file:
```
using System.ServiceModel;
using System.ServiceModel.Description;
```
If you created a Visual Basic solution, right-click the WorkflowServiceClient project node and select Properties. Select the References tab, and under Imported namespaces, click the check boxes for System.ServiceModel and System.ServiceModel.Description.

Because you will now be using a WorkflowServiceHost to enable local host communication and to run the client workflow operation invocations with the workflow service, you must modify the Main method so that the console host application can communicate with the workflow service client. The following code shows how the implementation of Main must change to facilitate local host communication.

Shared Sub Main()
    ' Create a WorkflowServiceHost object to listen for operation invocations.
    Using ConsoleHost As New WorkflowServiceHost(GetType(ClientWorkflow))
        Dim waitHandle As New AutoResetEvent(False)

        ' Add ChannelManagerService to the list of services used 
        ' by the WorkflowRuntime.
        Dim cms As New ChannelManagerService()
        ConsoleHost.Description.Behaviors.Find(Of WorkflowRuntimeBehavior)().WorkflowRuntime.AddService(cms)
        AddHandler ConsoleHost.Description.Behaviors.Find(Of WorkflowRuntimeBehavior)().WorkflowRuntime.WorkflowCompleted, AddressOf OnWorkflowCompleted
        AddHandler ConsoleHost.Description.Behaviors.Find(Of WorkflowRuntimeBehavior)().WorkflowRuntime.WorkflowTerminated, AddressOf OnWorkflowTerminated
        AddHandler ConsoleHost.Closed, AddressOf OnConsoleClosed

        ' Call Open to start receiving messages.
        ConsoleHost.Open()

        ' After the client workflow is started, block until receiving waitHandle.Set is called
        ' so that the console application does not exit before the client workflow has completed
        ' and ConsoleHost.Close is called.
        waitHandle.WaitOne()
    End Using
End Sub

Shared Sub OnWorkflowCompleted(ByVal sender As Object, ByVal e As WorkflowCompletedEventArgs)
    Console.WriteLine("The client workflow has completed." + vbLf + "Press <Enter> to exit the client application.")
    Console.ReadLine()
    WaitHandle.Set()
End Sub

Shared Sub OnWorkflowTerminated(ByVal sender As Object, ByVal e As WorkflowTerminatedEventArgs)
    Console.WriteLine(e.Exception.Message)
    WaitHandle.Set()
End Sub

' After the WorkflowServiceHost transitions to the closed state, allow the console 
' application to exit by signaling to the AutoResetEvent object that it is okay to unblock 
' the main thread.
Shared Sub OnConsoleClosed(ByVal sender As Object, ByVal e As EventArgs)
    WaitHandle.Set()
End Sub

static void Main(string[] args)
{
    // Create a WorkflowServiceHost object to listen for operation invocations.
    using (WorkflowServiceHost ConsoleHost = new WorkflowServiceHost(typeof(ClientWorkflow)))
    {
        AutoResetEvent waitHandle = new AutoResetEvent(false);

        // Add ChannelManagerService to the list of services used 
        // by the WorkflowRuntime.
        ChannelManagerService cms = new ChannelManagerService();
        ConsoleHost.Description.Behaviors.Find<WorkflowRuntimeBehavior>().WorkflowRuntime.AddService(cms);

        ConsoleHost.Description.Behaviors.Find<WorkflowRuntimeBehavior>().WorkflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) 
        { 
            Console.WriteLine("The client workflow has completed. \nPress <Enter> to exit the client application."); 
            Console.ReadLine();
            ConsoleHost.Close();
        };

        ConsoleHost.Description.Behaviors.Find<WorkflowRuntimeBehavior>().WorkflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)
        {
            Console.WriteLine(e.Exception.Message);
            waitHandle.Set();
        };

        // After the WorkflowServiceHost transitions to the closed state, allow the console 
        // application to exit by signaling to the AutoResetEvent object that it is okay to unblock 
        // the main thread.
        ConsoleHost.Closed += delegate(object sender, EventArgs e)
        {
            waitHandle.Set();
        };

        // Call Open to start receiving messages.
        ConsoleHost.Open();

        // After the client workflow is started, block until receiving waitHandle.Set is called
        // so that the console application does not exit before the client workflow has completed
        // and ConsoleHost.Close is called.
        waitHandle.WaitOne();
    }
}

Build and run your client service.
Use SvcUtil.exe to generate the proxy code and configuration code needed to interact with the local host communication operations.

Using SvcUtil.exe

To use SvcUtil.exe, see ServiceModel Metadata Utility Tool.

After you have generated your proxy code and configuration files, add those files to your WorkflowServiceClient project by doing the following:
1. Navigate to the Solution Explorer pane.
2. Right-click the WorkflowServiceClient project node.
3. Highlight Add and select Existing Item.
4. Navigate to the folder where SvcUtil.exe generated the configuration and proxy code files.
5. Select the files and click OK.

Once you have generated your proxy code and configuration files, modify the configuration code in App.config so that the new client endpoint used to facilitate local host communication is recognized by the host application. Also, you can use the same binding configuration information as the one currently used to communicate with your workflow service if you want to. The following code example shows which code to add to your App.Config file.

    <bindings>
    ...
    </bindings>
    <client>
        <endpoint address="https://localhost:8080/ServerWorkflow" binding="wsHttpContextBinding"
                bindingConfiguration="WSHttpContextBinding_IWorkflow1" contract="IWorkflow1"
                name="WSHttpContextBinding_IWorkflow1">
            <identity>
                <userPrincipalName value="someone@example.com" />
            </identity>
        </endpoint>
        <endpoint address="https://localhost:8090/ClientWorkflow" binding="wsHttpContextBinding"
                bindingConfiguration="WSHttpContextBinding_IWorkflow1"
                contract="ILocalHostContract" name="WSHttpContextBinding_ILocalHostContract">
            <identity>
                <userPrincipalName value="someone@example.com" />
            </identity>
        </endpoint>
    </client>
    <services>
    ...
    </services>
    <behaviors>
    ...
    </behaviors>

Now that you have generated your proxy client code to communicate between the host and the workflow service client, you must add code to invoke the LocalHostContractClient.StartClientWorkflow operation in your client workflow, so open Program.cs (or Module1.vb if you created a Visual Basic solution) and add the following code.

Class Program

    Shared WaitHandle As New AutoResetEvent(False)

    Shared Sub Main()
        ' Create a WorkflowServiceHost object to listen for operation invocations.
        Using ConsoleHost As New WorkflowServiceHost(GetType(WorkflowServiceClient.ClientWorkflow))
            Dim waitHandle As New AutoResetEvent(False)

            ' Create a client that is used by the host application to communicate with the workflow service client.            Dim LCSClient As New WorkflowServiceClient.LocalHostContractClient("WSHttpContextBinding_ILocalHostContract")

            ' Add ChannelManagerService to the list of services used 
            ' by the WorkflowRuntime.
            Dim cms As New ChannelManagerService()
            ConsoleHost.Description.Behaviors.Find(Of WorkflowRuntimeBehavior)().WorkflowRuntime.AddService(cms)
            AddHandler ConsoleHost.Description.Behaviors.Find(Of WorkflowRuntimeBehavior)().WorkflowRuntime.WorkflowCompleted, AddressOf OnWorkflowCompleted
            AddHandler ConsoleHost.Description.Behaviors.Find(Of WorkflowRuntimeBehavior)().WorkflowRuntime.WorkflowTerminated, AddressOf OnWorkflowTerminated
            AddHandler ConsoleHost.Closed, AddressOf OnConsoleClosed

            ' Call Open to start receiving messages.
             ConsoleHost.Open()

            Console.WriteLine("Client host service is ready.")            Console.WriteLine("Enter a starting value: ")            ' Read in a number from the user and use it as the initial number in the arithmetic operation calls.            LCSClient.StartClientWorkflow(Int32.Parse(Console.ReadLine()))

            ' After the client workflow is started, block until receiving waitHandle.Set is called
            ' so that the console application does not exit before the client workflow has completed
            ' and ConsoleHost.Close is called.
            waitHandle.WaitOne()
        End Using
    End Sub

    Shared Sub OnWorkflowCompleted(ByVal sender As Object, ByVal e As WorkflowCompletedEventArgs)
        Console.WriteLine("The client workflow has completed." + vbLf + "Press <Enter> to exit the client application.")
        Console.ReadLine()
        WaitHandle.Set()
    End Sub

    Shared Sub OnWorkflowTerminated(ByVal sender As Object, ByVal e As WorkflowTerminatedEventArgs)
        Console.WriteLine(e.Exception.Message)
        WaitHandle.Set()
    End Sub

    ' After the WorkflowServiceHost transitions to the closed state, allow the console 
    ' application to exit by signaling to the AutoResetEvent object that it is okay to unblock 
    ' the main thread.
    Shared Sub OnConsoleClosed(ByVal sender As Object, ByVal e As EventArgs)
        WaitHandle.Set()
    End Sub
End Class

static void Main(string[] args)
{
    // Create a WorkflowServiceHost object to listen for operation invocations.
    using (WorkflowServiceHost ConsoleHost = new WorkflowServiceHost(typeof(ClientWorkflow)))
    {
        AutoResetEvent waitHandle = new AutoResetEvent(false);

        // Create a client that is used by the host application to communicate with the workflow service client.        LocalHostContractClient LCSClient = new LocalHostContractClient("WSHttpContextBinding_ILocalHostContract");

        // Add ChannelManagerService to the list of services used 
        // by the WorkflowRuntime.
        ChannelManagerService cms = new ChannelManagerService();
        ConsoleHost.Description.Behaviors.Find<WorkflowRuntimeBehavior>().WorkflowRuntime.AddService(cms);

        ConsoleHost.Description.Behaviors.Find<WorkflowRuntimeBehavior>().WorkflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) 
        { 
            Console.WriteLine("The client workflow has completed. \nPress <Enter> to exit the client application."); 
            Console.ReadLine();
            ConsoleHost.Close();
        };

        ConsoleHost.Description.Behaviors.Find<WorkflowRuntimeBehavior>().WorkflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)
        {
            Console.WriteLine(e.Exception.Message);
            waitHandle.Set();
        };

        // After the WorkflowServiceHost transitions to the closed state, allow the console 
        // application to exit by signaling to the AutoResetEvent object that it is okay to unblock 
        // the main thread.
        ConsoleHost.Closed += delegate(object sender, EventArgs e)
        {
            waitHandle.Set();
        };

        // Call Open to start receiving messages.
        ConsoleHost.Open();

        Console.WriteLine("Client host service is ready.");        Console.WriteLine("Enter a starting value: ");        // Read in a number from the user and use it as the initial number in the arithmetic operation calls.        LCSClient.StartClientWorkflow(Int32.Parse(Console.ReadLine()));

        // After the client workflow is started, block until receiving waitHandle.Set is called
        // so that the console application does not exit before the client workflow has completed and 
        // ConsoleHost.Close is called.
        waitHandle.WaitOne();
    }
}

Because the ReceiveActivity that implements this operation has CanCreateInstance set to True, a new workflow instance will be created and the rest of the workflow will run as it did in the previous exercises. Also, the value that is entered through the command prompt will be the initial seed value used when invoking the rest of the arithmetic operations against the workflow service.

Open Workflow1.cs (or Workflow1.vb if you created a Visual Basic solution) and remove the line of code that assigns the number 1 to the inputValue variable in the sendActivity2_BeforeSend method implementation so that when the user enters a value in the command prompt, that value is used as the initial seed value for all of the operation invocations against the workflow service. The following code example shows what the revised event handler method implementation should look like.
```
Private Sub sendActivity2_BeforeSend(ByVal sender As System.Object, ByVal e As System.Workflow.Activities.SendActivityEventArgs)
    Console.WriteLine("The initial input value is {0}", inputValue)
End Sub
```
```
private void sendActivity2_BeforeSend(object sender, SendActivityEventArgs e)
{
    Console.WriteLine("The initial input value is {0}", inputValue);
}
```

Build and run the WorkflowServiceTutorial solution. You should observe output similar to this from the console host application.

Client host service is ready.
Enter a starting value:
7
A service instance has successfully been created.
The initial input value is 7
The value after invoking the Add operation is 7
The new input value is 2
The value after invoking the Subtract operation is 5
The new input value is 6
The value after invoking the Multiply operation is 30
The new input value is 3
The value after invoking the Divide operation is 10
The workflow service instance has successfully shutdown.
The client workflow has completed.
Press <Enter> to exit the client application.

Share via

Task 1: Enable Communication between the Client and Its Host

Procedures

To create the local host communication contract

To set up the local host communication

See Also

Reference

Additional resources