Welcome to ForkCan.com

ForkCan is all about sharing code in a social way.

Discuss, debate or argue with other devs about their or your own code.

Give other devs feedback or make a Fork (Make a better version of a shared code).

Rate the code, if you use the code mark it as used so others can see if the shared code is used by someone.

Help each other to be better devs and to be more productive.

Features not working yet:

Flag a post

QR Code

Tiny Url

http://4kcan.com/s/Mjk2

Related Code

UnityServiceHostFactory, a WCF host factory:

using System;
using System.ServiceModel.Activation;
using System.ServiceModel;
using Infrastructure.IoContainer;

namespace Services.Host.Infrastructure
{
   public abstract class UnityServiceHostFactory : ServiceHostFactoryBase
   {
     private readonly IUnityConfiguration _unityConfiguration;

     protected UnityServiceHostFactory(IUnityConfiguration unityConfiguration)
     {
        _unityConfiguration = unityConfiguration;
     }

     public override ServiceHostBase CreateServiceHost(string constructorString, Uri[] baseAddresses)
     {
        var serviceType = Type.GetType(constructorString);

        var host = new UnityServiceHost(serviceType, baseAddresses);

        Unity.Configure(_unityConfiguration);

        host.Container = Unity.Current;

        return host;
      }
   }
}

UnityServiceHost, a WCF Service host:

using System;
using System.ServiceModel;
using Microsoft.Practices.Unity;

namespace Services.Host.Infrastructure
{
   public class UnityServiceHost : ServiceHost
   {
       public IUnityContainer Container { set; get; }


       public UnityServiceHost() : base() {}


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


       protected override void OnOpening()
       {
          if (Container == null)
              throw new ApplicationException("The UnityServiceHost's Container property can't be null");

           new UnityServiceBehavior(Container).AddToHost(this);
           base.OnOpening();
       }
   }
}

UnityServiceBehavior, a WCF Service behavior:

using System.Linq;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Description;
using System.ServiceModel;
using Microsoft.Practices.Unity;
using System.ServiceModel.Channels;
using System.Collections.ObjectModel;

namespace Services.Host.Infrastructure
{
   public class UnityServiceBehavior : IServiceBehavior
   {
      public UnityInstanceProvider InstanceProvider { get; set; }

      private ServiceHost _serviceHost;


      public UnityServiceBehavior()
      {
         InstanceProvider = new UnityInstanceProvider();
      }


      public UnityServiceBehavior(IUnityContainer unity)
      {
         InstanceProvider = new UnityInstanceProvider {Container = unity};
      }


      public void ApplyDispatchBehavior(
                                        ServiceDescription serviceDescription,
                                        ServiceHostBase serviceHostBase)
      {
          foreach (var ed in
              serviceHostBase.ChannelDispatchers.OfType<ChannelDispatcher>().SelectMany(cd => cd.Endpoints))
          {
              InstanceProvider.ServiceType = serviceDescription.ServiceType;
              ed.DispatchRuntime.InstanceProvider = InstanceProvider;
          }
       }


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


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


       public void AddToHost(ServiceHost host)
       {
           if (_serviceHost != null)
               return;

           host.Description.Behaviors.Add(this);

           _serviceHost = host;
       }
    }
}

UnityInstanceProvider, a WCF Service Instance provider:

using System;
using System.ServiceModel.Dispatcher;
using System.ServiceModel;
using System.ServiceModel.Channels;
using Microsoft.Practices.Unity;

namespace Services.Host.Infrastructure
{
    public class UnityInstanceProvider : IInstanceProvider
    {
       public IUnityContainer Container { set; get; }


       public Type ServiceType { set; get; }


       public UnityInstanceProvider() : this(null) { }


       public UnityInstanceProvider(Type type)
       {
           ServiceType = type;
           Container = new UnityContainer();
       }


       public object GetInstance(
                       InstanceContext instanceContext,
                       Message message)
       {
           return Container.Resolve(ServiceType);
       }


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


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

DefaultHostFactory that will take a Unity Configuration class as an argument (A class where all type is registered to the Unity Container):

using DependencyConfiguration;
using Services.Host.Infrastructure;

namespace HostFactory
{
    public class DefaultHostFactory : UnityServiceHostFactory
    {
        public DefaultHostFactory() : base(new WcfUnityConfiguration())
        {
        }
    }
}

Make sure to set the new Host Factory in the .svc file:

<%@ ServiceHost Language="C#" Factory="HostFactory.DefaultHostFactory"
Service="MyService, MyServices" %>

Unity, a helper class to Configure the Unity Container and also can be used to Resolve a type:

using System;
using Microsoft.Practices.Unity;

namespace Infrastructure.IocContainer
{

   public static class Unity
   {
      private static IUnityContainer _container;
      private static object _lock = new object();


      public static void Configure(IUnityConfiguration configuration)
      {
         if (configuration == null)
             throw new ArgumentNullException("configuration");

         lock (_lock)
         {
            if (_container != null)
                return;

            _container = new UnityContainer();
            configuration.Configure(_container);
         }
      }


      public static T Resolve<T>()
      {
         return Current.Resolve<T>();
      }


      public static IUnityContainer Current
      {
          get
          {
              if (_container == null)
                  throw new ApplicationException("You have to Configure the Unity first, you can do that by calling the Configure method");

              return _container;
          }
       }
   }
}

IUnityConfiguration:

using Microsoft.Practices.Unity;

namespace Infrastructure.IocContainer
{
    public interface IUnityConfiguration
    {
        void Configure(IUnityContainer container);
    }
}

WcfUnityConfiguration, a separate class to put all registration of types into the Unity container:

using Infrastructure.IocContainer;
using Microsoft.Practices.Unity;

namespace DependencyConfiguration
{
    public class WcfUnityConfiguration : IUnityConfiguration
    {
        public void Configure(IUnityContainer container)
        {
            container.RegisterType<IFoo, Foo>();
            //...
        }
    }
}

Share: twitter | facebook   Action: used | fork | flag