Dependency injection in WCF services

Background
In Dependency Injection class dependencies are injected at runtime. For achieving this code is done for abstractions and at the runtime concrete implementation are passed/injected either by constructor/property/method injection.
For example:
In typical 3 layered architecture Business access layer depends on Data access layer. So instead of referencing concrete Data access layer objects, BAL refers to the abstraction which is DAL contracts and inject dependency for contract at the runtime. This give way to loose coupling and DAL can be replaced at any time without rebuilding BAL as we only need to write new implementation of DAL contracts.

WCF
In WCF, we write services which are consumed by client. On the server side typically 3 layered architecture is followed where in Service refers to Business layer and business layer refers to Data access layer.
As discussed in previous post  this sort of binding is hard binding and has potential drawbacks.

In WCF we need to have default constructor and cannot have parametrized constructor alone.
In order to inject dependency we can use a parametrized constructor and can implement our custom instance provider which will resolve to exact dependencies. Instance provider is responsible for creating WCF service instance, so we need to create custom behavior for instance provider and register the same with service.
Unity is used for dependency resolution in the same code.
Follow the following steps to implement same:

  1. Implement custom Instance provider:
   public class UnityInstanceProvider : IInstanceProvider  
   {  
     #region Properties  
     private readonly IUnityContainer container;  
     private readonly Type contractType;  
     #endregion  
     #region Constructors  
     public UnityInstanceProvider(IUnityContainer container, Type contractType)  
     {  
       this.container = container;  
       this.contractType = contractType;  
     }  
     #endregion  
     #region IInstanceProvider methods  
     public object GetInstance(System.ServiceModel.InstanceContext instanceContext, System.ServiceModel.Channels.Message message)  
     {  
       return GetInstance(instanceContext);  
     }  
     public object GetInstance(System.ServiceModel.InstanceContext instanceContext)  
     {  
       return container.Resolve(contractType);  
     }  
     public void ReleaseInstance(System.ServiceModel.InstanceContext instanceContext, object instance)  
     {  
       container.Teardown(instance);  
     }  
     #endregion  
   }

   2. Implement custom service behavior for instance provider:

  public class UnityServiceBehaviour : IServiceBehavior  
   {  
     #region Constants  
     private const string METADATA_EXCHANGE_CONTRACT = "IMetadataExchange";  
     private const string UNITY_CONTAINER_NAME = "unity";  
     #endregion  
     #region Static fields  
     private static IUnityContainer container;  
     #endregion  
     #region Constructors  
     static UnityServiceBehaviour()  
     {  
       container = new UnityContainer();  
       var section = (UnityConfigurationSection)ConfigurationManager.GetSection(UNITY_CONTAINER_NAME);  
       section.Containers.Default.Configure(container);  
     }  
     #endregion  
     #region IServiceBehavior methods  
     public void AddBindingParameters(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase, System.Collections.ObjectModel.Collection<ServiceEndpoint> endpoints, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)  
     {  
     }  
     public void ApplyDispatchBehavior(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase)  
     {  
       Type serviceType = serviceDescription.ServiceType;  
       foreach (ChannelDispatcher channelDispatcher in serviceHostBase.ChannelDispatchers)  
       {  
         foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints)  
         {  
           if (endpointDispatcher.ContractName != METADATA_EXCHANGE_CONTRACT)  
           {  
             endpointDispatcher.DispatchRuntime.InstanceProvider = new UnityInstanceProvider(UnityServiceBehaviour.container, serviceType);  
           }  
         }  
       }  
     }  
     public void Validate(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase)  
     {  
     }  
     #endregion  
   }

3. Implement custom behavior extension so that service behavior can be registered through behavior extensions in config.

   public class UnityServiceBehaviorExtensionElement : BehaviorExtensionElement  
   {  
     public override Type BehaviorType  
     {  
       get { return typeof(UnityServiceBehaviour); }  
     }  
     protected override object CreateBehavior()  
     {  
       return new UnityServiceBehaviour();  
     }  
   }

 4. Register behavior extension in config file:
 <extensions>  
    <behaviorExtensions>  
     <add name="unityBehaviorExtension" type="WCFBehaviourExtensions.UnityServiceBehaviorExtensionElement, WCFBehaviourExtensions, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />  
    </behaviorExtensions>  
   </extensions>

5. Add this in service behavior.

6. Now you need to resolve constructor defined in the WCF service to parameterized with interfaces resolving to concrete classes in config file.
For unity the configuration will look like:
  <configSections>  
   <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration"/>  
  </configSections>  
  <startup>  
   <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />  
  </startup>  
  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">  
   <typeAliases>  
    <typeAlias alias="IDAL"  type="<<Fully qualified name of DAL Contract>>, <<Name of dll>>" />  
    <typeAlias alias="DAL"  type="<<Fully qualified name of DAL concrete class>>, << Name of dll>>" />  
    <typeAlias alias="Controller"  type="<<Fully qualified name of Controller concrete class>>, <<Name of dll>>" />  
    <typeAlias alias="IController"  type="<<Fully qualified name of Controller contract>>, <<Name of dll>>" />  
    <typeAlias alias="ServiceClass"  type="<<Fully qualified name of Service Class>>, <<Name of dll>>" />  
   </typeAliases>  
   <containers>  
    <container>  
     <register type="IController" mapTo="Controller" >  
      <constructor>  
       <param name="<<ConstructorParameterName>>" >  
        <dependency/>  
       </param>  
      </constructor>  
     </register>  
     <register type="IDAL" mapTo="DAL" >  
     </register>  
     <register type="ServiceClass" mapTo="ServiceClass" >  
      <constructor>  
       <param name="<<ConstructorParameterName>>">  
        <dependency/>  
       </param>  
      </constructor>  
     </register>  
    </container>  
   </containers>  
  </unity>

Now your service has all dependencies injected.

Happy coding!!!!

Comments

Post a Comment

Popular posts from this blog

Inversion of control in 3 layer architecture

Image
While designing layered application we typically follow following structure: In this traditional approach UI layer refers to Business access layer(BAL/Controller layer) and BAL refers to Data access layer (DAL). This referring is usually hard coded at each layer leading to numerous problems simply because of the reason that we don't program to abstraction. The problem which could crop up are: Data access layer is not interchangeable. Suppose in future in stead of storing data to data we choose flat file storage, so in order to accommodate this in current layering BAL and DAL both has to rebuilt. Its not easy to test the whole system without each and every component up and running. In short its not east the fake the data layer or controller layer to test the same using automated tests. Its not easy to share the business rules across application or modules as they are dependent on the lower layers directly. Business rules are generally shared across all the systems despite...
Read more

Singleton pattern for logger class

Implementing Singleton Design pattern for logger service is something used extensively. Here is the implementation which i used recently:     class Logger     {         #region Private member         //Stream writer to write log to file.         private static StreamWriter streamWriter = null;         //Will be used in synchLock to make initialisation thread safe.         private static Object synchLock = typeof(Logger);         private static Logger logger = null;         //Log file name.         private const string LOG_FILE_NAME = "Log.txt";         #endregion         #region Constructors ...
Read more

Consistent Response Validation - Invalid Value for types & Business Rules in Web API

Image
Fluent validation is a great library to perform validation on objects. Integrating fluent validation in .net core is very simple and minimal steps are described along with a way to make validation response consistent be it binding error or business validation error. Steps  1. Add a reference to NuGet package      <PackageReference Include="FluentValidation.AspNetCore" Version="8.4.0" /> Adding sample validator Person Validator 3. Validating Object Validating Object This works fine and the correct error message is displayed. Fluent Validation Error Message response However, consider the request where  Date of Birth  of person is passed as an invalid date. In this case, controller method gets  null  as input because of invalid type value during the model biding phase. By default below error message is thrown if model state is validated in the controller method Default Model State Error In t...
Read more