/// <inheritdoc/>
public override void Init(NLite.Mini.Activation.IActivator activator, IKernel kernel, IComponentInfo info, Action<IComponentInfo, object> onDestroying, Action<IComponentContext> onFetch)
{
Guard.NotNull(activator, "activator");
Guard.NotNull(kernel, "kernel");
Guard.NotNull(info, "info");
Real.Init(new ProxyActivator(activator), kernel, info, onDestroying,OnFetch);
}
/// <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;
}
/// <summary>
///
/// </summary>
/// <param name="ctx"></param>
public override void OnPostCreation(NLite.Mini.Context.IComponentContext ctx)
{
var instance = ctx.Instance;
if (instance == null || SubscribeListener.MessageBusType.IsAssignableFrom(instance.GetType()))
return;
var bus = Kernel.Get<IMessageBus>();
if (bus == null)
return;
if (!ctx.Component.ExtendedProperties.ContainsKey("subscribeProviders"))
return;
var subscribers = ctx.Component.ExtendedProperties["subscribeProviders"] as ISubscribeInfoFactoryProvider[];
if (subscribers == null || subscribers.Length == 0)
return;
var disCollector = instance as IDisposeCollector;
var compositeDis = instance as ICompositeDisposable;
foreach(var subscriber in subscribers)
{
var unsubscriber = bus.Subscribe(subscriber.Factory(instance));
if (!subscriber.Method.IsStatic)
{
if (compositeDis != null)
compositeDis.AddDisposable(unsubscriber);
else if (disCollector != null)
disCollector.Disposes.AddDisposable(unsubscriber);
}
}
}
/// <inheritdoc/>
public override void OnPostCreation(NLite.Mini.Context.IComponentContext ctx)
{
if (ctx.Component.Implementation == null
|| ctx.Instance == null)
return;
if (!ctx.Component.ExtendedProperties.ContainsKey("AppSettings"))
return;
var injections = ctx.Component.ExtendedProperties["AppSettings"] as IAppSettingInjection[];
if (injections == null || injections.Length == 0)
return;
var instance = ctx.Instance;
var members = new List<IAppSettingInjection>();
foreach (var item in injections)
{
item.Inject(instance);
if (item.Reinjection)
members.Add(item);
}
if (members.Count > 0)
{
lock (resetMap)
resetMap[instance] = members.ToArray();
}
}
/// <summary>
///
/// </summary>
/// <param name="ctx"></param>
public override void OnPostInitialization(NLite.Mini.Context.IComponentContext ctx)
{
var supportInit = ctx.Instance as ISupportInitialize;
if (supportInit != null)
{
supportInit.BeginInit();
supportInit.EndInit();
}
}
/// <summary>
///
/// </summary>
/// <param name="ctx"></param>
public override void OnPostInitialization(NLite.Mini.Context.IComponentContext ctx)
{
if (ctx.Component.Implementation == null
|| ctx.Instance == null)
return;
if (!ctx.Component.ExtendedProperties.ContainsKey("MembersRegistered"))
return;
var exports = ctx.Component.ExtendedProperties["MembersRegistered"] as IExportInfo[];
if (exports == null)
return;
foreach (var item in exports)
item.Execute(ctx);
}
/// <inheritdoc/>
public override object Get(NLite.Mini.Context.IComponentContext ctx)
{
return Real.Get(ctx);
}
internal static void AddVersionHeader(NLite.Net.IHttpContext httpContext)
{
httpContext.Response.AppendHeader(VersionHeaderName, Version);
}
/// <summary>
///
/// </summary>
/// <param name="ctx"></param>
public override void OnInitialization(NLite.Mini.Context.IComponentContext ctx)
{
var startable = ctx.Instance as IInitializable;
if (startable != null)
startable.Init();
}
//public LifecycleLogListner() : base(ComponentListenStage.PostCreation | ComponentListenStage.PreDestroy) { }
public override void OnPostCreation(NLite.Mini.Context.IComponentContext ctx)
{
Console.WriteLine(string.Format("DI container created {0} component", ctx.Instance.GetType().Name));
}
public override void OnPreCreation(NLite.Mini.Context.IComponentContext ctx)
{
Console.WriteLine("OnPreCreation:" + ctx.Component.Implementation.Name);
}
/// <summary>
///
/// </summary>
/// <param name="ctx"></param>
public override void OnPostCreation(NLite.Mini.Context.IComponentContext ctx)
{
var instance = ctx.Instance;
if (instance != null && instance.GetType() != typeof(LifecycleListnerManager))
Manager.ForEach(lisnter => lisnter.OnCreated(instance));
}
/// <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());
}
}
