Quelle est la meilleure façon de convertir les secondes en (heure: minutes: secondes: millisecondes)?

Quelle est la meilleure façon de convertir les secondes en (heure: minutes: secondes: millisecondes)?

Disons que j'ai 80 secondes, y a-t-il des classes / techniques spécialisées dans .NET qui me permettraient de convertir ces 80 secondes au format (00h: 00m: 00s: 00ms) comme en DateTime ou quelque chose?

Pour .Net <= 4.0 Utilisez la classe TimeSpan.

TimeSpan t = TimeSpan.FromSeconds( secs );

string answer = string.Format("{0:D2}h:{1:D2}m:{2:D2}s:{3:D3}ms", 
                t.Hours, 
                t.Minutes, 
                t.Seconds, 
                t.Milliseconds);

(Comme indiqué par Inder Kumar Rathore) Pour .NET> 4.0, vous pouvez utiliser

TimeSpan time = TimeSpan.FromSeconds(seconds);

//here backslash is must to tell that colon is
//not the part of format, it just a character that we want in output
string str = time .ToString(@"hh\:mm\:ss\:fff");

(De Nick Molyneux) Assurez-vous que les secondes sont inférieures à TimeSpan.MaxValue.TotalSecondspour éviter une exception.

Pour .NET> 4.0, vous pouvez utiliser

TimeSpan time = TimeSpan.FromSeconds(seconds);

//here backslash is must to tell that colon is
//not the part of format, it just a character that we want in output
string str = time .ToString(@"hh\:mm\:ss\:fff");

ou si vous voulez le format date-heure, vous pouvez également le faire

TimeSpan time = TimeSpan.FromSeconds(seconds);
DateTime dateTime = DateTime.Today.Add(time);
string displayTime = dateTime.ToString("hh:mm:tt");

Pour plus d'informations, vous pouvez vérifier les chaînes de format TimeSpan personnalisées

Si vous savez que vous disposez d'un certain nombre de secondes, vous pouvez créer une valeur TimeSpan en appelant TimeSpan.FromSeconds:

 TimeSpan ts = TimeSpan.FromSeconds(80);

Vous pouvez alors obtenir le nombre de jours, heures, minutes ou secondes. Ou utilisez l'une des surcharges ToString pour la sortir de la manière que vous souhaitez.

J'ai fait quelques repères pour voir quel est le moyen le plus rapide et ce sont mes résultats et mes conclusions. J'ai exécuté chaque méthode 10 millions de fois et ajouté un commentaire avec le temps moyen par exécution.

Si vos millisecondes d'entrée ne sont pas limitées à un jour (votre résultat peut être 143: 59: 59.999), ce sont les options, de la plus rapide à la plus lente:

// 0.86 ms
static string Method1(int millisecs)
{
    int hours = millisecs / 3600000;
    int mins = (millisecs % 3600000) / 60000;
    // Make sure you use the appropriate decimal separator
    return string.Format("{0:D2}:{1:D2}:{2:D2}.{3:D3}", hours, mins, millisecs % 60000 / 1000, millisecs % 1000);
}

// 0.89 ms
static string Method2(int millisecs)
{
    double s = millisecs % 60000 / 1000.0;
    millisecs /= 60000;
    int mins = millisecs % 60;
    int hours = millisecs / 60;
    return string.Format("{0:D2}:{1:D2}:{2:00.000}", hours, mins, s);
}

// 0.95 ms
static string Method3(int millisecs)
{
    TimeSpan t = TimeSpan.FromMilliseconds(millisecs);
    // Make sure you use the appropriate decimal separator
    return string.Format("{0:D2}:{1:D2}:{2:D2}.{3:D3}",
        (int)t.TotalHours,
        t.Minutes,
        t.Seconds,
        t.Milliseconds);
}

Si vos millisecondes d'entrée sont limitées à un jour (votre résultat ne sera jamais supérieur à 23: 59: 59.999), ce sont les options, de la plus rapide à la plus lente:

// 0.58 ms
static string Method5(int millisecs)
{
    // Fastest way to create a DateTime at midnight
    // Make sure you use the appropriate decimal separator
    return DateTime.FromBinary(599266080000000000).AddMilliseconds(millisecs).ToString("HH:mm:ss.fff");
}

// 0.59 ms
static string Method4(int millisecs)
{
    // Make sure you use the appropriate decimal separator
    return TimeSpan.FromMilliseconds(millisecs).ToString(@"hh\:mm\:ss\.fff");
}

// 0.93 ms
static string Method6(int millisecs)
{
    TimeSpan t = TimeSpan.FromMilliseconds(millisecs);
    // Make sure you use the appropriate decimal separator
    return string.Format("{0:D2}:{1:D2}:{2:D2}.{3:D3}",
        t.Hours,
        t.Minutes,
        t.Seconds,
        t.Milliseconds);
}

Si votre saisie ne dure que quelques secondes , les méthodes sont légèrement plus rapides. Encore une fois, si vos secondes d'entrée ne sont pas limitées à un jour (votre résultat peut être 143: 59: 59):

// 0.63 ms
static string Method1(int secs)
{
    int hours = secs / 3600;
    int mins = (secs % 3600) / 60;
    secs = secs % 60;
    return string.Format("{0:D2}:{1:D2}:{2:D2}", hours, mins, secs);
}

// 0.64 ms
static string Method2(int secs)
{
    int s = secs % 60;
    secs /= 60;
    int mins = secs % 60;
    int hours = secs / 60;
    return string.Format("{0:D2}:{1:D2}:{2:D2}", hours, mins, s);
}

// 0.70 ms
static string Method3(int secs)
{
    TimeSpan t = TimeSpan.FromSeconds(secs);
    return string.Format("{0:D2}:{1:D2}:{2:D2}",
        (int)t.TotalHours,
        t.Minutes,
        t.Seconds);
}

Et si vos secondes d'entrée sont limitées à un jour (votre résultat ne sera jamais supérieur à 23:59:59):

// 0.33 ms
static string Method5(int secs)
{
    // Fastest way to create a DateTime at midnight
    return DateTime.FromBinary(599266080000000000).AddSeconds(secs).ToString("HH:mm:ss");
}

// 0.34 ms
static string Method4(int secs)
{
    return TimeSpan.FromSeconds(secs).ToString(@"hh\:mm\:ss");
}

// 0.70 ms
static string Method6(int secs)
{
    TimeSpan t = TimeSpan.FromSeconds(secs);
    return string.Format("{0:D2}:{1:D2}:{2:D2}",
        t.Hours,
        t.Minutes,
        t.Seconds);
}

Pour terminer, permettez-moi d'ajouter que j'ai remarqué que string.Formatc'est un peu plus rapide si vous utilisez à la D2place de 00.

TimeSpan.FromSeconds(80);

http://msdn.microsoft.com/en-us/library/system.timespan.fromseconds.aspx

Le constructeur TimeSpan vous permet de passer en quelques secondes. Déclarez simplement une variable de type TimeSpan quantité de secondes. Ex:

TimeSpan span = new TimeSpan(0, 0, 500);
span.ToString();

Je vous suggère d'utiliser la TimeSpanclasse pour cela.

public static void Main(string[] args)
{
    TimeSpan t = TimeSpan.FromSeconds(80);
    Console.WriteLine(t.ToString());

    t = TimeSpan.FromSeconds(868693412);
    Console.WriteLine(t.ToString());
}

Les sorties:

00:01:20
10054.07:43:32

Dans VB.NET, mais c'est la même chose en C #:

Dim x As New TimeSpan(0, 0, 80)
debug.print(x.ToString())
' Will print 00:01:20

Pour .NET <4.0 (ex: Unity ), vous pouvez écrire une méthode d'extension pour avoir le TimeSpan.ToString(string format)comportement comme .NET> 4.0

public static class TimeSpanExtensions
{
    public static string ToString(this TimeSpan time, string format)
    {
        DateTime dateTime = DateTime.Today.Add(time);
        return dateTime.ToString(format);
    }
}

Et de n'importe où dans votre code, vous pouvez l'utiliser comme:

var time = TimeSpan.FromSeconds(timeElapsed);

string formattedDate = time.ToString("hh:mm:ss:fff");

De cette façon, vous pouvez formater n'importe quel TimeSpanobjet en appelant simplement ToString à partir de n'importe où dans votre code.

Pourquoi les gens ont-ils besoin de TimeSpan ET DateTime si nous avons DateTime.AddSeconds ()?

var dt = new DateTime(2015, 1, 1).AddSeconds(totalSeconds);

La date est arbitraire. totalSeconds peut être supérieur à 59 et c'est un double. Ensuite, vous pouvez formater votre heure comme vous le souhaitez en utilisant DateTime.ToString ():

dt.ToString("H:mm:ss");

Cela ne fonctionne pas si totalSeconds <0 ou> 59:

new DateTime(2015, 1, 1, 0, 0, totalSeconds)

private string ConvertTime(double miliSeconds)
{
    var timeSpan = TimeSpan.FromMilliseconds(totalMiliSeconds);
    // Converts the total miliseconds to the human readable time format
    return timeSpan.ToString(@"hh\:mm\:ss\:fff");
}

//Tester

    [TestCase(1002, "00:00:01:002")]
    [TestCase(700011, "00:11:40:011")]
    [TestCase(113879834, "07:37:59:834")]
    public void ConvertTime_ResturnsCorrectString(double totalMiliSeconds, string expectedMessage)
    {
        // Arrange
        var obj = new Class();;

        // Act
        var resultMessage = obj.ConvertTime(totalMiliSeconds);

        // Assert
        Assert.AreEqual(expectedMessage, resultMessage);
    }

pour obtenir un total de secondes

var i = TimeSpan.FromTicks(startDate.Ticks).TotalSeconds;

et pour obtenir datetime de quelques secondes

var thatDateTime = new DateTime().AddSeconds(i)

Cela retournera au format hh: mm: ss

 public static string ConvertTime(long secs)
    {
        TimeSpan ts = TimeSpan.FromSeconds(secs);
        string displayTime = $"{ts.Hours}:{ts.Minutes}:{ts.Seconds}";
        return displayTime;
    }