您可以舍入 .NET TimeSpan 对象吗？

Question

您可以舍入 .NET TimeSpan 对象吗？

我的 Timespan 值为：00:00:00.6193789

有没有一种简单的方法可以将其保留为 TimeSpan 对象，但将其舍入为类似
00:00:00.62？

Answer 1

抱歉，伙计们，但是这个问题和迄今为止流行的答案都是错误的:-)

这个问题是错误的，因为廷德尔要求一种方法圆，但显示了截断的示例。

Will Dean 的答案是错误的，因为它还解决了截断问题，而不是舍入问题。 （我想有人可能会认为答案对于两个问题之一是正确的，但让我们暂时把哲学放在一边......）

这是一种简单的四舍五入技巧 ：

int precision = 2; // Specify how many digits past the decimal point
TimeSpan t1 = new TimeSpan(19365678); // sample input value

const int TIMESPAN_SIZE = 7; // it always has seven digits
// convert the digitsToShow into a rounding/truncating mask
int factor = (int)Math.Pow(10,(TIMESPAN_SIZE - precision));

Console.WriteLine("Input: " + t1);
TimeSpan truncatedTimeSpan = new TimeSpan(t1.Ticks - (t1.Ticks % factor));
Console.WriteLine("Truncated: " + truncatedTimeSpan);
TimeSpan roundedTimeSpan =
    new TimeSpan(((long)Math.Round((1.0*t1.Ticks/factor))*factor));
Console.WriteLine("Rounded: " + roundedTimeSpan);

根据示例代码中的输入值和位数，这就是输出：

Input: 00:00:01.9365678
Truncated: 00:00:01.9300000
Rounded: 00:00:01.9400000

将精度从 2 位更改为 5 位，然后得到此结果：

Input: 00:00:01.9365678
Truncated: 00:00:01.9365600
Rounded: 00:00:01.9365700

甚至将其更改为 0 以获得此结果：

Input: 00:00:01.9365678
Truncated: 00:00:01
Rounded: 00:00:02

最后，如果您想要对输出进行更多控制，添加一些格式。 下面是一个示例，显示您可以将精度与显示的位数分开。 精度再次设置为 2，但显示 3 位数字，如格式控制字符串的最后一个参数中所指定：

Console.WriteLine("Rounded/formatted: " + 
  string.Format("{0:00}:{1:00}:{2:00}.{3:000}",
      roundedTimeSpan.Hours, roundedTimeSpan.Minutes,
      roundedTimeSpan.Seconds, roundedTimeSpan.Milliseconds));
// Input: 00:00:01.9365678
// Truncated: 00:00:01.9300000
// Rounded: 00:00:01.9400000
// Rounded/formatted: 00:00:01.940

---

2010.01.06 更新：开箱即用的解决方案

如果您正在寻找想法，上述材料很有用; 从那以后，我有时间为那些寻找即用代码的人实现一个打包的解决方案。

请注意，这是未注释的代码。 带有 XML-doc-comments 的完整注释版本将于本季度末在我的开源库中提供。 虽然我犹豫是否像这样“原始”发布它，但我认为它仍然对感兴趣的读者有一些好处。

此代码改进了我上面的代码，尽管它四舍五入，但仍然显示 7 个位置，并用零。 此完成版本四舍五入并修剪为指定的位数。

这是一个示例调用：

Console.Write(new RoundedTimeSpan(19365678, 2).ToString());
// Result = 00:00:01.94

这是完整的 RoundedTimeSpan.cs 文件：

using System;

namespace CleanCode.Data
{
    public struct RoundedTimeSpan
    {

        private const int TIMESPAN_SIZE = 7; // it always has seven digits

        private TimeSpan roundedTimeSpan;
        private int precision;

        public RoundedTimeSpan(long ticks, int precision)
        {
            if (precision < 0) { throw new ArgumentException("precision must be non-negative"); }
            this.precision = precision;
            int factor = (int)System.Math.Pow(10, (TIMESPAN_SIZE - precision));

            // This is only valid for rounding milliseconds-will *not* work on secs/mins/hrs!
            roundedTimeSpan = new TimeSpan(((long)System.Math.Round((1.0 * ticks / factor)) * factor));
        }

        public TimeSpan TimeSpan { get { return roundedTimeSpan; } }

        public override string ToString()
        {
            return ToString(precision);
        }

        public string ToString(int length)
        { // this method revised 2010.01.31
            int digitsToStrip = TIMESPAN_SIZE - length;
            string s = roundedTimeSpan.ToString();
            if (!s.Contains(".") && length == 0) { return s; }
            if (!s.Contains(".")) { s += "." + new string('0', TIMESPAN_SIZE); }
            int subLength = s.Length - digitsToStrip;
            return subLength < 0 ? "" : subLength > s.Length ? s : s.Substring(0, subLength);
        }
    }
}

---

2010.02.01 更新：打包解决方案现已可用

我昨天刚刚发布了我的开源库的新版本，比预期的要早，包括我上面描述的 RoundedTimeSpan。 代码位于此处； 对于 API，请从此处开始，然后导航至 RoundedTimeSpan >CleanCode.Data 命名空间。 CleanCode.DLL 库包含上面显示的代码，但以成品包形式提供。 请注意，自从我在 2010 年 1 月 6 日发布以来，我对上面的 ToString(int) 方法做了一些改进。

Answer 2

如果要四舍五入到整秒，则最简单的一行：

public static TimeSpan RoundSeconds( TimeSpan span ) {
    return TimeSpan.FromSeconds( Math.Round( span.TotalSeconds ) );
}

---

四舍五入到最多 3 位数字（例如十分之一、百分之一秒或毫秒：

public static TimeSpan RoundSeconds( TimeSpan span, int nDigits ) {
    // TimeSpan.FromSeconds rounds to nearest millisecond, so nDigits should be 3 or less - won't get good answer beyond 3 digits.
    Debug.Assert( nDigits <= 3 );
    return TimeSpan.FromSeconds( Math.Round( span.TotalSeconds, nDigits ) );
}

---

对于超过 3 位数字，它稍微复杂一些 - 但仍然是单行。这也可以用于 3 个或更少的数字 - 它是上面显示的版本的替代品：

public static TimeSpan RoundSeconds( TimeSpan span, int nDigits ) {
    return TimeSpan.FromTicks( (long)( Math.Round( span.TotalSeconds, nDigits ) * TimeSpan.TicksPerSecond) );
}

如果你想要一个字符串（根据评论，这种技术最多只能工作到） 7 位数字）：

public static string RoundSecondsAsString( TimeSpan span, int nDigits ) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < nDigits; i++)
        sb.Append( "f" );
    return span.ToString( @"hh\:mm\:ss\." + sb );
}

---

对于一天中的时间，如小时和分钟，四舍五入：

public static TimeSpan RoundMinutes(TimeSpan span)
    {
        return TimeSpan.FromMinutes(Math.Round(span.TotalMinutes));
    }

如果您有 DateTime，并且想要提取一天中的时间四舍五入：

DateTime dt = DateTime.Now();
TimeSpan hhmm = RoundMinutes(dt.TimeOfDay);

显示四舍五入的 24 小时time:

string hhmmStr = RoundMinutes(dt.TimeOfDay).ToString(@"hh\:mm");

要显示当前文化中的时间：

string hhmmStr = new DateTime().Add(RoundMinutes(dt.TimeOfDay)).ToShortTimeString();

---

学分：

cc1960 的答案显示了 FromSeconds 的使用，但他四舍五入到整秒。

Ed 的答案建议使用格式字符串，并包含指向的链接 。

Chris Marisic 展示了如何将 ToShortTimeString 应用于 TimeSpan（首先转换为日期时间）。

---

要舍入为其他单位的倍数，例如 1/30 秒：

    // Rounds span to multiple of "unitInSeconds".
    // NOTE: This will be close to the requested multiple,
    // but is not exact when unit cannot be exactly represented by a double.
    // e.g. "unitInSeconds = 1/30" isn't EXACTLY 1/30,
    // so the returned value won't be exactly a multiple of 1/30.
    public static double RoundMultipleAsSeconds( TimeSpan span, double unitInSeconds )
    {
        return unitInSeconds * Math.Round( span.TotalSeconds / unitInSeconds );
    }

    public static TimeSpan RoundMultipleAsTimeSpan( TimeSpan span, double unitInSeconds )
    {
        return TimeSpan.FromTicks( (long)(RoundMultipleAsSeconds( span, unitInSeconds ) * TimeSpan.TicksPerSecond) );

        // IF USE THIS: TimeSpan.FromSeconds rounds the result to nearest millisecond.
        //return TimeSpan.FromSeconds( RoundMultipleAsSeconds( span, unitInSeconds ) );
    }

    // Rounds "span / n".
    // NOTE: This version might be a hair closer in some cases,
    // but probably not enough to matter, and can only represent units that are "1 / N" seconds.
    public static double RoundOneOverNAsSeconds( TimeSpan span, double n )
    {
        return Math.Round( span.TotalSeconds * n ) / n;
    }

    public static TimeSpan RoundOneOverNAsTimeSpan( TimeSpan span, double n )
    {
        return TimeSpan.FromTicks( (long)(RoundOneOverNAsSeconds( span, n ) * TimeSpan.TicksPerSecond) );

        // IF USE THIS: TimeSpan.FromSeconds rounds the result to nearest millisecond.
        //return TimeSpan.FromSeconds( RoundOneOverNAsSeconds( span, n ) );
    }

要使用其中之一舍入为 1/30 秒的倍数：

    private void Test()
    {
        long ticks = (long) (987.654321 * TimeSpan.TicksPerSecond);
        TimeSpan span = TimeSpan.FromTicks( ticks );
        TestRound( span, 30 );
        TestRound( TimeSpan.FromSeconds( 987 ), 30 );
    }

    private static void TestRound(TimeSpan span, int n)
    {
        var answer1 = RoundMultipleAsSeconds( span, 1.0 / n );
        var answer2 = RoundMultipleAsTimeSpan( span, 1.0 / n );
        var answer3 = RoundOneOverNAsSeconds( span, n );
        var answer4 = RoundOneOverNAsTimeSpan( span, n );
    }

在调试器中查看结果：

// for 987.654321 seconds:
    answer1 987.66666666666663  double
    answer2 {00:16:27.6666666}  System.TimeSpan
    answer3 987.66666666666663  double
    answer4 {00:16:27.6666666}  System.TimeSpan

// for 987 seconds:
    answer1 987 double
    answer2 {00:16:27}  System.TimeSpan
    answer3 987 double
    answer4 {00:16:27}  System.TimeSpan

Answer 3

TimeSpan 只不过是“Ticks”成员的包装。 从另一个 TimeSpan 的 Ticks 的舍入版本创建一个新的 TimeSpan 非常容易。

TimeSpan t1 = new TimeSpan(2345678);
Console.WriteLine(t1);
TimeSpan t2 = new TimeSpan(t1.Ticks - (t1.Ticks % 100000));
Console.WriteLine(t2);

给出：

00:00:00.2345678
00:00:00.2300000

Answer 4

鉴于一些关于舍入到秒的评论，我认为舍入到任何 TimeSpan 会很好：

public static TimeSpan Round(this TimeSpan ts, TimeSpan rnd) {
    if (rnd == TimeSpan.Zero)
        return ts;
    else {
        var rndTicks = rnd.Ticks;
        var ansTicks = ts.Ticks + Math.Sign(ts.Ticks) * rndTicks / 2;
        return TimeSpan.FromTicks(ansTicks - ansTicks % rndTicks);
    }
}
public static TimeSpan Round(this TimeSpan ts) => ts.Round(TimeSpan.FromSeconds(1));

考虑到处理小数单位时舍入到刻度的潜在不准确性（根据 @ToolmakerSteve），我添加了一个小数舍入选项，以便当您需要更高的值时精度并四舍五入到计算机小数秒：

public static TimeSpan RoundToFraction(this TimeSpan ts, long num, long den) => (den == 0.0) ? TimeSpan.Zero : TimeSpan.FromTicks((long)Math.Round(Math.Round((double)ts.Ticks * (double)den / num / TimeSpan.TicksPerSecond) * (double)num / den * TimeSpan.TicksPerSecond));
public static TimeSpan RoundToFraction(this TimeSpan ts, long den) => (den == 0.0) ? TimeSpan.Zero : TimeSpan.FromTicks((long)(Math.Round((double)ts.Ticks * den / TimeSpan.TicksPerSecond) / den * TimeSpan.TicksPerSecond));

Answer 5

new TimeSpan(tmspan.Hours, tmspan.Minutes, tmspan.Seconds, (int)Math.Round(Convert.ToDouble(tmspan.Milliseconds / 10)));

Answer 6

我的解决方案：

    static TimeSpan RoundToSec(TimeSpan ts)
    {
        return TimeSpan.FromSeconds((int)(ts.TotalSeconds));
    }

Answer 7

不确定 TimeSpan，但您可以查看有关 DateTimes 的这篇文章：
http://mikeinmadison.wordpress.com/2008/03/12/datetimeround/< /a>

Answer 8

将毫秒四舍五入到最接近的秒的另一种方法。

private const long TicksPer1000Milliseconds = 1000 * TimeSpan.TicksPerMillisecond;

// Round milliseconds to nearest second
// To round up, add the sub-second ticks required to reach the next second
// To round down, subtract the sub-second ticks
elapsedTime = new TimeSpan(elapsedTime.Ticks + (elapsedTime.Milliseconds >= 500 ? TicksPer1000Milliseconds - (elapsedTime.Ticks % TicksPer1000Milliseconds) : -(elapsedTime.Ticks % TicksPer1000Milliseconds)));

Answer 9

这是一个很好的扩展方法：

    public static TimeSpan RoundToSeconds(this TimeSpan timespan, int seconds = 1)
    {
        long offset = (timespan.Ticks >= 0) ? TimeSpan.TicksPerSecond / 2 : TimeSpan.TicksPerSecond / -2;
        return TimeSpan.FromTicks((timespan.Ticks + offset) / TimeSpan.TicksPerSecond * TimeSpan.TicksPerSecond);
    }

这里有一些示例：

DateTime dt1 = DateTime.Now.RoundToSeconds();  // round to full seconds
DateTime dt2 = DateTime.Now.RoundToSeconds(5 * 60);  // round to full 5 minutes

Answer 10

如果您需要使用 DateTime，但仍想对时间进行舍入，则可以使用扩展方法。 就我而言，我想四舍五入到分钟。

public static DateTime RoundToMinute(this DateTime date)
    {
        return DateTime.MinValue.AddMinutes(Math.Round((date - DateTime.MinValue).TotalMinutes));
    }