Können Sie eine Runde .NET TimeSpan-Objekt?

Sorry, Jungs, aber beide die Frage und die gängigen Antworten bisher sind falsch 🙂

Die Frage ist falsch, weil Tyndall fragt nach einem Weg, um Runde aber zeigt ein Beispiel abschneiden.

Wird Dean ' s Antwort ist falsch, weil es auch Adressen abschneiden eher als Rundung. (Ich nehme an, man argumentieren könnte, die Antwort ist richtig, wenn eine der beiden Fragen, aber lassen wir die Philosophie beiseite für den moment...)

Hier ist eine einfache Technik für Rundung:

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

Mit dem input-Wert und die Anzahl der Ziffern im Beispiel-code, das ist die Ausgabe:

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

Ändern Sie die Genauigkeit von 2 Ziffern 5 Ziffern und erhalten dadurch statt:

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

Und sogar ändern Sie ihn auf 0 zu bekommen dieses Ergebnis:

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

Schließlich, wenn Sie wollen einfach nur ein bisschen mehr Kontrolle über die Ausgabe, fügen Sie einige Formatierungen. Hier ist ein Beispiel, die zeigen, dass Sie getrennt werden können, die Genauigkeit von der Anzahl der angezeigten Ziffern. Die Präzision ist wieder auf 2 gesetzt, aber 3 Ziffern angezeigt werden, wie in dem letzten argument der Steuerung der Formatierung string:

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 UPDATE: Eine Out-of-the-box-Lösung

Den oben genannten Materialien ist nützlich, wenn Sie sind auf der Suche nach Ideen; ich habe da mal umsetzen eine Pauschale Lösung für diejenigen, die ready-to-use code.

Beachten Sie, dass dies unkommentiert code. Die vollständig kommentierte version mit XML-doc-Kommentare werden in meinem open-source-Bibliothek Ende des Quartals. Aber ich zögerte, um es zu veröffentlichen "raw" wie diese, ich vermute, dass es noch von einigen nutzen für Interessierte Leser.

Dieser code verbessert auf meine obigen code, die, wenn es abgerundete, noch zeigte 7 Nachkommastellen, aufgefüllt mit Nullen. Diese fertigen version Runden und trimmt, um die angegebene Anzahl von stellen.

Hier ist ein Beispiel-Aufruf:

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

Und hier ist die komplette RoundedTimeSpan.cs-Datei:

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 UPDATE: Pauschale Lösung jetzt erhältlich

Ich soeben eine neue version meiner open-source-Bibliotheken gestern, früher als erwartet, einschließlich der RoundedTimeSpan die ich oben beschrieben habe. Code ist hier; für die API starten hier navigieren Sie dann zu RoundedTimeSpan unter der CleanCode.Data namespace. Die CleanCode.DLL die Bibliothek enthält den code oben aber sieht es in einem fertigen Paket. Beachten Sie, dass ich eine leichte Verbesserung in der ToString(int) Methode vor, seit ich gepostet es auf 2010.01.06.

InformationsquelleAutor der Antwort Michael Sorens

Wenn Sie möchten, eine Zeitspanne, eine einfache one-liner:

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

Wenn Sie möchten, eine Zeichenfolge:

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

Credits:

cc1960 Antwort zeigt die Verwendung von FromSecondsaber er gerundet auf ganze Sekunden. Meine Antwort verallgemeinert um die angegebene Anzahl von stellen.

Ed ' s Antwort schlägt mit einem format-string und enthält den link zur Formatierung Dokument.

InformationsquelleAutor der Antwort ToolmakerSteve

Gegeben, einige der Kommentare, die über Runden Sekunden, dachte ich, Rundung, jede Zeitspanne wäre nett:

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

InformationsquelleAutor der Antwort NetMage

Hier ist eine schöne Erweiterung-Methode:

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

Und hier sind einige Beispiele:

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

InformationsquelleAutor der Antwort Gewalius

Meine Lösung:

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

InformationsquelleAutor der Antwort cc1960