protected override void Init()
{
ComponentRegistration <object> component = Component.For(typeof(IRepository <>)).ImplementedBy(typeof(NHRepository <>));
if (!string.IsNullOrEmpty(config.RepositoryKey))
{
component.Named(config.RepositoryKey);
}
Kernel.Register(component);
ComponentRegistration <IUnitOfWorkFactory> registerFactory =
Component.For <IUnitOfWorkFactory>()
.ImplementedBy <NHibernateUnitOfWorkFactory>();
registerFactory.Parameters(ComponentParameter.ForKey("configurationFileName").Eq(config.NHibernateConfigurationFile));
// if we are running in test mode, we don't want to register
// the assemblies directly, we let the DatabaseTestFixtureBase do it
// this allow us to share the configuration between the test & prod projects
if (DatabaseTestFixtureBase.IsRunningInTestMode == false)
{
registerFactory.DependsOn(Property.ForKey("assemblies").Eq(Assemblies));
}
Kernel.Register(registerFactory);
Kernel.AddComponentInstance("entitiesToRepositories", typeof(INHibernateInitializationAware),
new EntitiesToRepositoriesInitializationAware(config.IsCandidateForRepository));
}
protected override void Init()
{
Kernel.ComponentRegistered += Kernel_ComponentRegistered;
_runtime = new WorkflowRuntime();
Kernel.AddComponentInstance("workflowruntime", _runtime);
}
private void ConfigureFactories(IConfiguration config)
{
String id = config.Attributes["id"];
if (id == null || String.Empty.Equals(id))
{
throw new System.Configuration.ConfigurationException("You must provide a valid 'id' attribute for the 'factory' node");
}
Configuration cfg = new Configuration();
ApplyConfigurationSettings(cfg, config.Children["settings"]);
RegisterAssemblies(cfg, config.Children["assemblies"]);
RegisterResources(cfg, config.Children["resources"]);
// Registers the Configuration object
Kernel.AddComponentInstance(String.Format("{0}.cfg", id), cfg);
// Registers the ISessionFactory with a custom activator
ComponentModel model = new ComponentModel(id, typeof(ISessionFactory), null);
model.ExtendedProperties.Add(ConfiguredObject, cfg);
model.LifestyleType = LifestyleType.Singleton;
model.CustomComponentActivator = typeof(SessionFactoryActivator);
Kernel.AddCustomComponent(model);
}
private void RegisterAdapterWithKernel()
{
String adapterName = String.Format("#ContainerAdapter:{0}#", Guid.NewGuid());
Kernel.AddComponentInstance(adapterName, this);
Kernel.ComponentUnregistered += new ComponentDataDelegate(OnComponentUnregistered);
}
private void CreateSnapshotTaker(PrevalenceEngine engine, float snapshotPeriod)
{
TimeSpan period = TimeSpan.FromHours(snapshotPeriod);
ICleanUpPolicy policy = (ICleanUpPolicy)Kernel[PrevalenceFacility.CleanupPolicyComponentPropertyKey];
SnapshotTaker taker = new SnapshotTaker(engine, period, policy);
Kernel.AddComponentInstance(PrevalenceFacility.SnapShotTakerComponentPropertyKey, taker);
}
private void Initialize(HttpApplication app)
{
Kernel.AddComponentInstance("this", typeof(IWindsorContainer), this);
if (app != null)
{
Kernel.AddComponentInstance("web.app", typeof(HttpApplication), app);
}
Initialize();
}
public void InitializeContainer(IApplicationContext context, PredefinedService[] predefinedServices)
{
((DefaultKernel)Kernel).ComponentModelBuilder = new ComponentModelBuilder(Kernel);
Kernel.ReleasePolicy = new ExplicitReleasePolicy();
Connect(RuntimeConstants.MiniKernelId, this, typeof(IKernel));
Connect("kernel", Kernel, typeof(IKernel));
Connect("windsorContainer", this, typeof(IWindsorContainer));
//AddCustomComponents(context);
Kernel.AddComponentInstance(RuntimeConstants.RuntimeConfigurationId, typeof(IApplicationContext), context);
if (KernelLogger.IsDebugEnabled)
{
new KernelLogger(Kernel);
}
Kernel.AddComponentInstance(RuntimeConstants.ProductId, typeof(IApplicationContext), context);
//AddCustomFacilities();
AddFacility(ComponentIdAwareFacilityId,
new TypeAwareFacility(ComponentIdAwareConcern.ComponentIdAwareModelPropertyName, typeof(IComponentIdAware),
ComponentIdAwareConcern.Instance));
AddFacility(ServiceRunnerFacility.ComponentTypeId, new ServiceRunnerFacility());
AddFacility(ComponentFacility.ComponentTypeId, new ComponentFacility());
if (null != context.Arguments)
{
Connect(RuntimeConstants.ParsedCommandLineArgumentsId, context.Arguments, typeof(ICommandLineArguments));
}
_logger.Debug(" + 开始添加预定义的服务...");
foreach (PredefinedService svc in predefinedServices)
{
Kernel.AddComponent(svc.Id, svc.Service, svc.Implementation);
}
_logger.Debug(" > 添加预定义的服务完成.");
//_initializing = false;
//_initialized = true;
}
protected override void Init()
{
Kernel.Register(Component.For(typeof(IRepository <>)).ImplementedBy(typeof(NHRepository <>)));
MultipleNHibernateUnitOfWorkFactory unitOfWorkFactory = new MultipleNHibernateUnitOfWorkFactory();
foreach (NHibernateUnitOfWorkFacilityConfig config in configs)
{
NHibernateUnitOfWorkFactory nestedUnitOfWorkFactory = new NHibernateUnitOfWorkFactory(config.NHibernateConfigurationFile);
nestedUnitOfWorkFactory.RegisterSessionFactory(CreateSessionFactory(config));
unitOfWorkFactory.Add(nestedUnitOfWorkFactory);
}
Kernel.AddComponentInstance <IUnitOfWorkFactory>(unitOfWorkFactory);
}
/// <summary>
/// Adds the specified service to the service container, and optionally
/// promotes the service to any parent service containers.
/// </summary>
/// <param name="serviceType">The type of service to add.</param>
/// <param name="serviceInstance">The instance of the service to add.</param>
/// <param name="promote">true to promote this request to any parent service containers.</param>
public virtual void AddService(Type serviceType, object serviceInstance, bool promote)
{
if (serviceInstance is ServiceCreatorCallback)
{
AddService(serviceType, (ServiceCreatorCallback)serviceInstance, promote);
return;
}
if (promote)
{
IServiceContainer parentServices = ParentServices;
if (parentServices != null)
{
parentServices.AddService(serviceType, serviceInstance, promote);
return;
}
}
if (serviceType == null)
{
throw new ArgumentNullException("serviceType");
}
if (serviceInstance == null)
{
throw new ArgumentNullException("serviceInstance");
}
if (!(serviceInstance.GetType().IsCOMObject ||
serviceType.IsAssignableFrom(serviceInstance.GetType())))
{
throw new ArgumentException(String.Format(
"Invalid service '{0}' for type '{1}'",
serviceInstance.GetType().FullName, serviceType.FullName));
}
if (HasService(serviceType))
{
throw new ArgumentException(String.Format(
"A service for type '{0}' already exists", serviceType.FullName));
}
String serviceName = GetServiceName(serviceType);
Kernel.AddComponentInstance(serviceName, serviceType, serviceInstance);
}
private void ConfigureFactories(IConfiguration config,
ISessionManager sessionManager, bool firstFactory)
{
String id = config.Attributes["id"];
if (id == null || String.Empty.Equals(id))
{
throw new ConfigurationException("You must provide a " +
"valid 'id' attribute for the 'factory' node. This id is used as key for " +
"the ISessionFactory component registered on the container");
}
String alias = config.Attributes["alias"];
if (!firstFactory && (alias == null || alias.Length == 0))
{
throw new ConfigurationException("You must provide a " +
"valid 'alias' attribute for the 'factory' node. This id is used to obtain " +
"the ISession implementation from the SessionManager");
}
else if (alias == null || alias.Length == 0)
{
alias = Constants.DefaultAlias;
}
Configuration cfg = new Configuration();
ApplyConfigurationSettings(cfg, config.Children["settings"]);
RegisterAssemblies(cfg, config.Children["assemblies"]);
RegisterResources(cfg, config.Children["resources"]);
// Registers the Configuration object
Kernel.AddComponentInstance(String.Format("{0}.cfg", id), cfg);
// Registers the ISessionFactory as a component
ISessionFactory sessionFactory = cfg.BuildSessionFactory();
Kernel.AddComponentInstance(id, typeof(ISessionFactory), sessionFactory);
// Registers the ISessionFactory within the ISessionManager
sessionManager.RegisterSessionFactory(alias, sessionFactory);
}
private void ConfigureSnapshot(IConfiguration engineConfig, IDictionary properties)
{
float period = GetSnapshotInterval(engineConfig);
if (RequiresSnapshots(period))
{
if (engineConfig.Attributes["cleanupPolicyComponent"] == null)
{
Kernel.AddComponentInstance(CleanupPolicyComponentPropertyKey, CleanUpAllFilesPolicy.Default);
}
properties.Add(SnapshotPeriodPropertyKey, period);
}
else
{
properties.Add(SnapshotPeriodPropertyKey, 0f);
}
}
private void OnRootTypeRegistered(object sender, Type rootType)
{
if (!Kernel.HasComponent("activerecord.sessionfactory"))
{
Kernel.AddComponentInstance(
"activerecord.sessionfactory",
typeof(NHibernate.ISessionFactory),
new SessionFactoryDelegate((ISessionFactoryHolder)sender, rootType));
}
else
{
sessionFactoryCount++;
Kernel.AddComponentInstance(
"activerecord.sessionfactory." + sessionFactoryCount.ToString(),
typeof(NHibernate.ISessionFactory),
new SessionFactoryDelegate((ISessionFactoryHolder)sender, rootType));
}
}
private void OnSessionFactoryHolderCreated(Castle.ActiveRecord.Framework.ISessionFactoryHolder holder)
{
holder.OnRootTypeRegistered += new RootTypeHandler(OnRootTypeRegistered);
if (!Kernel.HasComponent("activerecord.sessionfactoryholder"))
{
Kernel.AddComponentInstance(
"activerecord.sessionfactoryholder",
typeof(ISessionFactoryHolder), holder);
}
else
{
sessionFactoryHolderCount++;
Kernel.AddComponentInstance(
"activerecord.sessionfactoryholder." + sessionFactoryCount.ToString(),
typeof(ISessionFactoryHolder), holder);
}
}
/// <summary>
/// Initializes the MethodValidatorFacility
/// </summary>
protected override void Init()
{
IValidatorRegistry registry;
if (Kernel.HasComponent(typeof(IValidatorRegistry)))
{
registry = Kernel.Resolve <IValidatorRegistry>();
}
else
{
registry = new CachedValidationRegistry();
}
IValidatorRegistry adapter = new ParameterValidatorRegistryAdapter(registry);
Kernel.AddComponentInstance("methodValidator.metaStore", new MethodValidatorMetaStore(adapter));
Kernel.AddComponent("methodValidator.interceptor", typeof(MethodValidatorInterceptor));
Kernel.AddComponent("methodValidator.contributor", typeof(MethodValidationContributor));
Kernel.ComponentModelBuilder.AddContributor(new MethodValidatorComponentInspector());
}
/// <summary>
/// Adds the specified <see cref="IComponent"/> to the <see cref="IContainer"/> at the end of the list,
/// and assigns a name to the component.
/// </summary>
/// <param name="component">The <see cref="IComponent"/> to add.</param>
/// <param name="name">The unique, case-insensitive name to assign to the component, or null.</param>
public virtual void Add(IComponent component, String name)
{
if (component != null)
{
rwlock.AcquireWriterLock(Timeout.Infinite);
try
{
ISite site = component.Site;
if ((site == null) || (site.Container != this))
{
IContainerAdapterSite newSite = CreateSite(component, name);
try
{
Kernel.AddComponentInstance(newSite.EffectiveName, typeof(IComponent), component);
}
catch (ComponentRegistrationException ex)
{
throw new ArgumentException(ex.Message);
}
if (site != null)
{
site.Container.Remove(component);
}
component.Site = newSite;
sites.Add(newSite);
}
}
finally
{
rwlock.ReleaseWriterLock();
}
}
}
private void DiscoverServices()
{
GraphNode[] nodes = this.Kernel.GraphNodes;
foreach (ComponentModel model in nodes)
{
bool markedWithServiceContract = typeof(IServiceInterface).IsAssignableFrom(model.Service);
if (!markedWithServiceContract)
{
foreach (object attr in model.Service.GetCustomAttributes(true))
{
if (attr.ToString().EndsWith("ServiceContractAttribute"))
{
markedWithServiceContract = true;
break;
}
}
}
if (markedWithServiceContract)
{
DynamicService service = new DynamicService(this, model.Service);
Kernel.AddComponentInstance(Guid.NewGuid().ToString(), service);
}
}
}
private void RegisterLoggerFactory()
{
Kernel.AddComponentInstance("iloggerfactory", typeof(ILoggerFactory), factory);
}
private void RegisterDefaultILogger()
{
Kernel.AddComponentInstance("ilogger.default", typeof(ILogger), factory.Create("Default"));
}
protected override void Init()
{
var mapper = Mapper ?? new MemoizingMappingManager(new AttributesMappingManager());
Kernel.AddComponentInstance <IReadOnlyMappingManager>(mapper);
//Kernel.Register(Component.For<ISolrCache>().ImplementedBy<HttpRuntimeCache>());
Kernel.Register(Component.For <ISolrConnection>().ImplementedBy <SolrConnection>()
.Parameters(Parameter.ForKey("serverURL").Eq(GetSolrUrl())));
Kernel.Register(Component.For(typeof(ISolrDocumentActivator <>)).ImplementedBy(typeof(SolrDocumentActivator <>)));
Kernel.Register(Component.For(typeof(ISolrDocumentResponseParser <>))
.ImplementedBy(typeof(SolrDocumentResponseParser <>)));
Kernel.Register(Component.For <ISolrDocumentResponseParser <Dictionary <string, object> > >()
.ImplementedBy <SolrDictionaryDocumentResponseParser>());
foreach (var parserType in new[] {
typeof(ResultsResponseParser <>),
typeof(HeaderResponseParser <>),
typeof(FacetsResponseParser <>),
typeof(HighlightingResponseParser <>),
typeof(MoreLikeThisResponseParser <>),
typeof(SpellCheckResponseParser <>),
typeof(StatsResponseParser <>),
typeof(CollapseResponseParser <>),
})
{
Kernel.Register(Component.For(typeof(ISolrResponseParser <>)).ImplementedBy(parserType));
}
Kernel.Register(Component.For <ISolrHeaderResponseParser>().ImplementedBy <HeaderResponseParser <string> >());
Kernel.Register(Component.For <ISolrExtractResponseParser>().ImplementedBy <ExtractResponseParser>());
foreach (var validationRule in new[] {
typeof(MappedPropertiesIsInSolrSchemaRule),
typeof(RequiredFieldsAreMappedRule),
typeof(UniqueKeyMatchesMappingRule),
})
{
Kernel.Register(Component.For <IValidationRule>().ImplementedBy(validationRule));
}
Kernel.Resolver.AddSubResolver(new StrictArrayResolver(Kernel));
Kernel.Register(Component.For(typeof(ISolrQueryResultParser <>))
.ImplementedBy(typeof(SolrQueryResultParser <>)));
Kernel.Register(Component.For(typeof(ISolrQueryExecuter <>)).ImplementedBy(typeof(SolrQueryExecuter <>)));
Kernel.Register(Component.For(typeof(ISolrDocumentSerializer <>))
.ImplementedBy(typeof(SolrDocumentSerializer <>)));
Kernel.Register(Component.For <ISolrDocumentSerializer <Dictionary <string, object> > >()
.ImplementedBy <SolrDictionarySerializer>());
Kernel.Register(Component.For(typeof(ISolrBasicOperations <>), typeof(ISolrBasicReadOnlyOperations <>))
.ImplementedBy(typeof(SolrBasicServer <>)));
Kernel.Register(Component.For(typeof(ISolrOperations <>), typeof(ISolrReadOnlyOperations <>))
.ImplementedBy(typeof(SolrServer <>)));
Kernel.Register(Component.For <ISolrFieldParser>()
.ImplementedBy <DefaultFieldParser>());
Kernel.Register(Component.For <ISolrFieldSerializer>().ImplementedBy <DefaultFieldSerializer>());
Kernel.Register(Component.For <ISolrQuerySerializer>().ImplementedBy <DefaultQuerySerializer>());
Kernel.Register(Component.For <ISolrFacetQuerySerializer>().ImplementedBy <DefaultFacetQuerySerializer>());
Kernel.Register(Component.For <ISolrDocumentPropertyVisitor>().ImplementedBy <DefaultDocumentVisitor>());
Kernel.Register(Component.For <ISolrSchemaParser>().ImplementedBy <SolrSchemaParser>());
Kernel.Register(Component.For <ISolrDIHStatusParser>().ImplementedBy <SolrDIHStatusParser>());
Kernel.Register(Component.For <IMappingValidator>().ImplementedBy <MappingValidator>());
AddCoresFromConfig();
foreach (var core in cores)
{
RegisterCore(core);
}
}
protected override void Init()
{
Kernel.AddComponentInstance <IMenuRegistry>(_topMenuRegistry);
Kernel.AddComponentInstance <IMenuController>(_menuController);
Kernel.ComponentCreated += Kernel_ComponentCreated;
}
private void ConfigureFactories(IConfiguration config,
ISessionFactoryResolver sessionFactoryResolver, bool firstFactory)
{
String id = config.Attributes["id"];
if (id == null || String.Empty.Equals(id))
{
throw new ConfigurationErrorsException("You must provide a " +
"valid 'id' attribute for the 'factory' node. This id is used as key for " +
"the ISessionFactory component registered on the container");
}
String alias = config.Attributes["alias"];
if (!firstFactory && (alias == null || alias.Length == 0))
{
throw new ConfigurationErrorsException("You must provide a " +
"valid 'alias' attribute for the 'factory' node. This id is used to obtain " +
"the ISession implementation from the SessionManager");
}
else if (alias == null || alias.Length == 0)
{
alias = Constants.DefaultAlias;
}
if (config.Attributes["isWeb"] == "true")
{
appRootPath = HttpContext.Current.Server.MapPath("~/");
}
else
{
appRootPath = Application.StartupPath;
}
NHibernate.Cfg.Configuration cfg = new NHibernate.Cfg.Configuration();
ApplyConfigurationSettings(cfg, config.Children["settings"]);
RegisterAssemblies(cfg, config.Children["assemblies"]);
RegisterResources(cfg, config.Children["resources"]);
// Registers the Configuration object
Kernel.AddComponentInstance(String.Format("{0}.cfg", id), cfg);
// If a Session Factory level interceptor was provided, we use it
if (Kernel.HasComponent("nhibernate.sessionfactory.interceptor"))
{
cfg.Interceptor = (IInterceptor)Kernel["nhibernate.sessionfactory.interceptor"];
}
// Registers the ISessionFactory as a component
ISessionFactory sessionFactory = cfg.BuildSessionFactory();
Kernel.AddComponentInstance(id, typeof(ISessionFactory), sessionFactory);
// Registers the ISessionFactory within the ISessionFactoryResolver
sessionFactoryResolver.RegisterAliasComponentIdMapping(alias, id);
}
public void Connect(string id, object instance, Type serviceType)
{
Kernel.AddComponentInstance(id, serviceType, instance);
}
protected override void Init()
{
Kernel.AddComponentInstance("eventPublisher.default", typeof(IEventPublisher), _eventPublisher);
Kernel.ComponentCreated += Kernel_ComponentCreated;
Kernel.ComponentDestroyed += Kernel_ComponentDestroyed;
}
