C# 使用linq获取列表项中的日期差异

我有一个约会列表，我想在当前约会开始时间和上次约会结束时间之间做一个差异，以确保没有差异。如果有，请添加一个假约会

我当前的实现是

public ObservableCollection<Appointment> FillGaps()
        {
            var appointments = this.Appointments.OrderByDescending(s => s.EndDate).ToList();

            for (int i = 0; i < appointments.Count() - 1; i++)
            {
                var now = appointments[i];

                var previous = appointments[i + 1];

                if((now.StartDate.Value - previous.EndDate.Value).Days > 1)
                {
                    // add a new appointment between this period
                    appointments.Add(new Appointment() 
                          { 
                             StartDate = previous.EndDate.Value.AddDays(1),
                             EndDate = now.StartDate.Value.AddDays(-1), 
                             IsCurrent = false 
                           });
                }
            }

            return appointments.ToObservableCollection();
        }

publicobservableCollection FillGaps（）
{
var appoints=this.appoints.OrderByDescending（s=>s.EndDate.ToList（）；
对于（int i=0；i1）
{
//在此期间之间添加新约会
约会。添加（新约会（）
{ 
StartDate=previous.EndDate.Value.AddDays（1），
EndDate=now.StartDate.Value.AddDays（-1），
IsCurrent=false
});
}
}
返回约会。ToObservableCollection（）；
}

有没有更好或更通用的方法来做到这一点

应要求。。。正在添加ToObservable的实现

 /// <summary>
        /// The to observable collection.
        /// </summary>
        /// <param name="coll">
        /// The collection.
        /// </param>
        /// <typeparam name="T"> Object T
        /// </typeparam>
        /// <returns>
        /// The <see cref="ObservableCollection"/>.
        /// </returns>
        public static ObservableCollection<T> ToObservableCollection<T>(this IEnumerable<T> coll)
        {
            var c = new ObservableCollection<T>();
            foreach (var e in coll)
            {
                c.Add(e);
            }

            return c;
        }

//
///可观察到的集合。
/// 
/// 
///收藏。
/// 
///对象T
/// 
/// 
///这个。
/// 
公共静态ObservableCollection ToObservableCollection（此IEnumerable coll）
{
var c=新的ObservableCollection（）；
foreach（coll中的变量e）
{
c、 加（e）；
}
返回c；
}

预约课没什么特别的

/// <summary>
    /// The Appointment.
    /// </summary>
    [Serializable]
    public class Appointment
    {
        public Appointment()
        {
            this.IsFake = false;
        }


        /// <summary>
        /// Gets or sets the start date.
        /// </summary>
        public DateTime? StartDate { get; set; }

        /// <summary>
        /// Gets or sets the end date.
        /// </summary>
        public DateTime? EndDate { get; set; }

        /// <summary>
        /// Gets or sets the Is Fake
        /// </summary>
        public bool IsFake { get; set; }

    }

//
///预约。
/// 
[可序列化]
公开课任命
{
公开任命（）
{
this.IsFake=false；
}
/// 
///获取或设置开始日期。
/// 
公共日期时间？开始日期{get；set；}
/// 
///获取或设置结束日期。
/// 
公共日期时间？结束日期{get；set；}
/// 
///获取或设置的值为假
/// 
公共bool是假的{get；set；}
}

如果不知道

this.Appointments

属性是如何实现的，或者

ToObservableCollection

扩展方法的参数是什么，就很难找到最有效的解决方案。但是，类似这样的方法应该有效：

private static IEnumerable<Tuple<T, T>> ListPairs<T>(IEnumerable<T> source)
{
   using (var enumerator = source.GetEnumerator())
   {
       if (!enumerator.MoveNext()) yield break;

       T previous = enumerator.Current;
       while (enumerator.MoveNext())
       {
          T current = enumerator.Current;
          yield return new Tuple<T, T>(previous, current);
          previous = current;
       }
   }
}

public ObservableCollection<Appointment> FillGaps()
{
   var gaps = ListPairs(this.Appointments.OrderByDescending(s => s.EndDate))
      .Where(pair => (pair.Item1.StartDate.Value - pair.Item2.EndDate.Value).Days > 1)
      .Select(pair => new Appointment
      {
         StartDate = pair.Item2.EndDate.Value.AddDays(1),
         EndDate = pair.Item1.StartDate.Value.AddDays(-1),
         IsCurrent = false,
      });

   // NB: Assumes "this.Appointments" is a cheap call;
   // Also assumes you don't need the results in any particular order.
   return this.Appointments.Concat(gaps).ToObservableCollection();
}

私有静态IEnumerable列表对（IEnumerable源）
{
使用（var enumerator=source.GetEnumerator（））
{
如果（！enumerator.MoveNext（））产生中断；
T previous=当前枚举数；
while（枚举数.MoveNext（））
{
T current=枚举数。current；
返回新元组（上一个元组，当前元组）；
先前=当前；
}
}
}
公共可观测集合FillGaps（）
{
var gaps=ListPairs（this.appoinces.OrderByDescending（s=>s.EndDate））
.Where（pair=>（pair.Item1.StartDate.Value-pair.Item2.EndDate.Value）.Days>1）
.选择（配对=>新约会
{
StartDate=pair.Item2.EndDate.Value.AddDays（1），
EndDate=pair.Item1.StartDate.Value.AddDays（-1），
IsCurrent=false，
});
//注：假设“this.appoints”是一个廉价电话；
//还假设您不需要任何特定顺序的结果。
返回此.appoints.Concat（gaps）.ToObservableCollection（）；
}

约会[i+1]不会抛出一个IndexOutOfRangeException吗？很可能。因此要求更好的实现。事实上，它不会，for循环转到