How to Implement StructureMap 4 in a WCF Service using Nested Containers

01-DefaultRegistry.cs

using StructureMap;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace GreenWCF.DependencyResolution
{
    public class DefaultRegistry : Registry
    {
        public DefaultRegistry()
        {
            Scan(scan => {
                scan.TheCallingAssembly();
                scan.WithDefaultConventions();
            });
        }
    }
}

02-IoC.cs

using GreenWCF.Services;
using StructureMap;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;


namespace GreenWCF.DependencyResolution
{
    public static class IoC
    {
        public static IContainer Initialize()
        {
            var registry = new Registry();
            registry.IncludeRegistry<DefaultRegistry>();
            var container = new Container(registry);
            return container;
        }
    }
}

03-StructureMapDependencyScope.cs

using StructureMap;
using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Web;

namespace GreenWCF.DependencyResolution
{
    public class StructureMapDependencyScope
    {
        private const string NestedContainerKey = "Nested.Container.Key";
        private IContainer _currentNestedContainer;
        public IContainer Container { get; private set; }
        public IContainer CurrentNestedContainer
        {
            get
            {
                try
                { _currentNestedContainer= (IContainer)OperationContext.Current.IncomingMessageProperties[NestedContainerKey]; } catch (Exception) { _currentNestedContainer = null; }
                return _currentNestedContainer;
            }
            set
            {
                OperationContext.Current.IncomingMessageProperties[NestedContainerKey] = value;
            }
        }
        public StructureMapDependencyScope(IContainer container)
        {
            if (container == null)
                throw new ArgumentNullException("container");
            Container = container;
        }
        public void CreateNestedContainer()
        {
            if (CurrentNestedContainer != null)
            {
                return;
            }
            CurrentNestedContainer = Container.GetNestedContainer();
        }

        public void Dispose()
        {
            DisposeNestedContainer();
            Container.Dispose();
        }

        public void DisposeNestedContainer()
        {
            if (CurrentNestedContainer != null)
            {
                CurrentNestedContainer.Dispose();
                CurrentNestedContainer = null;
            }
        }
    }
}

04-StructureMapWcf.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace GreenWCF.DependencyResolution
{
    public static class StructureMapWcf
    {
        public static StructureMapDependencyScope StructureMapDependencyScope { get; set; }
    }
}

05-StructureMapInstanceProvider.cs

using StructureMap;
using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Dispatcher;
using System.Web;

namespace GreenWCF.DependencyResolution
{
    public class StructureMapInstanceProvider : IInstanceProvider
    {
        private readonly Type _serviceType;

        public StructureMapInstanceProvider(Type serviceType)
        {
            _serviceType = serviceType;
        }

        public object GetInstance(InstanceContext instanceContext)
        {
            return GetInstance(instanceContext, null);
        }

        public object GetInstance(InstanceContext instanceContext, Message message)
        {
            return StructureMapWcf.StructureMapDependencyScope.CurrentNestedContainer.GetInstance(_serviceType);
        }

        public void ReleaseInstance(InstanceContext instanceContext, object instance)
        {
        }
    }
}

06-StructureMapInspector.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Dispatcher;
using System.Web;

namespace GreenWCF.DependencyResolution
{
    public class StructureMapInspector : IDispatchMessageInspector
    {
        public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
        {
            StructureMapWcf.StructureMapDependencyScope.CreateNestedContainer();
            return null;
        }

        public void BeforeSendReply(ref Message reply, object correlationState)
        {
            StructureMapWcf.StructureMapDependencyScope.DisposeNestedContainer();
        }
    }
}

07-StructureMapServiceBehavior.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.Web;

namespace GreenWCF.DependencyResolution
{
    public class StructureMapServiceBehavior : IServiceBehavior
    {
        public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
        {
            foreach (ChannelDispatcherBase cdb in serviceHostBase.ChannelDispatchers)
            {
                ChannelDispatcher cd = cdb as ChannelDispatcher;
                if (cd != null)
                {
                    foreach (EndpointDispatcher ed in cd.Endpoints)
                    {
                        ed.DispatchRuntime.InstanceProvider =
                            new StructureMapInstanceProvider(serviceDescription.ServiceType);
                        ed.DispatchRuntime.MessageInspectors.Add(new StructureMapInspector());
                    }
                }
            }
        }

        public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters)
        {
        }

        public void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
        {
        }
    }
}

08-StructureMapServiceHost.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Web;

namespace GreenWCF.DependencyResolution
{
    public class StructureMapServiceHost : ServiceHost
    {
        public StructureMapServiceHost()
        {
        }

        public StructureMapServiceHost(Type serviceType, params Uri[] baseAddresses)
            : base(serviceType, baseAddresses)
        {
        }

        protected override void OnOpening()
        {
            Description.Behaviors.Add(new StructureMapServiceBehavior());
            base.OnOpening();
        }
    }
}

09-StructureMapServiceHostFactory.cs

using GreenWCF.Services;
using StructureMap;
using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.Web;

namespace GreenWCF.DependencyResolution
{
    public class StructureMapServiceHostFactory : ServiceHostFactory
    {
        public StructureMapServiceHostFactory()
        {
            IContainer container = IoC.Initialize();
            StructureMapWcf.StructureMapDependencyScope = new StructureMapDependencyScope(container);
        }

        protected override ServiceHost CreateServiceHost(Type serviceType, Uri[] baseAddresses)
        {
            return new StructureMapServiceHost(serviceType, baseAddresses);
        }
    }
}

10-GreenService.svc

<%@ ServiceHost Language="C#" Debug="true" Service="GreenWCF.GreenService" Factory="GreenWCF.DependencyResolution.StructureMapServiceHostFactory" CodeBehind="GreenService.svc.cs" %>