Format TimeSpan größer als 24 Stunden

Microsoft nicht (aktuell) haben ein einfaches format-string-Verknüpfung. Die einfachsten Optionen, die bereits geteilt wurde.

string.Format("{0}hr {1:mm}mn {1:ss}sec", (int)t.TotalHours, t);

Jedoch eine allzu Gründliche Möglichkeit ist die Umsetzung Ihrer eigenen ICustomFormatter für TimeSpan. Ich würde es nicht empfehlen, es sei denn, Sie verwenden Sie diese so oft, dass es sparen Sie Zeit auf lange Sicht. Es gibt jedoch Zeiten, in denen Sie eine Klasse schreiben, wo schreiben Sie Ihre eigenen ICustomFormatter geeignet ist, so schrieb ich dieses als ein Beispiel.

///<summary>
///Custom string formatter for TimeSpan that allows easy retrieval of Total segments.
///</summary>
///<example>
///TimeSpan myTimeSpan = new TimeSpan(27, 13, 5);
///string.Format("{0:th,###}h {0:mm}m {0:ss}s", myTimeSpan) -> "27h 13m 05s"
///string.Format("{0:TH}", myTimeSpan) -> "27.2180555555556"
///
///NOTE: myTimeSpan.ToString("TH") does not work.  See Remarks.
///</example>
///<remarks>
///Due to a quirk of .NET Framework (up through version 4.5.1), 
///<code>TimeSpan.ToString(format, new TimeSpanFormatter())</code> will not work; it will always call 
///TimeSpanFormat.FormatCustomized() which takes a DateTimeFormatInfo rather than an 
///IFormatProvider/ICustomFormatter.  DateTimeFormatInfo, unfortunately, is a sealed class.
///</remarks>
public class TimeSpanFormatter : IFormatProvider, ICustomFormatter
{
    ///<summary>
    ///Used to create a wrapper format string with the specified format.
    ///</summary>
    private const string DefaultFormat = "{{0:{0}}}";

    ///<remarks>
    ///IFormatProvider.GetFormat implementation. 
    ///</remarks>
    public object GetFormat(Type formatType)
    {
        //Determine whether custom formatting object is requested. 
        if (formatType == typeof(ICustomFormatter))
        {
            return this;
        }

        return null;
    }

    ///<summary>
    ///Determines whether the specified format is looking for a total, and formats it accordingly.
    ///If not, returns the default format for the given <para>format</para> of a TimeSpan.
    ///</summary>
    ///<returns>
    ///The formatted string for the given TimeSpan.
    ///</returns>
    ///<remarks>
    ///ICustomFormatter.Format implementation.
    ///</remarks>
    public string Format(string format, object arg, IFormatProvider formatProvider)
    {
        //only apply our format if there is a format and if the argument is a TimeSpan
        if (string.IsNullOrWhiteSpace(format) ||
            formatProvider != this || //this should always be true, but just in case...
            !(arg is TimeSpan) ||
            arg == null)
        {
            //return the default for whatever our format and argument are
            return GetDefault(format, arg);
        }

        TimeSpan span = (TimeSpan)arg;

        string[] formatSegments = format.Split(new char[] { ',' }, 2);
        string tsFormat = formatSegments[0];

        //Get inner formatting which will be applied to the int or double value of the requested total.
        //Default number format is just to return the number plainly.
        string numberFormat = "{0}";
        if (formatSegments.Length > 1)
        {
            numberFormat = string.Format(DefaultFormat, formatSegments[1]);
        }

        //We only handle two-character formats, and only when those characters' capitalization match
        //(e.g. 'TH' and 'th', but not 'tH').  Feel free to change this to suit your needs.
        if (tsFormat.Length != 2 ||
            char.IsUpper(tsFormat[0]) != char.IsUpper(tsFormat[1]))
        {
            return GetDefault(format, arg);
        }

        //get the specified time segment from the TimeSpan as a double
        double valAsDouble;
        switch (char.ToLower(tsFormat[1]))
        {
            case 'd':
                valAsDouble = span.TotalDays;
                break;
            case 'h':
                valAsDouble = span.TotalHours;
                break;
            case 'm':
                valAsDouble = span.TotalMinutes;
                break;
            case 's':
                valAsDouble = span.TotalSeconds;
                break;
            case 'f':
                valAsDouble = span.TotalMilliseconds;
                break;
            default:
                return GetDefault(format, arg);
        }

        //figure out if we want a double or an integer
        switch (tsFormat[0])
        {
            case 'T':
                //format Total as double
                return string.Format(numberFormat, valAsDouble);

            case 't':
                //format Total as int (rounded down)
                return string.Format(numberFormat, (int)valAsDouble);

            default:
                return GetDefault(format, arg);
        }
    }

    ///<summary>
    ///Returns the formatted value when we don't know what to do with their specified format.
    ///</summary>
    private string GetDefault(string format, object arg)
    {
        return string.Format(string.Format(DefaultFormat, format), arg);
    }
}

Beachten Sie, wie in den hinweisen im code, TimeSpan.ToString(format, myTimeSpanFormatter) wird nicht funktionieren, aufgrund eines Fehlers der .NET Framework, so dass Sie immer über die Verwendung von string.Format(format, myTimeSpanFormatter) um diese Klasse zu verwenden. Sehen Wie erstellen und verwenden einer benutzerdefinierten IFormatProvider für DateTime?.

BEARBEITEN:
Wenn Sie wirklich, und ich meine wirklich, funktionieren soll, mit TimeSpan.ToString(string, TimeSpanFormatter) können Sie fügen Sie den folgenden, um die oben TimeSpanFormatter Klasse:

///<remarks>
///Update this as needed.
///</remarks>
internal static string[] GetRecognizedFormats()
{
    return new string[] { "td", "th", "tm", "ts", "tf", "TD", "TH", "TM", "TS", "TF" };
}

Und fügen Sie die folgende Klasse irgendwo im gleichen Namensraum:

public static class TimeSpanFormatterExtensions
{
    private static readonly string CustomFormatsRegex = string.Format(@"([^\\])?({0})(?:,{{([^(\\}})]+)}})?", string.Join("|", TimeSpanFormatter.GetRecognizedFormats()));

    public static string ToString(this TimeSpan timeSpan, string format, ICustomFormatter formatter)
    {
        if (formatter == null)
        {
            throw new ArgumentNullException();
        }

        TimeSpanFormatter tsFormatter = (TimeSpanFormatter)formatter;

        format = Regex.Replace(format, CustomFormatsRegex, new MatchEvaluator(m => MatchReplacer(m, timeSpan, tsFormatter)));
        return timeSpan.ToString(format);
    }

    private static string MatchReplacer(Match m, TimeSpan timeSpan, TimeSpanFormatter formatter)
    {
        //the matched non-'\' char before the stuff we actually care about
        string firstChar = m.Groups[1].Success ? m.Groups[1].Value : string.Empty;

        string input;
        if (m.Groups[3].Success)
        {
            //has additional formatting
            input = string.Format("{0},{1}", m.Groups[2].Value, m.Groups[3].Value);
        }
        else
        {
            input = m.Groups[2].Value;
        }

        string replacement = formatter.Format(input, timeSpan, formatter);
        if (string.IsNullOrEmpty(replacement))
        {
            return firstChar;
        }

        return string.Format("{0}\\{1}", firstChar, string.Join("\\", replacement.ToCharArray()));
    }
}

Nachdem diese, können Sie

ICustomFormatter formatter = new TimeSpanFormatter();
string myStr = myTimeSpan.ToString(@"TH,{000.00}h\:tm\m\:ss\s", formatter);

wo {000.00} ist, aber Sie wollen die TotalHours int oder double formatiert werden. Hinweis: die geschweifte Klammern, die nicht da sein sollte, in der Zeichenfolge.Format() Fall. Beachten Sie auch, formatter muss erklärt (oder cast) als ICustomFormatter eher als TimeSpanFormatter.

Übermäßige? Ja. Genial? Uhhh....

InformationsquelleAutor der Antwort dfoverdx

Müssen Sie möglicherweise, um die Berechnung der Stunden. Die Reihe für die Stunden, in der Zeitspanne.ToString ist nur 0-23.

Schlimmsten werden Sie brauchen, ist zu tun, raw-string-Formatierung a la Jon Skeet.

InformationsquelleAutor der Antwort John

Versuchen, diese Funktion:

Public Shared Function GetTimeSpanString(ByVal ts As TimeSpan) As String
        Dim output As New StringBuilder()

        Dim needsComma As Boolean = False

        If ts = Nothing Then

            Return "00:00:00"

        End If

        If ts.TotalHours >= 1 Then
            output.AppendFormat("{0} hr", Math.Truncate(ts.TotalHours))
            If ts.TotalHours > 1 Then
                output.Append("s")
            End If
            needsComma = True
        End If

        If ts.Minutes > 0 Then
            If needsComma Then
                output.Append(", ")
            End If
            output.AppendFormat("{0} m", ts.Minutes)
            'If ts.Minutes > 1 Then
            '    output.Append("s")
            'End If
            needsComma = True
        End If

        Return output.ToString()

 End Function       

Konvertieren Sie Eine Zeitspanne In Stunden Und Minuten

InformationsquelleAutor der Antwort Angkor Wat

Meine Lösung ist:

string text = Math.Floor(timeUsed.TotalHours) + "h " + ((int)timeUsed.TotalMinutes) % 60 + "min";

InformationsquelleAutor der Antwort alansiqueira27

Als pro (https://msdn.microsoft.com/en-us/library/1ecy8h51(v=vs. 110).aspx), die Standard ToString() Methode für ein TimeSpan-Objekt verwendet die "c" formatieren, was bedeutet, dass standardmäßig, eine Zeitspanne, die länger als 24 Stunden sieht so etwas wie "1.03:14:56", wenn die Ausgabe auf einer razor-Ansicht. Dies verursachte einige Verwirrung bei meinen Kunden, die nicht verstehen, dass die "1." steht für einen Tag.

So, wenn Sie verwenden können, interpolierte strings (C#6+), eine einfache Möglichkeit, die ich kam mit, um die Erhaltung der Formatierung so viel wie möglich, während der Verwendung TotalHours anstatt in Tagen+Stunden ist es, ein get property zur Ausgabe der Uhrzeit als formatierten string, etwa so:

public TimeSpan SystemTime { get; set; }
public string SystemTimeAsString
{
    get
    {
        //Note: ignoring fractional seconds.
        return $"{(int)SystemTime.TotalHours}:SystemTime.Minutes.ToString("00")}:SystemTime.Seconds.ToString("00")}";
    }
}

Das Ergebnis dieser mit der gleichen Zeit wie oben wird "27:14:56".

InformationsquelleAutor der Antwort Michael Villere