/// <summary>
/// Register a contract and implementation types
/// </summary>
/// <param name="implType">Implementation Type</param>
/// <param name="scope">Lifetime Scope (Singleton, Transient, PerInstance)</param>
public void RegisterType <TContract>(Type implType, LifetimeScopeType scope = LifetimeScopeType.Transient)
{
//IResolver resolver = GetResolver(scope);
types[typeof(TContract)] = new Creator {
Type = implType, Scope = scope
};
}
private IResolver GetResolver(LifetimeScopeType scopeType = LifetimeScopeType.Transient)
{
switch (scopeType)
{
case LifetimeScopeType.PerInstance:
return(new InstanceResolver());
case LifetimeScopeType.Singleton:
return(_singletonResolver);
case LifetimeScopeType.Transient:
default:
return(_transientResolver);
}
}
/// <summary>
/// Register a contract and implementation types
/// </summary>
/// <param name="scope">Lifetime Scope (Singleton, Transient, PerInstance)</param>
public void Register <TContract, TImpl>(LifetimeScopeType scope = LifetimeScopeType.Transient)
{
RegisterType <TContract>(typeof(TImpl), scope);
}
/*
/// <summary>
/// 以有参数构造获取T接口类型的实例（构造函数不准使用默认参数和命名参数）
/// </summary>
/// <typeparam name="T">T接口类型</typeparam>
/// <returns>实例</returns>
public T Resolve<T>(params object[] parameters)
{
try
{
Type classType;
//尝试读取T接口类型对应的实现类型
_dictionary.TryGetValue(typeof(T), out classType);
//获取第一个构造函数
ConstructorInfo constructor = classType.GetConstructors().FirstOrDefault();
//获取构造函数参数
//ParameterInfo[] parameters = constructor.GetParameters();
object o = constructor.Invoke(parameters);
return (T)o;
}
catch
{
return default(T);
}
}
//*/
/// <summary>
/// 以无参数构造获取T接口类型的实例
/// </summary>
/// <typeparam name="T">T接口类型</typeparam>
/// <returns>实例</returns>
public T Resolve<T>(ILifetimeScope lifetimeScope = null)
{
try
{
T temp;
LifetimeScopeType lifetimeScopeType = GetLifetimeScopeType(typeof(T));
bool isDisposal = typeof(IDisposable).IsAssignableFrom(typeof(T));
if (lifetimeScopeType == LifetimeScopeType.Single)
{
//单例
if (_singleDictionary.ContainsKey(typeof(T)))
{
//已存在
temp = (T)_singleDictionary[typeof(T)];
}
else
{
//不存在
temp = InnerResolve<T>();
_singleDictionary.TryAdd(typeof(T), temp);
}
}
else if (lifetimeScopeType == LifetimeScopeType.PerLifetimeScope)
{
//生命周期，即生命周期中只能实例化一次
bool isInstanced = lifetimeScope.IsInstancedByType<T>();
if (isInstanced)
{
//如果已经实例化，则从lifetimeScope实例中获取T实例
temp = lifetimeScope.GetInstanceByType<T>();
}
else
{
//如果还没实例化，则由Container实例来实例化T
temp = InnerResolve<T>();
//添加到LifetimeScope级别实例字典
lifetimeScope.AddInstanceByType<T>(temp);
//如果实现IDispose接口
if (isDisposal)
{
lifetimeScope.AddDisposal(temp);
}
}
}
else
{
//每次都实例化
temp = InnerResolve<T>();
//如果实现IDispose接口
if (isDisposal)
{
lifetimeScope.AddDisposal(temp);
}
}
return temp;
}
catch(Exception ex)
{
return default(T);
}
}
