判断集合内时间是否交叉？

Question

有如下集合：List<DataRow> lstRows = new List<DataRow>();
lstRows里的DataRow包含两列：StatrTime和EndTime，我如何写一个方法去判断这个集合中的时间是否交叉？或者说我用另一种方式，把StartTime和EndTime存于两个不同的集合？
请各位帮帮忙，谢谢，急用，最好是一个比较通用的方法，可以用来判断时间段是否交叉

Answer 1

//用来记录开始和结束的时间   
DateTime startTime = new DateTime();   
DateTime endTime = new DateTime();   
  
//定义集合类型ArrayList的一个实例   
ArrayList list = new ArrayList();   
  
//取得当前时间   
startTime = DateTime.Now;   
  
//★★★★★★★★①使用ArrayList类★★★★★★★★   
//ArrayList的add方法的参数是Object型，   
//当我们把int型作为参数传入的时候需要做装箱操作   
//装箱操作将值类型转化为Object类型   
for (int i = 0; i < 1000000; i++)   
{   
    list.Add(i);   
}   
  
int iCount = 0;   
//当我们使用int型的时候需要做拆箱操作操作   
//拆箱操作将应用类型转化为Object类型，拆箱过程要做大量的工作   
foreach (int i in list)   
{   
    iCount += 1;   
}   
  
Console.WriteLine("使用ArrayList的结果 ： {0}", iCount.ToString());   
  
//取得结束时间并计算差值   
endTime = DateTime.Now;   
TimeSpan ts = endTime - startTime;   
  
Console.WriteLine("使用ArrayList的耗时 ：" + ts.TotalMilliseconds);   
  
//★★★★★★★★②使用泛型类★★★★★★★★   
//使用List的泛型定义List<T>,int类型在编译器动态生成的类中本替换为int型   
//执行过程中不再执行装箱拆箱操作   
List<int> list2 = new List<int>();   
  
startTime = DateTime.Now;               
  
for (int i = 0; i < 1000000; i++)   
{   
    list2.Add(i);   
}   
  
iCount = 0;   
foreach (int i in list2)   
{   
    iCount += 1;   
}   
  
Console.WriteLine("使用泛型的结果 ： {0}", iCount.ToString());   
  
endTime = DateTime.Now;   
ts = endTime - startTime;   
  
Console.WriteLine("使用泛型的耗时 ：" + ts.TotalMilliseconds);   
  
//显示三次结果如下   
  
/* 第一次  
 * 使用ArrayList的耗时 ：92  
 * 使用泛型的耗时 ：25  
 *   
 * 第二次  
 * 使用ArrayList的耗时 ：96  
 * 使用泛型的耗时 ：22  
 *   
 * 第三次  
 * 使用ArrayList的耗时 ：90  
 * 使用泛型的耗时 ：22  
 *   
 * 由此可以明显看出两者的差别  
 * 这里仅仅是时间上的，并不包括对内存消耗的统计  
 *   
 * ※但是也要注意到差别的单位是毫秒，  
 * 我这里只想说明用泛型是有好处的，  
 * 但也不可过分追求程序的孰优孰劣，  
 * 总之要把握好这个度，适合自己的才是最好的   
 * O(∩_∩)O~  
 */  
  
Console.Read(); 

Answer 2

List<DataRow> lstRows = new List<DataRow>();var result = lstRows.Where(row =>
    DateTime.Now >= Convert.ToDateTime(row["StartTime"]) &&
    DateTime.Now <= Convert.ToDateTime(row["EndTime"]));if (result.Count() > 0) // 交叉

Answer 3

bool HasTimeSlotConflicts(IList<DataRow> rowList)
{
    DataRow[] rows = rowList.OrderBy(r => r.Field<DateTime>("StartTime")).ToArray();
    for (int i = 1; i < rows.Length; i++)
    {
        if (rows[i].Field<DateTime>("StartTime") < rows[i - 1].Field<DateTime>("EndTime")) return true;
    }
    return false;
}

Answer 4

ls方法不错
要不就两次循环 比较两个不相同datarow的starttime 和endtime

Answer 5

SqlMethods.DateDiffMonth(i.DateStart, i.DateEnd);   
System.Data.Linq.SqlClient.SqlMethods.DateDiffDay(v.DateStart, DateTime.Now) < 0  
判断时间差

Answer 6

=> 这个是啥符号？C++里的？我的是C#

Answer 7

我的开发环境是VS2005，没有Linq

Answer 8

那就建个DataRowComparer类继承IComparer,然后用list.Sort(new DataRowComparer()),再使用ls方法

Answer 9

DataTable table = new DataTable();
table.Columns.AddRange(new DataColumn[] {
    new DataColumn("StartTime", typeof(DateTime)),
    new DataColumn("EndTime", typeof(DateTime))
});table.Rows.Add(new object[] {
    DateTime.Parse("2011/1/1 09:00:00"),
    DateTime.Parse("2011/1/1 17:00:00")
});
table.Rows.Add(new object[] {
    DateTime.Parse("2011/1/2 09:00:00"),
    DateTime.Parse("2011/1/2 17:00:00")
});
table.Rows.Add(new object[] {
    DateTime.Parse("2011/1/3 09:00:00"),
    DateTime.Parse("2011/1/3 17:00:00")
});
table.Rows.Add(new object[] {
    DateTime.Parse("2011/1/4 09:00:00"),
    DateTime.Parse("2011/1/4 17:00:00")
});
table.Rows.Add(new object[] {
    DateTime.Parse("2011/1/5 09:00:00"),
    DateTime.Parse("2011/1/5 17:00:00")
});table.Rows.Add(new object[] {
    DateTime.Parse("2011/1/3 12:00:00"),
    DateTime.Parse("2011/1/3 14:00:00")
});
table.Rows.Add(new object[] {
    DateTime.Parse("2011/1/3 05:00:00"),
    DateTime.Parse("2011/1/5 19:00:00")
});
table.Rows.Add(new object[] {
    DateTime.Parse("2011/1/4 15:00:00"),
    DateTime.Parse("2011/1/4 18:00:00")
});
table.Rows.Add(new object[] {
    DateTime.Parse("2011/1/4 21:00:00"),
    DateTime.Parse("2011/1/5 19:00:00")
});IEnumerable<DataRow> rows = table.Rows.Cast<DataRow>();var newRows = rows.Select((row, index) => new
{
    Index = index,
    Start = Convert.ToDateTime(row["StartTime"]),
    End = Convert.ToDateTime(row["EndTime"])
});var result = newRows.Where(row =>
    newRows.Where(compare =>
        compare.Index != row.Index && ((
        compare.Start <= row.Start && row.Start <= compare.End ||
        compare.Start <= row.End && row.End <= compare.End) || (
        row.Start <= compare.Start && compare.Start <= row.End ||
        row.Start <= compare.End && compare.End <= row.End))).Count() > 0
    );foreach (var item in result)
{
    Console.WriteLine("Index:{0} StartTime:{1} EndTime:{2}",
        item.Index, item.Start, item.End);
}Console.WriteLine("\r\n===== 没有 Linq 是悲哀的 =====\r\n");// 没有 Linq 是悲哀的foreach (DataRow row in table.Rows)
{
    DateTime rowStart = Convert.ToDateTime(row["StartTime"]);
    DateTime rowEnd = Convert.ToDateTime(row["EndTime"]);    Console.WriteLine("{0}: {1} {2}",
        table.Rows.IndexOf(row), rowStart, rowEnd);    foreach (DataRow compare in table.Rows)
    {
        DateTime compareStart = Convert.ToDateTime(compare["StartTime"]);
        DateTime compareEnd = Convert.ToDateTime(compare["EndTime"]);        if (row == compare) continue;        if ((
            compareStart <= rowStart && rowStart <= compareEnd ||
            compareStart <= rowEnd && rowEnd <= compareEnd) || (
            rowStart <= compareStart && compareStart <= rowEnd ||
            rowStart <= compareEnd && compareEnd <= rowEnd))
        {
            Console.WriteLine("\t- {0}: {1} {2}",
                table.Rows.IndexOf(compare), compareStart, compareEnd);
        }
    }
    Console.WriteLine();
}

Answer 10

===== 没有 Linq 是悲哀的 =====.....

Answer 11

呵呵，感谢各位，自己用IComparable<Range>解决了