Pouvez-vous autour d'une .NET objet TimeSpan?

Désolé, les gars, mais les deux la question et la réponse sont jusqu'à présent mal 🙂

La question est mal parce que Tyndall demande un moyen de ronde mais montre un exemple de troncature.

Sera Doyen de la réponse est incorrecte, car elle aborde également les troncature plutôt que arrondissement. (Je suppose que l'on pourrait faire valoir que la réponse est juste pour l'une des deux questions, mais laissons la philosophie de côté pour le moment...)

Voici une technique simple pour arrondissement:

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

Avec la valeur d'entrée et le nombre de chiffres dans l'exemple de code, c'est la sortie:

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

Modifier la précision de 2 chiffres 5 chiffres et obtenir ceci à la place:

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

Et même de changer à 0 pour obtenir ce résultat:

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

Enfin, si vous voulez juste un peu plus de contrôle sur la sortie, ajouter un peu de mise en forme. Voici un exemple, qui montre que vous pouvez séparer la précision du nombre de chiffres affichés. La précision est de nouveau fixé à 2 mais à 3 chiffres sont affichés, comme spécifié dans le dernier argument du formatage de chaîne de contrôle:

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 mise à JOUR: Un Out-of-the-box Solution

Le matériel ci-dessus sont utiles si vous êtes à la recherche d'idées; depuis, j'ai eu le temps de mettre en œuvre une solution packagée pour ceux à la recherche de prêt-à-utiliser le code.

Noter que c'est sans commentaire code. L'commenté complet version avec XML-doc-commentaires seront disponibles dans mon bibliothèque open source par la fin du trimestre. Bien que j'ai hésité à le poster "raw" comme ça, je me dis que ça pourrait quand même être d'une certaine utilité pour les lecteurs intéressés.

Ce code améliore mon code ci-dessus qui, bien arrondis, montraient encore 7 places, complétée par des zéros. Cette version finale des tours et des garnitures pour le nombre spécifié de chiffres.

Voici un exemple d'appel:

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

Et voici la RoundedTimeSpan.cs fichier:

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 mise à JOUR: solution packagée maintenant disponible

Je viens de sortir une nouvelle version de mon bibliothèques open-source hier, plus tôt que prévu, y compris la RoundedTimeSpan que j'ai décrit ci-dessus. Le Code est ici; pour l'API de commencer ici puis accédez à RoundedTimeSpan en vertu de la CleanCode.Data espace de noms. L'CleanCode.DLL la bibliothèque comprend le code indiqué ci-dessus, mais il fournit dans un emballage fini. Notez que j'ai fait une légère amélioration dans le ToString(int) méthode ci-dessus depuis que je l'ai posté sur 2010.01.06.

OriginalL'auteur Michael Sorens

Si vous voulez une plage de Temps, de ses un one-liner:

public static TimeSpan RoundSeconds( TimeSpan span, int nDigits ) {
return TimeSpan.FromTicks( (long)( Math.Round( span.TotalSeconds, nDigits ) * TimeSpan.TicksPerSecond) );
//A simpler one-liner, if not doing more than 3 digits (TimeSpan.FromSeconds rounds to nearest millisecond):
//return TimeSpan.FromSeconds( Math.Round( span.TotalSeconds, nDigits ) );
}

Si vous voulez une chaîne de caractères:

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

---

Crédits:

cc1960 expositions de la réponse de l'utilisation de FromSeconds, mais il a arrondi à l'entier de secondes. Ma réponse généralise à un nombre spécifié de chiffres.

Ed réponse suggère d'utiliser une chaîne de format, et inclut un lien pour la mise en forme du document.

---

À arrondir au multiple de certains autres, comme le 1 /30e de seconde:

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

À utiliser l'un de ces à tour à des multiples de 1 /30e de seconde:

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

Résultats affichés dans le débogueur:

//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

OriginalL'auteur ToolmakerSteve

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

OriginalL'auteur mapache

Voici une belle Extension-Méthode:

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

Et voici quelques Exemples:

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

OriginalL'auteur Gewalius

Ma solution:

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

OriginalL'auteur cc1960