如何在一段时间内获得日期范围内的差距

Question

我有一个初始和最终日期范围 = 1/1/2015 - 1/30/2015

我有这些代表不可用日期的日期范围。

1/5/2015 - 1/10/2015
1/15/2015 - 1/20/2015
1/22/2015 - 1/28/2015

我想要这个输出，主要是主要范围的可用日期：

A: 1/1/2015 - 1/4/2015
B: 1/11/2015 - 1/14/2015
C: 1/21/2015 - 1/21/2015
D: 1/29/2015 - 1/30/2015

我试图生成这样的顺序日期范围，以便使用 Except() 获取异常日期，但我认为我让事情变得复杂了。

 //dtStartDate = 1/1/2015
 //dtEndDate = 1/30/2015  
 var days = (int)(dtEndDate - dtStartDate).TotalDays + 1;
 var completeSeq = Enumerable.Range(0, days).Select(x => dtStartDate.AddDays(x)).ToArray();

如何从时间段中获取日期范围的差距。

换句话说，如何从这张图片中得到A、B、C和D

http://www.tiikoni.com/tis/view/?id=ebe851c

如果这些日期重叠，则不能只在有差距的地方考虑。

------------更新------------

我想如果我这样做：

 var range = Enumerable.Range(0, (int)(1/10/2015 - 1/5/2015).TotalDays + 1).Select(i => 1/5/2015.AddDays(i));
 var missing = completeSeq.Except(range).ToArray();

对于每个日期范围，我都会排除给定的每个日期范围，但仍然无法得到差距！

Answer 1

using System;
using System.Collections.Generic;
using System.Linq;
public static class Program {
    public static void Main() {
        Tuple<DateTime,DateTime> range=Tuple.Create(new DateTime(2015,1,1),new DateTime(2015,1,30));
        Tuple<DateTime,DateTime>[] exclude=new[] {
            Tuple.Create(new DateTime(2015,1,5),new DateTime(2015,1,10)),
            Tuple.Create(new DateTime(2015,1,15),new DateTime(2015,1,20)),
            Tuple.Create(new DateTime(2015,1,22),new DateTime(2015,1,28))
        };
        foreach(Tuple<DateTime,DateTime> r in ExcludeIntervals(range,exclude)) {
            Console.WriteLine("{0} - {1}",r.Item1,r.Item2);
        }
    }
    public static IEnumerable<Tuple<DateTime,DateTime>> ExcludeIntervals(Tuple<DateTime,DateTime> range,IEnumerable<Tuple<DateTime,DateTime>> exclude) {
        IEnumerable<Tuple<DateTime,bool>> dates=
            new[] { Tuple.Create(range.Item1.AddDays(-1),true),Tuple.Create(range.Item2.AddDays(1),false) }.
            Concat(exclude.SelectMany(r => new[] { Tuple.Create(r.Item1,false),Tuple.Create(r.Item2,true) })).
            OrderBy(d => d.Item1).ThenBy(d => d.Item2); //Get ordered list of time points where availability can change.
        DateTime firstFreeDate=default(DateTime);
        int count=1; //Count of unavailability intervals what is currently active. Start from 1 to threat as unavailable before range starts.
        foreach(Tuple<DateTime,bool> date in dates) {
            if(date.Item2) { //false - start of unavailability interval. true - end of unavailability interval.
                if(--count==0) { //Become available.
                    firstFreeDate=date.Item1.AddDays(1);
                }
            } else {
                if(++count==1) { //Become unavailable.
                    DateTime lastFreeDate=date.Item1.AddDays(-1);
                    if(lastFreeDate>=firstFreeDate) { //If next unavailability starts right after previous ended, then no gap.
                        yield return Tuple.Create(firstFreeDate,lastFreeDate);
                    }
                }
            }
        }
    }
}

ideone.com

Answer 2

有点晕...

public class DateRange
    {
        public DateTime Start { get; set; }
        public DateTime End { get; set; }

        public bool HasStart
        {
            get { return Start != DateTime.MinValue; }
        }
        public bool IsInRange(DateTime date)
        {
            return (date >= this.Start && date <= this.End);
        }

        public List<DateRange> GetAvailableDates(DateRange excludedRange)
        {
            return GetAvailableDates(new List<DateRange>(){excludedRange});
        }

        public List<DateRange> GetAvailableDates(List<DateRange> excludedRanges)
        {
            if (excludedRanges == null)
            {
                return new List<DateRange>() { this };
            }
            var list = new List<DateRange>();
            var aRange = new DateRange();
            var date = this.Start;
            while (date <= this.End)
            {
                bool isInARange = excludedRanges.Any(er => er.HasStart && er.IsInRange(date));
                if (!isInARange)
                {
                    if (!aRange.HasStart)
                    {
                        aRange.Start = date;
                    }
                    aRange.End = date;
                }
                else
                {
                    if (aRange.HasStart)
                    {
                        list.Add(aRange);
                        aRange = new DateRange();
                    }
                }
                date = date.AddDays(1);
            }
            if (aRange.HasStart)
            {
                list.Add(aRange);
            }
            return list;
            }
}

Answer 3

我今天早上看到你的问题，非常喜欢，但是整天都很忙。所以，有机会回答你的问题，相信我，我很喜欢。这是我的代码：-

DateTime startDate = new DateTime(2015, 1, 1);
DateTime endDate = new DateTime(2015, 1, 30);
int totalDays = (int)(endDate - startDate).TotalDays + 1;
availability.Add(new Availability { StartDate = endDate, EndDate = endDate });

var result = from x in Enumerable.Range(0, totalDays)
            let d = startDate.AddDays(x)
            from a in availability.Select((v, i) => new { Value = v, Index = i })
            where (a.Index == availability.Count - 1 ? 
                     d <= a.Value.StartDate : d < a.Value.StartDate)
            && (a.Index != 0 ? d > availability[a.Index - 1].EndDate : true)
            group new { d, a } by a.Value.StartDate into g
            select new
            {
                 AvailableDates = String.Format("{0} - {1}",g.Min(x => x.d),
                                                            g.Max(x => x.d))
            };

这个，绝对需要解释，所以在这里：-

第 1 步： 使用 Enumerable.Range
创建从 1 月 1 日到 1 月 30 日的日期范围 第 2 步： 由于在第二个不可用日期范围之后，我们需要限制从上次结束日期到当前对象开始日期选择的日期，我计算了 index 这样我们就可以访问到最后一个结束日期。
第 3 步：一旦我们获得索引，我们需要做的就是过滤除第一个日期范围之外的日期，因为在这种情况下我们没有最后一个对象。
第 4 步： 对于最后一项，因为我们没有最大范围，所以我将 endDate 添加到我们的不可用列表中（希望这是有意义的）。

这是 Working Fiddle，如果您感到困惑，只需删除 group by 和其他过滤器并调试并查看结果输出，它看起来相当简单:)

如何在一段时间内获得日期范围内的差距

How to get gap in date ranges from a period of time

c#

linq

date

range