自己实现的一个简单的C# IOC 容器

IService接口，以实现服务的启动、停止功能：

using System;
 System.Collections.Generic;
 System.Linq;
 System.Text;
 System.Threading.Tasks;

namespace Utils
{
    /// <summary>
    /// 服务接口
    </summary>
    public interface IService
    {
        <summary>
         服务启动
        </summary>
        void OnStart();

         服务停止
         OnStop();
    }
}

View Code

AbstractService服务抽象类：

 服务抽象类
    abstract class AbstractService : IService
    {
        virtual  OnStart() { }

         OnStop() { }
    }
}

View Code

IOC容器帮助类：

 System.Collections.Concurrent;
 System.Reflection;
 System.Threading.Tasks;
 System.Web;

 服务帮助类
    partial  ServiceHelper
    {
        #region 变量
         接口的对象集合
        private static ConcurrentDictionary<Type,object> _dict = new ConcurrentDictionary<Type,1)">object>();
        #endregion

        #region Get 获取实例
         获取实例
        static T Get<T>()
        {
            Type type = typeof(T);
            object obj = _dict.GetorAdd(type,key => Activator.CreateInstance(type));

            return (T)obj;
        }
        #region Get 通过Func获取实例
        static T Get<T>(Func<T> func)
        {
            Type type =  func());

            #region Registerassembly 注册程序集
         注册程序集
        </summary>
        <param name="type">程序集中的一个类型</param>
        static  Registerassembly(Type type)
        {
            Registerassembly(Assembly.GetAssembly(type).FullName);
        }

        <param name="assemblyString">程序集名称的长格式void Registerassembly(string assemblyString)
        {
            LogTimeUtil logTimeUtil = new LogTimeUtil();
            Assembly assembly = Assembly.Load(assemblyString);
            Type[] typeArr = assembly.GetTypes();
            string iServiceInterfaceName = (IService).FullName;

            foreach (Type type in typeArr)
            {
                Type typeIService = type.GetInterface(iServiceInterfaceName);
                if (typeIService != null && !type.IsAbstract)
                {
                    Type[] interfaceTypeArr = type.GetInterfaces();
                    object obj = Activator.CreateInstance(type);
                    _dict.GetorAdd(type,obj);

                    foreach (Type interfaceType  interfaceTypeArr)
                    {
                        if (interfaceType != (IService))
                        {
                            _dict.GetorAdd(interfaceType,obj);
                        }
                    }
                }
            }
            logTimeUtil.LogTime("ServiceHelper.Registerassembly 注册程序集 " + assemblyString +  耗时");
        }
        #region 启动所有服务
         启动所有服务
        static Task StartAllService()
        {
            return Task.Run(() =>
            {
                List<Task> taskList = new List<Task>();
                foreach (object o  _dict.Values.distinct())
                {
                    Task task = Task.Factory.StartNew(obj =>
                    {
                        IService service = obj as IService;

                        try
                        {
                            service.OnStart();
                            LogUtil.Log(服务 " + obj.GetType().FullName +  已启动);
                        }
                        catch (Exception ex)
                        {
                            LogUtil.Error(ex, 启动失败);
                        }
                    },o);
                    taskList.Add(task);
                }
                Task.WaitAll(taskList.ToArray());
            });
        }
        #region 停止所有服务
         停止所有服务
         Task StopAllService()
        {
            ();
                Type iServiceInterfaceType = (IService);
                
                    {
                        if (iServiceInterfaceType.IsAssignableFrom(obj.GetType()))
                        {
                            IService service = obj  IService;

                            
                            {
                                service.OnStop();
                                LogUtil.Log( 已停止).Wait();
                            }
                             (Exception ex)
                            {
                                LogUtil.Error(ex,1)"> 停止失败).Wait();
                            }
                        }
                    },1)">#endregion

    }
}

View Code

说明：

Registerassembly方法：注册实现类，只要程序集中的类实现了某个接口，就注册，把它的类型以及接口的类型作为Key添加到字典中，以接口类型作为Key的时候，过滤掉IService这个接口。

StartAllService方法：调用所有服务的OnStart方法。

StopAllService方法：调用所有服务的OnStop方法。

如何使用：

服务的注册与启动：

ServiceHelper.Registerassembly((MyActionFilter));
ServiceHelper.StartAllService().Wait();

View Code

说明：Registerassembly方法的参数，传递程序集中任何一个类型即可。

服务的停止：

ServiceHelper.StopAllService().Wait();

View Code

服务的定义：

 Models;
 Newtonsoft.Json;
 NetWebApi.DAL;
 System.IO;
 System.Net;
 System.Threading;
 System.Timers;
 System.Web;
 Utils;
 System.Configuration;

 NetWebApi.BLL
{
     通用
     CommonBll : AbstractService
    {
        #region OnStart 服务启动
        override  OnStart()
        {

        }
        #region OnStop 服务停止
         OnStop()
        {

        }
        

    }
}

View Code

调用服务：

CommonBll commonBll = ServiceHelper.Get<CommonBll>();

View Code

临时注册并调用服务：

SaveDataBll m_SaveDataBll = ServiceHelper.Get<SaveDataBll>();

View Code