一天中日期的轮班时间范围，分为10分钟间隔C＃

如何解决一天中日期的轮班时间范围，分为10分钟间隔C＃

我想知道是否有人可以帮助我，所以我有一天上班的开始时间和结束时间的集合。时间可以分布在一天当中。我正在尝试按一天中的小时分组（例如0、1、2 ... 23、24），并以10分钟为间隔显示该小时，或者工作或不工作。所以，我想得到如下的最终结果：

我想区分工作与不工作，输入提供了工作，但是我计算出不工作，我创建了一种方法来处理如果时间超出10分钟间隔，它将设置为最近的一个。称为DoRounding的方法：

示例：

9 am => 0 - 10 Worked 
       10 - 20 Not Worked
       20 - 30 Worked
       30 - 40 Worked
       40 - 50 Worked
       50 - 60 Worked

可以通过这种方式处理超出期限的时间

private static int DoRounding(DateTime date)
{

    if (Enumerable.Range(0,10).Contains(date.Minute))
        return 0;

    if (Enumerable.Range(10,20).Contains(date.Minute))
        return 20;

    if (Enumerable.Range(20,30).Contains(date.Minute))
        return 30;

    if (Enumerable.Range(30,40).Contains(date.Minute))
        return 40;

    if (Enumerable.Range(40,50).Contains(date.Minute))
        return 50;

    return 60;
}

我分解工作块的方法（我试图在这里将工作时间分解为几个小时，以便可以用另一种方法添加缺少的部分）

    public static IEnumerable<Tuple<int,DateTime>> CalculateIntervals(WorkPeriod workBlock)
    {
        yield return new Tuple<int,DateTime>(workBlock.StartTime.Hour,workBlock.StartTime);

        var dateTime = new DateTime(workBlock.StartTime.Year,workBlock.StartTime.Month,workBlock.StartTime.Day,workBlock.StartTime.Hour,workBlock.StartTime.Minute,workBlock.StartTime.Kind).AddHours(1);

        while (dateTime < workBlock.EndTime)
        {
            yield return new Tuple<int,DateTime>(dateTime.Hour,dateTime);
            dateTime = dateTime.AddHours(1);
        }

        yield return new Tuple<int,DateTime>(workBlock.EndTime.Hour,workBlock.EndTime);
    }

我尝试分组（我想将此处的时隙分组为小时和时间间隔，例如1 pm，0-10分钟，并将其标记为有效，但如果此处缺少间隔，则将其添加为无效）

    public static void WorkingHourIntervalStrings(List<WorkPeriod> WorkingHours)
    {
        var output = new List<Tuple<int,DateTime>>();

        foreach (var result in WorkingHours.Select(CalculateIntervals))
            output.AddRange(result);

        output = output.OrderBy(x => x.Item2).ToList();

        var test = output.GroupBy(
            p => p.Item1,p => p.Item2.Minute,(key,g) => new { Worked = key,Minute = g.ToList() });
    }

班级

public class WorkPeriod 
{
    public DateTime StartTime { get; set; }
    public DateTime EndTime { get; set; }
}

呼叫

 var input = new List<WorkPeriod>
 {
   new WorkPeriod { StartTime  = new DateTime(2020,5,25,9,40,56),EndTime = new DateTime(2020,14,22,12) },new WorkPeriod { StartTime = new DateTime(2020,50,59,13,18,19,23,12) }
};

  TimeIntervals.WorkingHourIntervalStrings(input);

可能的输出结构：

public class Interval
{
    public Interval() => Contents = new List<Contents>();

    public int Hour { get; set; }
    public List<Contents> Contents { get; set; }
}

public class Contents
{
    public bool Worked { get; set; }
    public int Start { get; set; }
    public int End { get; set; }
}

 

解决方法

根据您的上述解释，我将执行以下操作：

public class Interval
{
    public Interval() => Contents = new List<Contents>();

    public int Hour { get; set; }
    public List<Contents> Contents { get; set; }
}

public class Contents
{
    public bool Worked { get; set; }
    public int Start { get; set; }
    //public int End { get; set; }
    public int End => Start + 10;
}

public class WorkPeriod
{
    public DateTime StartTime { get; set; }
    public DateTime EndTime { get; set; }
}

查看Contents类。 End属性是根据Start自动计算得出的。 然后，我将创建以下Calculator类：

public class Calculator
{
    public bool[] WorkedIntervals = new bool[24 * 6];

    private void SetWork(int Hour,int Min)
    {
        int pos = Hour * 6 + Min / 10;
        WorkedIntervals[pos] = true;
    }

    private void UpdateIntervals(WorkPeriod period)
    {
        var cur = period.StartTime;
        while (cur < period.EndTime)
        {
            SetWork(cur.Hour,cur.Minute);
            cur = cur.AddMinutes(10);
        }
    }

    private void UpdateIntervals(List<WorkPeriod> periods)
    {
        foreach (var l in periods)
            UpdateIntervals(l);
    }
    
    public IEnumerable<Interval> CalcIntervals(List<WorkPeriod> periods)
    {
        var minTime = (from p in periods
                       select p.StartTime).Min();
        var maxTime = (from p in periods
                       select p.EndTime).Max();

        UpdateIntervals(periods);

        for(int h=minTime.Hour; h<=maxTime.Hour; ++h)
        {
            int pos = h * 6;
            var intrvl = new Interval() { Hour = h };
            for (int m=0; m<=5; m++)
            {
                if (WorkedIntervals[pos + m])
                    intrvl.Contents.Add(new Contents() { Start = m * 10,Worked = true });
                else
                    intrvl.Contents.Add(new Contents() { Start = m * 10,Worked = false });
            }
            yield return intrvl;
        }
    }
}

这个想法是，您必须将所有时间间隔展平为144个布尔值（24 * 6）的数组，这些值表示是否已处理了这10分钟时间间隔中的每个时间间隔。例如。如果数组的第7个索引为true，则表示在第1个小时（第0个小时在索引0-5中）已经工作了10-20分钟。

然后，在主要功能上执行以下操作。

var input = new List<WorkPeriod>
{
   new WorkPeriod { StartTime  = new DateTime(2020,5,25,9,40,56),EndTime = new DateTime(2020,14,22,12) },new WorkPeriod { StartTime = new DateTime(2020,50,59,13,18,19,23,12) }
};

Calculator ints = new Calculator();
var res = ints.CalcIntervals(input).ToList();

res列表应包含从最小的StartTime到最大的EndTime的小时间隔以及它们受尊重的子列表。