internal void Init(IKernel kernel, WcfFacility facility)
{
this.kernel = kernel;
this.facility = facility;
AddDefaultChannelBuilders();
AddDefaultBindingPolicies();
kernel.Register(
Component.For(typeof(IChannelFactoryBuilder <>))
.ImplementedBy(typeof(AsynChannelFactoryBuilder <>))
.DependsOn(Property.ForKey <ProxyGenerator>().Eq(proxyGenerator))
.Unless(Component.ServiceAlreadyRegistered)
);
if (kernel.GetFacilities().OfType <TypedFactoryFacility>().Any())
{
kernel.Register(
Component.For <IWcfClientFactory>().AsFactory(c => c.SelectedWith(new WcfClientFactorySelector()))
);
}
kernel.ComponentModelCreated += Kernel_ComponentModelCreated;
kernel.ComponentUnregistered += Kernel_ComponentUnregistered;
if (afterInit != null)
{
afterInit();
afterInit = null;
}
}
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));
}
public ISagaQueryScopeContext <TSaga, T> GetQueryScope <T>(SagaQueryConsumeContext <TSaga, T> context) where T : class
{
if (context.TryGetPayload <IKernel>(out _))
{
return(new ExistingSagaQueryScopeContext <TSaga, T>(context));
}
var scope = _container.BeginScope();
_container.Register(Component.For <ConsumeContext, ConsumeContext <T> >().Instance(context));
try
{
var proxy = new SagaQueryConsumeContextProxy <TSaga, T>(context, new PayloadCacheScope(context), context.Query);
var consumerContainer = _container;
proxy.GetOrAddPayload(() => consumerContainer);
foreach (Action <ConsumeContext> scopeAction in _scopeActions)
{
scopeAction(proxy);
}
return(new CreatedSagaQueryScopeContext <IDisposable, TSaga, T>(scope, proxy));
}
catch
{
scope.Dispose();
throw;
}
}
public void Init(IKernel kernel, IConfiguration facilityConfig)
{
kernel.Register(Component.For <INameBasedComponentSelector>().ImplementedBy <NameBasedComponentSelector>().LifestyleTransient());
kernel.Register(Component.For <IConfigBasedComponentSelector>().ImplementedBy <ConfigBasedComponentSelector>().LifestyleTransient());
kernel.Resolver.AddSubResolver(new CollectionResolver(kernel, true));
kernel.Resolver.AddSubResolver(new ChildContainerSubResolver(kernel));
}
public void Subscribe()
{
foreach (var listener in _listeners)
{
var processManagerType = listener.GetProcessType();
foreach (var message in listener.ListeningTo)
{
// adapter
var handlerType = typeof(IHandleMessages <>).MakeGenericType(message);
var handlerImpl = typeof(RebusSagaAdapter <, ,>).MakeGenericType(
processManagerType,
processManagerType.BaseType.GetGenericArguments()[0], //this is the state of the process manager
message);
_kernel.Register(
Component
.For(handlerType)
.ImplementedBy(handlerImpl)
.LifeStyle.Transient);
}
//do not forget to register the process manager, it has dependencies.
_kernel.Register(
Component
.For(processManagerType)
.ImplementedBy(processManagerType)
.LifestyleTransient()
);
}
}
/// <summary>
/// Specify that the service bus should load the StateMachineSagas from the container passed as argument
/// </summary>
/// <param name="configurator"></param>
/// <param name="container"></param>
public static void LoadStateMachineSagas(this IReceiveEndpointConfigurator configurator, IKernel container)
{
if (configurator == null)
{
throw new ArgumentNullException(nameof(configurator));
}
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
var registrationConfigurator = new RegistrationConfigurator();
container.Register(Component.For <ISagaStateMachineFactory>().Instance(new WindsorSagaStateMachineFactory(container)));
container.Register(Component.For <IStateMachineActivityFactory>().Instance(new WindsorStateMachineActivityFactory()));
container.Register(Component.For <ISagaRepositoryFactory>().Instance(new WindsorSagaRepositoryFactory(container)));
IEnumerable <Type> sagaTypes = FindStateMachineSagaTypes(container);
foreach (var sagaType in sagaTypes)
{
SagaStateMachineRegistrationCache.AddSagaStateMachine(registrationConfigurator, sagaType);
}
var registration = registrationConfigurator.CreateRegistration(new WindsorConfigurationServiceProvider(container));
registration.ConfigureSagas(configurator);
}
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;
}
public void Init(IKernel kernel, IConfiguration facilityConfig)
{
_kernel = kernel;
_kernel.ComponentModelCreated += ComponentModelCreated;
_connectionRegistration = Component.For <IObservableConnection>()
.UsingFactoryMethod(
() =>
{
return(ObservableConnectionFactory.Create(
c =>
{
foreach (var customization in _customizations)
{
customization.Invoke(c);
}
}));
})
.NamedAutomatically(Guid.NewGuid().ToString());
_kernel.Register(_connectionRegistration);
_kernel.Register(Component.For <ISerializer>().Instance(_configuredSerializer));
foreach (var interceptor in _interceptingTypes)
{
_kernel.Register(Component.For(interceptor.Value.ToArray()).ImplementedBy(interceptor.Key).LifeStyle.Singleton);
}
}
private static void RegisterStorageSources(IKernel kernel)
{
kernel.Register(Component.For <ILocalStorageSettings>().ImplementedBy <LocalStorageSettings>().LifestyleTransient());
kernel.Register(Component.For <IStorageSource>().ImplementedBy <LocalFileSystemStorageSource>().LifestyleTransient());
kernel.Register(Component.For <IAmazonStorageSettings>().ImplementedBy <AmazonStorageSettings>().LifestyleTransient());
kernel.Register(Component.For <IStorageSource>().ImplementedBy <AmazonS3StorageSource>().LifestyleTransient());
}
public void Register(Type from, Type to)
{
if (kernel.HasComponent(from) || kernel.HasComponent(to))
{
return;
}
kernel.Register(Component.For(from).ImplementedBy(to).LifeStyle.Transient.Unless(Component.ServiceAlreadyRegistered));
}
public void Can_resolve_component_with_primitive_dependency_via_factory()
{
kernel.Register(
Component.For <ClassWithPrimitiveDependency>()
.UsingFactoryMethod(() => new ClassWithPrimitiveDependency(2)));
kernel.Resolve <ClassWithPrimitiveDependency>();
}
public void Register(Type from, Type to)
{
if (kernel.HasComponent(from) || kernel.HasComponent(to))
{
return;
}
kernel.Register(Component.For(from).ImplementedBy(to).LifeStyle.Transient.OnlyNewServices());
}
/// <summary>
/// Initializes a new instance of the <see cref="CastleAspectContainer"/> class.
/// </summary>
/// <param name="container">The container.</param>
public CastleAspectContainer(IKernel container)
{
Proxy = new MasterProxy();
_kernel = container;
_kernel.Register(Component.For(this.GetType()).Named("CastleAspectContainer").Instance(this));
_kernel.Register(Component.For(Proxy.GetType()).Named("MasterProxy").Instance(Proxy));
_kernel.AddFacility<CastleAspectFacility>();
_kernel.Register(Component.For<PseudoInterceptor>());
}
public void Should_register_IContainerContextStore_when_first_context_is_created()
{
kernel.Register(Component.For <ComponentA>().LifeStyle.Custom(typeof(ContextualLifestyle)));
using (new ContainerContext(kernel))
{
Assert.That(kernel.HasComponent(typeof(IContainerContextStore)));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CastleAspectContainer"/> class.
/// </summary>
/// <param name="container">The container.</param>
public CastleAspectContainer(IKernel container)
{
Proxy = new MasterProxy {Container = new WindsorServiceLocatorAdapter(container)};
_kernel = container;
_kernel.Register(Component.For(GetType()).Named("CastleAspectContainer").Instance(this));
_kernel.Register(Component.For(Proxy.GetType())/*.Named("MasterProxy")*/.Instance(Proxy));
_kernel.AddFacility<CastleAspectFacility>();
_kernel.Register(Component.For<PseudoInterceptor>());
}
public void Init()
{
kernel = new DefaultKernel();
kernel.Register(Component.For(typeof(CompA)).Named("compa"));
kernel.Register(Component.For(typeof(CompB)).Named("compb"));
deps = new Dictionary<string, object>();
deps.Add("cc", new CompC(12));
deps.Add("myArgument", "ernst");
}
/// <inheritdoc />
public override void BindAspects(IComponentsStore settings)
{
_kernel.Register(Component.For <IComponentsStore>().Instance(settings));
_kernel.Register(
Component.For(typeof(WeavedInterceptor <,>))
.ImplementedBy(typeof(WeavedInterceptor <,>)));
_kernel.AddFacility(new WindsorAspectFacility(settings));
}
public void Given()
{
_taskList = new TaskList<string>();
_container = new DefaultKernel();
ServiceLocator<string>.SetInstance(_container);
_container.Register(Component.For<TaskList<string>>().Instance(_taskList));
_container.Register(Component.For<SequentialBuilder<string>>().Instance(new SequentialBuilder<string>(_taskList)));
_container.Register(Component.For<WorkflowEngine<string>>().Instance(new WorkflowEngine<string>()));
_workflow = new Workflow<string>();
_function = new Func<bool>(RedOrangeYellow);
}
/// <summary>
/// Initializes a new instance of the <see cref="CastleAspectContainer"/> class.
/// </summary>
/// <param name="container">The container.</param>
public CastleAspectContainer(IKernel container)
{
Proxy = new MasterProxy {
Container = new WindsorServiceLocatorAdapter(container)
};
_kernel = container;
_kernel.Register(Component.For(GetType()).Named("CastleAspectContainer").Instance(this));
_kernel.Register(Component.For(Proxy.GetType()) /*.Named("MasterProxy")*/.Instance(Proxy));
_kernel.AddFacility <CastleAspectFacility>();
_kernel.Register(Component.For <PseudoInterceptor>());
}
public virtual void Register(IKernel kernel)
{
kernel.AddFacility<TypedFactoryFacility>();
kernel.Register(Component.For<IViewModelFactory>().AsFactory());
kernel.Register(Component.For<IDialogFactory>().AsFactory());
kernel.Register(AllTypes.FromAssemblyContaining<ViewModelRegistration>()
.Where(t => t.Namespace == "Rhino.Licensing.AdminTool.Factories")
.WithService.FirstInterfaceOnClass());
}
public virtual void Register(IKernel kernel)
{
kernel.AddFacility <TypedFactoryFacility>();
kernel.Register(Component.For <IViewModelFactory>().AsFactory());
kernel.Register(Component.For <IDialogFactory>().AsFactory());
kernel.Register(AllTypes.FromAssemblyContaining <ViewModelRegistration>()
.Where(t => t.Namespace == "Rhino.Licensing.AdminTool.Factories")
.WithService.FirstInterfaceOnClass());
}
public void Given()
{
_taskList = new TaskList <string>();
_container = new DefaultKernel();
ServiceLocator <string> .SetInstance(_container);
_container.Register(Component.For <TaskList <string> >().Instance(_taskList));
_container.Register(Component.For <SequentialBuilder <string> >().Instance(new SequentialBuilder <string>(_taskList)));
_container.Register(Component.For <WorkflowEngine <string> >().Instance(new WorkflowEngine <string>()));
_workflow = new Workflow <string>();
_function = new Func <bool>(RedOrangeYellow);
}
public virtual void Register(IKernel kernel)
{
kernel.Register(AllTypes.FromAssemblyContaining<ViewModelRegistration>()
.Where(t => ViewModelNamespaces.Contains(t.Namespace) &&
!SkipAutoRegistration.Contains(t))
.WithService.FirstInterfaceOnClass()
.Configure(c => c.LifeStyle.Transient));
kernel.Register(Component.For<IShellViewModel>()
.ImplementedBy<ShellViewModel>()
.Forward<IStatusService>()
.LifeStyle.Singleton);
}
private void ConfigureAspNetCompatibility()
{
if (AspNetCompatibility.HasValue)
{
kernel.Register(
Component.For <AspNetCompatibilityRequirementsAttribute>()
.Instance(new AspNetCompatibilityRequirementsAttribute
{
RequirementsMode = AspNetCompatibility.Value
})
);
}
}
public virtual void Register(IKernel kernel)
{
kernel.Register(AllTypes.FromAssemblyContaining <ViewModelRegistration>()
.Where(t => ViewModelNamespaces.Contains(t.Namespace) &&
!SkipAutoRegistration.Contains(t))
.WithService.FirstInterfaceOnClass()
.Configure(c => c.LifeStyle.Transient));
kernel.Register(Component.For <IShellViewModel>()
.ImplementedBy <ShellViewModel>()
.Forward <IStatusService>()
.LifeStyle.Singleton);
}
public override void Register(Type serviceType, Func <object> activator)
{
ComponentRegistration <object> component = Component
.For(serviceType)
.UsingFactoryMethod(activator, true);
if (kernel == null) // SignalR invokes this method in the base constructor, before our constructor is executed.
{
deferredRegistrations.Add(component);
}
else
{
kernel.Register(component.OverridesExistingRegistration());
}
}
private void RegisterIStartupTasks(IKernel kernel)
{
kernel.Register(
AllTypes.Of<IStartupTask>().FromAssembly(_assembly)
.WithService.FirstInterface()
);
}
private void RegisterIModelBinder(IKernel kernel)
{
kernel.Register(
Component.For<IModelBinder>()
.ImplementedBy<SimpleValidatingModelBinder>()
);
}
private void RegisterIMappingEngine(IKernel kernel)
{
kernel.Register(
Component.For<IMappingEngine>()
.UsingFactoryMethod(k => new MappingEngine(kernel.Resolve<IConfigurationProvider>()))
);
}
public virtual void Register(IKernel kernel)
{
kernel.Register(AllTypes.FromAssemblyContaining <ServiceRegistration>()
.Where(t => t.Namespace == "Rhino.Licensing.AdminTool.Services")
.WithService.FirstInterfaceOnClass()
.Configure(c => c.LifeStyle.Transient));
}
private void RegisterRouteCollection(IKernel kernel)
{
kernel.Register(
Component.For<RouteCollection>()
.UsingFactoryMethod(() => RouteTable.Routes)
);
}
public virtual void Register(IKernel kernel)
{
kernel.Register(AllTypes.FromAssemblyContaining<ServiceRegistration>()
.Where(t => t.Namespace == "Rhino.Licensing.AdminTool.Services")
.WithService.FirstInterfaceOnClass()
.Configure(c => c.LifeStyle.Transient));
}
private void RegisterIValidatorRegistry(IKernel kernel)
{
kernel.Register(
Component.For(typeof(IValidatorRegistry))
.ImplementedBy(typeof(CachedValidationRegistry))
);
}
private static IKernel RegisterServices(this IKernel kernel)
{
kernel.Bind(x => x.FromAssemblyContaining <FileDialogService>()
.SelectAllClasses()
.InNamespaceOf <FileDialogService>()
.BindDefaultInterface());
kernel.Bind(x => x.FromAssemblyContaining <FileService>()
.SelectAllClasses()
.InNamespaceOf <FileService>()
.NotInNamespaceOf <Playlist>()
.BindDefaultInterface());
kernel.Register <ILoggingService, LoggingService>()
.Register <ITaggingService, TagLibService>()
.Register <ITwitterService, TwitterService>()
.Register <IVideoService, YouTubeVideoService>()
.Register <ILyricsService, LyricsService>()
.Register <IEventsService, BandsInTownArtistEventsService>()
.Register <IDefaultTrackSorter, DefaultTrackSorter>()
.Register <IRandomTrackSorter, RandomTrackSorter>()
.Register <IAsyncMethodInterceptor, WebMethodInterceptor>();
return(kernel);
}
private void RegisterIModelBinder(IKernel kernel)
{
kernel.Register(
Component.For <IModelBinder>()
.ImplementedBy <SimpleValidatingModelBinder>()
);
}
private void RegisterIMapCreators(IKernel kernel)
{
kernel.Register(
AllTypes.Of <IMapCreator>().FromAssembly(_assembly)
.WithService.FirstInterface()
);
}
private void RegisterIStartupTasks(IKernel kernel)
{
kernel.Register(
AllTypes.Of <IStartupTask>().FromAssembly(_assembly)
.WithService.FirstInterface()
);
}
private static IKernel RegisterRepositories(this IKernel kernel)
{
kernel.Register <ITrackXmlParser, TrackXmlParser>();
kernel.Bind <IPlaylistRepository>()
.To <PlaylistRepository>()
.InTransientScope()
.WithConstructorArgument(typeof(IXmlProvider), ctx => ctx.Kernel.Get <PlaylistXmlProvider>());
kernel.Bind <ITrackRepository>()
.To <TrackRepository>()
.InTransientScope()
.WithConstructorArgument(typeof(IXmlProvider), ctx => ctx.Kernel.Get <TrackXmlProvider>());
kernel.Bind <IRssFeedsRepository>()
.To <RssFeedsRepository>()
.InTransientScope()
.WithConstructorArgument(typeof(IXmlProvider), ctx => ctx.Kernel.Get <RssFeedsXmlProvider>());
kernel.Bind <IConfigSettings>()
.To <ConfigSettings>()
.InSingletonScope()
.WithConstructorArgument(typeof(IXmlProvider), ctx => ctx.Kernel.Get <ConfigXmlProvider>());
return(kernel);
}
internal bool TryRegister(Type type, IKernel kernel)
{
Type[] baseTypes;
if (!Accepts(type, out baseTypes))
{
return(false);
}
var defaults = CastleComponentAttribute.GetDefaultsFor(type);
var serviceTypes = service.GetServices(type, baseTypes);
if (serviceTypes.Count == 0 && defaults.Services.Length > 0)
{
serviceTypes = defaults.Services;
}
var registration = Component.For(serviceTypes);
registration.ImplementedBy(type);
if (configuration != null)
{
configuration(registration);
}
if (String.IsNullOrEmpty(registration.Name) && !String.IsNullOrEmpty(defaults.Name))
{
registration.Named(defaults.Name);
}
else
{
registration.RegisterOptionally();
}
kernel.Register(registration);
return(true);
}
private static IKernel RegisterLastFmComponents(this IKernel kernel)
{
kernel.Register <ISessionService, SessionService>();
kernel.RegisterErrorHandlingLastFmService <IScrobblingService,
ScrobblingService,
IScrobbler,
ErrorHandlingScrobbler,
Scrobbler>()
.RegisterErrorHandlingLastFmService <LastFmApi.Interfaces.ITrackLoveService,
LastFmApi.TrackLoveService,
Services.Interfaces.ITrackLoveService,
ErrorHandlingTrackLoveService,
LastFm.TrackLoveService>()
.RegisterErrorHandlingLastFmService <LastFmApi.Interfaces.IArtistInfoService,
LastFmApi.ArtistInfoService,
Services.Interfaces.IArtistInfoService,
ErrorHandlingArtistInfoService,
LastFm.ArtistInfoService>()
.RegisterErrorHandlingLastFmService <LastFmApi.Interfaces.IAlbumInfoService,
LastFmApi.AlbumInfoService,
Services.Interfaces.IAlbumInfoService,
ErrorHandlingAlbumInfoService,
LastFm.AlbumInfoService>()
.RegisterErrorHandlingLastFmService <IUserInfoService,
LastFmApi.UserInfoService,
IPlayHistoryService,
ErrorHandlingUserInfoService,
LastFm.UserInfoService>();
return(kernel);
}
/// <summary>
/// Registers the interfaces of the entities defined in the session factory in the kernel.
/// </summary>
/// <param name="kernel">The kernel.</param>
/// <param name="sessionFactory">The session factory.</param>
/// <param name="repository">The repository type to map to <seealso cref="IRepository{T}"/>.</param>
/// <param name="isCandidateForRepository">The is candidate for repository.</param>
/// <remarks>
/// The reason that we have the <paramref name="isCandidateForRepository"/> is to avoid registering services
/// for interfaces that are not related to the domain (INotifyPropertyChanged, as a good example).
/// </remarks>
public static void Register(
IKernel kernel,
ISessionFactory sessionFactory,
Type repository,
IsCandidateForRepositoryDelegate isCandidateForRepository
)
{
if (ImplementsOpenIRepository(repository) == false)
{
throw new ArgumentException("Repository must be a type inheriting from IRepository<T>, and must be an open generic type. Sample: typeof(NHRepository<>).");
}
foreach (IClassMetadata meta in sessionFactory.GetAllClassMetadata().Values)
{
Type mappedClass = meta.GetMappedClass(EntityMode.Poco);
if (mappedClass == null)
{
continue;
}
foreach (Type interfaceType in mappedClass.GetInterfaces())
{
if (isCandidateForRepository(interfaceType, mappedClass) == false)
{
continue;
}
kernel.Register(
Component.For(typeof(IRepository <>).MakeGenericType(interfaceType))
.ImplementedBy(repository.MakeGenericType(interfaceType))
.DependsOn(Property.ForKey("ConcreteType").Eq(mappedClass))
);
}
}
}
private void RegisterIMapCreators(IKernel kernel)
{
kernel.Register(
AllTypes.Of<IMapCreator>().FromAssembly(_assembly)
.WithService.FirstInterface()
);
}
private void RegisterIConfigurationProviderAndIProfileExpression(IKernel kernel)
{
kernel.Register(
Component.For<IConfigurationProvider, IProfileExpression>()
.UsingFactoryMethod(k => new Configuration(MapperRegistry.AllMappers()))
);
}
private void RegisterIValidatorRunner(IKernel kernel)
{
kernel.Register(
Component.For(typeof(IValidatorRunner))
.ImplementedBy(typeof(ValidatorRunner))
);
}
private void RegisterChannelBuilder(Type channelBuilder, Type builder, bool force)
{
if (force || kernel.HasComponent(channelBuilder) == false)
{
kernel.Register(Component.For(channelBuilder).ImplementedBy(builder));
}
}
private void RegisterCache(IKernel kernel)
{
kernel.Register(
Component.For<Cache>()
.UsingFactoryMethod(() => HttpRuntime.Cache)
);
}
public void Setup()
{
kernel = new DefaultKernel();
kernel.AddFacility<MethodValidatorFacility>();
kernel.Register(Component.For<IOrderService>().ImplementedBy<OrderService>());
//Add the WindsorContainer so we have an IProxyFactory instance
WindsorContainer container = new WindsorContainer(kernel, new DefaultComponentInstaller());
}
private void RegisterHttpContextBase(IKernel kernel)
{
kernel.Register(
Component.For<HttpContextBase>()
.LifeStyle.PerWebRequest
.UsingFactoryMethod(() => new HttpContextWrapper(HttpContext.Current))
);
}
private void RegisterHttpSessionStateBase(IKernel kernel)
{
kernel.Register(
Component.For<HttpSessionStateBase>()
.LifeStyle.PerWebRequest
.UsingFactoryMethod(k => k.Resolve<HttpContextBase>().Session)
);
}
private void RegisterControllers(IKernel kernel)
{
kernel.Register(
AllTypes.Of<IController>().FromAssembly(_assembly)
.If(t => !t.Name.StartsWith("T4MVC_", StringComparison.InvariantCultureIgnoreCase))
.Configure(c => c.LifeStyle.Transient)
);
}
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 void Register(IKernel kernel)
{
AssemblyScanner.FindValidatorsInAssemblyContaining<CustomerValidator>()
.ForEach(result => {
kernel.Register(Component.For(result.InterfaceType)
.ImplementedBy(result.ValidatorType)
.LifeStyle.Singleton);
});
}
/// <summary>
/// Executes task.
/// </summary>
/// <param name="application">The application.</param><param name="kernel">The kernel.</param>
public void Execute(IApplication application, IKernel kernel)
{
var configurationManager = kernel.Resolve<IConfigurationManager>();
var resourcesDirectory = configurationManager.AppSettings[ResourcesDirectoryKey];
if (String.IsNullOrEmpty(resourcesDirectory))
{
resourcesDirectory = DefaultResourcesDirectory;
}
var resourceCacheHolder = new YamlResourceCacheHolder(application.Environment, Path.Combine(application.RootPath, resourcesDirectory));
kernel.Register(Component.For<IResourceCachesHolder>().Instance(resourceCacheHolder).LifeStyle.Singleton);
}
private void RegisterIRouteValueOptimizers(IKernel kernel)
{
kernel.Register(
Component.For<IRouteValueOptimizer>()
.ImplementedBy<RouteConstraintOptimizer>()
.Named(typeof(ListConstraint).FullName),
Component.For<IRouteValueOptimizer>()
.ImplementedBy<StringOptimizer>()
.Named(typeof(string).FullName)
);
}
public SammyApplication(IKernel kernel, Assembly[] assembly)
{
_kernel = kernel;
var types = assembly.SelectMany<Assembly, Type>(a => a.GetTypes()).ToArray();
// Should this be off some kind of marker (like HttpApplication)?
_kernel.Register(AllTypes.From(types).BasedOn<SammyController>());
// This is getting a bit large - how do we initialize this better?
Routes = RouteCollector.Collect(_kernel.GetAssignableHandlers(typeof(SammyController)).Select(h => h.Service).ToArray());
}
public void Init(IKernel kernel, IConfiguration facilityConfig)
{
kernel.Resolver.AddSubResolver(new CollectionResolver(kernel));
kernel.ComponentModelBuilder.AddContributor(new RequireCachingContributor());
kernel.ComponentModelBuilder.AddContributor(new RequireBustCacheContributor());
kernel.Register(
Component.For<ICacheProvider>().ImplementedBy<DefaultCacheProvider>(),
Component.For<ICacheKeyGenerator>().ImplementedBy<DefaultCacheKeyGenerator>(),
Component.For<CacheInterceptor>(),
Component.For<BustCacheInterceptor>()
);
}
public void SetUp()
{
kernel = new DefaultKernel();
kernel.AddFacility<StartableFacility>();
kernel.Register(
Component.For<StartableDisposableAndInitializableComponent>()
.LifeStyle.Transient
);
component = kernel.Resolve<StartableDisposableAndInitializableComponent>();
component.DoSomething();
kernel.ReleaseComponent(component);
calledMethods = component.calledMethods;
}
public void Multithreaded()
{
kernel = new DefaultKernel();
kernel.Register(Component.For(typeof(PoolableComponent1)).Named("a"));
const int threadCount = 15;
var threads = new Thread[threadCount];
for (var i = 0; i < threadCount; i++)
{
threads[i] = new Thread(ExecuteMethodUntilSignal);
threads[i].Start();
}
startEvent.Set();
Thread.CurrentThread.Join(3*1000);
stopEvent.Set();
}
/// <summary>
/// 지정된 <see cref="ISessionFactory"/> 인스턴스에 등록된 모든 NHibernate용 Entity를 조사해서,
/// 자동으로 Generic Dao (INHRepository{T} 구현 클래스)를 <see cref="IKernel"/>에 Component로 등록한다.
/// 이렇게 하면, NHRepository{T} 하나만 만들고, 실제 Entity별의 NHRepository는 Castle에 자동으로 등록되고, Instancing될 것이다!!!
/// (예 NHRepository{Blog}, NHRepository{Customer} 등을 Castle Component로 정의하지 않아도, 이 함수에서 자동으로 조사하여, IoC에 등록시켜 준다는 뜻!!!)
/// </summary>
/// <param name="sessionFactory">NHibernate Session Factory</param>
/// <param name="kernel">Castle.MicroKernel 인스턴스</param>
/// <param name="repositoryType">INHRepository{T} 를 구현한 Concrete Class Type</param>
/// <param name="isCandidateForRepository">NHibernate의 매핑된 Entity 중에 IoC Container에 등록할 Type을 선별하는 Predicator</param>
public static void Register(IKernel kernel,
ISessionFactory sessionFactory,
Type repositoryType,
Predicate<Type> isCandidateForRepository) {
if(IsDebugEnabled)
log.Debug("NHibernate SessionFactory에 등록된 Entity Class에 대한 " +
@"Generic Repository (INHRepository<TEntity>) 의 인스턴스를 생성합니다. repositoryType=[{0}]", repositoryType);
if(IsImplementsOfGenericNHRepository(repositoryType) == false)
throw new InvalidOperationException("Repository must be a type inheriting from INHRepository<T>, " +
"and must be an open generic type. Sample: typeof(NHRepository<>).");
// GetAllClassMetadata 는 IDictionary<Type, IClassMetadata> 이고 Type은 Mapping된 entity의 Type이다.
//
foreach(IClassMetadata meta in sessionFactory.GetAllClassMetadata().Values) {
var mappedClass = meta.GetMappedClass(EntityMode.Poco);
if(mappedClass == null)
continue;
foreach(Type interfaceType in mappedClass.GetInterfaces()) {
if(isCandidateForRepository(interfaceType)) {
if(IsDebugEnabled)
log.Debug("Register Generic Repository. INHRepository<{0}>", interfaceType.FullName);
// NOTE : INHRepository<TEnitity> 는 꼭 ConcreteType 속성 (Entity의 Type) 을 가져야한다.
//
kernel.Register(
Component
.For(typeof(INHRepository<>).MakeGenericType(interfaceType))
.ImplementedBy(repositoryType.MakeGenericType(interfaceType))
.DependsOn(Dependency.OnValue("ConcreteType", mappedClass))
.OnlyNewServices());
//.DependsOn(Property.ForKey("ConcreteType").Eq(mappedClass))
//.Unless(Component.ServiceAlreadyRegistered));
}
}
}
}
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);
}
}
}
