J'ai deux vars DateTime, beginTime et endTime. J'ai compris la différence en procédant comme suit:
TimeSpan dateDifference = endTime.Subtract(beginTime);
Comment est-ce que je peux maintenant renvoyer une chaîne de ceci en hh heures, mm minutes, format ss secondes utilisant C #.
Si la différence était de 00: 06: 32.4458750
Il devrait revenir ce 00 heures, 06 minutes, 32 secondes
Est-ce que TimeSpan.ToString () ferait l'affaire pour vous? Sinon, il semble que l'exemple de code de cette page explique comment formater un objet TimeSpan
de façon personnalisée.
Je viens de construire quelques méthodes d'extension TimeSpan. Je pensais pouvoir partager:
public static string ToReadableAgeString(this TimeSpan span)
{
return string.Format("{0:0}", span.Days / 365.25);
}
public static string ToReadableString(this TimeSpan span)
{
string formatted = string.Format("{0}{1}{2}{3}",
span.Duration().Days > 0 ? string.Format("{0:0} day{1}, ", span.Days, span.Days == 1 ? String.Empty : "s") : string.Empty,
span.Duration().Hours > 0 ? string.Format("{0:0} hour{1}, ", span.Hours, span.Hours == 1 ? String.Empty : "s") : string.Empty,
span.Duration().Minutes > 0 ? string.Format("{0:0} minute{1}, ", span.Minutes, span.Minutes == 1 ? String.Empty : "s") : string.Empty,
span.Duration().Seconds > 0 ? string.Format("{0:0} second{1}", span.Seconds, span.Seconds == 1 ? String.Empty : "s") : string.Empty);
if (formatted.EndsWith(", ")) formatted = formatted.Substring(0, formatted.Length - 2);
if (string.IsNullOrEmpty(formatted)) formatted = "0 seconds";
return formatted;
}
En le convertissant en date/heure, vous pouvez obtenir des formats localisés:
new DateTime(timeSpan.Ticks).ToString("HH:mm");
C'est la solution la plus courte.
timeSpan.ToString(@"hh\:mm");
Utilisez String.Format () avec plusieurs paramètres.
using System;
namespace TimeSpanFormat
{
class Program
{
static void Main(string[] args)
{
TimeSpan dateDifference = new TimeSpan(0, 0, 6, 32, 445);
string formattedTimeSpan = string.Format("{0:D2} hrs, {1:D2} mins, {2:D2} secs", dateDifference.Hours, dateDifference.Minutes, dateDifference.Seconds);
Console.WriteLine(formattedTimeSpan);
}
}
}
Le moyen le plus simple de formater une TimeSpan
consiste à l'ajouter à une DateTime
et à un format qui:
string formatted = (DateTime.Today + dateDifference).ToString("HH 'hrs' mm 'mins' ss 'secs'");
Cela fonctionne tant que le décalage horaire ne dépasse pas 24 heures.
La propriété Today
renvoie une valeur DateTime
où le composant heure est égal à zéro. Le composant heure du résultat est donc la valeur TimeSpan
.
public static class TimeSpanFormattingExtensions
{
public static string ToReadableString(this TimeSpan span)
{
return string.Join(", ", span.GetReadableStringElements()
.Where(str => !string.IsNullOrWhiteSpace(str)));
}
private static IEnumerable<string> GetReadableStringElements(this TimeSpan span)
{
yield return GetDaysString((int)Math.Floor(span.TotalDays));
yield return GetHoursString(span.Hours);
yield return GetMinutesString(span.Minutes);
yield return GetSecondsString(span.Seconds);
}
private static string GetDaysString(int days)
{
if (days == 0)
return string.Empty;
if (days == 1)
return "1 day";
return string.Format("{0:0} days", days);
}
private static string GetHoursString(int hours)
{
if (hours == 0)
return string.Empty;
if (hours == 1)
return "1 hour";
return string.Format("{0:0} hours", hours);
}
private static string GetMinutesString(int minutes)
{
if (minutes == 0)
return string.Empty;
if (minutes == 1)
return "1 minute";
return string.Format("{0:0} minutes", minutes);
}
private static string GetSecondsString(int seconds)
{
if (seconds == 0)
return string.Empty;
if (seconds == 1)
return "1 second";
return string.Format("{0:0} seconds", seconds);
}
}
Selon la documentation Microsoft , la structure TimeSpan expose les heures, les minutes, les secondes et les millisecondes en tant que membres entiers. Peut-être que vous voulez quelque chose comme:
dateDifference.Hours.ToString() + " hrs, " + dateDifference.Minutes.ToString() + " mins, " + dateDifference.Seconds.ToString() + " secs"
Merci à Peter pour la méthode d'extension. Je l'ai modifié pour fonctionner avec des durées plus longues:
namespace ExtensionMethods
{
public static class TimeSpanExtensionMethods
{
public static string ToReadableString(this TimeSpan span)
{
string formatted = string.Format("{0}{1}{2}",
(span.Days / 7) > 0 ? string.Format("{0:0} weeks, ", span.Days / 7) : string.Empty,
span.Days % 7 > 0 ? string.Format("{0:0} days, ", span.Days % 7) : string.Empty,
span.Hours > 0 ? string.Format("{0:0} hours, ", span.Hours) : string.Empty);
if (formatted.EndsWith(", ")) formatted = formatted.Substring(0, formatted.Length - 2);
return formatted;
}
}
}
Vous pouvez utiliser le code suivant.
public static class TimeSpanExtensions
{
public static String Verbose(this TimeSpan timeSpan)
{
var hours = timeSpan.Hours;
var minutes = timeSpan.Minutes;
if (hours > 0) return String.Format("{0} hours {1} minutes", hours, minutes);
return String.Format("{0} minutes", minutes);
}
}
Je sais que cette question est plus ancienne, mais .Net 4 prend désormais en charge les formats Formats personnalisés TimeSpan .
De plus, je sais que cela a été mentionné, mais cela m’a pris au dépourvu. Convertir Ticks en DateTime fonctionne, mais ne gère pas correctement plus de 24 heures.
new DateTime((DateTime.Now - DateTime.Now.AddHours(-25)).Ticks).ToString("HH:mm")
Cela vous donnera 01:00 pas 25:00 comme vous pouvez vous attendre.
J'ai également eu un problème similaire et est venu avec ma propre extension mais il semble être un peu différent de tout le reste.
public static string TimeSpanToString(this TimeSpan timeSpan)
{
//if it's negative
if (timeSpan.Ticks < 0)
{
timeSpan = timeSpan - timeSpan - timeSpan;
if (timeSpan.Days != 0)
return string.Format("-{0}:{1}", timeSpan.Days.ToString("d"), new DateTime(timeSpan.Ticks).ToString("HH:mm:ss"));
else
return new DateTime(timeSpan.Ticks).ToString("-HH:mm:ss");
}
//if it has days
else if (timeSpan.Days != 0)
return string.Format("{0}:{1}", timeSpan.Days.ToString("d"), new DateTime(timeSpan.Ticks).ToString("HH:mm:ss"));
//otherwise return the time
else
return new DateTime(timeSpan.Ticks).ToString("HH:mm:ss");
}
Je sais que c'est une réponse tardive mais cela fonctionne pour moi:
TimeSpan dateDifference = new TimeSpan(0,0,0, (int)endTime.Subtract(beginTime).TotalSeconds);
dateDifference devrait maintenant exclure les parties inférieures à une seconde. Fonctionne également en .net 2.0.