/// <inheritdoc cref="Make"/> private static TService Resolve(params object[] userParams) { released = false; if (!inited && (App.IsResolved(service) || App.CanMake(service))) { App.Watch <TService>(ServiceRebound); inited = true; } else if (binder != null && !binder.IsStatic) { // If it has been initialized, the binder has been initialized. // Then judging in advance can optimize performance without // going through a hash lookup. return(Build(userParams)); } var newBinder = App.GetBind(service); if (newBinder == null || !newBinder.IsStatic) { binder = newBinder; return(Build(userParams)); } Rebind(newBinder); return(instance = Build(userParams)); }
/// <summary> /// 构建一个服务 /// </summary> private static TService Resolve(params object[] userParams) { released = false; if (!inited) { App.Watch <TService>(ServiceRebound); inited = true; } else { // 如果已经初始化了说明binder已经被初始化过。 // 那么提前判断可以优化性能而不用经过一个hash查找。 if (binder != null && !binder.IsStatic) { return(Build(userParams)); } } var newBinder = App.GetBind(service); if (newBinder == null || !newBinder.IsStatic) { binder = newBinder; return(Build(userParams)); } Rebind(newBinder); return(instance = Build(userParams)); }
/// <summary> /// 执行全局释放修饰器 /// </summary> /// <param name="bindData">服务绑定数据</param> /// <param name="obj">服务实例</param> /// <returns>被修饰器修饰后的服务实例</returns> private void ExecOnReleaseDecorator(IBindData bindData, object obj) { foreach (var action in release) { action.Invoke(bindData, obj); } }
/// <summary> /// 当静态服务被释放时 /// </summary> /// <param name="bindData">绑定数据</param> /// <param name="action">处理事件</param> /// <returns>服务绑定数据</returns> public static IBindData OnRelease(this IBindData bindData, Action<object> action) { Guard.Requires<ArgumentNullException>(action != null); return bindData.OnRelease((_, instance) => { action(instance); }); }
/// <summary> /// 当静态服务被释放时 /// </summary> /// <param name="bindData">绑定数据</param> /// <param name="action">处理事件</param> /// <returns>服务绑定数据</returns> public static IBindData OnRelease(this IBindData bindData, Action action) { Guard.Requires <ArgumentNullException>(action != null); return(bindData.OnRelease((_, __) => { action(); })); }
/// <inheritdoc cref="IBindData.OnAfterResolving"/> public static IBindData OnAfterResolving(this IBindData bindData, Action closure) { Guard.Requires <ArgumentNullException>(closure != null); return(bindData.OnAfterResolving((_, instance) => { closure(); })); }
/// <inheritdoc cref="IBindData.OnRelease"/> public static IBindData OnRelease(this IBindData bindData, Action <object> closure) { Guard.Requires <ArgumentNullException>(closure != null); return(bindData.OnRelease((_, instance) => { closure(instance); })); }
/// <summary> /// 解决服务事件之后的回调 /// </summary> /// <param name="bindData">绑定数据</param> /// <param name="action">解决事件</param> /// <returns>服务绑定数据</returns> public static IBindData OnAfterResolving(this IBindData bindData, Action <object> action) { Guard.Requires <ArgumentNullException>(action != null); return(bindData.OnAfterResolving((_, instance) => { action(instance); })); }
/// <summary> /// 执行全局解决修饰器 /// </summary> /// <param name="bindData">服务绑定数据</param> /// <param name="obj">服务实例</param> /// <returns>被修饰器修饰后的服务实例</returns> private object ExecOnResolvingDecorator(IBindData bindData, object obj) { foreach (var func in resolving) { obj = func(bindData, obj); } return(obj); }
/// <summary> /// 重新绑定 /// </summary> /// <param name="newBinder">新的Binder</param> private static void Rebind(IBindData newBinder) { if (newBinder != null && binder != newBinder && newBinder.IsStatic) { newBinder.OnRelease(OnRelease); } binder = newBinder; }
/// <summary> /// 解决服务时触发的回调 /// </summary> /// <param name="bindData">绑定数据</param> /// <param name="action">解决事件</param> /// <returns>服务绑定数据</returns> public static IBindData OnResolving(this IBindData bindData, Action action) { Guard.Requires<ArgumentNullException>(action != null); return bindData.OnResolving((_, instance) => { action(); return instance; }); }
/// <summary> /// 如果服务不存在那么则绑定服务 /// </summary> /// <typeparam name="TService">服务名</typeparam> /// <typeparam name="TAlias">服务别名</typeparam> /// <param name="container">服务容器</param> /// <param name="bindData">如果绑定失败则返回历史绑定对象</param> /// <returns>是否完成绑定</returns> public static bool SingletonIf <TService, TAlias>(this IContainer container, out IBindData bindData) { if (container.BindIf(container.Type2Service(typeof(TService)), typeof(TService), true, out bindData)) { bindData.Alias(container.Type2Service(typeof(TAlias))); return(true); } return(false); }
/// <summary> /// When the resolved object is released. /// </summary> /// <param name="oldBinder">The old bind data with resolved object.</param> /// <param name="instance">The ignored parameter.</param> private static void OnRelease(IBindData oldBinder, object instance) { if (oldBinder != binder) { return; } that = default; released = true; }
/// <summary> /// 当服务被释放时 /// </summary> /// <param name="oldBinder">旧的绑定器</param> /// <param name="_">忽略的参数</param> private static void OnRelease(IBindData oldBinder, object _) { if (oldBinder != binder) { return; } instance = default(TService); released = true; }
/// <summary> /// The facade static constructor . /// </summary> static Facade() { service = App.Type2Service(typeof(TService)); App.OnNewApplication += app => { instance = default(TService); binder = null; inited = false; released = false; }; }
/// <summary> /// 解决服务时触发的回调 /// </summary> /// <typeparam name="T">指定的类型</typeparam> /// <param name="bindData">绑定数据</param> /// <param name="closure">闭包</param> /// <returns>服务绑定数据</returns> public static IBindData OnResolving <T>(this IBindData bindData, Action <IBindData, T> closure) { Guard.Requires <ArgumentNullException>(closure != null); return(bindData.OnResolving((bind, instance) => { if (instance is T) { closure(bind, (T)instance); } })); }
/// <summary> /// 默认的释放事件 /// </summary> /// <param name="binder">绑定数据</param> /// <param name="obj">对象</param> private void DefaultOnRelease(IBindData binder, object obj) { if (obj == null) { return; } if (binder.IsStatic) { Detach(obj); } }
/// <summary> /// Initializes static members of the <see cref="Facade{TService}"/> class. /// </summary> #pragma warning disable S3963 static Facade() #pragma warning restore S3963 { Service = App.Type2Service(typeof(TService)); App.OnNewApplication += app => { that = default; binder = null; inited = false; released = false; }; }
/// <summary> /// 默认的解决事件 /// </summary> /// <param name="binder">绑定数据</param> /// <param name="obj">对象</param> /// <returns>处理后的对象</returns> private void DefaultOnResolving(IBindData binder, object obj) { if (obj == null) { return; } if (binder.IsStatic) { Attach(obj); } }
/// <summary> /// 当释放时 /// </summary> /// <param name="binder">绑定数据</param> /// <param name="obj">实例</param> /// <returns>处理后的实例</returns> private void OnRelease(IBindData binder, object obj) { var tick = obj as ITick; if (tick == null) { return; } lock (ticks) { ticks.Remove(tick); } }
/// <summary> /// 当解决时 /// </summary> /// <param name="binder">绑定数据</param> /// <param name="obj">实例</param> /// <returns>处理后的实例</returns> private object OnResolving(IBindData binder, object obj) { var tick = obj as ITick; if (tick == null || !binder.IsStatic) { return(obj); } lock (ticks) { ticks.Add(tick); } return(obj); }
public void BindFunc() { var container = MakeContainer(); container.Bind("Test", (cont, param) => { return("HelloWorld"); }, true); IBindData bind = container.GetBind("Test"); bool hasBind = container.HasBind("Test"); object obj = container.Make("Test"); Assert.AreNotEqual(null, bind); Assert.AreEqual(true, hasBind); Assert.AreEqual(true, bind.IsStatic); Assert.AreSame("HelloWorld", obj); }
public bool SingletonIf <TService>(out IBindData bindData) => CatApplication.SingletonIf <TService>(out bindData);
/// <summary> /// 如果服务不存在那么则绑定服务 /// </summary> /// <param name="container">服务容器</param> /// <param name="service">服务名</param> /// <param name="concrete">服务实现</param> /// <param name="bindData">如果绑定失败则返回历史绑定对象</param> /// <returns>是否完成绑定</returns> public static bool SingletonIf(this IContainer container, string service, Func <IContainer, object[], object> concrete, out IBindData bindData) { return(container.BindIf(service, concrete, true, out bindData)); }
/// <summary> /// 如果服务不存在那么则绑定服务 /// </summary> /// <typeparam name="TService">服务名</typeparam> /// <param name="container">服务容器</param> /// <param name="concrete">服务实现</param> /// <param name="bindData">如果绑定失败则返回历史绑定对象</param> /// <returns>是否完成绑定</returns> public static bool SingletonIf <TService>(this IContainer container, Func <object> concrete, out IBindData bindData) { Guard.Requires <ArgumentNullException>(concrete != null); return(container.BindIf(container.Type2Service(typeof(TService)), (c, p) => concrete.Invoke(), true, out bindData)); }
/// <summary> /// 如果服务不存在那么则绑定服务 /// </summary> /// <typeparam name="TService">服务名</typeparam> /// <param name="container">服务容器</param> /// <param name="concrete">服务实现</param> /// <param name="bindData">如果绑定失败则返回历史绑定对象</param> /// <returns>是否完成绑定</returns> public static bool SingletonIf <TService>(this IContainer container, Func <IContainer, object[], object> concrete, out IBindData bindData) { return(container.BindIf(container.Type2Service(typeof(TService)), concrete, true, out bindData)); }
/// <summary> /// 如果服务不存在那么则绑定服务 /// </summary> /// <typeparam name="TService">服务名,同时也是服务实现</typeparam> /// <param name="container">服务容器</param> /// <param name="bindData">如果绑定失败则返回历史绑定对象</param> /// <returns>是否完成绑定</returns> public static bool SingletonIf <TService>(this IContainer container, out IBindData bindData) { return(container.BindIf(container.Type2Service(typeof(TService)), typeof(TService), true, out bindData)); }
/// <summary> /// 如果服务不存在那么则绑定服务 /// </summary> /// <typeparam name="TService">服务名</typeparam> /// <typeparam name="TConcrete">服务实现</typeparam> /// <param name="container">服务容器</param> /// <param name="bindData">如果绑定失败则返回历史绑定对象</param> /// <returns>是否完成绑定</returns> public static bool BindIf <TService, TConcrete>(this IContainer container, out IBindData bindData) { return(container.BindIf(container.Type2Service(typeof(TService)), typeof(TConcrete), false, out bindData)); }
/// <summary> /// 为服务设定一个别名 /// </summary> /// <typeparam name="TAlias">别名</typeparam> /// <param name="bindData">绑定数据</param> /// <returns>服务绑定数据</returns> public static IBindData Alias <TAlias>(this IBindData bindData) { return(bindData.Alias(bindData.Container.Type2Service(typeof(TAlias)))); }
/// <summary> /// 如果服务不存在那么则绑定服务 /// </summary> /// <typeparam name="TService">服务名</typeparam> /// <param name="container">服务容器</param> /// <param name="concrete">服务实现</param> /// <param name="bindData">如果绑定失败则返回历史绑定对象</param> /// <returns>是否完成绑定</returns> public static bool BindIf <TService>(this IContainer container, Func <object[], object> concrete, out IBindData bindData) { Guard.Requires <ArgumentNullException>(concrete != null); return(container.BindIf(container.Type2Service(typeof(TService)), (c, @params) => concrete(@params), false, out bindData)); }