public class UnityInstanceProvider : IInstanceProvider
    {
        private IUnityContainer Container { set; get; }

        public Type ServiceType { set; get; }

        public UnityInstanceProvider()
        {
            this.Container = new UnityContainer();
            this.Container
                .RegisterType<IMyService, MyService>()
                .RegisterType(typeof(IRepository<>), typeof(Repository<>));
        }

        #region IInstanceProvider Members

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

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

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

        #endregion

    }

public class UnityServiceBehavior : IServiceBehavior
    {
        private UnityInstanceProvider InstanceProvider { get; set; }

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

        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)
                    {
                        this.InstanceProvider.ServiceType = serviceDescription.ServiceType;
                        ed.DispatchRuntime.InstanceProvider = this.InstanceProvider;
                    }
                }
            }
        }

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

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

class Program
    {
        static void Main(string[] args)
        {
            var baseTcpAddress = "net.tcp://localhost:8112";
            var host = new ServiceHost(typeof(MyService), new Uri(baseTcpAddress));

            host.AddServiceEndpoint(typeof(IMyService), new NetTcpBinding(SecurityMode.None), "");

            var metadataBehavior = host.Description.Behaviors.Find<ServiceMetadataBehavior>();
            if (metadataBehavior == null)
            {
                metadataBehavior = new ServiceMetadataBehavior();
                //metadataBehavior.HttpGetEnabled = true;
                //metadataBehavior.HttpGetUrl = new Uri("http://localhost:8111");
                host.Description.Behaviors.Add(metadataBehavior);
            }
            host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "mex");

            var unityBehavior = host.Description.Behaviors.Find<UnityServiceBehavior>();
            if (unityBehavior == null)
                host.Description.Behaviors.Add(new UnityServiceBehavior());

            host.Open();
            Console.WriteLine("Started");
            Console.ReadKey();
            host.Close();
        }
    }

    [ServiceContract]
    public interface IMyService
    {
        [OperationContract]
        string MyMethod(int i);
    }

    public class MyService : IMyService
    {
        private IRepository<object> r;

        //public MyService() { }

        public MyService(IRepository<object> repository) { this.r = repository; }

        public string MyMethod(int i) { return "Called MyMethod int"; }
    }

    public interface IRepository<T> where T : class { }

    public class Repository<T> : IRepository<T> where T : class { }