依赖注入相关

src/Plus/Dependency/BasicConventionalRegistrar.cs

+using Castle.DynamicProxy;
+using Castle.MicroKernel.Registration;
+using System.Reflection;
+
+namespace Plus.Dependency
+{
+    /// <summary>
+    /// 用于注册基本依赖项实现
+    /// </summary>
+    public class BasicConventionalRegistrar : IDependencyRegistrar
+    {
+        public void RegisterAssembly(IRegistrationContext context)
+        {
+            //Transient
+            context.IocManager.IocContainer.Register(
+                Classes.FromAssembly(context.Assembly)
+                    .IncludeNonPublicTypes()
+                    .BasedOn<ITransientDependency>()
+                    .If(type => !type.GetTypeInfo().IsGenericTypeDefinition)
+                    .WithService.Self()
+                    .WithService.DefaultInterfaces()
+                    .LifestyleTransient()
+                );
+
+            //Singleton
+            context.IocManager.IocContainer.Register(
+                Classes.FromAssembly(context.Assembly)
+                    .IncludeNonPublicTypes()
+                    .BasedOn<ISingletonDependency>()
+                    .If(type => !type.GetTypeInfo().IsGenericTypeDefinition)
+                    .WithService.Self()
+                    .WithService.DefaultInterfaces()
+                    .LifestyleSingleton()
+                );
+
+            //Windsor Interceptors
+            context.IocManager.IocContainer.Register(
+                Classes.FromAssembly(context.Assembly)
+                    .IncludeNonPublicTypes()
+                    .BasedOn<IInterceptor>()
+                    .If(type => !type.GetTypeInfo().IsGenericTypeDefinition)
+                    .WithService.Self()
+                    .LifestyleTransient()
+                );
+        }
+    }
+}
\ No newline at end of file

src/Plus/Dependency/ConventionalRegistrationConfig.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Plus.Dependency
+{
+    public class ConventionalRegistrationConfig : DictionaryBasedConfig
+    {
+        /// <summary>
+        /// Install all <see cref="IInterceptor"/> implementations automatically or not.
+        /// Default: true. 
+        /// </summary>
+        public bool InstallInstallers { get; set; }
+
+        /// <summary>
+        /// Creates a new <see cref="ConventionalRegistrationConfig"/> object.
+        /// </summary>
+        public ConventionalRegistrationConfig()
+        {
+            InstallInstallers = true;
+        }
+    }
+}
\ No newline at end of file

src/Plus/Dependency/ConventionalRegistrationContext.cs

+using System.Reflection;
+
+namespace Plus.Dependency
+{
+    internal class ConventionalRegistrationContext : IConventionalRegistrationContext
+    {
+        /// <summary>
+        /// Gets the registering Assembly.
+        /// </summary>
+        public Assembly Assembly { get; private set; }
+
+        /// <summary>
+        /// Reference to the IOC Container to register types.
+        /// </summary>
+        public IIocManager IocManager { get; private set; }
+
+        /// <summary>
+        /// Registration configuration.
+        /// </summary>
+        public ConventionalRegistrationConfig Config { get; private set; }
+
+        internal ConventionalRegistrationContext(Assembly assembly, IIocManager iocManager, ConventionalRegistrationConfig config)
+        {
+            Assembly = assembly;
+            IocManager = iocManager;
+            Config = config;
+        }
+    }
+}
\ No newline at end of file

src/Plus/Dependency/DependencyLifeStyle.cs

+namespace Plus.Dependency
+{
+    /// <summary>
+    /// 依赖注入方式
+    /// </summary>
+    public enum DependencyLifeStyle
+    {
+        /// <summary>
+        /// Singleton
+        /// </summary>
+        Singleton,
+
+        /// <summary>
+        /// Transient
+        /// </summary>
+        Transient
+    }
+}
\ No newline at end of file

src/Plus/Dependency/DisposableDependencyObjectWrapper.cs

+namespace Plus.Dependency
+{
+    internal class DisposableDependencyObjectWrapper : DisposableDependencyObjectWrapper<object>, IDisposableDependencyObjectWrapper
+    {
+        public DisposableDependencyObjectWrapper(IIocResolver iocResolver, object obj)
+            : base(iocResolver, obj)
+        {
+
+        }
+    }
+}
\ No newline at end of file

src/Plus/Dependency/DisposableDependencyObjectWrapperOfT.cs

+using System;
+
+namespace Plus.Dependency
+{
+    internal class DisposableDependencyObjectWrapper<T> : IDisposableDependencyObjectWrapper<T>, IDisposable
+    {
+        private readonly IIocResolver _iocResolver;
+
+        public T Object { get; private set; }
+
+        public DisposableDependencyObjectWrapper(IIocResolver iocResolver, T obj)
+        {
+            _iocResolver = iocResolver;
+            Object = obj;
+        }
+
+        public void Dispose()
+        {
+            _iocResolver.Release(Object);
+        }
+    }
+}
\ No newline at end of file

src/Plus/Dependency/IConventionalRegistrationContext.cs

+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+
+namespace Plus.Dependency
+{
+    public interface IConventionalRegistrationContext
+    {
+        /// <summary>
+        /// Gets the registering Assembly.
+        /// </summary>
+        Assembly Assembly { get; }
+
+        /// <summary>
+        /// Reference to the IOC Container to register types.
+        /// </summary>
+        IIocManager IocManager { get; }
+
+        /// <summary>
+        /// Registration configuration.
+        /// </summary>
+        ConventionalRegistrationConfig Config { get; }
+    }
+}
\ No newline at end of file

src/Plus/Dependency/IDependencyRegistrar.cs

+namespace Plus.Dependency
+{
+    public interface IDependencyRegistrar
+    {
+        void RegisterAssembly(IRegistrationContext context);
+    }
+}
\ No newline at end of file

src/Plus/Dependency/IDisposableDependencyObjectWrapper.cs

+using System;
+
+namespace Plus.Dependency
+{
+    /// <summary>
+    /// 此接口用于包装从IOC容器解析的对象
+    /// </summary>
+    public interface IDisposableDependencyObjectWrapper : IDisposableDependencyObjectWrapper<object>, IDisposable
+    {
+
+    }
+}
\ No newline at end of file

src/Plus/Dependency/IDisposableDependencyObjectWrapperOfT.cs

+using System;
+
+namespace Plus.Dependency
+{
+    /// <summary>
+    /// 此接口用于包装从IOC容器解析的对象
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public interface IDisposableDependencyObjectWrapper<out T> : IDisposable
+    {
+        /// <summary>
+        /// The resolved object
+        /// </summary>
+        T Object { get; }
+    }
+}
\ No newline at end of file

src/Plus/Dependency/IIocManager.cs

+using Castle.Windsor;
+using System;
+
+namespace Plus.Dependency
+{
+    /// <summary>
+    /// 此接口用于直接执行依赖项注入任务
+    /// </summary>
+    public interface IIocManager : IIocRegistrar, IIocResolver, IDisposable
+    {
+        /// <summary>
+        /// <see cref="IWindsorContainer"/>
+        /// </summary>
+        IWindsorContainer IocContainer { get; }
+
+        /// <summary>
+        /// 是否注册了给定的类型
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        new bool IsRegistered(Type type);
+
+        /// <summary>
+        /// 是否注册了给定的类型
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        new bool IsRegistered<T>();
+    }
+}
\ No newline at end of file

src/Plus/Dependency/IIocRegistrar.cs

+using System;
+using System.Reflection;
+
+namespace Plus.Dependency
+{
+    /// <summary>
+    /// 用于注册依赖项的接口
+    /// </summary>
+    public interface IIocRegistrar
+    {
+        /// <summary>
+        /// Add Registrar
+        /// </summary>
+        /// <param name="registrar"></param>
+        void AddRegistrar(IDependencyRegistrar registrar);
+
+        /// <summary>
+        /// Register Assembly
+        /// </summary>
+        /// <param name="assembly"></param>
+        void RegisterAssembly(Assembly assembly);
+
+        /// <summary>
+        /// Register
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="lifeStyle"></param>
+        void Register<T>(DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton) where T : class;
+
+        /// <summary>
+        /// Register
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="lifeStyle"></param>
+        void Register(Type type, DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton);
+
+        /// <summary>
+        /// Register
+        /// </summary>
+        /// <typeparam name="TType"></typeparam>
+        /// <typeparam name="TImpl"></typeparam>
+        /// <param name="lifeStyle"></param>
+        void Register<TType, TImpl>(DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton) where TType : class where TImpl : class, TType;
+
+        /// <summary>
+        /// Register
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="impl"></param>
+        /// <param name="lifeStyle"></param>
+        void Register(Type type, Type impl, DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton);
+
+        /// <summary>
+        /// 是否注册了给定的类型
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        bool IsRegistered<T>();
+
+        /// <summary>
+        /// 是否注册了给定的类型
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        bool IsRegistered(Type type);
+    }
+}
\ No newline at end of file

src/Plus/Dependency/IIocResolver.cs

+using System;
+
+namespace Plus.Dependency
+{
+    /// <summary>
+    /// 用于解析依赖项的接口
+    /// </summary>
+    public interface IIocResolver
+    {
+        /// <summary>
+        /// 从IOC容器中获取对象
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        T Resolve<T>();
+
+        /// <summary>
+        /// 从IOC容器中获取对象
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        object Resolve(Type type);
+
+        /// <summary>
+        /// 从IOC容器中获取对象
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        T[] ResolveAll<T>();
+
+        /// <summary>
+        /// 是否注册了给定的类型
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        bool IsRegistered<T>();
+
+        /// <summary>
+        /// 是否注册了给定的类型
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        bool IsRegistered(Type type);
+
+        /// <summary>
+        /// 释放预解析对象
+        /// </summary>
+        /// <param name="obj"></param>
+        void Release(object obj);
+    }
+}
\ No newline at end of file

src/Plus/Dependency/IRegistrationContext.cs

+using System.Reflection;
+
+namespace Plus.Dependency
+{
+    public interface IRegistrationContext
+    {
+        Assembly Assembly { get; }
+
+        IIocManager IocManager { get; }
+    }
+}
\ No newline at end of file

src/Plus/Dependency/ISingletonDependency.cs

+namespace Plus.Dependency
+{
+    public interface ISingletonDependency
+    {
+
+    }
+}
\ No newline at end of file

src/Plus/Dependency/ITransientDependency.cs

+namespace Plus.Dependency
+{
+    public interface ITransientDependency
+    {
+
+    }
+}
\ No newline at end of file

src/Plus/Dependency/IocManager.cs

+using Castle.MicroKernel.Registration;
+using Castle.Windsor;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+
+namespace Plus.Dependency
+{
+    public class IocManager : IIocManager, IIocRegistrar, IIocResolver, IDisposable
+    {
+        private readonly List<IDependencyRegistrar> _conventionalRegistrars;
+
+        public IWindsorContainer IocContainer { get; private set; }
+
+        public static IocManager Instance { get; private set; }
+
+        static IocManager()
+        {
+            Instance = new IocManager();
+        }
+
+        public IocManager()
+        {
+            IocContainer = new WindsorContainer();
+            _conventionalRegistrars = new List<IDependencyRegistrar>();
+            IocContainer.Register(
+                Component
+                    .For<IocManager, IIocManager, IIocRegistrar, IIocResolver>()
+                    .Instance(this)
+            );
+        }
+
+        public void AddRegistrar(IDependencyRegistrar registrar)
+        {
+            _conventionalRegistrars.Add(registrar);
+        }
+
+        public void RegisterAssembly(Assembly assembly)
+        {
+            ConventionalRegistrationContext context = new ConventionalRegistrationContext(assembly, this);
+            foreach (IDependencyRegistrar conventionalRegistrar in _conventionalRegistrars)
+            {
+                conventionalRegistrar.RegisterAssembly(context);
+            }
+        }
+
+        public void Register<TType>(DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton) where TType : class
+        {
+            IocContainer.Register(ApplyLifestyle(Component.For<TType>(), lifeStyle));
+        }
+
+        public void Register(Type type, DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton)
+        {
+            IocContainer.Register(ApplyLifestyle(Component.For(type), lifeStyle));
+        }
+
+        public void Register<TType, TImpl>(DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton) where TType : class where TImpl : class, TType
+        {
+            IocContainer.Register(ApplyLifestyle(Component.For<TType, TImpl>().ImplementedBy<TImpl>(), lifeStyle));
+        }
+
+        public void Register(Type type, Type impl, DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton)
+        {
+            IocContainer.Register(ApplyLifestyle(Component.For(type, impl).ImplementedBy(impl), lifeStyle));
+        }
+
+        public bool IsRegistered(Type type)
+        {
+            return IocContainer.Kernel.HasComponent(type);
+        }
+
+        public bool IsRegistered<TType>()
+        {
+            return IocContainer.Kernel.HasComponent(typeof(TType));
+        }
+
+        public T Resolve<T>()
+        {
+            return IocContainer.Resolve<T>();
+        }
+
+        public T Resolve<T>(Type type)
+        {
+            return (T)IocContainer.Resolve(type);
+        }
+
+        public object Resolve(Type type)
+        {
+            return IocContainer.Resolve(type);
+        }
+
+        //public object Resolve(Type type, object argumentsAsAnonymousType)
+        //{
+        //    return IocContainer.Resolve(type, argumentsAsAnonymousType);
+        //}
+
+        //public T Resolve<T>(object argumentsAsAnonymousType)
+        //{
+        //    return IocContainer.Resolve<T>(argumentsAsAnonymousType);
+        //}
+
+        public T[] ResolveAll<T>()
+        {
+            return IocContainer.ResolveAll<T>();
+        }
+
+        //public T[] ResolveAll<T>(object argumentsAsAnonymousType)
+        //{
+        //    return IocContainer.ResolveAll<T>(argumentsAsAnonymousType);
+        //}
+
+        public object[] ResolveAll(Type type)
+        {
+            return IocContainer.ResolveAll(type).Cast<object>().ToArray();
+        }
+
+        //public object[] ResolveAll(Type type, object argumentsAsAnonymousType)
+        //{
+        //    return IocContainer.ResolveAll(type, argumentsAsAnonymousType).Cast<object>().ToArray();
+        //}
+
+        public void Release(object obj)
+        {
+            IocContainer.Release(obj);
+        }
+
+        public void Dispose()
+        {
+            IocContainer.Dispose();
+        }
+
+        private static ComponentRegistration<T> ApplyLifestyle<T>(ComponentRegistration<T> registration, DependencyLifeStyle lifeStyle) where T : class
+        {
+            switch (lifeStyle)
+            {
+                case DependencyLifeStyle.Transient:
+                    return registration.LifestyleTransient();
+                case DependencyLifeStyle.Singleton:
+                    return registration.LifestyleSingleton();
+                default:
+                    return registration;
+            }
+        }
+    }
+}
\ No newline at end of file

src/Plus/Dependency/IocRegistrarExtensions.cs

+using System;
+
+namespace Plus.Dependency
+{
+    /// <summary>
+    /// <see cref="IIocRegistrar"/> 接口的扩展方法
+    /// </summary>
+    public static class IocRegistrarExtensions
+    {
+        public static bool RegisterIfNot<T>(this IIocRegistrar iocRegistrar, DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton)
+            where T : class
+        {
+            if (iocRegistrar.IsRegistered<T>())
+            {
+                return false;
+            }
+
+            iocRegistrar.Register<T>(lifeStyle);
+            return true;
+        }
+
+        public static bool RegisterIfNot(this IIocRegistrar iocRegistrar, Type type, DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton)
+        {
+            if (iocRegistrar.IsRegistered(type))
+            {
+                return false;
+            }
+
+            iocRegistrar.Register(type, lifeStyle);
+            return true;
+        }
+
+        public static bool RegisterIfNot<TType, TImpl>(this IIocRegistrar iocRegistrar, DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton)
+            where TType : class
+            where TImpl : class, TType
+        {
+            if (iocRegistrar.IsRegistered<TType>())
+            {
+                return false;
+            }
+
+            iocRegistrar.Register<TType, TImpl>(lifeStyle);
+            return true;
+        }
+
+        public static bool RegisterIfNot(this IIocRegistrar iocRegistrar, Type type, Type impl, DependencyLifeStyle lifeStyle = DependencyLifeStyle.Singleton)
+        {
+            if (iocRegistrar.IsRegistered(type))
+            {
+                return false;
+            }
+
+            iocRegistrar.Register(type, impl, lifeStyle);
+            return true;
+        }
+    }
+}
\ No newline at end of file

src/Plus/Dependency/IocResolverExtensions.cs

+using System;
+
+namespace Plus.Dependency
+{
+    public static class IocResolverExtensions
+    {
+        public static IDisposableDependencyObjectWrapper<T> ResolveAsDisposable<T>(this IIocResolver iocResolver)
+        {
+            return new DisposableDependencyObjectWrapper<T>(iocResolver, iocResolver.Resolve<T>());
+        }
+
+        public static IDisposableDependencyObjectWrapper<T> ResolveAsDisposable<T>(this IIocResolver iocResolver, Type type)
+        {
+            return new DisposableDependencyObjectWrapper<T>(iocResolver, (T)iocResolver.Resolve(type));
+        }
+
+        public static IDisposableDependencyObjectWrapper ResolveAsDisposable(this IIocResolver iocResolver, Type type)
+        {
+            return new DisposableDependencyObjectWrapper(iocResolver, iocResolver.Resolve(type));
+        }
+    }
+}
\ No newline at end of file