在WebApi 中使用AutoFac (二)

WebApi 中使用AutoFac  (一)

前篇说了怎么使用AutoFac,但是还存在一个问题，就是一个接口多个实现类的时候，怎么区分实现类？

解决办法有很多，有 Named<T>等等，但是都需要去分别单独注册，少的话可以，多了就有点儿麻烦了。

最后决定利用泛型解决该问题。

第一步：新增一个实现类：UsersRepository2

    public interface IUsersRepository
    {
        int GetUserIsExists(UsersEntity criteria);

    }

    //实现类1
    public class UsersRepository : IUsersRepository
    {
        Logger log = LogManager.GetLogger("UsersRepository");

        /// <summary>
        /// 获取用户是否存在
        /// </summary>
        /// <param name="criteria"></param>
        /// <returns></returns>
        public int GetUserIsExists(UsersEntity criteria)
        {
            string sql = "。。。。";
            。。。。。
        }
    }

    //实现类2
    public class UsersRepository2 : IUsersRepository
    {
        Logger log = LogManager.GetLogger("UsersRepository2");

        /// <summary>
        /// 获取用户是否存在
        /// </summary>
        /// <param name="criteria"></param>
        /// <returns></returns>
        public int GetUserIsExists(UsersEntity criteria)
        {
            string sql = "。。。。";
            。。。。。
        }
    }

第二步：调整服务接口和实现类

    public enum UsersType
    {
        /// <summary>
        /// 实现类1
        /// </summary>
        [Description("实现类1")]
        UsersRepository = 1,
        /// <summary>
        /// 实现类2
        /// </summary>
        [Description("实现类2")]
           UsersRepository2 = 2,
      }

    //调整服务接口  
    public interface IUsersService
    {
        int GetUserIsExists<T>(T t, UsersEntity criteria);   //这里改为泛型方法
    }

    //调整实现类
    public class UsersService : IUsersService
    {
        //这里改为使用 IEnumerable<T>类型
        private readonly IEnumerable<IUsersRepository> _usersrepository;
        public UsersService(IEnumerable<IUsersRepository> usersrepository)
        {
            _usersrepository = usersrepository;
        }

        /// <summary>
        /// 获取用户是否存在
        /// </summary>
        /// <param name="criteria"></param>
        /// <returns></returns>
        public int GetUserIsExists<T>(T t, UsersEntity criteria)
        {
            //根据泛型T 获取想要的实例对象
            var getinstance = _usersrepository.Where(ob => ob.GetType().Name == t.ToString()).FirstOrDefault();  //获取指定实例
            if (getinstance != null)
            {
                return getinstance.GetUserIsExists(criteria);
            }
            return 0;
        }
    }

第三步：测试

    public class UsersController : ApiController
    {
        private readonly IUsersService _usersService;
        public UsersController(IUsersService usersService)
        {
            _usersService = usersService;
        }


        /// <summary>
        /// 获取用户是否存在
        /// </summary>
        /// <param name="username"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        [HttpPost]
        public IHttpActionResult GetUserIsExists(string username, string password)
        {
            //验证是否存在当前用户
            var obModel = new UsersEntity()
            {
                Username = username,
                Password = Encryption.MD5(password)
            };

            //这里调用时，传入枚举：UsersType.UsersRepository 或 UsersType.UsersRepository2
            var getresult = _usersService.GetUserIsExists(UsersType.UsersRepository, obModel);

            return Json(new { isexists = getresult > 0 });
        }


    }

我们分别把两个实现类都打上断点，

当传 UsersType.UsersRepository 时，UsersRepository类的断点进来了，

 当传 UsersType.UsersRepository2 时，UsersRepository2类的断点进来了，

当然，这里是分开执行实现类的，如果你想执行全部的实现类，只需要把服务类里边的泛型筛选去掉就行了

例如：

    public class UsersService : IUsersService
    {
        //这里改为使用 IEnumerable<T>类型
        private readonly IEnumerable<IUsersRepository> _usersrepository;
        public UsersService(IEnumerable<IUsersRepository> usersrepository)
        {
            _usersrepository = usersrepository;
        }

        /// <summary>
        /// 获取用户是否存在
        /// </summary>
        /// <param name="criteria"></param>
        /// <returns></returns>
        public int GetUserIsExists<T>(T t, UsersEntity criteria)
        {
            //根据泛型T 获取想要的实例对象
            //var getinstance = _usersrepository.Where(ob => ob.GetType().Name == t.ToString()).FirstOrDefault();  //获取指定实例
            //if (getinstance != null)
            //{
            //    return getinstance.GetUserIsExists(criteria);
            //}

            //这里调整代码为 执行全部的实现类
            var getresult = 0;
            _usersrepository.ToList().ForEach(item =>
            {
                var gettype = item.GetType().Name;
                switch (gettype)
                {
                    case "UsersRepository":
                        //其他业务逻辑
                        getresult = item.GetUserIsExists(criteria);
                        break;
                    //case 2 .....
                    //case 3 .....
                    default:
                        break;
                }
            });
            return 0;
        }
    }

结束。