public void Register(IKernelInternal kernel)
        {
            // 1. Interceptor Registration
            kernel.Register(
                Component.For <LoggingInterceptor>()
                .ImplementedBy <LoggingInterceptor>());

            // Another Interceptor registration.
            //kernel.Register(
            //    Component.For<AnotherInterceptor>()
            //        .ImplementedBy<AnotherInterceptor>());

            // 2. Interceptor attached with Example Class.
            kernel.Register(
                Component.For <IExample>()
                .ImplementedBy <Example>()
                .Interceptors(InterceptorReference.ForType <LoggingInterceptor>()).Anywhere);

            // Mutiple Interceptors for the same class can be registered with one line as below.
            //kernel.Register(
            //     Component.For<IExample>()
            //                .ImplementedBy<Example>()
            //                .Interceptors(new InterceptorReference[] {
            //                                InterceptorReference.ForType<LoggingInterceptor>(),
            //                                InterceptorReference.ForType<AnotherInterceptor>()
            //     }).Anywhere);
        }
 /// <summary>
 /// Performs the registration in the <see cref="T:Castle.MicroKernel.IKernel"/>.
 /// </summary>
 /// <param name="kernel">The kernel.</param>
 public void Register(IKernelInternal kernel)
 {
     kernel.Register(Component.For <IWindowManager, WindowManager>()
                     .LifeStyle.Singleton,
                     Component.For <IEventAggregator, EventAggregator>()
                     .LifeStyle.Singleton);
 }
示例#3
0
        public void Init(IKernelInternal kernel)
        {
            this.kernel = kernel;
#if !SILVERLIGHT
            InitStandardExtensions();
#endif
        }
示例#4
0
        /// <summary>
        ///   Resolves the component(s) from given kernel.
        /// </summary>
        /// <param name = "kernel"></param>
        /// <param name = "scope"></param>
        /// <returns>Resolved component(s).</returns>
        public virtual object Resolve(IKernelInternal kernel, IReleasePolicy scope)
        {
            if (LoadByName(kernel))
            {
                try
                {
                    return(kernel.Resolve(componentName, componentType, additionalArguments, scope));
                }
                catch (ComponentNotFoundException e)
                {
                    if (actualSelectorType == typeof(DefaultDelegateComponentSelector) && fallbackToResolveByTypeIfNameNotFound == false)
                    {
                        e.Data["breakingChangeId"] = "typedFactoryFallbackToResolveByTypeIfNameNotFound";
                        e.Data["breakingChange"]   = "This exception may have been caused by a breaking change between Windsor 2.5 and 3.0 See breakingchanges.txt for more details.";
                    }
                    throw;
                }
            }

            // Ignore thread-static parent context call stack tracking. Factory-resolved components
            // are already tracked by the factory itself and should not be added as burdens just because
            // we happen to be resolving in the call stack of some random component’s constructor.

            // Specifically, act the same as we would if the timing was slightly different and we were not
            // resolving within the call stack of the random component’s constructor.
            return(kernel.Resolve(componentType, additionalArguments, scope, ignoreParentContext: true));
        }
示例#5
0
        /*/// <summary>
         * ///   Constructs a container using the specified
         * ///   <see cref = "IConfigurationInterpreter" /> implementation.
         * /// </summary>
         * /// <param name = "interpreter">The instance of an <see cref = "IConfigurationInterpreter" /> implementation.</param>
         * public EssexContainer(IConfigurationInterpreter interpreter)
         *  : this()
         * {
         *  if (interpreter == null)
         *  {
         *      throw new ArgumentNullException("interpreter");
         *  }
         *  interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore, kernel);
         *
         *  RunInstaller();
         * }
         *
         *      /// <summary>
         * ///   Constructs a container using the specified
         * ///   <see cref = "IConfigurationStore" /> implementation.
         * /// </summary>
         * /// <param name = "store">The instance of an <see cref = "IConfigurationStore" /> implementation.</param>
         * public EssexContainer(IConfigurationStore store)
         *  : this()
         * {
         *  kernel.ConfigurationStore = store;
         *
         *  RunInstaller();
         * }
         *
         *
         *
         * /// <summary>
         * ///   Initializes a new instance of the <see cref = "EssexContainer" /> class.
         * /// </summary>
         * /// <param name = "interpreter">The interpreter.</param>
         * /// <param name = "environmentInfo">The environment info.</param>
         * public EssexContainer(IConfigurationInterpreter interpreter, IEnvironmentInfo environmentInfo)
         *  : this()
         * {
         *  if (interpreter == null)
         *  {
         *      throw new ArgumentNullException("interpreter");
         *  }
         *  if (environmentInfo == null)
         *  {
         *      throw new ArgumentNullException("environmentInfo");
         *  }
         *
         *  interpreter.EnvironmentName = environmentInfo.GetEnvironmentName();
         *  interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore, kernel);
         *
         *  RunInstaller();
         * }*/


        public IEssexContainer Install(params IEssexInstaller[] installers)
        {
            if (installers == null)
            {
                throw new ArgumentNullException("installers");
            }
            if (installers.Length != 0)
            {
                DefaultComponentInstaller scope  = new DefaultComponentInstaller();
                IKernelInternal           kernel = this.kernel as IKernelInternal;
                if (kernel == null)
                {
                    this.Install(installers, scope);
                }
                else
                {
                    IDisposable disposable = kernel.OptimizeDependencyResolution();
                    this.Install(installers, scope);
                    if (disposable != null)
                    {
                        disposable.Dispose();
                    }
                }
            }
            return(this);
        }
示例#6
0
 /// <summary>
 /// Constructs an AbstractComponentActivator
 /// </summary>
 protected AbstractComponentActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
 {
     this.model         = model;
     this.kernel        = kernel;
     this.onCreation    = onCreation;
     this.onDestruction = onDestruction;
 }
		/// <summary>
		/// Initializes a new instance of the <see cref = "CreateOnUIThreadActivator" /> class.
		/// </summary>
		/// <param name = "model"> The model. </param>
		/// <param name = "kernel"> The kernel. </param>
		/// <param name = "onCreation"> Delegate called on construction. </param>
		/// <param name = "onDestruction"> Delegate called on destruction. </param>
		public CreateOnUIThreadActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation,
		                                 ComponentInstanceDelegate onDestruction)
			: base(model, kernel, onCreation, onDestruction)
		{
			customActivator = CreateCustomActivator(model, kernel);
			performCreation = PerformCreation;
		}
 /// <summary>
 /// Initializes a new instance of the <see cref = "CreateOnUIThreadActivator" /> class.
 /// </summary>
 /// <param name = "model"> The model. </param>
 /// <param name = "kernel"> The kernel. </param>
 /// <param name = "onCreation"> Delegate called on construction. </param>
 /// <param name = "onDestruction"> Delegate called on destruction. </param>
 public CreateOnUIThreadActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation,
                                  ComponentInstanceDelegate onDestruction)
     : base(model, kernel, onCreation, onDestruction)
 {
     customActivator = CreateCustomActivator(model, kernel);
     performCreation = PerformCreation;
 }
		/// <summary>
		/// Constructor for SessionFactoryActivator
		/// </summary>
		/// <param name="model"></param>
		/// <param name="kernel"></param>
		/// <param name="onCreation"></param>
		/// <param name="onDestruction"></param>
		public SessionFactoryActivator(ComponentModel model,
		                               IKernelInternal kernel,
		                               ComponentInstanceDelegate onCreation,
		                               ComponentInstanceDelegate onDestruction)
			: base(model, kernel, onCreation, onDestruction)
		{
		}
示例#10
0
 public AspNetCoreComponentActivator(
     ComponentModel model,
     IKernelInternal kernel,
     ComponentInstanceDelegate onCreation,
     ComponentInstanceDelegate onDestruction) : base(model, kernel, onCreation, onDestruction)
 {
 }
		/// <summary>
		/// Constructs an AbstractComponentActivator
		/// </summary>
		protected AbstractComponentActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
		{
			this.model = model;
			this.kernel = kernel;
			this.onCreation = onCreation;
			this.onDestruction = onDestruction;
		}
示例#12
0
 public WcfClientActivator(ComponentModel model, IKernelInternal kernel,
                           ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
     : base(model, kernel, onCreation, onDestruction)
 {
     clients      = kernel.Resolve <WcfClientExtension>();
     proxyFactory = new WcfProxyFactory(clients.ProxyGenerator, clients);
 }
示例#13
0
 /// <summary>
 /// Constructor for SessionFactoryActivator
 /// </summary>
 /// <param name="model"></param>
 /// <param name="kernel"></param>
 /// <param name="onCreation"></param>
 /// <param name="onDestruction"></param>
 public SessionFactoryActivator(ComponentModel model,
                                IKernelInternal kernel,
                                ComponentInstanceDelegate onCreation,
                                ComponentInstanceDelegate onDestruction)
     : base(model, kernel, onCreation, onDestruction)
 {
 }
		/// <summary>
		/// 	Initializes a new instance of the <see cref = "DefaultComponentActivator" /> class.
		/// </summary>
		/// <param name = "model"> </param>
		/// <param name = "kernel"> </param>
		/// <param name = "onCreation"> </param>
		/// <param name = "onDestruction"> </param>
		public DefaultComponentActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
			: base(model, kernel, onCreation, onDestruction)
		{
#if (!SILVERLIGHT)
			useFastCreateInstance = !model.Implementation.IsContextful && new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).IsGranted();
#endif
		}
        private void CollectForwardedTypes(IKernelInternal kernel, IConfiguration component, string typeName, string id,
                                           IConversionManager converter, List <Type> services)
        {
            if (kernel == null)
            {
                return;
            }
            var forwardedTypes = component.Children["forwardedTypes"];

            if (forwardedTypes == null)
            {
                return;
            }

            foreach (var forwardedType in forwardedTypes.Children
                     .Where(c => c.Name.Trim().Equals("add", StringComparison.InvariantCultureIgnoreCase)))
            {
                var forwardedServiceTypeName = forwardedType.Attributes["service"];
                try
                {
                    services.Add(converter.PerformConversion <Type>(forwardedServiceTypeName));
                }
                catch (Exception e)
                {
                    throw new ComponentRegistrationException(
                              string.Format("Component {0}-{1} defines invalid forwarded type.", id ?? string.Empty, typeName), e);
                }
            }
        }
示例#16
0
        /// <summary>
        ///     Initializes a new instance of the <see cref = "DefaultComponentActivator" /> class.
        /// </summary>
        /// <param name = "model"> </param>
        /// <param name = "kernel"> </param>
        /// <param name = "onCreation"> </param>
        /// <param name = "onDestruction"> </param>
        public DefaultComponentActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
            : base(model, kernel, onCreation, onDestruction)
        {
#if (!SILVERLIGHT)
            useFastCreateInstance = !model.Implementation.IsContextful && new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).IsGranted();
#endif
        }
示例#17
0
        public void Register(IKernelInternal kernel)
        {
            //kernel.Register(
            //    Component.For<SecurityInterceptor>()
            //        .ImplementedBy<SecurityInterceptor>());

            kernel.Register(Component.For <SecurityAspect>());
            kernel.Register(Component.For <LoggingAspect>());



            // Registrer All BLO Objects
            foreach (Type EntityType in new GwinEntitiesManager().GetAll_Entities_Type())
            {
                Type BLOEntity_Type = GwinBaseBLO <BaseEntity> .Detemine_Type_EntityBLO(EntityType, GwinApp.Instance.TypeBaseBLO);


                //   kernel.Register(
                //Component.For(BLOEntity_Type).ImplementedBy(BLOEntity_Type)
                //         .Interceptors(
                //    InterceptorReference.ForType<SecurityInterceptor>()).Anywhere);

                kernel.Register(
                    Component.For(BLOEntity_Type).ImplementedBy(BLOEntity_Type)
                    .Interceptors(
                        typeof(SecurityAspect),
                        typeof(LoggingAspect)));
            }
        }
		/// <summary>
		///   Resolves the component(s) from given kernel.
		/// </summary>
		/// <param name = "kernel"></param>
		/// <param name = "scope"></param>
		/// <returns>Resolved component(s).</returns>
		public virtual object Resolve(IKernelInternal kernel, IReleasePolicy scope)
		{
			if (ComponentName != null && kernel.LoadHandlerByKey(ComponentName, ComponentType, AdditionalArguments) != null)
			{
				return kernel.Resolve(ComponentName, ComponentType, AdditionalArguments, scope);
			}
			return kernel.Resolve(ComponentType, AdditionalArguments, scope);
		}
		/// <summary>
		///   Resolves the component(s) from given kernel.
		/// </summary>
		/// <param name = "kernel"></param>
		/// <param name = "scope"></param>
		/// <returns>Resolved component(s).</returns>
		public virtual object Resolve(IKernelInternal kernel, IReleasePolicy scope)
		{
			if (LoadByName(kernel))
			{
				return kernel.Resolve(componentName, componentType, additionalArguments, scope);
			}
			return kernel.Resolve(componentType, additionalArguments, scope);
		}
 /// <summary>
 ///   Resolves the component(s) from given kernel.
 /// </summary>
 /// <param name = "kernel"></param>
 /// <param name = "scope"></param>
 /// <returns>Resolved component(s).</returns>
 public virtual object Resolve(IKernelInternal kernel, IReleasePolicy scope)
 {
     if (ComponentName != null && kernel.LoadHandlerByKey(ComponentName, ComponentType, AdditionalArguments) != null)
     {
         return(kernel.Resolve(ComponentName, ComponentType, AdditionalArguments, scope));
     }
     return(kernel.Resolve(ComponentType, AdditionalArguments, scope));
 }
		private bool LoadByName(IKernelInternal kernel)
		{
			if (componentName == null)
			{
				return false;
			}
			return fallbackToResolveByTypeIfNameNotFound == false || kernel.LoadHandlerByKey(componentName, componentType, additionalArguments) != null;
		}
 /// <summary>
 ///   Resolves the component(s) from given kernel.
 /// </summary>
 /// <param name = "kernel"></param>
 /// <param name = "scope"></param>
 /// <returns>Resolved component(s).</returns>
 public virtual object Resolve(IKernelInternal kernel, IReleasePolicy scope)
 {
     if (LoadByName(kernel))
     {
         return(kernel.Resolve(componentName, componentType, additionalArguments, scope));
     }
     return(kernel.Resolve(componentType, additionalArguments, scope));
 }
 public WindsorServiceResolver(IKernel kernel)
 {
     _kernel = kernel as IKernelInternal;
     if (_kernel == null)
     {
         throw new ArgumentException($"The kernel must implement {typeof(IKernelInternal)}");
     }
 }
 public WindsorServiceProvider(IWindsorContainer container)
 {
     kernel = container.Kernel as IKernelInternal;
     if (kernel == null)
     {
         throw new ArgumentException(string.Format("The kernel must implement {0}", typeof(IKernelInternal)));
     }
 }
 public WindsorServiceResolver(IKernel kernel)
 {
     _kernel = kernel as IKernelInternal;
     if (_kernel == null)
     {
         throw new ArgumentException(string.Format("The kernel must implement {0}", typeof(IKernelInternal)));
     }
 }
 private bool LoadByName(IKernelInternal kernel)
 {
     if (componentName == null)
     {
         return(false);
     }
     return(fallbackToResolveByTypeIfNameNotFound == false || kernel.LoadHandlerByName(componentName, componentType, additionalArguments) != null);
 }
示例#27
0
 public ResourceProviderActivator(
     ComponentModel model,
     IKernelInternal kernel,
     ComponentInstanceDelegate onCreation,
     ComponentInstanceDelegate onDestruction)
     : base(model, kernel, onCreation, onDestruction)
 {
 }
示例#28
0
 public NHibernateConfigurationActivator(
     ComponentModel model,
     IKernelInternal kernel,
     ComponentInstanceDelegate onCreation,
     ComponentInstanceDelegate onDestruction)
     : base(model, kernel, onCreation, onDestruction)
 {
 }
        public void Register(IKernelInternal kernel)
        {
            kernel.Register(Component.For<LoggingInterceptor>().ImplementedBy<LoggingInterceptor>());

            kernel.Register(
                Component.For<ITask>().ImplementedBy<Task>().Interceptors(
                    InterceptorReference.ForType<LoggingInterceptor>()).Anywhere);
            //Anywhere tells the registration process that this interceptor could be attached anywhere.
        }
示例#30
0
 public MessageHandlerActivator(
     ComponentModel model,
     IKernelInternal kernel,
     ComponentInstanceDelegate onCreation,
     ComponentInstanceDelegate onDestruction)
     : base(model, kernel, onCreation, onDestruction)
 {
     m_Endpoints = model.ExtendedProperties["MessageHandlerFor"] as string[];
 }
示例#31
0
        public void Register(IKernelInternal kernel)
        {
            kernel.Register(Component.For <LoggingInterceptor>().ImplementedBy <LoggingInterceptor>());

            kernel.Register(
                Component.For <ITask>().ImplementedBy <Task>().Interceptors(
                    InterceptorReference.ForType <LoggingInterceptor>()).Anywhere);
            //Anywhere tells the registration process that this interceptor could be attached anywhere.
        }
		/// <summary>
		///   Resolves the component(s) from given kernel.
		/// </summary>
		/// <param name = "kernel"></param>
		/// <param name = "scope"></param>
		/// <returns>Resolved component(s).</returns>
		public virtual object Resolve(IKernelInternal kernel, IReleasePolicy scope)
		{
			if (kernel.HasComponent(ComponentName) == false)
			{
				return kernel.Resolve(ComponentType, AdditionalArguments, scope);
			}

			return kernel.Resolve(ComponentName, ComponentType, AdditionalArguments, scope);
		}
示例#33
0
 public void Register(IKernelInternal kernel)
 {
     kernel.Register(
         Component.For <MethodLoggerInterceptor>()
         .ImplementedBy <MethodLoggerInterceptor>());
     kernel.Register(
         Component.For <IPdfDocumentBuilder>()
         .ImplementedBy <PdfDocumentBuilder>()
         .Interceptors(InterceptorReference.ForType <MethodLoggerInterceptor>()).Anywhere);
 }
示例#34
0
 /// <summary>
 /// Performs the registration in the <see cref="T:Castle.MicroKernel.IKernel"/>.
 /// </summary>
 /// <param name="kernel">The kernel.</param>
 public void Register(IKernelInternal kernel)
 {
     kernel.Register(Component.For <IDataService, DataService>()
                     .LifeStyle.Singleton,
                     Component.For <IWorkspaceReaderWriter, WorkspaceReaderWriter>()
                     .LifeStyle.Transient,
                     Component.For <IWorkspaceReader, XmlWorkspaceReader>()
                     .LifeStyle.Transient,
                     Component.For <IWorkspaceWriter, XmlWorkspaceWriter>()
                     .LifeStyle.Transient);
 }
示例#35
0
        public void Register(IKernelInternal kernel)
        {
            kernel.Register(
                Component.For <LoggingInterceptor>()
                .ImplementedBy <LoggingInterceptor>());

            kernel.Register(
                Component.For <IRocket>()
                .ImplementedBy <Rocket>()
                .Interceptors(InterceptorReference.ForType <LoggingInterceptor>()).Anywhere);
        }
示例#36
0
        public void Register(IKernelInternal kernel)
        {
            kernel.Register(
                Component.For <TestInterceptor>()
                .ImplementedBy <TestInterceptor>());

            kernel.Register(
                Component.For <OrderLogic>()
                .ImplementedBy <OrderLogic>()
                .Interceptors(InterceptorReference.ForType <TestInterceptor>()).Anywhere);
        }
示例#37
0
        public void Register(IKernelInternal kernel)
        {
            kernel.Register(
                Component.For <IInterceptor>()
                .ImplementedBy <ServiceInterceptor>());

            kernel.Register(
                Component.For <IDemoService>()
                .ImplementedBy <DemoService>()
                .Interceptors(InterceptorReference.ForType <ServiceInterceptor>()).Anywhere);
        }
        public void Register(IKernelInternal kernel)
        {
            kernel.Register(
                Component.For <StudentInterceptor>()
                .ImplementedBy <StudentInterceptor>());

            kernel.Register(
                Component.For <IStudent>()
                .ImplementedBy <Student>()
                .Interceptors(InterceptorReference.ForType <StudentInterceptor>()).Anywhere);
        }
示例#39
0
 /// <summary>
 /// Performs the registration in the <see cref="T:Castle.MicroKernel.IKernel"/>.
 /// </summary>
 /// <param name="kernel">The kernel.</param>
 public void Register(IKernelInternal kernel)
 {
     kernel.Register(Component.For <IViewModelFactory, ViewModelFactory>().LifeStyle.Transient,
                     Component.For <ModelEditorLoader>().LifeStyle.Transient,
                     Component.For <SharedDomainLoader>().LifeStyle.Transient,
                     Component.For <ConstraintLoader>().LifeStyle.Transient,
                     Component.For <VariableLoader>().LifeStyle.Transient,
                     Component.For <IWorkspaceLoader, WorkspaceLoader>().LifeStyle.Transient,
                     Component.For <IResourceManager, ResourceManager>().LifeStyle.Singleton,
                     Component.For <IDocumentManager, DocumentManager>().LifeStyle.Singleton);
 }
示例#40
0
		public override void Init(IKernelInternal kernel)
		{
			base.Init(kernel);

			if (resolveExtensions != null)
			{
				foreach (var extension in resolveExtensions)
				{
					extension.Init(kernel, this);
				}
			}
			if (releaseExtensions != null)
			{
				foreach (var extension in releaseExtensions)
				{
					extension.Init(kernel, this);
				}
			}
		}
		/// <summary>
		///   Resolves the component(s) from given kernel.
		/// </summary>
		/// <param name = "kernel"></param>
		/// <param name = "scope"></param>
		/// <returns>Resolved component(s).</returns>
		public virtual object Resolve(IKernelInternal kernel, IReleasePolicy scope)
		{
			if (LoadByName(kernel))
			{
				try
				{
					return kernel.Resolve(componentName, componentType, additionalArguments, scope);
				}
				catch (ComponentNotFoundException e)
				{
					if (actualSelectorType == typeof(DefaultDelegateComponentSelector) && fallbackToResolveByTypeIfNameNotFound == false)
					{
						e.Data["breakingChangeId"] = "typedFactoryFallbackToResolveByTypeIfNameNotFound";
						e.Data["breakingChange"] = "This exception may have been caused by a breaking change between Windsor 2.5 and 3.0 See breakingchanges.txt for more details.";
					}
					throw;
				}
			}
			return kernel.Resolve(componentType, additionalArguments, scope);
		}
示例#42
0
		void IRegistration.Register(IKernelInternal 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 TypedFactoryInterceptor(IKernelInternal kernel, ITypedFactoryComponentSelector componentSelector)
		{
			ComponentSelector = componentSelector;
			this.kernel = kernel;
			scope = kernel.ReleasePolicy.CreateSubPolicy();
		}
		public void Init(IKernelInternal kernel)
		{
			partial.Init(kernel);
		}
		public PartialConfigurationStore(IKernelInternal kernel)
		{
			inner = kernel.ConfigurationStore;
			partial = new DefaultConfigurationStore();
			partial.Init(kernel);
		}
		public override void Init(IKernelInternal kernel)
		{
			base.Init(kernel);
			InitStandardExtensions();
		}
		/// <summary>
		/// Initializes a new instance of the <see cref = "WebUserControlComponentActivator" /> class.
		/// </summary>
		/// <param name = "model"> The model. </param>
		/// <param name = "kernel"> The kernel. </param>
		/// <param name = "onCreation"> The on creation. </param>
		/// <param name = "onDestruction"> The on destruction. </param>
		public WebUserControlComponentActivator(ComponentModel model, IKernelInternal kernel,
		                                        ComponentInstanceDelegate onCreation,
		                                        ComponentInstanceDelegate onDestruction)
			: base(model, kernel, onCreation, onDestruction)
		{
		}
		/// <summary>
		/// Initializes a new instance of the <see cref = "RemoteActivatorThroughConnector" /> class.
		/// </summary>
		/// <param name = "model"> The model. </param>
		/// <param name = "kernel"> The kernel. </param>
		/// <param name = "onCreation"> The oncreation event handler. </param>
		/// <param name = "onDestruction"> The ondestruction event handler. </param>
		public RemoteActivatorThroughConnector(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
			: base(model, kernel, onCreation, onDestruction)
		{
		}
		public DefaultHandlerFactory(IKernelInternal kernel)
		{
			this.kernel = kernel;
		}
示例#50
0
		public override void Init(IKernelInternal kernel)
		{
			base.Init(kernel);

			kernel.Register(Component.For<IScopeManager>().Instance(this));
		}
示例#51
0
		/// <summary>
		///   Saves the kernel instance, subscribes to
		///   <see cref = "IKernelEvents.AddedAsChildKernel" />
		///   event,
		///   creates the lifestyle manager instance and computes
		///   the handler state.
		/// </summary>
		/// <param name = "kernel"></param>
		public virtual void Init(IKernel kernel)
		{
			if (kernel == null)
			{
				throw new ArgumentNullException("kernel");
			}
			this.kernel = kernel as IKernelInternal;
			if (this.kernel == null)
			{
				throw new HandlerException(
					string.Format("The kernel does not implement {0}. It must also provide contract for internal usage.",
					              typeof(IKernelInternal).FullName));
			}
			this.kernel.AddedAsChildKernel += OnAddedAsChildKernel;

			var activator = this.kernel.CreateComponentActivator(ComponentModel);
			lifestyleManager = CreateLifestyleManager(activator);
			EnsureDependenciesCanBeSatisfied(activator as IDependencyAwareActivator);

			if (state == HandlerState.Valid)
			{
				DisconnectEvents();
			}
		}
		private void CollectForwardedTypes(IKernelInternal kernel, IConfiguration component, string typeName, string id,
		                                   IConversionManager converter, List<Type> services)
		{
			if (kernel == null)
			{
				return;
			}
			var forwardedTypes = component.Children["forwardedTypes"];
			if (forwardedTypes == null)
			{
				return;
			}

			foreach (var forwardedType in forwardedTypes.Children
				.Where(c => c.Name.Trim().Equals("add", StringComparison.InvariantCultureIgnoreCase)))
			{
				var forwardedServiceTypeName = forwardedType.Attributes["service"];
				try
				{
					services.Add(converter.PerformConversion<Type>(forwardedServiceTypeName));
				}
				catch (Exception e)
				{
					throw new Exception(
						string.Format("Component {0}-{1} defines invalid forwarded type.", id ?? string.Empty, typeName), e);
				}
			}
		}
		/// <summary>
		///   Saves the kernel instance, subscribes to
		///   <see cref = "IKernelEvents.AddedAsChildKernel" />
		///   event,
		///   creates the lifestyle manager instance and computes
		///   the handler state.
		/// </summary>
		/// <param name = "kernel"></param>
		public virtual void Init(IKernelInternal kernel)
		{
			if (kernel == null)
			{
				throw new ArgumentNullException("kernel");
			}
			this.kernel = kernel;
			this.kernel.AddedAsChildKernel += OnAddedAsChildKernel;

			InitDependencies();
			if (AllRequiredDependenciesResolvable())
			{
				SetNewState(HandlerState.Valid);
				DisconnectEvents();
				missingDependencies = null;
			}
		}
示例#54
0
		public virtual void Init(IKernelInternal kernel)
		{
			this.kernel = kernel;
		}
 public void Register(IKernelInternal kernel)
 {
     kernel.Register(Component.For<IAnotherExample>().ImplementedBy<AnotherExample>());
 }
		/// <summary>
		/// Initializes a new instance of the <see cref = "RemoteMarshallerActivator" /> class.
		/// </summary>
		/// <param name = "model"> The model. </param>
		/// <param name = "kernel"> The kernel. </param>
		/// <param name = "onCreation"> The oncreation event handler. </param>
		/// <param name = "onDestruction"> The ondestruction event handler. </param>
		public RemoteMarshallerActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
			: base(model, kernel, onCreation, onDestruction)
		{
		}
		public virtual void Init(IKernelInternal kernel)
		{
		}
		/// <summary>
		///   Initializes this instance with the specified dependency delegate.
		/// </summary>
		/// <param name = "kernel">kernel</param>
		/// <param name = "dependencyDelegate">The dependency delegate.</param>
		public void Initialize(IKernelInternal kernel, DependencyDelegate dependencyDelegate)
		{
			this.kernel = kernel;
			converter = kernel.GetConversionManager();
			dependencyResolvingDelegate = dependencyDelegate;
		}
 public void Register(IKernelInternal kernel)
 {
     kernel.Register(Component.For<ILogger>().ImplementedBy<ConsoleLogger>());
 }
		public void Init(IKernelInternal kernel)
		{
			this.kernel = kernel;
			InitStandardExtensions();
		}