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

[tanghuawei]

有如下集合：List<DataRow> lstRows = new List<DataRow>();
lstRows里的DataRow包含两列：StatrTime和EndTime，我如何写一个方法去判断这个集合中的时间是否交叉？

或者说我用另一种方式，把StartTime和EndTime存于两个不同的集合？


请各位帮帮忙，谢谢，急用，最好是一个比较通用的方法，可以用来判断时间段是否交叉

[tanghuawei]

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

[小丫头]

我看看

[小丫头]

//用来记录开始和结束的时间
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();

[tanghuawei]

呵呵，谢谢你的回答，可是没有说到判断时间段交叉的啊

[tanghuawei]

请各位帮帮忙啊

[龍过鸡年]

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) // 交叉

[gomoku]

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

[TimZhuFaith]

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

[wuyq11]

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

[wy811007]

过来学习下。 有点意思哦

[tanghuawei]

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

[tanghuawei]

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

[TimZhuFaith]

那就建个DataRowComparer类继承IComparer,然后用list.Sort(new DataRowComparer()),再使用ls方法[Quote=引用 11 楼 tanghuawei 的回复:]
我的开发环境是VS2005，没有Linq
[/Quote]

[龍过鸡年]

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

[macooidle]

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