如何从字符串中以c#形式累加一天中的时间

我想累积一个时间值字符串数组，并检查总时间是否大于一天。在这个测试用例中，我从上午12:00开始，加上12小时。然后再加上12小时5分钟。总时间应为24小时5分钟

问题是，从下午12:00到凌晨12:05的计算是11小时55分钟，而不是12小时5分钟

如何为我的用例正确地累积这些时间

string[] times = {"12:00 AM", "12:00 PM", "12:05 AM"};
const string timePattern = "h:mm tt";

double totalMillis = 0;
var prevTimeSpan = new TimeSpan(0);

foreach (var time in times)
{
    var parsedDate = DateTime.ParseExact(time, timePattern, null, DateTimeStyles.None);
    var currTimeSpan = parsedDate.TimeOfDay;
    var millis = Math.Abs((prevTimeSpan - currTimeSpan).TotalMilliseconds);
    prevTimeSpan = currTimeSpan;
    totalMillis += millis;
}

// 24 hours = 86400000
Console.WriteLine("Result is more than 24 hours? {0}", totalMillis >= 86400000 ? "Yes" : "No");

---

如果添加一个日期部分，它的计算是正确的

2013年1月1日12:00-2013年1月1日00:05=11小时55分钟

---

我想你期待的是2013年1月2日00:05——提前一天。12小时5分钟

如果您添加了日期部分，则计算正确

2013年1月1日12:00-2013年1月1日00:05=11小时55分钟

---

我想你期待的是2013年1月2日00:05——提前一天。12小时5分钟

此特定用例的解决方案是：

string[] times = {"12:00 AM", "12:00 PM", "12:00 AM"};
const string timePattern = "h:mm tt";

double totalMillis = 0;
var prevTimeSpan = new TimeSpan(0);

foreach (var time in times)
{
    var parsedDate = DateTime.ParseExact(time, timePattern, null, DateTimeStyles.None);
    var currTimeSpan = parsedDate.TimeOfDay;
    var millis = (prevTimeSpan - currTimeSpan).TotalMilliseconds;
    prevTimeSpan = currTimeSpan;
    totalMillis += millis;
}

// 24 hours = 86400000
Console.WriteLine("Result is more than 24 hours? {0}", totalMillis >= 0 ? "No" : "Yes");

---

请注意，我没有检查totalMillis是否大于一天，而是检查它是否变为负值。我仍然认为将字符串数组转换成一个不包含日期的总计时间跨度会很有趣。

此特定用例的解决方案是：

string[] times = {"12:00 AM", "12:00 PM", "12:00 AM"};
const string timePattern = "h:mm tt";

double totalMillis = 0;
var prevTimeSpan = new TimeSpan(0);

foreach (var time in times)
{
    var parsedDate = DateTime.ParseExact(time, timePattern, null, DateTimeStyles.None);
    var currTimeSpan = parsedDate.TimeOfDay;
    var millis = (prevTimeSpan - currTimeSpan).TotalMilliseconds;
    prevTimeSpan = currTimeSpan;
    totalMillis += millis;
}

// 24 hours = 86400000
Console.WriteLine("Result is more than 24 hours? {0}", totalMillis >= 0 ? "No" : "Yes");

---

请注意，我没有检查totalMillis是否大于一天，而是检查它是否变为负值。我仍然认为将字符串数组转换成一个不包含日期的总计时间跨度会很有趣。

因此，可以在DateTime上操作：

string[] times = { "12:00 AM", "12:00 PM", "12:05 AM" };
         const string timePattern = "h:mm tt";

         var dateTime = new DateTime(2010,1,1,0,0,0,0);
         foreach (var time in times)
         {
            var parsedDate = DateTime.ParseExact(time, timePattern, null, DateTimeStyles.None);
            dateTime = dateTime.AddHours(parsedDate.Hour);
            dateTime = dateTime.AddMinutes(parsedDate.Minute);
         }
         Console.WriteLine(a.ToShortTimeString());
         Console.ReadKey();

---

现在计算机知道你在新的一天

所以可能在DateTime操作：

string[] times = { "12:00 AM", "12:00 PM", "12:05 AM" };
         const string timePattern = "h:mm tt";

         var dateTime = new DateTime(2010,1,1,0,0,0,0);
         foreach (var time in times)
         {
            var parsedDate = DateTime.ParseExact(time, timePattern, null, DateTimeStyles.None);
            dateTime = dateTime.AddHours(parsedDate.Hour);
            dateTime = dateTime.AddMinutes(parsedDate.Minute);
         }
         Console.WriteLine(a.ToShortTimeString());
         Console.ReadKey();

---

现在计算机知道你在新的一天

问题是你忽略了一个事实，即

12:05 AM

之后的

12:00 PM

是第二天

试试这个

string[] times = { "12:00 AM", "12:00 PM", "12:05 AM" };
const string timePattern = "h:mm tt";
TimeSpan prev = TimeSpan.Zero;
var spans = times.Select(x =>
{
    var span = DateTime.ParseExact(x, timePattern, null, DateTimeStyles.None).TimeOfDay;
    if (span < prev)
    {
        span = span.Add(TimeSpan.FromDays(1.0) - prev);
    }
    prev = span;
    return span;
});
var totalMillis = spans.Sum(x => x.TotalMilliseconds);

// 24 hours = 86400000
Console.WriteLine("Result is more than 24 hours? {0}", totalMillis >= 86400000 ? "Yes" : "No");

string[]次={“12:00am”，“12:00pm”，“12:05am”}；
常量字符串timePattern=“h:mm tt”；
TimeSpan prev=TimeSpan.Zero；
变量跨度=时间。选择（x=>
{
var span=DateTime.ParseExact（x，timePattern，null，DateTimeStyles.None）；
如果（跨度<上一个）
{
span=span.Add（TimeSpan.FromDays（1.0）-prev）；
}
prev=跨度；
返回跨度；
});
var totalMillis=spans.Sum（x=>x.TotalMills）；
//24小时=86400000
WriteLine（“结果超过24小时？{0}”，totalMillis>=86400000？“是”：“否”）；

问题在于，您忽略了这样一个事实，即

12:05 AM

之后的

12:00 PM

是第二天

试试这个

string[] times = { "12:00 AM", "12:00 PM", "12:05 AM" };
const string timePattern = "h:mm tt";
TimeSpan prev = TimeSpan.Zero;
var spans = times.Select(x =>
{
    var span = DateTime.ParseExact(x, timePattern, null, DateTimeStyles.None).TimeOfDay;
    if (span < prev)
    {
        span = span.Add(TimeSpan.FromDays(1.0) - prev);
    }
    prev = span;
    return span;
});
var totalMillis = spans.Sum(x => x.TotalMilliseconds);

// 24 hours = 86400000
Console.WriteLine("Result is more than 24 hours? {0}", totalMillis >= 86400000 ? "Yes" : "No");

string[]次={“12:00am”，“12:00pm”，“12:05am”}；
常量字符串timePattern=“h:mm tt”；
TimeSpan prev=TimeSpan.Zero；
变量跨度=时间。选择（x=>
{
var span=DateTime.ParseExact（x，timePattern，null，DateTimeStyles.None）；
如果（跨度<上一个）
{
span=span.Add（TimeSpan.FromDays（1.0）-prev）；
}
prev=跨度；
返回跨度；
});
var totalMillis=spans.Sum（x=>x.TotalMills）；
//24小时=86400000
WriteLine（“结果超过24小时？{0}”，totalMillis>=86400000？“是”：“否”）；

需要注意的一点是，你正在对自己的时间做出假设。你假设每一次都比上一次晚，因此如果是一天中较早的时间，那么必须是在第二天

基于该假设，您可以通过一天中的一组时间计算总时间跨度：

string[] times = { "12:00 AM", "12:00 PM", "12:05 AM" };
const string timePattern = "h:mm tt";

DateTime[] dates = times.Select(x => DateTime.ParseExact(x, timePattern, null)).ToArray();

TimeSpan totalTimeSpan = new TimeSpan();

for (int i = 1; i < dates.Length; i++)
{
    // Assume that each time is at least the same date as the previous time
    dates[i] = dates[i - 1].Date + dates[i].TimeOfDay;

    // If this time is earlier than the previous time then assume it must be on the next day
    if (dates[i - 1].TimeOfDay > dates[i].TimeOfDay)
        dates[i] = dates[i].AddDays(1);

    totalTimeSpan += dates[i] - dates[i - 1];
}

Console.WriteLine("Result is more than 24 hours? {0}", totalTimeSpan.TotalHours > 24);

string[]次={“12:00am”，“12:00pm”，“12:05am”}；
常量字符串timePattern=“h:mm tt”；
DateTime[]dates=times.Select（x=>DateTime.ParseExact（x，timePattern，null））.ToArray（）；
TimeSpan totalTimeSpan=新的TimeSpan（）；
对于（int i=1；idates[i].TimeOfDay）
日期[i]=日期[i]。添加天数（1）；
totalTimeSpan+=日期[i]-日期[i-1]；
}
WriteLine（“结果超过24小时？{0}”，totalTimeSpan.TotalHours>24）；

需要注意的一点是，你正在对自己的时间做出假设。你假设每一次都比上一次晚，因此如果是一天中较早的时间，那么必须是在第二天

基于该假设，您可以通过一天中的一组时间计算总时间跨度：

string[] times = { "12:00 AM", "12:00 PM", "12:05 AM" };
const string timePattern = "h:mm tt";

DateTime[] dates = times.Select(x => DateTime.ParseExact(x, timePattern, null)).ToArray();

TimeSpan totalTimeSpan = new TimeSpan();

for (int i = 1; i < dates.Length; i++)
{
    // Assume that each time is at least the same date as the previous time
    dates[i] = dates[i - 1].Date + dates[i].TimeOfDay;

    // If this time is earlier than the previous time then assume it must be on the next day
    if (dates[i - 1].TimeOfDay > dates[i].TimeOfDay)
        dates[i] = dates[i].AddDays(1);

    totalTimeSpan += dates[i] - dates[i - 1];
}

Console.WriteLine("Result is more than 24 hours? {0}", totalTimeSpan.TotalHours > 24);

string[]次={“12:00am”，“12:00pm”，“12:05am”}；
常量字符串timePattern=“h:mm tt”；
DateTime[]dates=times.Select（x=>DateTime.ParseExact（x，timePattern，null））.ToArray（）；
TimeSpan totalTimeSpan=新的TimeSpan（）；
对于（int i=1；idates[i].TimeOfDay）
日期[i]=日期[i]。添加天数（1）；
totalTimeSpan+=日期[i]-日期[i-1]；
}
WriteLine（“结果超过24小时？{0}”，totalTimeSpan.TotalHours>24）；

使用LINQ，您可以轻松做到这一点：

string[] times = { "12:00 AM", "12:00 PM", "12:05 AM" };
const string timePattern = "h:mm tt";

var timesOfDay = times.Select(x => DateTime.ParseExact(x, timePattern, CultureInfo.InvariantCulture).TimeOfDay).ToList();
var elapsedTimes = timesOfDay.Zip(timesOfDay.Skip(1), (a, b) => b - a + TimeSpan.FromDays(a > b ? 1 : 0));
TimeSpan totalElapsedTime = elapsedTimes.Aggregate((s, t) => s.Add(t));

---

使用LINQ可以轻松做到这一点：

string[] times = { "12:00 AM", "12:00 PM", "12:05 AM" };
const string timePattern = "h:mm tt";

var timesOfDay = times.Select(x => DateTime.ParseExact(x, timePattern, CultureInfo.InvariantCulture).TimeOfDay).ToList();
var elapsedTimes = timesOfDay.Zip(timesOfDay.Skip(1), (a, b) => b - a + TimeSpan.FromDays(a > b ? 1 : 0));
TimeSpan totalElapsedTime = elapsedTimes.Aggregate((s, t) => s.Add(t));

---

为什么要使用

字符串

数组而不是

日期时间

数组或诸如此类的数组？这些值来自MVC表单。问题是时间显然不是都来自同一天（根据您的描述），但您的代码假设它是。因此，上午12:05是从下午12点算起的11小时55分钟。与其做

math.Abs

，不如在负值上加一天，这样可以得到正确的值。另外，您的实际输入是什么。听起来你在说你在加上12小时，然后加上12小时5分钟，但是你的代码表明你有一天的时间。你的问题没有多大意义。你似乎把d的时间弄糊涂了