C# C每周第二天逻辑

我在提高代码的效率方面遇到了一些问题；我正在编写一个基本的计划程序，希望知道从当前日期到下一次运行之间的天数。我所拥有的一切都是有效的，但对于一项简单的任务来说，它似乎是巨大的

我设定了一周中我想在课堂上使用bools的天数

这就是我所拥有的：

class Schedule
{
    public string StartTime;
    public bool Monday;
    public bool Tuesday;
    public bool Wednesday;
    public bool Thursday;
    public bool Friday;
    public bool Saturday;
    public bool Sunday;
} 

Schedule jobSchedule = new Schedule();

jobSchedule.Monday = true;
jobSchedule.Tuesday = true;
jobSchedule.Wednesday = false;
jobSchedule.Thursday = true;
jobSchedule.Friday = true;
jobSchedule.Saturday = true;
jobSchedule.Sunday = true;

这将在我希望代码运行时设置。我现在想要的是一个函数，返回下一次执行的天数的整数。。。我有以下资料：

   private int nextDay()
    {
        int days = 0;
        DayOfWeek dow = DateTime.Now.DayOfWeek;

        switch (dow)
        {
            case DayOfWeek.Monday:
                if (jobSchedule.Tuesday) {
                    days += 1;
                } else if (jobSchedule.Wednesday) {
                    days += 2;
                } else if (jobSchedule.Thursday) {
                    days += 3;
                } else if (jobSchedule.Friday) {
                    days += 4;
                } else if (jobSchedule.Saturday) { 
                    days += 5;
                } else if (jobSchedule.Sunday) {
                    days += 6;
                }
        break;
            case DayOfWeek.Tuesday:
                if (jobSchedule.Wednesday)
                {
                    days += 1;
                }
                else if (jobSchedule.Thursday)
                {
                    days += 2;
                }
                else if (jobSchedule.Friday)
                {
                    days += 3;
                }
                else if (jobSchedule.Saturday)
                {
                    days += 4;
                }
                else if (jobSchedule.Sunday)
                {
                    days += 5;
                }
                else if (jobSchedule.Monday)
                {
                    days += 6;
                }
                break;
            case DayOfWeek.Wednesday:
                if (jobSchedule.Thursday)
                {
                    days += 1;
                }
                else if (jobSchedule.Friday)
                {
                    days += 2;
                }
                else if (jobSchedule.Saturday)
                {
                    days += 3;
                }
                else if (jobSchedule.Sunday)
                {
                    days += 4;
                }
                else if (jobSchedule.Monday)
                {
                    days += 5;
                }
                else if (jobSchedule.Tuesday)
                {
                    days += 6;
                }
                break;
            case DayOfWeek.Thursday:
                if (jobSchedule.Friday)
                {
                    days += 1;
                }
                else if (jobSchedule.Saturday)
                {
                    days += 2;
                }
                else if (jobSchedule.Sunday)
                {
                    days += 3;
                }
                else if (jobSchedule.Monday)
                {
                    days += 4;
                }
                else if (jobSchedule.Tuesday)
                {
                    days += 5;
                }
                else if (jobSchedule.Wednesday)
                {
                    days += 6;
                }
                break;
            case DayOfWeek.Friday:
                if (jobSchedule.Saturday)
                {
                    days += 1;
                }
                else if (jobSchedule.Sunday)
                {
                    days += 2;
                }
                else if (jobSchedule.Monday)
                {
                    days += 3;
                }
                else if (jobSchedule.Tuesday)
                {
                    days += 4;
                }
                else if (jobSchedule.Wednesday)
                {
                    days += 5;
                }
                else if (jobSchedule.Thursday)
                {
                    days += 6;
                }
                break;
            case DayOfWeek.Saturday:
                if (jobSchedule.Sunday)
                {
                    days += 1;
                }
                else if (jobSchedule.Monday)
                {
                    days += 2;
                }
                else if (jobSchedule.Tuesday)
                {
                    days += 3;
                }
                else if (jobSchedule.Wednesday)
                {
                    days += 4;
                }
                else if (jobSchedule.Thursday)
                {
                    days += 5;
                }
                else if (jobSchedule.Friday)
                {
                    days += 6;
                }
                break;
            case DayOfWeek.Sunday:
                if (jobSchedule.Monday)
                {
                    days += 1;
                }
                else if (jobSchedule.Tuesday)
                {
                    days += 2;
                }
                else if (jobSchedule.Wednesday)
                {
                    days += 3;
                }
                else if (jobSchedule.Thursday)
                {
                    days += 4;
                }
                else if (jobSchedule.Friday)
                {
                    days += 5;
                }
                else if (jobSchedule.Saturday)
                {
                    days += 6;
                }
                break;
        }

        return days;
    }

我怎么能把它短路？以上内容符合我的要求，但似乎太多了：

---

谢谢你的帮助。

好吧，我本想做的是改变日程安排，举行一天的工作，而不是所有这些布尔人，但假设这是不可能的，你可以这样做

 private static DayOfWeek ToDayOfWeek(this Schedule schedule, DayOfWeek today)
    {
        while(true)

        {
            if(schedule.Monday && (int)today < (int)DayOfWeek.Monday)
                return DayOfWeek.Monday;
            if(schedule.Tuesday && (int)today < (int)DayOfWeek.Tuesday)
                return DayOfWeek.Tuesday;
            if(schedule.Wednesday&& (int)today < (int)DayOfWeek.Wednesday)
                return DayOfWeek.Wednesday;
            if(schedule.Thursday&& (int)today < (int)DayOfWeek.Thursday)
                return DayOfWeek.Thursday;
            if(schedule.Friday&& (int)today < (int)DayOfWeek.Friday)
                return DayOfWeek.Friday;
            if(schedule.Saturday&& (int)today < (int)DayOfWeek.Saturday)
                return DayOfWeek.Saturday;
            if(schedule.Sunday&& (int)today < (int)DayOfWeek.Sunday)
                return DayOfWeek.Sunday;

            today = (DayOfWeek)(Math.Abs((int)today - 1));
        }
    }

private int DifferenceInDays(DayOfWeek left, DayOfWeek right)
{
     if((left == DayOfWeek.Sunday || right == DayOfWeek.Sunday) && (right == DayOfWeek.Saturday || left == DayOfWeek.Saturday))
     {
        return 1;
     }

     return Math.Abs((int)left - (int)right);
 }


private int nextDay()
{
        int days = 0;
        DayOfWeek dow = DateTime.Now.DayOfWeek;
       return DifferenceInDays(dow, schedule.ToDayOfWeek(dow));
}

---

首先，您应该使用枚举，而不是在7个变量和DateTime之间拆分相同的逻辑来存储开始时间。关于枚举，DayOfWeek是一个很好的起点，但它没有允许位标志操作的Flags属性。。。所以我建议你实施你自己的

[Flags]
public enum ScheduleDays
{
    None = 0x00,
    Monday = 0x01,
    Tuesday = 0x02,
    Wednesday = 0x04,
    Thursday = 0x08,
    Friday = 0x10,
    Saturday = 0x20,
    Sunday = 0x40,
    All = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday
}

public class Schedule
{
    public DateTime Start;
    public ScheduleDays Days; // ScheduleDay.None by default
} 

这是一个用法示例：

// all days except wednesday
Schedule s = new Schedule();
s.Days = ScheduleDays.All & ~ScheduleDays.Wednesday;

为了计算到下一个计划日的天数，我将使用以下方法：

private static Int32 NextRunDays(ScheduleDays days)
{
    if ((Int32)days == 0)
        return -1;

    ScheduleDays[] values = (ScheduleDays[])Enum.GetValues(typeof(ScheduleDays));
    List<Int32> scheduledDays = new List<Int32>(values.Length);

    foreach (ScheduleDays scheduledDay in values)
    {
        Int32 scheduledDayValue = (Int32)scheduledDay;

        if ((scheduledDayValue == 0) || (scheduledDayValue == (Int32)ScheduleDays.All))
            continue;

        if (!days.HasFlag(scheduledDay))
            continue;

        scheduledDays.Add(Array.IndexOf(values, scheduledDay) - 1);
    }

    scheduledDays = scheduledDays.OrderBy(x => x).ToList();

    Int32 dowValue = (Int32)DateTime.Now.DayOfWeek;

    if (dowValue == 0)
        dowValue = 6;
    else
        dowValue -= 1;

    List<Int32> scheduledDaysNext = scheduledDays.Where(x => x >= dowValue).ToList();
    Int32 nextDayValue = ((scheduledDaysNext.Count > 0) ? scheduledDaysNext.First() : scheduledDays.First());

    return ((nextDayValue - dowValue + 7) % 7);
}

---

你可以尝试一个工作例子。

假设你不能改变你的日程安排，我会考虑这样的事情：

    private int NextDay(Schedule jobSchedule)
    {
        var availableSchedules = new[]
        {
            new {Position = 0, Enabled = jobSchedule.Sunday },
            new {Position = 1, Enabled = jobSchedule.Monday },
            new {Position = 2, Enabled = jobSchedule.Tuesday },
            new {Position = 3, Enabled = jobSchedule.Wednesday },
            new {Position = 4, Enabled = jobSchedule.Thursday },
            new {Position = 5, Enabled = jobSchedule.Friday },
            new {Position = 6, Enabled = jobSchedule.Saturday }
        };

        var currentDayOfWeek = (int)DateTime.Now.DayOfWeek;
        var currentPosition = currentDayOfWeek + 1;
        var requiredDays = 1;

        //Optional. incase nothing is enabled
        if (!availableSchedules.Any(x => x.Enabled))
        {
            throw new ArgumentException(nameof(jobSchedule));
        }
        //End Optional. incase nothing is enabled

        do
        {
            var nextSchedule = availableSchedules.First(s => s.Position == currentPosition);

            if (nextSchedule.Enabled)
            {
                break;
            }

            requiredDays++;
            currentPosition++;

            if (currentPosition > 6) //incase we go to the following week. Reset
            {
                currentPosition = 0;
            }

        } while (true);

        return requiredDays;
    }

这里的方法是有一个评分机制，该机制在找到下一个可用时间表之前一直递增。即使下一个日程安排在下一周，这也有效

---

如果可以更改Schedule类，则可以避免声明availableSchedules。我建议您通过添加Position或类似于Schedule类的内容来实现这一点

这似乎更适合您可能想要签出的内容，它使编写调度器的这一部分变得更加简单。有趣的方法！我以前从未使用过枚举-这看起来是一个很好的解决方法。但是，简单地看一下该代码——它返回下一个计划的DayOfWeek的Int；而不是离下一个计划还有多少天。因此，如果今天是星期一，星期二在日程安排中-它应该返回11天，直到下一个日程安排-或者如果今天是星期三和星期四，星期五不在日程安排中，但星期六在日程安排中，那么它应该返回3I编辑我的答案，以满足您的需要。访问链接以查看它的运行情况。