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();
}