Example #1
0
 void IComponentListener.OnFetch(NLite.Mini.Context.IComponentContext ctx)
 {
     if (Enabled && Fetch != null)
     {
         Fetch(ctx);
     }
 }
Example #2
0
 void IComponentListener.OnPostInitialization(NLite.Mini.Context.IComponentContext ctx)
 {
     if (Enabled && PostInitialization != null)
     {
         PostInitialization(ctx);
     }
 }
Example #3
0
 void IComponentListener.OnPreCreation(NLite.Mini.Context.IComponentContext ctx)
 {
     if (Enabled && PreCreation != null)
     {
         PreCreation(ctx);
     }
 }
Example #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="ctx"></param>
        public override void OnPostCreation(NLite.Mini.Context.IComponentContext ctx)
        {
            if (ctx.Instance == null)
            {
                return;
            }

            var instance      = ctx.Instance;
            var componentType = instance.GetType();
            var key           = componentType.FullName + ":InjectionInfos";
            var ep            = ctx.Component.ExtendedProperties;

            IMemberInjection[] injections = null;
            if (ep.ContainsKey(key))
            {
                injections = ep[key] as IMemberInjection[];
            }
            else
            {
                ResolveInjectionInfo(ctx.Component, componentType, key);
                injections = ep[key] as IMemberInjection[];
            }

            if (injections == null || injections.Length == 0)
            {
                return;
            }

            bool hasReinjection = false;

            foreach (var item in injections)
            {
                if (item.Reinjection)
                {
                    hasReinjection = true;
                }
                item.Inject(ctx);
            }


            if (hasReinjection)
            {
                lock (reinjectionMap)
                    reinjectionMap.Add(ctx
                                       , injections.Where(p => p.Reinjection).ToArray());
            }
        }
Example #5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override object Create(NLite.Mini.Context.IComponentContext context)
        {
            var impType = context.Component.Implementation;
            //if (impType.IsOpenGenericType())
            //    impType = impType.MakeCloseGenericType(context.GenericParameters);

            var  Kernel       = context.Kernel;
            var  proxyFactory = Kernel.Get <IProxyFactory>();
            bool createProxy  = proxyFactory != null;

            if (createProxy == false)
            {
                return(Real.Create(context));
            }

            object instance = null;

            object[] args = null;

            if (proxyFactory.RequiresTargetInstance(Kernel, context.Component))
            {
                instance = Real.Create(context);
            }
            else if (!typeof(DefaultActivator).IsAssignableFrom(Real.GetType()))
            {
                instance = Real.Create(context);
            }
            else
            {
                args = GetConstructurArgs(context);
            }

            try
            {
                instance = proxyFactory.Create(context, instance, args);
            }
            catch (Exception ex)
            {
                throw new ActivatorException("ComponentActivator: could not proxy " + impType.FullName, ex);
            }

            return(instance);
        }
Example #6
0
 /// <inheritdoc/>
 public override object Get(NLite.Mini.Context.IComponentContext ctx)
 {
     return(Real.Get(ctx));
 }