In a previous post I wrote something about putting an NHibernate session in your operation context. Guess what? I ended up never using that implementation because shortly after actually putting that behavior in my app, I decided to make it more generic first.
I thought, what will I do with this or that operation of this or that service? I don’t need this kind of context, I need something else here. I was really not into creating a different behavior (and so on) every time something else needed to be scoped. So I thought, why not just configure the type of the context I want?
End Result
Let’s start with the goal. The end result allows you to configure a certain type of context by adding the following behavior extension to the system.ServiceModel section of your configuration file:
<extensions> <behaviorExtensions> <add name="callContextBehavior" type="typesafe.ServiceModel.CallContextServiceBehaviorExtensionElement, typesafe.ServiceModel, Version=0.2.0.0, Culture=neutral, PublicKeyToken=b7fa8d8d247605f2"/> </behaviorExtensions> </extensions> <behaviors> <serviceBehaviors> <behavior name="behavior"> <callContextBehavior contextType="[ASSEMBLY QUALIFIED NAME OF CONTEXT TYPE]"/> </behavior> </serviceBehaviors> </behaviors>
With this configuration I can ensure that every service operation of a certain service will be able to access the specified type of context. All I have to do is add behaviorConfiguration="behavior" to a service configuration element. I could do the same thing on endpoint level as well (if I add the behaviorExtension to an endpointBehavior).
If you don’t like config, you can alternatively go ahead and apply the behavior by the means of a CallContextBehavior attribute which you can apply on either service or operation level. (Doing so also makes unit testing easier to maintain/write.)
[CallContextBehavior(typeof(MyCallContext))]
public bool OperationHasContext()
{
return CallContext.Current != null;
}
// or
[CallContextBehavior(typeof(MyCallContext))]
public class TestService : ITestService
{
// now all operations can assert CallContext.Current != null
}
How do we achieve this?
Basically, you’ll need to do the following…
- Provide a way to access and create your custom context from your code
- initialize and dispose the context when required/appropriate
- allow yourself to apply the context (at various levels)
First thing you need is an interface for you context. Well, technically speaking, you don’t, but I decided to do so to make things more explicit and somewhat safer. I have a context interface (an abstract class, actually) that looks like this:
public abstract class CallContext
{
[ThreadStatic] // who needs OperationContext? ;-)
private static CallContext callContext;
/// <summary>
/// Gets the context of the current operation.
/// </summary>
public static CallContext Current
{
get { return callContext; }
internal set { callContext = value;}
}
protected internal abstract void Initialize();
protected internal abstract void Dispose();
}
The static Current property allows you to access the configured context from your service operation code (that’s the main reason I went for an abstract class opposed to an interface). You’ll only have to cast it to your exact type the moment you need to access it (more on this later).
If you want to create a custom context, all you have to do is inherit from CallContext and override its two methods. It goes without saying that the Initialize method is called right before your service call, and the Dispose method right after.
In case you’re wondering why the CallContext class is not IDisposable (while specifying a Dispose method), I did this so I could hide the method from the service implementation code: operations cannot call it. Besides, it didn’t add any value anyway.
The second part consists of an ICallContextInitializer that makes sure the context gets initialized and disposed when we want it, right before and right after our operation executes.
public class CallContextInitializer : ICallContextInitializer
{
private readonly Type contextType;
public CallContextInitializer(Type contextType)
{
this.contextType = contextType;
}
object ICallContextInitializer.BeforeInvoke(System.ServiceModel.InstanceContext instanceContext, System.ServiceModel.IClientChannel channel, Message message)
{
CallContext.Current = Activator.CreateInstance(contextType) as CallContext;
if (CallContext.Current == null)
throw new ConfigurationErrorsException(string.Format("The type '{0}' could not be initialized or is no CallContext derived type.", contextType));
CallContext.Current.Initialize();
return null; // we don't need no correlation
}
void ICallContextInitializer.AfterInvoke(object state)
{
// Dispose the context
if (CallContext.Current != null)
CallContext.Current.Dispose();
}
}
Finally we need to apply the ICallContextInitializer to the service operations with a behavior. The following behavior implements IServiceBehavior, IEndpointBehavior and IOperationBehavior. This allows you to choose the granularity of applying the behavior.
public class CallContextServiceBehavior : Attribute, IServiceBehavior, IEndpointBehavior, IOperationBehavior
{
private readonly Type contextType;
public CallContextServiceBehavior(Type type)
{
contextType = type;
}
void IServiceBehavior.ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
{
foreach (ChannelDispatcher cd in serviceHostBase.ChannelDispatchers)
foreach (var ed in cd.Endpoints)
foreach (var operation in ed.DispatchRuntime.Operations)
{
operation.CallContextInitializers.Add(new CallContextInitializer(contextType));
}
}
void IEndpointBehavior.ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
foreach (var operation in endpointDispatcher.DispatchRuntime.Operations)
{
operation.CallContextInitializers.Add(new CallContextInitializer(contextType));
}
}
void IOperationBehavior.ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation)
{
dispatchOperation.CallContextInitializers.Add(new CallContextInitializer(contextType));
}
// remainder of the interfaces have no implementation...
}
To enable applying the behavior through the system.ServiceModel configuration section (as in the first listing above), we need to create the following BehaviorExtensionElement.
public class CallContextBehaviorExtensionElement : BehaviorExtensionElement
{
private ConfigurationPropertyCollection properties;
public override Type BehaviorType
{
get { return typeof(CallContextBehavior); }
}
protected override object CreateBehavior()
{
Type type = Type.GetType(ContextType);
if (type == null)
throw new ConfigurationErrorsException(string.Format("The type '{0}' could not be initialized.", ContextType));
return new CallContextBehavior(type);
}
protected override ConfigurationPropertyCollection Properties
{
get
{
if (properties == null)
{
properties = new ConfigurationPropertyCollection {new ConfigurationProperty("contextType", typeof (string))};
}
return properties;
}
}
[ConfigurationProperty("contextType", IsRequired = true)]
public string ContextType
{
get { return (string)base["contextType"]; }
set { base["contextType"] = value; }
}
}
Example
To illustrate how it all fits together: The following listing contains a completely self-contained unit test that illustrates the usage and working of the above solution.
[TestFixture]
public class CallContextBehaviorTests
{
private const string address = "net.pipe://localhost/TestService";
private ServiceHost host;
private ITestService service;
[TestFixtureSetUp]
public void SetUp()
{
host = new ServiceHost(typeof(TestService));
host.AddServiceEndpoint(typeof(ITestService), new NetNamedPipeBinding(), address);
host.Open();
var factory = new ChannelFactory<ITestService>(new NetNamedPipeBinding(), new EndpointAddress(address));
service = factory.CreateChannel();
}
[TestFixtureTearDown]
public void TearDown()
{
host.Close();
}
[Test]
public void CallContext_is_null_by_default()
{
Assert.IsTrue(service.OperationWithoutContext());
}
[Test]
public void CallContext_should_be_available_after_applying_service_attribute()
{
Assert.IsTrue(service.OperationWithContext());
}
}
internal class MyCallContext : CallContext
{
// any property we like
public new static MyCallContext Current
{
get { return CallContext.Current as MyCallContext; }
}
protected override void Initialize() { }
protected override void Dispose() { }
}
[ServiceContract]
internal interface ITestService
{
[OperationContract]
bool OperationWithContext();
[OperationContract]
bool OperationWithoutContext();
}
internal class TestService : ITestService
{
[CallContextBehavior(typeof(MyCallContext))]
public bool OperationWithContext()
{
return MyCallContext.Current != null;
}
public bool OperationWithoutContext()
{
return MyCallContext.Current == null;
}
}
Image may be NSFW.
Clik here to view.
Image may be NSFW.Clik here to view.
