C# 计算每周和每月固定日期

最近发现写程序不是简单的实现功能，过程中偶尔伴随者一点小小的算法，比如排序算法，比如周期性的数据等等，发现算法不仅仅需要考虑全面，而且要计算简便、性能优良，而我远远没有达到要求！

一：周、月固定日期

        /// <summary>
        /// 保洁计划按周获取日期
        /// </summary>
        /// <param name="startDate">开始时间</param>
        /// <param name="endDate">结束时间</param>
        /// <param name="date">周开始日期</param>
        /// <returns></returns>
        public List<DateTime> GetListDatekForCleanPlan(DateTime startDate, DateTime endDate, int date, int cycle)
        {
            //算法：通过计算开始时间(startdate)与规定开始周期（date）的差
            //      将开始时间增加至第一个周期的开始时间,然后循环得出每周的一个时间
            //周：每周按照七天计算
            //月：需要考虑最大天数不一致，原则采用设置天数和最大天数的比较值
            //计算开始时间和规定时间之间的差值

            List<DateTime> listdate = new List<DateTime>();
            if (cycle == )//周
            {
                int dayString = (int)startDate.DayOfWeek - date;
                //将开始时间增加到第一个周期的第一天
                if (dayString >= )
                {
                    startDate = startDate.AddDays( - dayString);
                }
                else
                {
                    startDate = startDate.AddDays(-dayString);
                }
                while (startDate <= endDate)
                {
                    if (startDate.Date >= DateTime.Now.Date)
                    {
                        break;//今日之前不添加保洁记录
                    }
                    listdate.Add(startDate);
                    startDate = startDate.AddDays();
                }
            }
            else//月
            {
                int dayString = (int)startDate.Day - date;
                if (dayString >= )//本月不加保洁，直接开始下月
                {
                    startDate = Convert.ToDateTime(startDate.Year + "-" + startDate.AddMonths().Month + "-" + startDate.Day);//加一个月
                }

                while (startDate <= endDate)//这里的算法有问题
                {

                    DateTime cleandate = new DateTime();
                    //判断当月最大天数是否大于指定日期，如果当月没有指定日期就按照最大一天安排打扫
                    if (date <= DateTime.DaysInMonth(startDate.Year, startDate.Month))
                    {
                        cleandate = Convert.ToDateTime(startDate.Year + "-" + startDate.Month + "-" + date);
                    }
                    else
                    {
                        cleandate = Convert.ToDateTime(startDate.Year + "-" + startDate.Month + "-" + DateTime.DaysInMonth(startDate.Year, startDate.Month));
                    }
                    if (cleandate.Date <= DateTime.Now.Date)
                    {
                        startDate = startDate.AddMonths();
                        continue;//今日之前不添加保洁记录
                    }
                    listdate.Add(cleandate);
                    startDate = startDate.AddMonths();
                }
            }
            return listdate;
        }

这个写法待整理

---

二：上下排序算法

在一个小功能中用到，需要对列表展示数据可上移一位可下移一位，而且考虑可用与不可用属性

修改排序：

 /// <summary>
         /// 支付方式排序
         /// </summary>
         /// <param name="ID">当前id</param>
         /// <param name="isUp">true->上移；false->下移</param>
         /// <returns></returns>
         public bool ChangePaymentTypeLevel(int ID, bool isUp)
         {
             //排序分为两部分，第一:有效记录中可以对记录上移一位和下移一位
             //第二：无效记录重新排序，排在有效记录后
             //通过两个规则完成，无效记录在后，有效记录在前，可以对有效记录调整顺序的操作
             try
             {
                 using (var trans = new TransactionScope())
                 {
                     using (var dbContext = new ConfigDbContext())
                     {
                         var commerid = ConfigManager.GetCurrentLoginInfoCommercialTenantID();//商户id
                         IEnumerable<PaymentType> paymentlist = dbContext.PaymentType.Where(p => p.CommercialTenantID == commerid).OrderBy(p => p.Level).ToList();//全部记录
                         var status = (byte)EnumPaymentTypeStatus.valid;//有效状态
                         var thispayment = paymentlist.Where(p => p.ID == ID).FirstOrDefault();//本条记录
                         if (paymentlist != null && thispayment != null && thispayment.Status == status)
                         {
                             var paymentstatuscount = paymentlist.Where(p => p.Status == status).Count();//总记录数
                             if ((thispayment.Level < paymentstatuscount && !isUp) || thispayment.Level !=  && isUp)//上升和下降的时候都不是不可操作的那一个
                             {
                                 //对本身和相邻记录进行调换等级（排序）start
                                 var thislevel = thispayment.Level;//本等级
                                 byte changelevel = ;//需要改变的等级，上移时意味着上一条记录的等级，下移时意味着下一条记录的等级，这里通过等级去寻找记录
                                 if (isUp)//上移
                                 {
                                     changelevel = Convert.ToByte(thispayment.Level - );//上一条记录等级
                                 }
                                 else//下移
                                 {
                                     changelevel = Convert.ToByte(thispayment.Level + );//下一条记录等级
                                 }
                                 var changepayment = paymentlist.Where(p => p.Level == changelevel).FirstOrDefault();//需要改变的记录
                                 dbContext.PaymentType.Where(p => p.ID == changepayment.ID).Update(p => new PaymentType() { Level = thislevel });//改变相邻记录等级
                                 dbContext.PaymentType.Where(p => p.ID == thispayment.ID).Update(p => new PaymentType() { Level = changelevel });//改变本条记录等级
                                 //对本身和相邻记录进行调换等级（排序）end

                                 //修改剩余支付类型排序，自增长
                                 var otherpayment = paymentlist.Where(p => p.Status != status).ToList();//获取无效状态的记录
                                 foreach (var item in otherpayment)
                                 {
                                     item.Level = (byte)(otherpayment.IndexOf(item) +  + paymentstatuscount);//修改排序等级自增长：本身位数加总的有效状态总数
                                     dbContext.Update(item,false);
                                 }
                                 dbContext.SaveChanges();
                                 trans.Complete();
                                 return true;
                             }
                             else
                             {
                                 //无聊的客户将最后一个有效的支付方式下移，告诉他成功了！
                                 //第一个还要上移，告诉他成功了！
                                 //页面最后对第一条和最后一条进行了限制不能修改排序（删除排序操作按钮，哈哈）
                                 return true;
                             }
                         }
                         else
                         {
                             //有效且是第一个
                             return false;
                         }
                     }
                 }
             }
             catch (Exception es)
             {
                 return false;
             }
         }

修改状态-调整排序

/// <summary>
        /// 更新支付类型状态
        /// </summary>
        /// <param name="ID"></param>
        /// <returns></returns>
        public bool ChangePaymentTypeStatus(int ID)
        {
            //1：修改有效状态的排序
            //2：修改本身记录的排序
            //3：修改无效状态的排序
            //4：本记录不在有效无效列表记录中计算
            try
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    using (var dbContext = new ConfigDbContext())
                    {
                        var paymenttype = dbContext.PaymentType.Find(ID);//本条记录
                        if (paymenttype != null)
                        {
                            //实时的状态信息，不考虑并发，状态转换
                            var status = paymenttype.Status == (byte)EnumPaymentTypeStatus.valid ? (byte)EnumPaymentTypeStatus.invalid : (byte)EnumPaymentTypeStatus.valid;
                            var commerid = ConfigManager.GetCurrentLoginInfoCommercialTenantID();//商户id
                            var paymentlist = dbContext.PaymentType.Where(p => p.CommercialTenantID == commerid).ToList();//全部列表
                            //有效且非本身按照等级排序
                            var paymentstatuslist = paymentlist.Where(p => p.Status == (byte)EnumPaymentTypeStatus.valid & p.ID != ID).OrderBy(p => p.Level).ToList();
                            //有效状态，从1开始重新排序
                            foreach (var item in paymentstatuslist)
                            {
                                item.Level = (byte)(paymentstatuslist.IndexOf(item) + );
                                dbContext.Update(item, false);
                            }
                            dbContext.SaveChanges();
                            //本身这条记录的排序，等于除了本身之外的有效状态总数加1
                            dbContext.PaymentType.Where(p => p.ID == ID).Update(p => new PaymentType() { Status = status, Level = (byte)(paymentstatuslist.Count() + ) });
                            //无效状态除本条记录列表
                            var paymentinvalidlist = paymentlist.Where(p => p.Status == (byte)EnumPaymentTypeStatus.invalid & p.ID != ID).OrderBy(p => p.Level).ToList();
                            foreach (var item in paymentinvalidlist)
                            {
                                item.Level = (byte)(paymentinvalidlist.IndexOf(item) +  + paymentstatuslist.Count() + );
                                dbContext.Update(item, false);
                            }
                            dbContext.SaveChanges();
                            scope.Complete();
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
            }
            catch (Exception)
            {
                return false;
            }
        }

---