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

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

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添加到我们的不可用列表中（希望这是有意义的）。

这是工作小提琴，如果您感到困惑，只需删除group by和其他过滤器并进行调试，然后查看结果输出，它看起来会很容易:)

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

嘎...

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;
            }
}