基础才是重中之重~这时应该用泛型方法了

​​回到目录​​

泛型方法：是一个抽象的概念，将批量具有共性的操作进行抽象，使用泛型类型来表示这个方法，实现这些类型的方法具有相同的逻辑，而唯一不同的是，它们的类型，即类型在泛型方法里是个变量，这话感觉是用肺说出来的，呵呵！

今天在做开发时，遇到了这个问题，最后重构了自己的代码，重构后，使用了泛型方法，感觉代码美丽多了

没用泛型方法前

/// <summary>
        /// 更新老师与学生的关系
        /// </summary>
        /// <param name="list">要插入的关系列表</param>
        /// <param name="isAll">是否为全部，如果全部，不需要向关系表插入</param>
        /// <param name="teacherId">当前老师ＩＤ</param>
        /// <param name="type">类型：０视频，１作业，３文档</param>
        public void AddUser_Source_R(List<User_Source_R> list, bool isAll, int teacherId, int objId, int objType)
        {

            switch (objType)
            {
                case 0:
                    var respository1 = LoadRepository<Classroom_Info>();
                    var entity1 = LoadRepository<Classroom_Info>().Find(objId);
                    if (isAll)
                    {
                        entity1.AccessStatus = 0;
                        respository1.Update(entity1);
                    }
                    else
                    {
                        entity1.AccessStatus = 1;
                        respository1.Update(entity1);
                        LoadRepository<User_Source_R>().Insert(list);
                    }
                    break;
                case 1:
                    var respository2 = LoadRepository<Courseware_Info>();
                    var entity2 = LoadRepository<Courseware_Info>().Find(objId);
                    if (isAll)
                    {
                        entity2.AccessStatus = 0;
                        respository2.Update(entity2);
                    }
                    else
                    {
                        entity2.AccessStatus = 1;
                        respository2.Update(entity2);
                        LoadRepository<User_Source_R>().Insert(list);
                    }
                    break;
                case 2:
                    var respository3 = LoadRepository<Task_Info>();
                    var entity3 = LoadRepository<Task_Info>().Find(objId);
                    if (isAll)
                    {
                        entity3.AccessStatus = 0;
                        respository3.Update(entity3);
                    }
                    else
                    {
                        entity3.AccessStatus = 1;
                        respository3.Update(entity3);
                        LoadRepository<User_Source_R>().Insert(list);
                    }
                    break;
                case 3:
                    var respository4 = LoadRepository<Substance_Info>();
                    var entity4 = LoadRepository<Substance_Info>().Find(objId);
                    if (isAll)
                    {
                        entity4.AccessStatus = 0;
                        respository4.Update(entity4);
                    }
                    else
                    {
                        entity4.AccessStatus = 1;
                        respository4.Update(entity4);
                        LoadRepository<User_Source_R>().Insert(list);
                    }
                    break;
                default:
                    throw new ArgumentException();
            }


        }

用了泛型方法后

/// <summary>
        /// 更新老师与学生的关系
        /// </summary>
        /// <param name="list">要插入的关系列表</param>
        /// <param name="isAll">是否为全部，如果全部，不需要向关系表插入</param>
        /// <param name="teacherId">当前老师ＩＤ</param>
        /// <param name="type">>资源类型０课程，１视频，２作业，３文档</param>
        public void AddUser_Source_R(
            List<User_Source_R> list,
            bool isAll,
            int objId,
            int objType)
        {
            switch (objType)
            {
                case 0:
                    UpdateSource_R<Classroom_Info>(list, isAll, objId);
                    break;
                case 1:
                    UpdateSource_R<Courseware_Info>(list, isAll, objId);
                    break;
                case 2:
                    UpdateSource_R<Task_Info>(list, isAll, objId);
                    break;
                case 3:
                    UpdateSource_R<Substance_Info>(list, isAll, objId);
                    break;
                default:
                    throw new ArgumentException();
            }


        }

        /// <summary>
        /// 泛型方法来干这逻辑相同，只是类型不同的事情
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="list"></param>
        /// <param name="isAll"></param>
        /// <param name="teacherId"></param>
        /// <param name="objId"></param>
        /// <param name="objType"></param>
        void UpdateSource_R<TEntity>(
            List<User_Source_R> list,
            bool isAll,
            int objId)
            where TEntity : class, IAccess
        {
            var entity = LoadRepository<TEntity>().Find(objId);
            if (isAll)
            {
                entity.AccessStatus = 0;
                LoadRepository<TEntity>().Update(entity);
            }
            else
            {
                entity.AccessStatus = 1;
                LoadRepository<TEntity>().Update(entity);
                LoadRepository<User_Source_R>().Insert(list);
            }
        }

我们可以看是，泛型方法把不变的逻辑抽象在一起，这样，有利于代码的扩展和维护，这才是面向对象的代码！

​​回到目录​​

作者：仓储大叔，张占岭，
荣誉：微软MVP