/// <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));
}
