/// <summary>
/// 创建对象，可以是未在容器注册
/// </summary>
/// <param name="serviceType">服务类型</param>
/// <returns></returns>
public RegisterRule CreateRule(Type serviceType)
{
var rule = this.QueryRule(serviceType, string.Empty, false);
if (rule != null)
{
return(rule);
}
if (!RegisterRuleCollector.TryRule(serviceType, serviceType))
{
return(null);
}
lock (locker)
{
rule = this.QueryRule(serviceType, string.Empty, false);
if (rule != null)
{
return(rule);
}
var containerRule = new RegisterRuleCollector();
containerRule.RegisterType(serviceType, serviceType);
this.Update(containerRule);
return(containerRule.Rules[0]);
}
}
/// <summary>
/// 更新容器规则
/// </summary>
/// <param name="collector"></param>
public void Update(RegisterRuleCollector collector)
{
if (option != null && option.Value.Unabled)
{
return;
}
this.AlwayUpdate(collector);
}
/// <summary>
/// 注册中间件与接口映射关系
/// </summary>
/// <param name="implementationType">继承TSservice对象的具体对象</param>
/// <param name="serviceType">服务类型</param>
/// <param name="key">key</param>
/// <param name="lifeStyle">生命周期</param>
public void RegisterType(Type implementationType, Type serviceType, string key, ComponentLifeStyle lifeStyle)
{
if (this.option.Value.Unabled)
{
throw new InvalidException("the builder is builded,can not update rules");
}
var rule = new RegisterRuleCollector(1);
rule.RegisterType(implementationType, serviceType, key, lifeStyle);
register.Update(rule);
}
/// <summary>
/// 注册对象实例映射关系
/// </summary>
/// <typeparam name="TService">服务类型</typeparam>
/// <param name="mission">回调生成</param>
/// <param name="key">key</param>
/// <param name="lifeStyle">生命周期</param>
/// <returns></returns>
public void RegisterCallBack <TService>(string key, ComponentLifeStyle lifeStyle, Func <ILifetimeScope, TService> mission)
{
if (this.option.Value.Unabled)
{
throw new InvalidException("the builder is builded,can not update rules");
}
var rule = new RegisterRuleCollector(1);
rule.RegisterCallBack(key, lifeStyle, mission);
register.Update(rule);
}
/// <summary>
/// 注册对象实例映射关系
/// </summary>
/// <param name="instance">服务对象</param>
/// <param name="serviceType">服务类型</param>
/// <param name="key">key</param>
public void RegisterInstance(object instance, Type serviceType, string key)
{
if (this.option.Value.Unabled)
{
throw new InvalidException("the builder is builded,can not update rules");
}
var rule = new RegisterRuleCollector(1);
rule.RegisterInstance(instance, serviceType, key);
register.Update(rule);
}
/// <summary>
/// 更新容器规则
/// </summary>
/// <param name="collector"></param>
public void AlwayUpdate(RegisterRuleCollector collector)
{
lock (locker)
{
foreach (var r in collector.Rules)
{
this.rules.Add(r);
}
/*子注册规则*/
foreach (var r in collector.Rules)
{
var subRules = r.SubRuleQueue;
if (subRules == null || subRules.Count == 0)
{
continue;
}
foreach (var sr in subRules)
{
this.rules.Add(sr);
}
subRules.Clear();
}
var proxyRules = new List <RegisterRule>(collector.Rules.Count);
foreach (var r in collector.Rules)
{
if (r.ProxyImplementationType == null & r.ProxyParameters.Length <= 0)
{
continue;
}
//if (r.ProxyParameters.Length <= 0)
// continue;
var interceptors = new List <Type>(r.ProxyParameters.Length);
foreach (var p in r.ProxyParameters)
{
interceptors.Add(p.Value);
}
var implementationType = r.ProxyImplementationType == null ? new MyProxyMockBuilder().Build(r.ImplementationType, r.ServiceType, interceptors.ToArray(), r.ProxySetting) : r.ProxyImplementationType;
var proxyRule = new RegisterRule(implementationType, r.ServiceType, string.Empty, r.ProxyParameters.Length > 0 ? ComponentLifeStyle.Transient : r.LifeStyle);
var paramters = new List <KeyValueTuple <string, Type> >(r.ProxyParameters.Length + 1);
paramters.AddRange(r.ProxyParameters);
paramters.AddRange(new[] { new KeyValueTuple <string, Type>(r.Key, r.ServiceType) });
proxyRule.PasteParameters(paramters.ToArray());
proxyRules.Add(proxyRule);
}
foreach (var r in proxyRules)
{
this.rules.Add(r);
}
return;
}
}
/// <summary>
/// 查询规则
/// </summary>
/// <param name="serviceType"></param>
/// <param name="key"></param>
/// <param name="throw">是否throw异常</param>
/// <returns></returns>
public RegisterRule QueryRule(Type serviceType, string key, bool @throw)
{
var rule = this.QueryForObject(serviceType, key);
if (rule != null)
{
return(rule);
}
if (serviceType.IsArray)
{
var typeTemp = typeof(ConstructorList <>).MakeGenericType(serviceType.GetElementType());
rule = this.QueryForObject(typeTemp, key);
if (rule != null)
{
return(rule);
}
lock (locker)
{
var containerRule = new RegisterRuleCollector(1);
var registerRule = (RegisterRule)containerRule.RegisterArrayType(typeTemp, serviceType, key, ComponentLifeStyle.Scoped);
/*更新容器*/
this.Update(containerRule);
return(registerRule);
}
}
if (!serviceType.IsGenericType)
{
if (!@throw)
{
return(null);
}
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException(string.Format("{0} not registed", serviceType.FullName));
}
throw new ArgumentNullException(string.Format("{0} with key {1} not registed", serviceType.FullName, key));
}
rule = this.QueryForObject(serviceType.GetGenericTypeDefinition(), key);
if (rule == null)
{
if (!@throw)
{
return(null);
}
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException(string.Format("{0} not registed", serviceType.GetGenericTypeDefinition().FullName));
}
throw new ArgumentNullException(string.Format("{0} with key {1} not registed", serviceType.FullName, key));
}
lock (locker)
{
var ruletemp = this.QueryForObject(rule.ServiceType.MakeGenericType(serviceType.GetGenericArguments()), key);
if (ruletemp != null)
{
return(ruletemp);
}
var containerRule = new RegisterRuleCollector(1);
var registerRule = (RegisterRule)containerRule.RegisterType(rule.ImplementationType.MakeGenericType(serviceType.GetGenericArguments()), rule.ServiceType.MakeGenericType(serviceType.GetGenericArguments()), key, rule.LifeStyle);
if (rule.ParametersCount > 0)
{
registerRule.PasteParameters(rule);
}
/*更新容器*/
this.Update(containerRule);
return(registerRule);
}
}
