C#随机生成

最新推荐文章于 2022-12-18 15:16:28 发布

刘梦凡呀

最新推荐文章于 2022-12-18 15:16:28 发布

阅读量439

点赞数

文章标签： c# java 前端

本文链接：https://blog.csdn.net/qq_42782011/article/details/127420631

版权

需求：两个筛选类型，N个评估任务，每个任务随机分配用户指定的专家数量。

思路：查出满足类型一和二的专家数量，然后分别存入对应的数组

接下来遍历数组：

     //遍历任务List
                foreach (var item in TaskNumber)
                {
                    List<string> ExpertId = new List<string>();
                    //类型一取多少位专家,组装模型
                    for (int i = 0; i < model.OneNumber; i++)
                    {
                        //分完为止
                        if (Expert != null && Expert.Count > 0)
                        {
                            //随机取一位专家，定义随机数
                            Random rd = new Random();
                            int Index = rd.Next(Expert.Count);
                            //随机选中一个
                            var con = Expert[Index];
                            ExpertId.Add(con.Id);
                            //删除数组对应的数据，防止随机重复
                            Expert.Remove(con);
                            //组装模型
                            TaskModel.Add(new AssessorsEntity
                            {
                               Id=item.Id,
                               UserId=con.Id,
                                PostId="4",
                                Name=con.FullName,
                                CreateUser=UserName,
                                CreateTime=DateTime.Now,
                                ISBXPGYJ=0,
                                ISZT=0,
                                ZTLXMSTR=null,
                                CompileReport=0

                            });
                        }
                        else 
                        {
                            ExceptionHelper.ThrowIfFalse(1 > 1, "符合类型一筛选条件的专家数量不足！");
                        }
                    }

                    //类型二取多少位专家,组装模型
                    for (int i = 0; i < model2.OneNumber; i++)
                    {
                        //先排除类型一已经分过任务的专家
                        var Expert1 = ExpertTwo.Where(p => !ExpertId.Contains(p.Id)).ToList();
                        //分完为止
                        if (Expert1 != null && Expert1.Count > 0)
                        {
                            //随机取一位专家，定义随机数
                            Random rd = new Random();
                            //随机数范围  在0-Expert1.Count中的任意一个数字
                            int Index = rd.Next(Expert1.Count);
                            //随机选中一个
                            var con = Expert1[Index];
                            //删除数组对应的数据，防止随机重复
                            Expert1.Remove(con);
                            //组装模型
                            TaskModel.Add(new AssessorsEntity
                            {
                                Id = item.Id,
                                UserId = con.Id,
                                PostId = "4",
                                Name = con.FullName,
                                CreateUser = UserName,
                                CreateTime = DateTime.Now,
                                ISBXPGYJ = 0,
                                ISZT = 0,
                                ZTLXMSTR = null,
                                CompileReport = 0

                            });
                        }
                        else 
                        {
                            ExceptionHelper.ThrowIfFalse(1 > 1, "符合类型二筛选条件的专家数量不足！");
                        }
                    }
                }

为了确保不重复，需要在随机生成后，移除数组对应的随机数。

全部代码：

       /// <summary>
        /// 随机分配专家
        /// </summary>
        /// <param name="distinctCode"></param>
        /// <param name="PlanId"></param>
        /// <param name="model"></param>
        /// <param name="model2"></param>
        /// <returns></returns>
        public int AutomaticExpert(string distinctCode, string PlanId,string UserName, PgTaskAutomatic model, PgTaskAutomatic model2)
        {
            //定义模型
            List<AssessorsEntity> TaskModel = new List<AssessorsEntity>();

            using (var db = SqlSugarConfig.DB_Insert_DbConnection)
            {
                //任务数量
                var TaskNumber = db.Queryable<PgTaskEntity>().Where(p => p.DistrictCode == distinctCode && p.PlanId == PlanId && p.IsAutomatic == "1").ToList();

                //类型一
                var Expert = db.Queryable<UserEntity, ArchivesEntity>((a, b) => new object[]
                   {
                       JoinType.Inner,a.Name==b.Name
                  })
                    .Where((a, b) => a.DistrictCode == distinctCode
                    &&(string.IsNullOrEmpty(model.OneDX) || b.DX.Contains(model.OneDX))
                    &&(string.IsNullOrEmpty(model.OneDZ) || b.DZ.Contains(model.OneDZ))
                    &&(string.IsNullOrEmpty(model.OnePGJC) || b.Monitor.Contains(model.OnePGJC))
                    &&(string.IsNullOrWhiteSpace(model.OneQT) || b.Other.Contains(model.OneQT))
                    &&(string.IsNullOrWhiteSpace(model.OneZW) || b.Post.Contains(model.OneZW))
                    &&(string.IsNullOrWhiteSpace(model.OneZC) || b.Titles.Contains(model.OneZC))
                    &&(string.IsNullOrWhiteSpace(model.OneZJLX) || b.ExpertType.Contains(model.OneZJLX)))
                .Select((a, b) => new ArchivesEntity
                 {
                     Id = a.Guid,
                     Name = a.Name,
                     FullName = a.FullName,
                 }).ToList();



                //类型二
                var ExpertTwo = db.Queryable<UserEntity, ArchivesEntity>((a, b) => new object[]
                   {
                       JoinType.Inner,a.Name==b.Name
                   })
                   .Where((a, b) => a.DistrictCode == distinctCode 
                   &&(string.IsNullOrEmpty(model2.OneDX) || b.DX.Contains(model2.OneDX))
                   &&(string.IsNullOrEmpty(model2.OneDZ) || b.DZ.Contains(model2.OneDZ))
                   &&(string.IsNullOrEmpty(model2.OnePGJC) || b.Monitor.Contains(model2.OnePGJC))
                   &&(string.IsNullOrWhiteSpace(model2.OneQT) || b.Other.Contains(model2.OneQT))
                   &&(string.IsNullOrWhiteSpace(model2.OneZW) || b.Post.Contains(model2.OneZW))
                   &&(string.IsNullOrWhiteSpace(model2.OneZC) || b.Titles.Contains(model2.OneZC))
                   &&(string.IsNullOrWhiteSpace(model2.OneZJLX) || b.ExpertType.Contains(model2.OneZJLX)))
                   .Select((a, b) => new ArchivesEntity
                 {
                     Id = a.Guid,
                     Name = a.Name,
                     FullName=a.FullName,
                     
                 }).ToList();
                //遍历任务数量
                foreach (var item in TaskNumber)
                {
                    List<string> ExpertId = new List<string>();
                    //类型一取多少位专家,组装模型
                    for (int i = 0; i < model.OneNumber; i++)
                    {
                        //分完为止
                        if (Expert != null && Expert.Count > 0)
                        {
                            //随机取一位专家，定义随机数
                            Random rd = new Random();
                            int Index = rd.Next(Expert.Count);
                            //随机选中一个
                            var con = Expert[Index];
                            ExpertId.Add(con.Id);
                            //删除数组对应的数据，防止随机重复
                            Expert.Remove(con);
                            //组装模型
                            TaskModel.Add(new AssessorsEntity
                            {
                               Id=item.Id,
                               UserId=con.Id,
                                PostId="4",
                                Name=con.FullName,
                                CreateUser=UserName,
                                CreateTime=DateTime.Now,
                                ISBXPGYJ=0,
                                ISZT=0,
                                ZTLXMSTR=null,
                                CompileReport=0

                            });
                        }
                        else 
                        {
                            ExceptionHelper.ThrowIfFalse(1 > 1, "符合类型一筛选条件的专家数量不足！");
                        }
                    }

                    //类型二取多少位专家,组装模型
                    for (int i = 0; i < model2.OneNumber; i++)
                    {
                        //先排除类型一已经分过任务的专家
                        var Expert1 = ExpertTwo.Where(p => !ExpertId.Contains(p.Id)).ToList();
                        //分完为止
                        if (Expert1 != null && Expert1.Count > 0)
                        {
                            //随机取一位专家，定义随机数
                            Random rd = new Random();
                            int Index = rd.Next(Expert1.Count);
                            //随机选中一个
                            var con = Expert1[Index];
                            //删除数组对应的数据，防止随机重复
                            Expert1.Remove(con);
                            //组装模型
                            TaskModel.Add(new AssessorsEntity
                            {
                                Id = item.Id,
                                UserId = con.Id,
                                PostId = "4",
                                Name = con.FullName,
                                CreateUser = UserName,
                                CreateTime = DateTime.Now,
                                ISBXPGYJ = 0,
                                ISZT = 0,
                                ZTLXMSTR = null,
                                CompileReport = 0

                            });
                        }
                        else 
                        {
                            ExceptionHelper.ThrowIfFalse(1 > 1, "符合类型二筛选条件的专家数量不足！");
                        }
                    }
                }
                //新增任务 jc
                var result = db.Insertable(TaskModel).ExecuteCommand();
                return result;
            }
        }