Qual é a melhor maneira de converter segundos em (hora: minutos: segundos: milissegundos)?

Qual é a melhor maneira de converter segundos em (hora: minutos: segundos: milissegundos)?

Digamos que eu tenho 80 segundos, existem classes / técnicas especializadas no .NET que me permitam converter esses 80 segundos no formato (00h: 00m: 00s: 00ms) como DateTime ou algo assim?

Para .Net <= 4.0 Use a 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);

(Como observado por Inder Kumar Rathore) Para .NET> 4.0, você pode usar

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) Verifique se os segundos são menores do que TimeSpan.MaxValue.TotalSecondspara evitar uma exceção.

Para .NET> 4.0, você pode usar

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 se você quiser o formato de data e hora, também poderá fazer isso

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

Para saber mais, você pode verificar as seqüências de caracteres personalizadas do formato TimeSpan

Se você souber que possui um número de segundos, poderá criar um valor TimeSpan chamando TimeSpan.FromSeconds:

 TimeSpan ts = TimeSpan.FromSeconds(80);

Você pode obter o número de dias, horas, minutos ou segundos. Ou use uma das sobrecargas do ToString para produzi-lo da maneira que desejar.

Fiz alguns benchmarks para ver qual é o caminho mais rápido e esses são meus resultados e conclusões. Executei cada método 10 milhões de vezes e adicionei um comentário com o tempo médio por execução.

Se seus milissegundos de entrada não estiverem limitados a um dia (seu resultado pode ser 143: 59: 59.999), estas são as opções, de mais rápida a mais lenta:

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

Se seus milissegundos de entrada são limitados a um dia (seu resultado nunca será superior a 23: 59: 59.999), estas são as opções, de mais rápida a mais lenta:

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

Caso sua entrada seja apenas alguns segundos , os métodos serão um pouco mais rápidos. Novamente, se os segundos de entrada não estiverem limitados a um dia (o resultado pode ser 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);
}

E se os segundos de entrada forem limitados a um dia (seu resultado nunca será maior que 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);
}

Como comentário final, deixe-me acrescentar que notei que string.Formaté um pouco mais rápido se você usar em D2vez de 00.

TimeSpan.FromSeconds(80);

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

O construtor TimeSpan permite passar em segundos. Simplesmente declare uma variável do tipo TimeSpan por segundos. Ex:

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

Eu sugiro que você use a TimeSpanclasse para isso.

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

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

Saídas:

00:01:20
10054.07:43:32

No VB.NET, mas é o mesmo em c #:

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

Para .NET <4.0 (ex: Unity ), você pode escrever um método de extensão para ter o TimeSpan.ToString(string format)comportamento como .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);
    }
}

E de qualquer lugar no seu código, você pode usá-lo como:

var time = TimeSpan.FromSeconds(timeElapsed);

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

Dessa forma, você pode formatar qualquer TimeSpanobjeto simplesmente chamando ToString de qualquer lugar do seu código.

Por que as pessoas precisam de TimeSpan AND DateTime se temos DateTime.AddSeconds ()?

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

A data é arbitrária. totalSeconds pode ser maior que 59 e é um dobro. Em seguida, você pode formatar seu horário como quiser usando DateTime.ToString ():

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

Isso não funciona se 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");
}

//Teste

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

para obter segundos totais

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

e para obter data e hora de segundos

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

Isso retornará no formato hh: mm: ss

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