public void WhenBeginTransactionFailsSessionIsRemovedFromSessionStore()
        {
            using (mockRepository.Record())
            {
                Expect.Call(kernel.Resolve <ITransactionManager>()).Return(transactionManager);
                Expect.Call(transactionManager.CurrentTransaction).Return(transaction);
                Expect.Call(factoryResolver.GetSessionFactory(Alias)).Return(sessionFactory);
                Expect.Call(kernel.HasComponent(string.Format(InterceptorFormatString, Alias))).Return(false);
                Expect.Call(kernel.HasComponent(InterceptorName)).Return(false).Repeat.Any();
                Expect.Call(sessionFactory.OpenSession()).Return(session);
                session.FlushMode = sessionManager.DefaultFlushMode;
                Expect.Call(transaction.Context).Return(contextDictionary).Repeat.Any();
                Expect.Call(transaction.IsolationMode).Return(DefaultIsolationMode).Repeat.Any();
                Expect.Call(session.BeginTransaction(DefaultIsolationLevel)).Throw(new Exception());
            }

            using (mockRepository.Playback())
            {
                try
                {
                    sessionManager.OpenSession(Alias);
                    Assert.Fail("DbException not thrown");
                }
                catch (Exception)
                {
                    //ignore
                    //Console.WriteLine(ex.ToString());
                }
                Assert.IsNull(sessionStore.FindCompatibleSession(Alias),
                              "The sessionStore shouldn't contain compatible session if the session creation fails");
            }
        }
Example #2
0
        private ISession CreateSession(String alias)
        {
            ISessionFactory sessionFactory = factoryResolver.GetSessionFactory(alias);

            if (sessionFactory == null)
            {
                throw new FacilityException("No ISessionFactory implementation " +
                                            "associated with the given alias: " + alias);
            }

            ISession session;

            string aliasedInterceptorId = string.Format("nhibernate.session.interceptor.{0}", alias);

            if (kernel.HasComponent(aliasedInterceptorId))
            {
                IInterceptor interceptor = (IInterceptor)kernel[aliasedInterceptorId];

                return(sessionFactory.OpenSession(interceptor));
            }
            else if (kernel.HasComponent("nhibernate.session.interceptor"))
            {
                IInterceptor interceptor = (IInterceptor)kernel["nhibernate.session.interceptor"];

                session = sessionFactory.OpenSession(interceptor);
            }
            else
            {
                session = sessionFactory.OpenSession();
            }

            session.FlushMode = defaultFlushMode;

            return(session);
        }
Example #3
0
        /// <summary>
        /// Injects the dependencies.
        /// </summary>
        /// <param name="kernel">The container.</param>
        /// <param name="object">The object to configure.</param>
        public static void InjectDependencies(this IKernel kernel, object @object)
        {
            var resolveCollections = kernel.HasComponent(typeof(CollectionResolver));

            foreach (var info in GetDependencyPropertiesFor(@object))
            {
                var o = info.GetValue(@object, null);

                // skip the object is it already contains a value of any sort
                if (o != null)
                {
                    continue;
                }
                else if (resolveCollections && info.PropertyType.IsGenericCollection())
                {
                    o = kernel.ResolveAll(info.PropertyType.GetGenericArguments()[0]);
                }
                else if ((info.PropertyType.IsInterface) || (info.PropertyType.IsClass))
                {
                    // try to resolve the related type if the component knows it
                    if (kernel.HasComponent(info.PropertyType))
                    {
                        o = kernel.Resolve(info.PropertyType);
                    }
                }

                if (o != null)
                {
                    info.SetValue(@object, o, null);
                }
            }
        }
        private ISession CreateSession(String alias)
        {
            ISessionFactory sessionFactory = factoryResolver.GetSessionFactory(alias);

            if (sessionFactory == null)
            {
                throw new FacilityException("No ISessionFactory implementation " +
                                            "associated with the given alias: " + alias);
            }

            ISession session;

            string aliasedInterceptorId = string.Format(InterceptorFormatString, alias);

            if (kernel.HasComponent(aliasedInterceptorId))
            {
                IInterceptor interceptor = kernel.Resolve <IInterceptor>(aliasedInterceptorId);

                session = sessionFactory.OpenSession(interceptor);
            }
            else if (kernel.HasComponent(InterceptorName))
            {
                IInterceptor interceptor = kernel.Resolve <IInterceptor>(InterceptorName);

                session = sessionFactory.OpenSession(interceptor);
            }
            else
            {
                session = sessionFactory.OpenSession();
            }

            session.FlushMode = defaultFlushMode;

            return(session);
        }
Example #5
0
            public object GetService(Type serviceType)
            {
                bool hasComponent = _kernel.HasComponent(serviceType);

                return(hasComponent
                    ? _kernel.Resolve(serviceType)
                    : _currentResolverScope.GetService(serviceType));
            }
Example #6
0
        public ITenant GetTenant(TenantId id)
        {
            var key = MakeTenantKey(id);

            if (_kernel.HasComponent(key))
            {
                return(_kernel.Resolve <ITenant>(key));
            }

            return(NullTenant.Instance);
        }
        public override ViewComponent Create(String name)
        {
            var type = ResolveType(name);

            if (kernel.HasComponent(type))
            {
                return((ViewComponent)kernel.Resolve(type));
            }

            return((ViewComponent)Activator.CreateInstance(type));
        }
Example #8
0
        private void RegisterPresenters(Assembly assembly)
        {
            IEnumerable <Type> allPresenters = assembly.GetTypes().Where(t => typeof(IPresenter).IsAssignableFrom(t));

            foreach (Type presenterType in allPresenters)
            {
                if (_kernel.HasComponent(presenterType))
                {
                    _kernel.AddComponent("presenter." + presenterType.FullName, presenterType);
                }
            }
        }
Example #9
0
        public void FacilityRegistersRequiredComponents()
        {
            Assert.IsTrue(kernel.HasComponent(typeof(MethodValidatorMetaStore)));
            Assert.IsTrue(kernel.HasComponent(typeof(MethodValidatorInterceptor)));
            IContributeComponentModelConstruction methodValidatorContributor = null;

            foreach (IContributeComponentModelConstruction contributor in kernel.ComponentModelBuilder.Contributors)
            {
                if (contributor is MethodValidatorComponentInspector)
                {
                    methodValidatorContributor = contributor;
                }
            }
            Assert.IsNotNull(methodValidatorContributor);
        }
 public object GetService(Type serviceType)
 {
     lock (lockObject)
     {
         return(_container.HasComponent(serviceType) ? _container.Resolve(serviceType) : null);
     }
 }
Example #11
0
        public static void InjectProperties(this IKernel kernel, object target)
        {
            if (target == null)
            {
                throw new ArgumentNullException("target");
            }
            if (kernel == null)
            {
                throw new ArgumentNullException("kernel");
            }

            var type = target.GetType();

            foreach (var property in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                if (property.CanWrite && kernel.HasComponent(property.PropertyType))
                {
                    var value = kernel.Resolve(property.PropertyType);
                    try
                    {
                        property.SetValue(target, value, null);
                    }
                    catch (Exception ex)
                    {
                        var message = string.Format(CultureInfo.InvariantCulture,
                                                    "Error setting property {0} on type {1}, See inner exception for more information.", property.Name, type.FullName);
                        throw new ComponentActivatorException(message, ex, null);
                    }
                }
            }
        }
        public void RemoteAccessToComponentGraph()
        {
            AppDomain current = AppDomain.CurrentDomain;

            AppDomain otherDomain = AppDomain.CreateDomain(
                "other", new Evidence(current.Evidence), current.SetupInformation);

            try
            {
                IKernel kernel = (IKernel)
                                 otherDomain.CreateInstanceAndUnwrap(
                    "Castle.MicroKernel", "Castle.MicroKernel.DefaultKernel");

                kernel.AddComponent("key", typeof(CustomerImpl));
                Assert.IsTrue(kernel.HasComponent("key"));

                GraphNode[] nodes = kernel.GraphNodes;

                Assert.IsNotNull(nodes);
                Assert.AreEqual(1, nodes.Length);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                AppDomain.Unload(otherDomain);
            }
        }
Example #13
0
 private void EnsureContainerContextStoreRegistered()
 {
     if (!kernel.HasComponent(typeof(IContainerContextStore)))
     {
         kernel.Register(Component.For <IContainerContextStore>().ImplementedBy <ContainerContextStore>());
     }
 }
Example #14
0
        /// <inheritdoc />
        public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, Castle.Core.ComponentModel model, DependencyModel dependency)
        {
            if (dependency.TargetType == null)
            {
                return(false);
            }

            Type genericArgument = null;

            if ((dependency.TargetType.IsGenericType) && (dependency.TargetType.GetGenericTypeDefinition() == typeof(IEnumerable <>)))
            {
                genericArgument = dependency.TargetType.GetGenericArguments()[0];
            }
            else
            {
                dependency.TargetType.GetInterfaces().Any(implemented => (implemented.IsGenericType) && (implemented.GetGenericTypeDefinition() == typeof(IEnumerable <>)) &&
                                                          ((genericArgument = implemented.GetGenericArguments()[0]) != null));
            }

            if ((genericArgument == null) || (!_kernel.HasComponent(genericArgument)))
            {
                return(false);
            }

            return(true);
        }
Example #15
0
        /// <summary>
        /// Releases the dependencies.
        /// </summary>
        /// <param name="kernel">The kernel.</param>
        /// <param name="object">The object.</param>
        public static void ReleaseDependencies(this IKernel kernel, object @object)
        {
            var resolveCollections = kernel.HasComponent(typeof(CollectionResolver));

            foreach (var info in GetDependencyPropertiesFor(@object))
            {
                var o = info.GetValue(@object, null);

                if (o == null)
                {
                    continue;
                }
                else if (resolveCollections && info.PropertyType.IsGenericCollection())
                {
                    foreach (var obj in ((o as IEnumerable) ?? Enumerable.Empty <object>()))
                    {
                        kernel.ReleaseComponent(obj);
                    }
                }
                else if ((info.PropertyType.IsInterface) || (info.PropertyType.IsClass))
                {
                    kernel.ReleaseComponent(o);
                }
            }
        }
 void IIoCConfiguration.Configure(IKernel kernel)
 {
     if (!kernel.HasComponent(typeof(IApplicationCache)))
     {
         kernel.Register(Component.For <IApplicationCache>().ImplementedBy <DotNet>().LifestyleSingleton());
     }
 }
        /// <summary>
        /// Performs property injection on the specified target.
        /// </summary>
        /// <param name="kernel">The kernel.</param>
        /// <param name="target">The target.</param>
        /// <exception cref="System.InvalidOperationException"></exception>
        public static void InjectProperties(this IKernel kernel, object target)
        {
            Check.Require(kernel != null);
            Check.Require(target != null);

            Type type = target.GetType();

            foreach (PropertyInfo property in GetProperties(type))
            {
                if (property.CanWrite && kernel.HasComponent(property.PropertyType))
                {
                    object value = kernel.Resolve(property.PropertyType);

                    try
                    {
                        property.SetValue(target, value, null);
                    }
                    catch (Exception exception)
                    {
                        throw new InvalidOperationException(
                                  string.Format(
                                      CultureInfo.CurrentCulture,
                                      "Error setting property {0} on type {1}.",
                                      property.Name,
                                      type.FullName),
                                  exception);
                    }
                }
            }
        }
Example #18
0
        private ISettingsProvider CreateSettingsProvider(IKernel kernel)
        {
            if (!kernel.HasComponent(typeof(IConversionManager)))
            {
                kernel.Register(Component.For <IConversionManager>().UsingFactoryMethod(k => k.GetConversionManager()));
            }

            var conversionManager = kernel.Resolve <IConversionManager>();

            IReadOnlyCollection <ISettingsProvider> providers;

            if (_settingsProviderTypes.Any())
            {
                providers = _settingsProviderTypes.Select(type =>
                {
                    kernel.Register(Component.For(type));
                    return((ISettingsProvider)kernel.Resolve(type));
                }).ToList().AsReadOnly();
            }
            else
            {
                providers = new ReadOnlyCollection <ISettingsProvider>(
                    new List <ISettingsProvider>(new[] { new AppSettingsProvider(conversionManager) }));
            }

            return(new AggregateSettingsProvider(conversionManager, providers));
        }
Example #19
0
        private bool EnlistSessionIfHasTransactionActive(String key, SqlMapper sqlMap)
        {
            if (!_kernel.HasComponent(typeof(ITransactionManager)))
            {
                return(false);
            }

            bool enlisted = false;

            if (key == null)
            {
                key = "iBATIS.DataMapper";
            }

            ITransactionManager manager = (ITransactionManager)_kernel[typeof(ITransactionManager)];

            Transaction transaction = manager.CurrentTransaction;

            if (transaction != null)
            {
                if (!transaction.Context.Contains(key))
                {
                    transaction.Context[key] = true;
                    transaction.Enlist(new ResourceSqlMapAdapter(sqlMap.BeginTransaction(false)));
                    transaction.RegisterSynchronization(new SqlMapKeeper(sqlMap));
                    enlisted = true;
                }
            }

            _kernel.ReleaseComponent(manager);

            return(enlisted);
        }
Example #20
0
        public IAggregateEx Build(Type type, IIdentity id, IMementoEx snapshot)
        {
            AggregateRoot aggregate = null;

            if (_kernel != null && _kernel.HasComponent(type))
            {
                aggregate = (AggregateRoot)_kernel.Resolve(type);
            }
            else
            {
                var ctor = type.Constructor(Flags.Default, new Type[] { });

                if (ctor == null)
                {
                    throw new MissingDefaultCtorException(type);
                }

                aggregate = (AggregateRoot)ctor.CreateInstance();
            }

            aggregate.AssignAggregateId(id);

            if (snapshot != null && aggregate is ISnapshotable)
            {
                ((ISnapshotable)aggregate).Restore(snapshot);
            }

            return(aggregate);
        }
Example #21
0
 public void Init(IKernel kernel, IConfiguration facilityConfig)
 {
     if (!kernel.HasComponent(typeof(IServiceProvider)))
     {
         kernel.Register(Component.For <IServiceProvider>().ImplementedBy <WindsorServiceResolver>().LifestyleSingleton());
     }
     kernel.Register(
         Component.For(typeof(ManyEnumerable <>)).ImplementedBy(typeof(ManyEnumerable <>)).LifestyleTransient(),
         Component.For <IProxyGenerator>().ImplementedBy <ProxyGenerator>().LifestyleScoped(),
         Component.For <IProxyTypeGenerator>().ImplementedBy <ProxyTypeGenerator>().LifestyleSingleton(),
         Component.For <IInterceptorSelector>().ImplementedBy <ConfigureInterceptorSelector>().LifestyleSingleton(),
         Component.For <IInterceptorSelector>().ImplementedBy <AttributeInterceptorSelector>().LifestyleSingleton(),
         Component.For <IAspectBuilderFactory>().ImplementedBy <AspectBuilderFactory>().LifestyleSingleton(),
         Component.For <IInterceptorCollector>().ImplementedBy <InterceptorCollector>().LifestyleSingleton(),
         Component.For <IAspectContextFactory>().ImplementedBy <AspectContextFactory>().LifestyleSingleton(),
         Component.For <IAspectCachingProvider>().ImplementedBy <AspectCachingProvider>().LifestyleSingleton(),
         Component.For <IAspectActivatorFactory>().ImplementedBy <AspectActivatorFactory>().LifestyleSingleton(),
         Component.For <IAspectValidatorBuilder>().ImplementedBy <AspectValidatorBuilder>().LifestyleSingleton(),
         Component.For <IPropertyInjectorFactory>().ImplementedBy <PropertyInjectorFactory>().LifestyleSingleton(),
         Component.For <IParameterInterceptorSelector>().ImplementedBy <ParameterInterceptorSelector>().LifestyleSingleton(),
         Component.For <IAdditionalInterceptorSelector>().ImplementedBy <AttributeAdditionalInterceptorSelector>().LifestyleSingleton(),
         Component.For <IAspectConfiguration>().Instance(_aspectConfiguration).LifestyleSingleton()
         );
     kernel.Register(Component.For <AspectCoreInterceptor>());
     kernel.ComponentModelCreated += Kernel_ComponentModelCreated;
     kernel.Resolver.AddSubResolver(new CompatibleCollectionResolver(kernel));
     _kernel = kernel;
 }
Example #22
0
 private void RegisterServiceHostBuilder(Type serviceHostBuilder, Type builder, bool force)
 {
     if (force || kernel.HasComponent(serviceHostBuilder) == false)
     {
         kernel.Register(Component.For(serviceHostBuilder).ImplementedBy(builder));
     }
 }
Example #23
0
 private void RegisterChannelBuilder(Type channelBuilder, Type builder, bool force)
 {
     if (force || kernel.HasComponent(channelBuilder) == false)
     {
         kernel.Register(Component.For(channelBuilder).ImplementedBy(builder));
     }
 }
Example #24
0
        public void RemoteAccess()
        {
            AppDomain current = AppDomain.CurrentDomain;

            AppDomain otherDomain = AppDomain.CreateDomain(
                "other", new Evidence(current.Evidence), current.SetupInformation);

            try
            {
                IKernel kernel = (IKernel)
                                 otherDomain.CreateInstanceAndUnwrap(
                    "Castle.Windsor", "Castle.MicroKernel.DefaultKernel");

                kernel.Register(Component.For(typeof(CustomerImpl)).Named("key"));
                Assert.IsTrue(kernel.HasComponent("key"));
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                AppDomain.Unload(otherDomain);
            }
        }
        public object Intercept(IMethodInvocation invocation, params object[] args)
        {
            String key = ObtainSessionFactoryKeyFor(invocation.InvocationTarget);

            if (SessionManager.IsCurrentSessionCompatible(key))
            {
                return(invocation.Proceed(args));
            }

            ISessionFactory sessionFactory = ObtainSessionFactoryFor(key);

            ISession session = null;

            if (_kernel.HasComponent(typeof(NHibernate.IInterceptor)))
            {
                session = sessionFactory.OpenSession((NHibernate.IInterceptor)_kernel[typeof(NHibernate.IInterceptor)]);
            }
            else
            {
                session = sessionFactory.OpenSession();
            }

            SessionManager.Push(session, key);

            FlushOption flushOption = ExtractFlushOption(invocation.MethodInvocationTarget);

            ConfigureFlushMode(flushOption, session);

            if (EnlistSessionIfHasTransactionActive(key, session))
            {
                return(invocation.Proceed(args));
            }

            try
            {
                return(invocation.Proceed(args));
            }
            finally
            {
                if (flushOption == FlushOption.Force)
                {
                    session.Flush();
                }
                session.Close();
                SessionManager.Pop(key);
            }
        }
 public T Resolve <T>() where T : class
 {
     if (_kernel.HasComponent(typeof(T)))
     {
         return(_kernel.Resolve <T>());
     }
     return(null);
 }
Example #27
0
        public void Init(IKernel kernel, Castle.Core.Configuration.IConfiguration facilityConfig)
        {
            Kernel = kernel;

            if (Kernel.HasComponent(typeof(ViewAccessor<>)) == false)
                Kernel.Register(Component.For(typeof(ViewAccessor<>)).LifeStyle.Singleton);

            if (Kernel.HasComponent(typeof(ControllerAccessor<,>)) == false)
                Kernel.Register(Component.For(typeof(ControllerAccessor<,>)).LifeStyle.Singleton);

            if (Kernel.HasComponent<IActionInvoker>() == false)
                Kernel.Register(Component.For<IActionInvoker>().ImplementedBy<DefaultActionInvoker>().LifeStyle.Singleton);

            if (Kernel.HasComponent<ICommandProvider>() == false)
                Kernel.Register(Component.For<ICommandProvider>().ImplementedBy<DefaultCommandProvider>().LifeStyle.Singleton);

            if (Kernel.HasComponent<IControllerAdapter>() == false)
                Kernel.Register(Component.For<IControllerAdapter>().ImplementedBy<DefaultControllerAdapter>().LifeStyle.Singleton);

            if (Kernel.HasComponent<IControllerLifecycleManager>() == false)
                Kernel.Register(Component.For<IControllerLifecycleManager>().ImplementedBy<MicroKernelControllerLifecycleManager>().LifeStyle.Singleton);

            if (Kernel.HasComponent<IAutoRegistration>() == false)
                Kernel.Register(Component.For<IAutoRegistration>().ImplementedBy<MicroKernelAutoRegistration>().LifeStyle.Singleton);

            Kernel.ComponentModelCreated += new ComponentModelDelegate(Kernel_ComponentModelCreated);
            Kernel.ComponentRegistered += new ComponentDataDelegate(Kernel_ComponentRegistered);
            Kernel.ComponentCreated += new ComponentInstanceDelegate(Kernel_ComponentCreated);
        }
Example #28
0
        public object GetService(Type serviceType)
        {
            if (Kernel.HasComponent(serviceType))
            {
                return(Kernel.Resolve(serviceType));
            }

            return(DefaultMvcResolver.GetService(serviceType));
        }
Example #29
0
        protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
        {
            if (controllerType == null || !kernel.HasComponent(controllerType))
            {
                return(base.GetControllerInstance(requestContext, controllerType));
            }

            return((IController)kernel.Resolve(controllerType));
        }
Example #30
0
        public IController CreateController(RequestContext requestContext, string controllerName)
        {
            var controllerKey = controllerName.ToLowerInvariant() + "controller";

            object area;

            if (requestContext.RouteData.Values.TryGetValue("area", out area))
            {
                var areaControllerKey = Convert.ToString(area).ToLowerInvariant() + "." + controllerKey;
                if (_kernel.HasComponent(areaControllerKey))
                {
                    //requestContext.RouteData.Values["controller"] = area + "/" + controllerName;
                    return(_kernel.Resolve <IController>(areaControllerKey));
                }
            }

            return(_kernel.HasComponent(controllerKey) ? _kernel.Resolve <IController>(controllerKey) : null);
        }
Example #31
0
        public ComponentReference(Type service)
        {
            _name = service.FullName;

            if (kernel.HasComponent(_name) == false)
            {
                kernel.Register(ComponentReg.For(service).Named(_name));
            }
        }
		/// <summary>
		///   Resolves the component(s) from given kernel.
		/// </summary>
		/// <param name = "kernel"></param>
		/// <returns>Resolved component(s).</returns>
		public virtual object Resolve(IKernel kernel)
		{
			if (string.IsNullOrEmpty(ComponentName) == false && kernel.HasComponent(ComponentName))
			{
				if (ComponentType == null)
				{
					return kernel.Resolve(ComponentName, AdditionalArguments);
				}

				return kernel.Resolve(ComponentName, ComponentType, AdditionalArguments);
			}

			return kernel.Resolve(ComponentType, AdditionalArguments);
		}
		public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
		{
			base.Init(componentActivator, kernel, model);

			// check ILoggerFactory is registered (logging is enabled)
			if (kernel.HasComponent(typeof(ILoggerFactory))) 
			{
				// get logger factory instance
				ILoggerFactory loggerFactory = kernel.Resolve<ILoggerFactory>();
				// create logger
				_Logger = loggerFactory.Create(GetType());
			}
			else
				_Logger = NullLogger.Instance;
		}
Example #34
0
		public override void ProcessModel(IKernel kernel, ComponentModel model)
		{
			if (model.Service is IBehaviorStore)
			{
				foreach (var node in kernel.GraphNodes.OfType<ComponentModel>())
				{
					SetProxyInformation(node, kernel.Resolve<IBehaviorConfigurator>());
				}
				return;
			}

			if (!kernel.HasComponent(typeof (IBehaviorStore))) return;
			var behaviorToProxyResolver = kernel.Resolve<IBehaviorConfigurator>();

			//Get the proxy info
			SetProxyInformation(model, behaviorToProxyResolver);
		}
        public static void InjectProperties(IKernel kernel, object target)
        {
            var type = target.GetType();

            foreach (var property in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                if (property.CanWrite && kernel.HasComponent(property.PropertyType))
                {
                    var value = kernel.Resolve(property.PropertyType);
                    try
                    {
                        property.SetValue(target, value, null);
                    }
                    catch (Exception ex)
                    {
                        var message = string.Format("Error setting property {0} on type {1}, See inner exception for more information.", property.Name, type.FullName);
                        throw new ComponentActivatorException(message, ex, null);
                    }
                }
            }
        }
Example #36
0
		void IRegistration.Register(IKernel kernel)
		{
			foreach (IWcfClientModel channel in channels)
			{
				var registration = Component.For(channel.Contract);
				registration.DependsOn(Property.ForKey("channel").Eq(channel));

				if (configurer != null)
				{
					configurer(registration);
				}

				if (String.IsNullOrEmpty(registration.Name))
				{
					registration.Named(Guid.NewGuid().ToString());
				}

				if (!kernel.HasComponent(registration.Name))
				{
					kernel.Register(registration);
				}
			}
		}
 public override object Resolve(IKernel kernel)
 {
     return kernel.HasComponent(ComponentName) ? base.Resolve(kernel) : new DefaultModelBinder();
 }