Extending the Service Factory v3

Jim Lavin — Sat, 15 Sep 2007 09:59:56 GMT

I've been needing a tailored version of the Web Service Software Factory to simplify the design and creation of web services for my development team. Not that the Service Factory isn't easy to use, but my team has to design and build services that use industry standard schemas as well as invoke workflows. So, I figured extending the the service factory would allow me to tailor it to my team's needs and by using some of the new features in the v3b117 Alpha I could keep the modifications simple. Granted, things will change between now and the final release, but half of the fun with being on the bleeding edge is taking things apart to get a good understanding of how they work.

Technology Extensions

What I needed was a way for the person designing the service to indicate if an operation should invoke a workflow or not. To do this I needed a new property on the operation contract model element in the service designer. Normally, you would have to modify the DSL model to add the new property, recompile and distribute the new version of the DSL. This is not always the best way to do things because you end up having various versions of the DSL laying about taking up space. Not anymore! By using the extensions provided in the service factory you can extend the model specifically for the purposes of the factory without having to modify the DSL. This is really nice! The new extensions are a really big step towards the reuse of DSLs for factory building.

In order to target the models for a specific implementation technology the team has added a Technology Extensions library which allows you to dynamically extend the model at runtime. If you look at the service designer model properties you'll see a property for implementation technology and you have a choice of either ASMX or WCF.

This property dynamically loads up a set of model extensions that provides additional properties and actions that are specific for the selected technology. Once the extension is loaded then the properties for the model elements show the additional properties for the specific technology extension.

Tailoring the Factory to Invoke a Workflow

It just so happens that just like there are two ways to create web services within .Net there are two ways to host workflows within a web service. You can use the native ASMX hosting method provided with Windows Workflow or you can instantiate the workflow runtime in a WCF web service and invoke the workflow using the ManualWorkflowScheduler. This allows us to use the existing Technology Extensions to tailor the hosting method based on the selected implementation technology in the service model.

Extending the Object Model

First we need to extend the OperationContract ObjectExtender with a new property called InvokesWorkflow that will be presented to the DSL user once they have selected an implementation technology.

Below is a sample of the code I added to the WCFOperationContract:

        private bool invokesWorkflow = false;

        [Category(ServiceContractWCFExtensionProvider.ExtensionProviderPropertyCategory),
         Description("Specifies the if the operation should invoke a workflow to handle the request."),
         ReadOnly(false),
         BrowsableAttribute(true)]
        [XmlElement("InvokesWorkflow")]
        public bool InvokesWorkflow
        {
            get { return invokesWorkflow; }
            set { invokesWorkflow = value; }
        }

That's all we have to do to add our new property to the DSL. Now as our designers are working on a service's design they can indicate if the operation should invoke a workflow or not. This is so much simpler than having to modify the DSL and republish it.

Modifying the Implementation Specific Text Templates

Next we need to modify the code generation templates to add the technology specific implementations to the code. You'll find the templates under the ServiceContractDSL project in a folder called TextTemplates. They have created one for each technology extension, I am assuming the Service Factory Team did this to keep things simple. If I find out differently, I'll let you know in a later post.

I modified the WCF specific service implementation template to do the following:

Add using statements for the various workflow assemblies.
Add a new method called GetWCFImplementation which inserts the hosting code to the generated classes methods.
Parse out the parts of the request and add them to a Dictionary that is passed to the workflow when it is invoked.
Instantiate the response message class.
Parse out the parts of the response and assigned their return values from the Dictionary after the workflow has completed.
Return the response message class.

Below is the modified template:

<#@ Template Language="C#" Inherits="Microsoft.Practices.Modeling.CodeGeneration.Strategies.TextTemplating.ModelingTextTransformation" #>
<#@ Import Namespace="System.Text" #>
<#@ Import Namespace="System.Globalization" #>
<#@ Import Namespace="System.Collections.Generic" #>
<#@ Import Namespace="System.ServiceModel" #>
<#@ Import Namespace="Microsoft.Practices.ServiceFactory.ServiceContracts" #>
<#@ Import Namespace="Microsoft.Practices.ServiceFactory.DataContracts" #>
<#@ Import Namespace="Microsoft.Practices.ServiceFactory.Extenders.DataContract.Wcf" #>
<#@ Import Namespace="Microsoft.VisualStudio.Modeling" #>
<#@ Assembly Name="Microsoft.Practices.ServiceFactory.DataContracts.Dsl, Version=1.0.0.0, Culture=neutral, PublicKeyToken=5d6a471ce3d28564" #>
<#@ Assembly Name="Microsoft.Practices.ServiceFactory.Extenders.DataContract.Wcf, Version=1.0.0.0, Culture=neutral, PublicKeyToken=5d6a471ce3d28564" #>
<#@ Assembly Name="Microsoft.Practices.ServiceFactory.ServiceContracts.Dsl, Version=1.0.0.0, Culture=neutral, PublicKeyToken=5d6a471ce3d28564" #>
<#@ Assembly Name="System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" #>
<#@ ModelInjector processor="ModelInjectorDirectiveProcessor" #>
<#@ include file="TextTemplates\WCF\CS\CommonTextTransformation.tt" #>
//------------------------------------------------------------------------------
// 
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// 
//------------------------------------------------------------------------------

using System;
using System.Workflow;
using System.Workflow.ComponentModel;
using System.Workflow.Runtime;
using System.Workflow.Runtime.Hosting;
using System.Workflow.Activities;
using WCF = global::System.ServiceModel;

namespace <#=CurrentExtender.ArtifactLink.Namespace#>
{	
	/// 
	/// Service Class - <#= CurrentElement.Name #>
	/// 
	[WCF::ServiceBehavior(Name = "<#= CurrentElement.Name #>", 
		Namespace = "<#= CurrentExtender.Namespace #>", 
		InstanceContextMode = WCF::InstanceContextMode.<#= CurrentExtender.InstanceContextMode.ToString() #>, 
		ConcurrencyMode = WCF::ConcurrencyMode.<#= CurrentExtender.ConcurrencyMode.ToString() #> )]
	public abstract class <#= CurrentElement.Name #>Base <#= BuildInheritedServiceContract(CurrentElement.ServiceContract) #>
	{
<#
		if (CurrentElement.ServiceContract != null) {
#>
		#region <#= CurrentElement.ServiceContract.Name #> Members
<#
		foreach(Operation operation in CurrentElement.ServiceContract.Operations)
		{
			WCFOperationContract wcfOperation = GetObjectExtender(operation);
            if(wcfOperation.GenerateCode)
            {
			    if (!wcfOperation.AsyncPattern)
			    {

#>

		public virtual <#= GetResponseElement(operation.Response) #> <#= operation.Name #>(<#= GetRequestElement(operation.Request) #>)
		{
			<#= GetImplementation(operation.Request) #>
		}

<#
			    }
			    else
			    {

#>

		public virtual IAsyncResult Begin<#=operation.Name#>(<#= GetRequestElement(operation.Request,UseComma.Yes) #>AsyncCallback callback, object state)
		{
			return null;
		}

		public virtual <#= GetResponseElement(operation.Response) #> End<#=operation.Name#>(IAsyncResult result)
		{
			<#= GetImplementation(operation.Request) #>
		}

<#			    } // close if AsyncPattern
            } // close if Generatecode

		} // close Operations foreach
#>
		#endregion		
<#
	} // end if
#>		
	}
	
	public partial class <#= CurrentElement.Name #> : <#= CurrentElement.Name #>Base
	{
<#
		if (CurrentElement.ServiceContract != null) {
#>
		#region <#= CurrentElement.ServiceContract.Name #> Members
<#
		foreach(Operation operation in CurrentElement.ServiceContract.Operations)
		{
			WCFOperationContract wcfOperation = GetObjectExtender(operation);
            if(wcfOperation.GenerateCode)
            {
			    if (!wcfOperation.AsyncPattern)
			    {

#>

		public override <#= GetResponseElement(operation.Response) #> <#= operation.Name #>(<#= GetRequestElement(operation.Request) #>)
		{
			<#= GetWCFImplementation(operation) #>
		}

<#
			    }
			    else
			    {

#>

		public override <#= GetResponseElement(operation.Response) #> End<#=operation.Name#>(IAsyncResult result)
		{
			<#= GetWCFImplementation(operation) #>
		}

<#			    } // close if AsyncPattern
            } // close if Generatecode

		} // close Operations foreach
#>
		#endregion		
<#
	} // end if
#>		
	}
	
}

<#+
	private string BuildInheritedServiceContract(ServiceContract serviceContract)
	{
		if (serviceContract == null)
		{
			return string.Empty;
		}
		else
		{
			return ": " + ResolveServiceContractNameAndAddProjectRef(serviceContract);
		}
	}
	
	private string ResolveServiceContractNameAndAddProjectRef(ServiceContract contract)
	{
		WCFServiceContract wfcSc = GetObjectExtender(contract);
		if(wfcSc == null)
		{
			return "I" + contract.Name;
		}
		AddProjectReference(wfcSc.ArtifactLink);
		return wfcSc.ArtifactLink.Namespace + ".I" + contract.Name;
	}

	private string GetWCFImplementation(Operation operation)
	{
		if(operation.Response != null)
		{
			string result = "";
    		WCFOperationContract wcfOc = GetObjectExtender(operation);

            if(wcfOc.InvokesWorkflow)
            {
				string nl = "\r\n\t\t\t"; 
                result = "// Build the parameters for the Workflow" + nl;
                result += "Dictionary parameters = new Dictionary();" + nl;

                foreach(MessagePart mPart in operation.Request.MessageParts)
                { 
                    result += "parameters.Add(\"" + mPart.Name +"\", " + operation.Request.Name + "." + mPart.Name+ ");" + nl; 
                }

                result += "// Execute the Workflow" + nl;
                result += "// TODO: change myWorkflow to the name of the workflow to execute" + nl;
                result += "WFHost.ExecuteWorkflow(typeof(myWorkflow), parameters);" + nl;
                result += "// Build the response based on the parameters" + nl;
                result += GetResponseElement(operation.Response) + " response = new " + GetResponseElement(operation.Response) + "();" + nl;

                foreach(MessagePart mPart in operation.Response.MessageParts)
                { 
                    if(mPart is DataContractMessagePart)
                    {
                        DataContractMessagePart dcmPart = (DataContractMessagePart)mPart;
                        result += "response." + mPart.Name + " = (" + dcmPart.Type + ")parameters[\"" + mPart.Name + "\"];" + nl; 
                    }
                    else if(mPart is XsdElementMessagePart)
                    {
                        XsdElementMessagePart xsdmPart = (XsdElementMessagePart)mPart;
                        int nPos = xsdmPart.Element.IndexOf('?');
                        string strTemp = xsdmPart.Element.Substring(nPos + 1, (xsdmPart.Element.Length - (nPos + 1)));
                        result += "response." + mPart.Name + " = (" + strTemp + ")parameters[\"" + mPart.Name + "\"];" + nl; 
                    }
                }

                result += "return response;" + nl;
            }
            else
            {
                result = "return null;";
            }

			return result;
		}

		return string.Empty;
	}
#>

Below is the generated code based on the template changes:

//------------------------------------------------------------------------------
// 
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// 
//------------------------------------------------------------------------------

using System;
using System.Workflow;
using System.Workflow.ComponentModel;
using System.Workflow.Runtime;
using System.Workflow.Runtime.Hosting;
using System.Workflow.Activities;
using WCF = global::System.ServiceModel;

namespace WCF.ServiceImplementation
{	
	/// 
	/// Service Class - MyService
	/// 
	[WCF::ServiceBehavior(Name = "MyService", 
		Namespace = "WCF.ServiceImplementation", 
		InstanceContextMode = WCF::InstanceContextMode.PerSession, 
		ConcurrencyMode = WCF::ConcurrencyMode.Single )]
	public abstract class MyServiceBase : WCF.ServiceContracts.IMyServiceContract
	{
		#region MyServiceContract Members

		public virtual WCF.MessageContracts.Response MyOperation(WCF.MessageContracts.Request request)
		{
			return null;
		}

		#endregion		
		
	}
	
	public partial class MyService : MyServiceBase
	{
		#region MyServiceContract Members

		public override WCF.MessageContracts.Response MyOperation(WCF.MessageContracts.Request request)
		{
			// Build the parameters for the Workflow
			Dictionary parameters = new Dictionary();
			parameters.Add("RequestPayload", Request.RequestPayload);
			// Execute the Workflow
			// TODO: change myWorkflow to the name of the workflow to execute
			WFHost.ExecuteWorkflow(typeof(myWorkflow), parameters);
			// Build the response based on the parameters
			WCF.MessageContracts.Response response = new WCF.MessageContracts.Response();
			response.ResponsePayload = (ServiceResponse)parameters["ResponsePayload"];
			return response;
			
		}

		#endregion		
		
	}
	
}

I made similar changes for the ASMX implementation but tailored them towards using the native workflow hosting methods. As you can see, you can make some minor modifications to the new version of the Service Factory, and provide a lot of additional functionality without much work.

If you decide you want to keep the original Technology Extensions intact, you can always create another Technology Extension based on one of the original extensions with just your changes. This way you can offer users of the service factory multiple custom implementations.

I think the direction the Service Factory Team has taken this new version of the service factory is really promising and I hope to see them apply these new extensions to the rest of the factories. Keep up the good work!