Castle Windsor WCF Lifestyle – PerWcfMessageLifestyleManager

If you want your resolved instances bound to the life time of a WCF operation then you can use the PerWebRequest lifestyle that comes with Windsor. However, this means making your services run in ASP.Net compatibility mode. This might not be ideal for your set of circumstances (as it wasn’t for mine). I did a great deal of googling around this subject and I couldn’t find anything someone had already done, so I thought I’d share this solution. Be great to get some feedback…

Updated – thanks to Krzysztof Koźmic for pointing out that the WCF facility for Windsor already has this, see here (I obviously didn’t google that hard).

The solution works by plugging into to some of the extension points within WCF. I created a service behaviour (IServiceBehavior) which applies a Message Inspector to all operations (IDispatchMessageInspector). That message inspector does two things. For each new call it adds in a extension (IExtension<OperationContext>) to the operation context. This extension is where I’m going to stick all the instances which are bound to the operation. The second is to evict all instances from the container once the operation has completed.

All the lifestyle manager has to do is to check if there’s already an instance registered with the operation context (by looking in our custom extension). If it finds one, then it is returned, if not it will Resolve a new instance. This should give the same result as using PerWebRequest + ASP.Net compatibility mode…

Here’s all the code. Hope it helps!

Code for plugging into WCF:

public class LifestyleManagerMessageInspector : IDispatchMessageInspector
{
    public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
    {
        OperationContext.Current.Extensions.Add(new MessageLifespanInstancesExtension());
        return null;
    }
  
    public void BeforeSendReply(ref Message reply, object correlationState)
    {
        var extenstion = OperationContext.Current.Extensions.Find<MessageLifespanInstancesExtension>();
        if (extenstion == null)
            throw new NotSupportedException("Message reply is being sent but there is no MessageLifespanInstancesExtenstion registered.  This implies that AfterReceiveRequest was not callled...");
        
        extenstion.EvictAll();
    }
}
  
public class LifestyleManagerServiceBehaviour : BehaviorExtensionElement, IServiceBehavior
{
    public void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
    {
    }
  
    public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters)
    {
    }
  
    public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
    {
        foreach (var endpointDispatcher in serviceHostBase.ChannelDispatchers.OfType<ChannelDispatcher>()
            .SelectMany(channelDispatcher => channelDispatcher.Endpoints))
        {
            endpointDispatcher.DispatchRuntime.MessageInspectors.Add(new LifestyleManagerMessageInspector());
        }
    }
  
    protected override object CreateBehavior()
    {
        return new LifestyleManagerServiceBehaviour();
    }
  
    public override Type BehaviorType
    {
        get { return (typeof (LifestyleManagerServiceBehaviour)); }
    }
}
  
public class MessageLifespanInstancesExtension : IExtension<OperationContext>
{
    private readonly Dictionary<PerWcfMessageLifestyleManager, object> instances = new Dictionary<PerWcfMessageLifestyleManager, object>();
  
    public void AddInstance(PerWcfMessageLifestyleManager lifestyleManager, object instance)
    {
        instances.Add(lifestyleManager, instance);
    }
  
    public object FindInstance(PerWcfMessageLifestyleManager lifestyleManager)
    {
        object instance;
        instances.TryGetValue(lifestyleManager, out instance);
        return instance;
    }
  
    public void EvictAll()
    {
        foreach (var item in instances.ToArray())
        {
            item.Key.Evict(item.Value);
        }
    }
  
    public void Attach(OperationContext owner)
    {
    }
  
    public void Detach(OperationContext owner)
    {
    }
  
    public void RemoveInstance(PerWcfMessageLifestyleManager lifestyleManager)
    {
        instances.Remove(lifestyleManager);
    }
}

You’ll need this bit of XML config. I will at some point change my stuff to use the WCF Facility in Castle, once I’ve done that I can add the behaviour programmatically…

<behaviors>
  <serviceBehaviors>
    <behavior>
...
      <lifestyleManagerServiceBehaviour />
    </behavior>
  </serviceBehaviors>
</behaviors>
<extensions>
  <behaviorExtensions>
    <add name="lifestyleManagerServiceBehaviour" type="IEMobile.Ioc.WCF.LifestyleManagerServiceBehaviour, IEMobile.Ioc" />
  </behaviorExtensions>
</extensions>
...

And plugging into castle:

public class PerWcfMessageLifestyleManager : AbstractLifestyleManager
{
    private readonly string perMessageKey = "PerWcfMessage_" + Guid.NewGuid();
    private bool evicting = false;
  
    public MessageLifespanInstancesExtension Extension
    {
        get
        {
            var extenstion = OperationContext.Current.Extensions.Find<MessageLifespanInstancesExtension>();
            if (extenstion == null)
                throw new NotSupportedException("Cannot find MessageLifespanInstancesExtenstion, check you've registered the LifestyleManagerMessageInspector in the web/app.config");
            return extenstion;
        }
    }
  
    public override object Resolve(Castle.MicroKernel.CreationContext context)
    {
        var instance = Extension.FindInstance(this);
  
        if (instance == null)
        {
            instance = base.Resolve(context);
            Extension.AddInstance(this, instance);
        }
  
        return instance;
    }
  
    public override bool Release(object instance)
    {
        if (!evicting) return false;
  
        Extension.RemoveInstance(this);
  
        return base.Release(instance);
    }
  
    public void Evict(object value)
    {
        using (new EvictionContext(this))
        {
            Release(value);
        }
    }
  
    private class EvictionContext : IDisposable
    {
        private readonly PerWcfMessageLifestyleManager lifestyleManager;
  
        public EvictionContext(PerWcfMessageLifestyleManager lifestyleManager)
        {
            this.lifestyleManager = lifestyleManager;
            lifestyleManager.evicting = true;
        }
  
        public void Dispose()
        {
            lifestyleManager.evicting = false;
        }
    }
  
    public override void Dispose()
    {
    }
  
    public bool Equals(PerWcfMessageLifestyleManager other)
    {
        if (ReferenceEquals(null, other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return Equals(other.perMessageKey, perMessageKey);
    }
  
    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (ReferenceEquals(this, obj)) return true;
        if (obj.GetType() != typeof (PerWcfMessageLifestyleManager)) return false;
        return Equals((PerWcfMessageLifestyleManager) obj);
    }
  
    public override int GetHashCode()
    {
        return (perMessageKey != null ? perMessageKey.GetHashCode() : 0);
    }
}

When you register the lifestyle with the container be sure to add it so it has a transient lifestyle itself (this means that there will be one WCF lifestyle manager per service type):

container.AddComponentLifeStyle("PerWcfMessage",typeof (PerWcfMessageLifestyleManager), LifestyleType.Transient)

Finally, just for a bit of context, the main thing which uses this lifestyle is my entity framework session… The lifestyle manager is a big win for me because it not only ensures there is only one session per service call, but that it is actually disposed (therefore, I don’t leak memory or connections to the DB).

4 Responses to Castle Windsor WCF Lifestyle – PerWcfMessageLifestyleManager

Pingback: Castle Windsor NServiceBus lifestyle manager – PerMessageLifestyleManager | pep => lowdown
Krzysztof Koźmic says:

July 1, 2010 at 10:55 am

You are aware that WCF Facility comes with this lifestyle out of the box, right? http://stw.castleproject.org/Windsor.WCF-Facility-Lifestyles.ashx

tpeplow says:

July 1, 2010 at 1:33 pm

No – but I am now! Thanks, I shall use that instead 🙂

max says:

January 24, 2011 at 4:26 pm

I must admit that I found this post before castle documentation. Official facility is so well hidden that I could’t find it even now that I’m aware of it : /