public override IRegisterLocator Register(
Type serviceType1, Type serviceType2, Type implementationType, LifeStyle lifeStyle = LifeStyles.Default, string key = null)
{
return(Component.For(serviceType1, serviceType2, implementationType).Include(this, lifeStyle, key));
}
public override IRegisterLocator Register <TContract1, TContract2, TImplementation>(
LifeStyle lifeStyle = LifeStyles.Default, string key = null)
{
return(Component.For <TContract1, TContract2>().ImplementedBy <TImplementation>().Include(this, lifeStyle, key));
}
public ComponentAttribute(LifeStyle lifeStyle = LifeStyle.Transient)
{
this.LifeStyle = lifeStyle;
}
public override IRegisterLocator Register <TContract>(
TContract instance, LifeStyle lifeStyle = LifeStyles.Default, string key = null)
{
return(Component.For <TContract>().Instance(instance).Include(this, lifeStyle, key));
}
public Component(Type baseType, Type concreteType, LifeStyle lifeStyle)
{
BaseType = baseType;
ConcreteType = concreteType;
LifeStyle = lifeStyle;
}
public void RegisterInstance <TType>(TType instance, LifeStyle life)
where TType : class
{
container.Register <TType>(instance).Life(life);
}
/// <summary>Register a implementation type.
/// </summary>
/// <param name="implementationType">The implementation type.</param>
/// <param name="life">The life cycle of the implementer type.</param>
public static void RegisterType(Type implementationType, LifeStyle life = LifeStyle.Singleton)
{
Current.RegisterType(implementationType, life);
}
public DependencyAttribute(Type serviceType, LifeStyle lifeStyle = LifeStyle.Singleton)
{
LifeStyle = lifeStyle;
ServiceType = serviceType;
}
/// <summary>
/// 根据程序集注册 接口
/// </summary>
/// <param name="service"></param>
/// <param name="assembly"></param>
/// <param name="predicate"></param>
/// <param name="lifeStyle"></param>
/// <returns></returns>
public static IServiceCollection RegisterAssemblyInterfaces(this IServiceCollection service, Assembly assembly, Func <Type, bool> predicate = null, LifeStyle lifeStyle = LifeStyle.PerLifetimeScope)
{
var types = assembly.GetTypes();
foreach (var implementationType in types)
{
if (JumpType(implementationType))
{
continue;
}
if (predicate != null)
{
if (predicate(implementationType) == false)
{
continue;
}
}
var interfacesTypes = implementationType.GetInterfaces();
if (interfacesTypes.Length == 1)
{
RegisterType(service, interfacesTypes[0], implementationType, lifeStyle);
}
}
return(service);
}
public static IObjectContainer RegisterType <T, F>(this IObjectContainer container, string name, LifeStyle lifestyle)
{
return(container.RegisterType(typeof(F), typeof(T), name, lifestyle));
}
/// <summary>
/// 根据程序集注册 接口
/// </summary>
/// <param name="service"></param>
/// <param name="assemblyName"></param>
/// <param name="predicate"></param>
/// <param name="lifeStyle"></param>
/// <returns></returns>
public static IServiceCollection RegisterAssemblyInterfaces(this IServiceCollection service, string assemblyName, Func <Type, bool> predicate = null, LifeStyle lifeStyle = LifeStyle.Singleton)
{
var assembly = Assembly.Load(assemblyName);
return(RegisterAssemblyInterfaces(service, assembly, predicate, lifeStyle));
}
public ImplementationInformation(Type type, LifeStyle lifeStyle)
{
Type = type;
LifeStyle = lifeStyle;
}
protected override void internalAdd(string name, Type serviceType, object implementTypeOrInstance, LifeStyle lifeStyle){
var component = new InversionComponent(this){Name = name};
serviceType = serviceType ??
(implementTypeOrInstance is Type
? (implementTypeOrInstance as Type)
: implementTypeOrInstance.GetType());
implementTypeOrInstance = implementTypeOrInstance ?? serviceType;
component.ServiceType = serviceType;
component.ImplementationType = implementTypeOrInstance is Type
? (implementTypeOrInstance as Type)
: implementTypeOrInstance.GetType();
component.ImplementationInstance = implementTypeOrInstance is Type ? null : implementTypeOrInstance;
component.LifeStyle = lifeStyle;
Components.Add(component);
}
/// <summary>
/// 注册
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="interceptTypeList">Aop类型</param>
/// <param name="serviceName">服务名称</param>
/// <param name="lifeStyle">生命周期</param>
public DependencyManage RegisterType <T>(Type[] interceptTypeList, string serviceName = null, LifeStyle lifeStyle = LifeStyle.Singleton)
{
Container.RegisterType <T>(interceptTypeList, serviceName: serviceName, lifeStyle: lifeStyle);
return(this);
}
/// <summary>Register a implementer type as a service implementation.
/// </summary>
/// <typeparam name="TService">The service type.</typeparam>
/// <typeparam name="TImplementer">The implementer type.</typeparam>
/// <param name="life">The life cycle of the implementer type.</param>
public static void Register <TService, TImplementer>(LifeStyle life = LifeStyle.Singleton)
where TService : class
where TImplementer : class, TService
{
Current.Register <TService, TImplementer>(life);
}
/// <summary>
/// 注册
/// </summary>
/// <typeparam name="TService">服务类型</typeparam>
/// <typeparam name="TImplementer">实例类型</typeparam>
/// <param name="instance">实例值</param>
/// <param name="serviceName">服务名字</param>
/// <param name="lifeStyle">生命周期</param>
public DependencyManage RegisterInstance <TService, TImplementer>(TImplementer instance, string serviceName = null, LifeStyle lifeStyle = LifeStyle.Singleton)
where TService : class
where TImplementer : class, TService
{
Container.RegisterInstance <TService, TImplementer>(instance, serviceName: serviceName, lifeStyle: lifeStyle);
return(this);
}
public static ComponentRegistration <T> Life <T>(this ComponentRegistration <T> registration, LifeStyle life) where T : class
{
if (life == LifeStyle.Singleton)
{
return(registration.LifeStyle.Singleton);
}
return(registration.LifeStyle.Transient);
}
public ComponentAttribute(LifeStyle lifeStyle)
{
this.LifeStyle = lifeStyle;
}
public void Register <TService, TImpl>(string key, LifeStyle life = LifeStyle.Singleton) where TService : class where TImpl : class, TService
{
_windsorContainer.Register(Component.For <TService>().ImplementedBy <TImpl>().Named(key).Life(life));
}
public void RegisterType <TFrom, TTo>(LifeStyle life)
where TFrom : class
where TTo : class, TFrom
{
container.Register <TFrom, TTo>().Life(life);
}
public void RegisterDefault <TService, TImpl>(LifeStyle life) where TService : class where TImpl : class, TService
{
_windsorContainer.Register(Component.For <TService>().ImplementedBy <TImpl>().Named(typeof(TService).FullName).IsDefault().Life(life));
}
public static TinyIoCContainer.RegisterOptions Life(this TinyIoCContainer.RegisterOptions registration, LifeStyle life)
{
if (life == LifeStyle.Singleton)
{
return(registration.AsSingleton());
}
return(registration.AsMultiInstance());
}
public void Register <T>(T instance, LifeStyle life) where T : class
{
_windsorContainer.Register(Component.For <T>().Instance(instance).Named(typeof(T).FullName).Life(life));
}
public Configuration SetDefault <TService, TImplementer>(string serviceName = null, LifeStyle life = LifeStyle.Singleton)
where TService : class
where TImplementer : class, TService
{
ObjectContainer.Register <TService, TImplementer>(serviceName, life);
return(this);
}
public void Register <T>(T instance, string key, LifeStyle life) where T : class
{
_windsorContainer.Register(Component.For <T>().Instance(instance).Named(key).Life(life));
}
public override IRegisterLocator Register <TContract>(
Func <TContract> func, LifeStyle lifeStyle = LifeStyles.Default, string key = null)
{
return(Component.For <TContract>().UsingFactoryMethod(func).Include(this, lifeStyle, key));
}
/// <summary>
/// 注册指定接口的实例
/// </summary>
public static void Register <T>(T instance, LifeStyle life = LifeStyle.Singleton) where T : class
{
_resolver.Register <T>(instance, life);
}
public override IRegisterLocator Register <TContract>(
Type implementationType, LifeStyle lifeStyle = LifeStyles.Default, string key = null)
{
return(Component.For <TContract>().ImplementedBy(implementationType).Include(this, lifeStyle, key));
}
/// <summary>
/// 注册给定类型的实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instance"></param>
/// <param name="key"></param>
/// <param name="life"></param>
public void Register <T>(T instance, string key, LifeStyle life = LifeStyle.Singleton) where T : class
{
_container.Register <T>(instance, key, life);
}
public ComponentAttribute(LifeStyle lifeStyle)
{
LifeStyle = lifeStyle;
}
/// <summary>
/// 注册给定接口的实现
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TImpl"></typeparam>
/// <param name="key"></param>
/// <param name="life"></param>
public void Register <TService, TImpl>(string key, LifeStyle life = LifeStyle.Singleton)
where TService : class
where TImpl : class, TService
{
_container.Register <TService, TImpl>(key, life);
}
/// <summary>
/// 注册
/// </summary>
/// <param name="serviceType">服务类型</param>
/// <param name="implementationType">实例类型</param>
/// <param name="interceptTypeList">Aop类型</param>
/// <param name="serviceName">服务名字</param>
/// <param name="lifeStyle">生命周期</param>
public DependencyManage RegisterType(Type serviceType, Type implementationType, Type[] interceptTypeList, string serviceName = null, LifeStyle lifeStyle = LifeStyle.Singleton)
{
Container.RegisterType(serviceType, implementationType, interceptTypeList, serviceName: serviceName, lifeStyle: lifeStyle);
return(this);
}
/// <summary>
/// 注册给定接口的默认实现
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TImpl"></typeparam>
/// <param name="life"></param>
public void RegisterDefault <TService, TImpl>(LifeStyle life = LifeStyle.Singleton)
where TService : class
where TImpl : class, TService
{
_container.RegisterDefault <TService, TImpl>(life);
}
public DependencyAttribute(LifeStyle lifeStyle = LifeStyle.Singleton)
{
LifeStyle = lifeStyle;
}
public static void RegisterType(Type serviceType, Type implementationType, string serviceName = null, LifeStyle life = LifeStyle.Singleton)
{
Current.RegisterType(serviceType, implementationType, serviceName, life);
}
protected abstract void internalAdd(string name, Type serviceType, object implementTypeOrInstance, LifeStyle lifeStyle);
public static void Register <TService, TImplementer>(string serviceName = null, LifeStyle life = LifeStyle.Singleton)
where TService : class
where TImplementer : class, TService
{
Current.Register <TService, TImplementer>(serviceName, life);
}
protected override void internalAdd(string name, Type serviceType, object implementTypeOrInstance, LifeStyle lifeStyle){
if(lifeStyle==LifeStyle.Singleton){
Container.RegisterService(name,serviceType,implementTypeOrInstance,new Dictionary<string, string>());
}else{
Container.RegisterTransient(name,serviceType,implementTypeOrInstance as Type,new Dictionary<string, string>());
}
}
public DeasyAttribute(string key = "", LifeStyle lifeStyle = LifeStyle.LifetimeScope)
{
Key = key;
LifeStyle = lifeStyle;
}
