C# 日期时间处理方法

我面临着一个问题，我找不到一个合适而优雅的解决方案。我有一个

视频列表

，它是一个包含视频信息的类。在这些信息中有一个

startDate

、

endDate

和一个

cameraId

属性

我的当前数据库具有以下值：

         startDate      endDate

我想迭代这些值，当一个视频与上一个视频相差不到5分钟，并且具有相同的

cameraId

时，应该将其计为一个。但我找不到一个合适的、优雅的方法来完成这项任务

上面显示的视频列表的输出应为

• 第一次：2013:03:0118:25:26->2013-03-0118:34:29
• 第二次：2013:03:01 18:40:26->2013:03:01 18:59:29

这是我目前掌握的代码：

private void ProcessVideos(List<Video> videos)
        {
            bool isSameVideo = false;
            Video lastVideo = null;


            //debugar e ver esquema do ultimo valor do database
            DateTime startDate = DateTime.MinValue;
            DateTime endDate = DateTime.MinValue;
            for (int i = 1; i < videos.Count; i++)
            {
                TimeSpan timeSpan = new TimeSpan(videos[i].DataInicio.Ticks - videos[i - 1].DataFim.Ticks);
                if (timeSpan.Minutes > 0 && timeSpan.Minutes < 5 && videos[i].IdCamera == videos[i - 1].IdCamera)
                {
                    if (!isSameVideo)
                    {
                        isSameVideo = true;
                        startDate = videos[i - 1].DataInicio;
                        endDate = videos[i].DataFim;
                    }
                    else
                    {
                        endDate = videos[i].DataFim;
                    }
                }
                else
                {
                    if (isSameVideo)
                    {
                        i++;
                        isSameVideo = false;
                        Debug.WriteLine("inicio: {0} fim: {1}", startDate, endDate);
                        startDate = DateTime.MinValue;
                        endDate = DateTime.MinValue;
                    }
                    Debug.WriteLine("inicio: {0} fim: {1}", videos[i - 1].DataInicio, videos[i - 1].DataFim);
                }
            }
            if (startDate != DateTime.MinValue)
            {
                Debug.WriteLine("inicio: {0} fim: {1}", startDate, endDate);
            }
        }

private void ProcessVideos（列出视频）
{
bool-isSameVideo=false；
Video lastVideo=null；
//debugar e ver esquema do ultimo valor do数据库
DateTime startDate=DateTime.MinValue；
DateTime endDate=DateTime.MinValue；
对于（int i=1；i0&&timeSpan.Minutes<5&&videos[i].IdCamera==videos[i-1].IdCamera）
{
如果（！isSameVideo）
{
isSameVideo=true；
startDate=视频[i-1].DataInicio；
endDate=videos[i].数据职能指令手册；
}
其他的
{
endDate=videos[i].数据职能指令手册；
}
}
其他的
{
如果（iSameVideo）
{
i++；
isSameVideo=假；
Debug.WriteLine（“inicio:{0}fim:{1}”，开始日期，结束日期）；
startDate=DateTime.MinValue；
endDate=DateTime.MinValue；
}
Debug.WriteLine（“inicio:{0}fim:{1}”，视频[i-1]。DataInicio，视频[i-1]。DataFim）；
}
}
if（startDate！=DateTime.MinValue）
{
Debug.WriteLine（“inicio:{0}fim:{1}”，开始日期，结束日期）；
}
}

---

主要问题是：根据timespan规范迭代这些值并输出值组合的良好逻辑是什么？

我创建了一个小示例来向您展示：

我的容器对象：

internal class Container
{
    public int Id { get; set; }
    public DateTime Start { get; set; }
    public DateTime Stop { get; set; }

    public override string ToString()
    {
        return "ID " + Id + ": " + Start + " -> " + Stop;
    }
}

我的方法：

    private static IEnumerable<Container> DoMerge(List<Container> elements, TimeSpan maxDiff)
    {
        var closedContainers = new List<Container>();
        var lastContainers = new Dictionary<int, Container>();

        foreach (Container container in elements.OrderBy(e => e.Start))
        {
            //First case, no previous container
            if (!lastContainers.ContainsKey(container.Id))
            {
                lastContainers[container.Id] = container;
            }
            else if (container.Start - lastContainers[container.Id].Stop > maxDiff)
                //We have a container, but not in our windows of 5 minutes
            {
                closedContainers.Add(lastContainers[container.Id]);
                lastContainers[container.Id] = container;
            }
            else
            {
                //We have to merge our two containers
                lastContainers[container.Id].Stop = container.Stop;
            }
        }

        //We have now to put all "lastContainer" in our final list
        foreach (KeyValuePair<int, Container> lastContainer in lastContainers)
        {
            closedContainers.Add(lastContainer.Value);
        }
        return closedContainers;
    }

private static IEnumerable DoMerge（列表元素，TimeSpan maxDiff）
{
var closedContainers=新列表（）；
var lastContainers=newdictionary（）；
foreach（elements.OrderBy（e=>e.Start）中的容器）
{
//第一种情况，没有以前的容器
如果（！lastContainers.ContainsKey（container.Id））
{
lastContainers[container.Id]=容器；
}
else if（container.Start-lastContainers[container.Id].Stop>maxDiff）
//我们有一个容器，但不在5分钟的窗口内
{
添加（lastContainers[container.Id]）；
lastContainers[container.Id]=容器；
}
其他的
{
//我们必须合并两个集装箱
lastContainers[container.Id].Stop=container.Stop；
}
}
//现在，我们必须将所有“lastContainer”放在最终列表中
foreach（lastContainers中的KeyValuePair lastContainer）
{
closedContainers.Add（lastContainer.Value）；
}
返回闭合容器；
}

我们只需给出最大时间跨度和元素列表：

    private static void Main(string[] args)
    {
        var elements = new List<Container>
            {
                new Container {Id = 1, Start = new DateTime(2013, 3, 1, 18, 25, 26), Stop = new DateTime(2013, 3, 1, 18, 27, 29)},
                new Container {Id = 1, Start = new DateTime(2013, 3, 1, 18, 30, 26), Stop = new DateTime(2013, 3, 1, 18, 34, 29)},
                new Container {Id = 1, Start = new DateTime(2013, 3, 1, 18, 40, 26), Stop = new DateTime(2013, 3, 1, 18, 52, 29)},
                new Container {Id = 1, Start = new DateTime(2013, 3, 1, 18, 55, 26), Stop = new DateTime(2013, 3, 1, 18, 59, 29)},
            };
        foreach (Container container in DoMerge(elements, TimeSpan.FromMinutes(5)))
        {
            Console.WriteLine(container);
        }
        Console.ReadLine();
    }

private static void Main（字符串[]args）
{
var元素=新列表
{
新容器{Id=1，Start=newdatetime（2013,3,1,18,25,26），Stop=newdatetime（2013,3,1,18,27,29）}，
新容器{Id=1，Start=newdatetime（2013,3,1,18,30,26），Stop=newdatetime（2013,3,1,18,34,29）}，
新容器{Id=1，Start=newdatetime（2013,3,1,18,40,26），Stop=newdatetime（2013,3,1,18,52,29）}，
新容器{Id=1，Start=newdatetime（2013,3,1,18,55,26），Stop=newdatetime（2013,3,1,18,59,29）}，
};
foreach（DoMerge中的容器（元素，时间跨度，从分钟（5）））
{
控制台写入线（容器）；
}
Console.ReadLine（）；
}

这给了我你的预期结果，我们两个对象左

上述数据的结果：

---

我创建了一个小示例，向您展示：

我的容器对象：

internal class Container
{
    public int Id { get; set; }
    public DateTime Start { get; set; }
    public DateTime Stop { get; set; }

    public override string ToString()
    {
        return "ID " + Id + ": " + Start + " -> " + Stop;
    }
}

我的方法：

    private static IEnumerable<Container> DoMerge(List<Container> elements, TimeSpan maxDiff)
    {
        var closedContainers = new List<Container>();
        var lastContainers = new Dictionary<int, Container>();

        foreach (Container container in elements.OrderBy(e => e.Start))
        {
            //First case, no previous container
            if (!lastContainers.ContainsKey(container.Id))
            {
                lastContainers[container.Id] = container;
            }
            else if (container.Start - lastContainers[container.Id].Stop > maxDiff)
                //We have a container, but not in our windows of 5 minutes
            {
                closedContainers.Add(lastContainers[container.Id]);
                lastContainers[container.Id] = container;
            }
            else
            {
                //We have to merge our two containers
                lastContainers[container.Id].Stop = container.Stop;
            }
        }

        //We have now to put all "lastContainer" in our final list
        foreach (KeyValuePair<int, Container> lastContainer in lastContainers)
        {
            closedContainers.Add(lastContainer.Value);
        }
        return closedContainers;
    }

private static IEnumerable DoMerge（列表元素，TimeSpan maxDiff）
{
var closedContainers=新列表（）；
var lastContainers=newdictionary（）；
foreach（elements.OrderBy（e=>e.Start）中的容器）
{
//第一种情况，没有以前的容器
如果（！lastContainers.ContainsKey（container.Id））
{
lastContainers[container.Id]=容器；
}
else if（container.Start-lastContainers[container.Id].Stop>maxDiff）
//我们有一个容器，但不在5分钟的窗口内
{
添加（lastContainers[container.Id]）；
lastContainers[container.Id]=容器；
}
其他的
{
//我们必须合并两个集装箱
lastContainers[container.Id].Stop=container.S