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"); } }
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); }
/// <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); }
public object GetService(Type serviceType) { bool hasComponent = _kernel.HasComponent(serviceType); return(hasComponent ? _kernel.Resolve(serviceType) : _currentResolverScope.GetService(serviceType)); }
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)); }
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); } } }
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); } }
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); } }
private void EnsureContainerContextStoreRegistered() { if (!kernel.HasComponent(typeof(IContainerContextStore))) { kernel.Register(Component.For <IContainerContextStore>().ImplementedBy <ContainerContextStore>()); } }
/// <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); }
/// <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); } } } }
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)); }
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); }
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); }
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; }
private void RegisterServiceHostBuilder(Type serviceHostBuilder, Type builder, bool force) { if (force || kernel.HasComponent(serviceHostBuilder) == false) { kernel.Register(Component.For(serviceHostBuilder).ImplementedBy(builder)); } }
private void RegisterChannelBuilder(Type channelBuilder, Type builder, bool force) { if (force || kernel.HasComponent(channelBuilder) == false) { kernel.Register(Component.For(channelBuilder).ImplementedBy(builder)); } }
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); }
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); }
public object GetService(Type serviceType) { if (Kernel.HasComponent(serviceType)) { return(Kernel.Resolve(serviceType)); } return(DefaultMvcResolver.GetService(serviceType)); }
protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType) { if (controllerType == null || !kernel.HasComponent(controllerType)) { return(base.GetControllerInstance(requestContext, controllerType)); } return((IController)kernel.Resolve(controllerType)); }
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); }
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; }
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); } } } }
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(); }