wcfdependency-injectionfactory-pattern

How do I pass values to the constructor on my wcf service?


I would like to pass values into the constructor on the class that implements my service.

However ServiceHost only lets me pass in the name of the type to create, not what arguments to pass to its contrstructor.

I would like to be able to pass in a factory that creates my service object.

What I have found so far:


Solution

  • You'll need to implement a combination of custom ServiceHostFactory, ServiceHost and IInstanceProvider.

    Given a service with this constructor signature:

    public MyService(IDependency dep)
    

    Here's an example that can spin up MyService:

    public class MyServiceHostFactory : ServiceHostFactory
    {
        private readonly IDependency dep;
    
        public MyServiceHostFactory()
        {
            this.dep = new MyClass();
        }
    
        protected override ServiceHost CreateServiceHost(Type serviceType,
            Uri[] baseAddresses)
        {
            return new MyServiceHost(this.dep, serviceType, baseAddresses);
        }
    }
    
    public class MyServiceHost : ServiceHost
    {
        public MyServiceHost(IDependency dep, Type serviceType, params Uri[] baseAddresses)
            : base(serviceType, baseAddresses)
        {
            if (dep == null)
            {
                throw new ArgumentNullException("dep");
            }
    
            foreach (var cd in this.ImplementedContracts.Values)
            {
                cd.Behaviors.Add(new MyInstanceProvider(dep));
            }
        }
    }
    
    public class MyInstanceProvider : IInstanceProvider, IContractBehavior
    {
        private readonly IDependency dep;
    
        public MyInstanceProvider(IDependency dep)
        {
            if (dep == null)
            {
                throw new ArgumentNullException("dep");
            }
    
            this.dep = dep;
        }
    
        #region IInstanceProvider Members
    
        public object GetInstance(InstanceContext instanceContext, Message message)
        {
            return this.GetInstance(instanceContext);
        }
    
        public object GetInstance(InstanceContext instanceContext)
        {
            return new MyService(this.dep);
        }
    
        public void ReleaseInstance(InstanceContext instanceContext, object instance)
        {
            var disposable = instance as IDisposable;
            if (disposable != null)
            {
                disposable.Dispose();
            }
        }
    
        #endregion
    
        #region IContractBehavior Members
    
        public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
        {
        }
    
        public void ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, ClientRuntime clientRuntime)
        {
        }
    
        public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime)
        {
            dispatchRuntime.InstanceProvider = this;
        }
    
        public void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint)
        {
        }
    
        #endregion
    }
    

    Register MyServiceHostFactory in your MyService.svc file, or use MyServiceHost directly in code for self-hosting scenarios.

    You can easily generalize this approach, and in fact some DI Containers have already done this for you (cue: Windsor's WCF Facility).