मैं कैसे कर सकता हूँ। स्ट्रिंग। एक नेट स्वरूप में एक कस्टम प्रारूप के साथ एक TimeSpan वस्तु?

184

TimeSpanकस्टम प्रारूप के साथ स्ट्रिंग में वस्तुओं को प्रारूपित करने का अनुशंसित तरीका क्या है ?

c#  .net  string  time  formatting 
— होसम ऐली
स्रोत

जवाबों:

247

कृपया ध्यान दें: यह उत्तर .Net 4.0 और इसके बाद के संस्करण के लिए है। यदि आप .net 3.5 या उससे नीचे के TimeSpan को फॉर्मेट करना चाहते हैं, तो कृपया जोहान्सह का उत्तर देखें ।

कस्टम टाइमस्पैन प्रारूप स्ट्रिंग .net 4.0 में पेश किए गए थे। आप MSDN कस्टम टाइमस्पैन प्रारूप स्ट्रिंग्स पृष्ठ पर उपलब्ध प्रारूप निर्दिष्टकर्ताओं का पूर्ण संदर्भ पा सकते हैं ।

यहाँ एक उदाहरण स्वरूप प्रारूप है:

string.Format("{0:hh\\:mm\\:ss}", myTimeSpan); //example output 15:36:15

( अद्यतन ) और यहाँ C # 6 स्ट्रिंग प्रक्षेप का उपयोग कर एक उदाहरण दिया गया है:

$"{myTimeSpan:hh\\:mm\\:ss}"; //example output 15:36:15

आपको "\" के साथ ":" वर्ण से बचने की आवश्यकता है (जो कि तब तक बचना चाहिए जब तक आप क्रियात्मक स्ट्रिंग का उपयोग नहीं कर रहे हैं)।

MSDN कस्टम टाइमस्पैन प्रारूप स्ट्रिंग्स पृष्ठ से यह अंश ":" और "" से बचने के बारे में बताता है। एक प्रारूप स्ट्रिंग में वर्ण:

कस्टम टाइमस्पैन प्रारूप विनिर्देशक में प्लेसहोल्डर विभाजक प्रतीक शामिल नहीं होते हैं, जैसे कि प्रतीक जो घंटों से दिन, मिनटों से घंटों या भिन्नात्मक सेकंड से अलग होते हैं। इसके बजाय, इन प्रतीकों को स्ट्रिंग प्रारूप के रूप में कस्टम प्रारूप स्ट्रिंग में शामिल किया जाना चाहिए। उदाहरण के लिए, "dd.hh: mm" एक अवधि (।) को दिन और घंटों के बीच विभाजक के रूप में परिभाषित करता है, और एक बृहदान्त्र (:) घंटे और मिनट के बीच विभाजक के रूप में।

— डॉक्टर जोन्स
स्रोत
7
@Andrei रिनिया: सही, जैसा कि मेरे दूसरे पैराग्राफ की शुरुआत में कहा गया है ".net 4 आपको Timespan के साथ कस्टम प्रारूप स्ट्रिंग का उपयोग करने की अनुमति देता है"।
— डॉक्टर जोन्स
1
@ आगे, यह बिल्कुल सही नहीं है। आपके उदाहरण में आप पहले m और पहले s से बच रहे हैं, इसलिए myTimeSpan = new TimeSpan(15, 35, 54);स्टेटमेंट के इनपुट के साथ myTimeSpan .ToString("hh\\mm\\ss");परिणाम आएगा 15m35s54। मुझे नहीं लगता है कि आपके इरादे क्या हैं क्योंकि यह आपके घंटों के बाद मी और आपके मिनटों के बाद एस होगा।
— डॉक्टर जोन्स
1
@ डॉक्टर जोन्स - धन्यवाद! मेरा मतलब था myTimeSpan.ToString ("h \\ hm \\ ms \\ s"); या myTimeSpan.ToString (@ "h \ hm \ ms \ s"); जो 15h35m54s देता है
— एडवर्ड
2
बस इस समाधान के साथ सावधान रहें, क्योंकि यह ठीक से काम नहीं करेगा जब घंटे का हिस्सा 24 से अधिक हो
— Zoltan Tirinda
1
@ क्वार्क में, कोई कस्टम प्रारूप निर्दिष्ट नहीं है जो ऐसा करता है, वे सभी आपको ऐसे घंटे देते हैं जिन्हें दिनों के हिस्से के रूप में नहीं गिना जाता है। आप हालांकि यह कर सकते हैं $"{myTimeSpan.TotalHours}:{myTimeSpan:mm\\:ss}"। उपयोगकर्ता के दृष्टिकोण से, यह दिनों को आउटपुट करने के लिए बेहतर हो सकता है, हालांकि, कोई भी मानसिक रूप से यह जानना नहीं चाहता है कि 200+ घंटे में कितने दिन हैं।
— चिकित्सक जोन्स
91

.NET 3.5 और उससे कम के लिए आप उपयोग कर सकते हैं:

string.Format ("{0:00}:{1:00}:{2:00}", 
               (int)myTimeSpan.TotalHours, 
                    myTimeSpan.Minutes, 
                    myTimeSpan.Seconds);

बाइट्स पर एक जॉन स्कीट उत्तर से लिया गया कोड

.NET 4.0 और इसके बाद के संस्करण के लिए, DoctaJonez उत्तर देखें ।

— JohannesH
स्रोत
हाँ धन्यवाद। लेकिन मुझे लगता है कि डेटटाइम दृष्टिकोण अधिक अनुकूलन योग्य है, क्योंकि यह डेटटाइम द्वारा समर्थित किसी भी समय प्रारूप के लिए काम करेगा। उदाहरण के लिए एएम / पीएम को दिखाने के लिए इस दृष्टिकोण का उपयोग करना कठिन है।
— होसम एलई
1
निश्चित रूप से, TimeSpan समय की अवधि का प्रतिनिधित्व करता है, दिन के समय का नहीं (भले ही DateTime.Now.TimeOfDay संपत्ति का मानना ​​है कि आप अन्यथा मानते हैं)। यदि आपको दिन के एक विशिष्ट समय का प्रतिनिधित्व करने की आवश्यकता है तो मेरा सुझाव है कि आप डेटाइम क्लास का उपयोग करना जारी रखें।
— जोहान्सह
7
बस याद रखें कि यदि TimeSpan 24 घंटे के बराबर या उससे अधिक है, तो आपको गलत स्वरूपण मिलेगा।
— जोहान्सह
31

एक तरीका यह है कि किसी DateTimeवस्तु को बनाया जाए और उसे प्रारूपण के लिए उपयोग किया जाए:

new DateTime(myTimeSpan.Ticks).ToString(myCustomFormat)

// or using String.Format:
String.Format("{0:HHmmss}", new DateTime(myTimeSpan.Ticks))

यह मेरे जानने का तरीका है। मुझे उम्मीद है कि कोई बेहतर रास्ता सुझा सकता है।

— होसम ऐली
स्रोत
14
यह वास्तव में केवल तभी काम करने वाला है जब TimeSpan एक दिन से कम हो। यह एक ऐसा भयानक प्रतिबंध नहीं हो सकता है, लेकिन यह इसे सामान्य समाधान होने से रोकता है।
— tvanfosson
क्या यह सही मूल्य लौटाता है? डिम ts As New TimeSpan (11, 22, 30, 30): डिम sss अस स्ट्रिंग = न्यू डेटाइम (ts.Ticks) .TStString ("dd.hh: mm: ss")
— नेवरलेस
10

सरल। MSDNTimeSpan.ToString पर c, g या G. अधिक जानकारी के साथ उपयोग करें

— केकेके
स्रोत
1
आपके उत्तर के लिए धन्यवाद। यह विधि .NET 4 में स्पष्ट रूप से नया है, और जब सवाल पूछा गया था तब मौजूद नहीं था। यह कस्टम प्रारूपों का भी समर्थन नहीं करता है। फिर भी, यह इस सवालों के जवाब के लिए एक मूल्यवान अतिरिक्त है। एक बार फिर धन्यवाद।
— होसम ऐली
5

व्यक्तिगत रूप से, मुझे यह तरीका पसंद है:

TimeSpan ts = ...;
string.Format("{0:%d}d {0:%h}h {0:%m}m {0:%s}s", ts);

आप इसे बिना किसी समस्या के जैसे चाहें कस्टम बना सकते हैं:

string.Format("{0:%d}days {0:%h}hours {0:%m}min {0:%s}sec", ts);
string.Format("{0:%d}d {0:%h}h {0:%m}' {0:%s}''", ts);
— कोई नहीं
स्रोत
5

यह बहुत बढ़िया है:

string.Format("{0:00}:{1:00}:{2:00}",
               (int)myTimeSpan.TotalHours,
               myTimeSpan.Minutes,
               myTimeSpan.Seconds);
— हरपाल
स्रोत
1
आपको myTimeSpan.TotalHours को एक इंट में डालना होगा - अन्यथा यह राउंड-अप हो सकता है।
— जोहान्सह
3

आप इसके साथ भी जा सकते हैं:

Dim ts As New TimeSpan(35, 21, 59, 59)  '(11, 22, 30, 30)    '
Dim TimeStr1 As String = String.Format("{0:c}", ts)
Dim TimeStr2 As String = New Date(ts.Ticks).ToString("dd.HH:mm:ss")

संपादित करें:

आप स्ट्रिंग्स पर भी देख सकते हैं ।

    Dim ts As New TimeSpan(23, 30, 59)
    Dim str As String = Strings.Format(New DateTime(ts.Ticks), "H:mm:ss")
— NeverHopeless
स्रोत
3 
if (timeSpan.TotalDays < 1)
    return timeSpan.ToString(@"hh\:mm\:ss");

return timeSpan.TotalDays < 2
    ? timeSpan.ToString(@"d\ \d\a\y\ hh\:mm\:ss")
    : timeSpan.ToString(@"d\ \d\a\y\s\ hh\:mm\:ss");

सभी शाब्दिक पात्रों को बच जाना चाहिए।

— रेयान विलियम्स
स्रोत
1

मैंने नीचे दिए गए कोड का उपयोग किया। यह लंबा है, लेकिन फिर भी यह एक अभिव्यक्ति है, और बहुत ही अनुकूल आउटपुट का उत्पादन करता है, क्योंकि यह दिन, घंटे, मिनट या सेकंड का आउटपुट नहीं देता है यदि उनके पास शून्य का मूल्य है।

नमूने में यह आउटपुट उत्पन्न करता है: "4 दिन 1 घंटा 3 सेकंड"।

TimeSpan sp = new TimeSpan(4,1,0,3);
string.Format("{0}{1}{2}{3}", 
        sp.Days > 0 ? ( sp.Days > 1 ? sp.ToString(@"d\ \d\a\y\s\ "): sp.ToString(@"d\ \d\a\y\ ")):string.Empty,
        sp.Hours > 0 ? (sp.Hours > 1 ? sp.ToString(@"h\ \h\o\u\r\s\ ") : sp.ToString(@"h\ \h\o\u\r\ ")):string.Empty,
        sp.Minutes > 0 ? (sp.Minutes > 1 ? sp.ToString(@"m\ \m\i\n\u\t\e\s\ ") :sp.ToString(@"m\ \m\i\n\u\t\e\ ")):string.Empty,
        sp.Seconds > 0 ? (sp.Seconds > 1 ? sp.ToString(@"s\ \s\e\c\o\n\d\s"): sp.ToString(@"s\ \s\e\c\o\n\d\s")):string.Empty);
— panpawel
स्रोत
अब इसको लिखने का बहुत बेहतर तरीका है! सभी आम कार्यों को फिर से भरने की कोशिश करें, और आप इस कोड को बहुत बेहतर, बहुत बेहतर बना सकते हैं।
— होसम ऐली
@ होसम एली; मैं हर समय सीख रहा हूं, क्या आपको अपना बेहतर कोड पोस्ट करने की परवाह है?
— पैनपॉवेल
String timeComponent(int value, String name) { return value > 0 ? value + " " + name + (value > 1 ? "s" : ""); }प्रत्येक घटक (जैसे timeComponent(sp.Days, "day")) के लिए कॉल करें , फिर String.joinरिक्त स्थान सम्मिलित करने के लिए उपयोग करें।
— होसम ऐली
1

मैं इस विधि का उपयोग करता हूं। मैं बेल्जियन हूं और डच बोलता हूं तो घंटों और मिनटों का बहुवचन सिर्फ अंत तक 'एस' नहीं जोड़ रहा है, बल्कि विलक्षण से लगभग एक अलग शब्द है।

यह लंबा लग सकता है लेकिन मुझे लगता है कि यह बहुत पठनीय है:

 public static string SpanToReadableTime(TimeSpan span)
    {
        string[] values = new string[4];  //4 slots: days, hours, minutes, seconds
        StringBuilder readableTime = new StringBuilder();

        if (span.Days > 0)
        {
            if (span.Days == 1)
                values[0] = span.Days.ToString() + " dag"; //day
            else
                values[0] = span.Days.ToString() + " dagen";  //days

            readableTime.Append(values[0]);
            readableTime.Append(", ");
        }
        else
            values[0] = String.Empty;


        if (span.Hours > 0)
        {
            if (span.Hours == 1)
                values[1] = span.Hours.ToString() + " uur";  //hour
            else
                values[1] = span.Hours.ToString() + " uren";  //hours

            readableTime.Append(values[1]);
            readableTime.Append(", ");

        }
        else
            values[1] = string.Empty;

        if (span.Minutes > 0)
        {
            if (span.Minutes == 1)
                values[2] = span.Minutes.ToString() + " minuut";  //minute
            else
                values[2] = span.Minutes.ToString() + " minuten";  //minutes

            readableTime.Append(values[2]);
            readableTime.Append(", ");
        }
        else
            values[2] = string.Empty;

        if (span.Seconds > 0)
        {
            if (span.Seconds == 1)
                values[3] = span.Seconds.ToString() + " seconde";  //second
            else
                values[3] = span.Seconds.ToString() + " seconden";  //seconds

            readableTime.Append(values[3]);
        }
        else
            values[3] = string.Empty;


        return readableTime.ToString();
    }//end SpanToReadableTime
— Dabriel
स्रोत
यदि आप ऐसा सॉफ़्टवेयर लिखते हैं, जिसका अनुवाद करना आवश्यक है, तो यह बहुत ही आसान तरीका है। सामान्य समय के उपयोगकर्ताओं को समझने के लिए मानक TimeSpan.ToString () अभी बहुत क्लूनी है, खासकर जब एक दिन में अवधि।
— नील
1

यह वह दृष्टिकोण है जिसका मैंने सशर्त स्वरूपण के साथ अपने स्वयं का उपयोग किया है। और मैं इसे यहां पोस्ट करता हूं क्योंकि मुझे लगता है कि यह साफ तरीका है।

$"{time.Days:#0:;;\\}{time.Hours:#0:;;\\}{time.Minutes:00:}{time.Seconds:00}"

आउटपुट का उदाहरण:

00:00 (न्यूनतम)

1:43:04 (जब हमारे पास घंटे हों)

15:03:01 (जब घंटे 1 अंक से अधिक हों)

2:4:22:04 (जब हमारे पास दिन हों)

स्वरूपण आसान है। time.Days:#0:;;\\इससे पहले ;;का फॉर्मेट तब होता है जब मूल्य सकारात्मक होता है। नकारात्मक मूल्यों की अनदेखी की जाती है। और शून्य मानों के लिए हमें ;;\\इसे स्वरूपित स्ट्रिंग में छिपाने के लिए है। ध्यान दें कि बच गया बैकस्लैश आवश्यक है अन्यथा यह सही ढंग से प्रारूपित नहीं होगा।

— एम। केज़म अखगीरी
स्रोत
1

यहाँ मेरा विस्तार तरीका है :

public static string ToFormattedString(this TimeSpan ts)
{
    const string separator = ", ";

    if (ts.TotalMilliseconds < 1) { return "No time"; }

    return string.Join(separator, new string[]
    {
        ts.Days > 0 ? ts.Days + (ts.Days > 1 ? " days" : " day") : null,
        ts.Hours > 0 ? ts.Hours + (ts.Hours > 1 ? " hours" : " hour") : null,
        ts.Minutes > 0 ? ts.Minutes + (ts.Minutes > 1 ? " minutes" : " minute") : null,
        ts.Seconds > 0 ? ts.Seconds + (ts.Seconds > 1 ? " seconds" : " second") : null,
        ts.Milliseconds > 0 ? ts.Milliseconds + (ts.Milliseconds > 1 ? " milliseconds" : " millisecond") : null,
    }.Where(t => t != null));
}

उदाहरण कॉल:

string time = new TimeSpan(3, 14, 15, 0, 65).ToFormattedString();

आउटपुट:

3 days, 14 hours, 15 minutes, 65 milliseconds
— chviLadislav
स्रोत
1

यह वीएस 2010 में दर्द है, यहां मेरा समाधान समाधान है।

 public string DurationString
        {
            get 
            {
                if (this.Duration.TotalHours < 24)
                    return new DateTime(this.Duration.Ticks).ToString("HH:mm");
                else //If duration is more than 24 hours
                {
                    double totalminutes = this.Duration.TotalMinutes;
                    double hours = totalminutes / 60;
                    double minutes = this.Duration.TotalMinutes - (Math.Floor(hours) * 60);
                    string result = string.Format("{0}:{1}", Math.Floor(hours).ToString("00"), Math.Floor(minutes).ToString("00"));
                    return result;
                }
            } 
        }
— rguez06
स्रोत
1

Substringविधि पूरी तरह से काम करता है जब आप केवल घंटे चाहते हैं: मिनट: सेकंड। यह सरल, साफ कोड और समझने में आसान है।

    var yourTimeSpan = DateTime.Now - DateTime.Now.AddMinutes(-2);

    var formatted = yourTimeSpan.ToString().Substring(0,8);// 00:00:00 

    Console.WriteLine(formatted);
— GER
स्रोत
0

यहाँ मेरा संस्करण है। यह केवल उतना ही दिखाता है जितना आवश्यक हो, बहुवचन, नकारात्मकता को संभालता है, और मैंने इसे हल्का बनाने की कोशिश की।

आउटपुट उदाहरण

0 seconds
1.404 seconds
1 hour, 14.4 seconds
14 hours, 57 minutes, 22.473 seconds
1 day, 14 hours, 57 minutes, 22.475 seconds

कोड

public static class TimeSpanExtensions
{
    public static string ToReadableString(this TimeSpan timeSpan)
    {
        int days = (int)(timeSpan.Ticks / TimeSpan.TicksPerDay);
        long subDayTicks = timeSpan.Ticks % TimeSpan.TicksPerDay;

        bool isNegative = false;
        if (timeSpan.Ticks < 0L)
        {
            isNegative = true;
            days = -days;
            subDayTicks = -subDayTicks;
        }

        int hours = (int)((subDayTicks / TimeSpan.TicksPerHour) % 24L);
        int minutes = (int)((subDayTicks / TimeSpan.TicksPerMinute) % 60L);
        int seconds = (int)((subDayTicks / TimeSpan.TicksPerSecond) % 60L);
        int subSecondTicks = (int)(subDayTicks % TimeSpan.TicksPerSecond);
        double fractionalSeconds = (double)subSecondTicks / TimeSpan.TicksPerSecond;

        var parts = new List<string>(4);

        if (days > 0)
            parts.Add(string.Format("{0} day{1}", days, days == 1 ? null : "s"));
        if (hours > 0)
            parts.Add(string.Format("{0} hour{1}", hours, hours == 1 ? null : "s"));
        if (minutes > 0)
            parts.Add(string.Format("{0} minute{1}", minutes, minutes == 1 ? null : "s"));
        if (fractionalSeconds.Equals(0D))
        {
            switch (seconds)
            {
                case 0:
                    // Only write "0 seconds" if we haven't written anything at all.
                    if (parts.Count == 0)
                        parts.Add("0 seconds");
                    break;

                case 1:
                    parts.Add("1 second");
                    break;

                default:
                    parts.Add(seconds + " seconds");
                    break;
            }
        }
        else
        {
            parts.Add(string.Format("{0}{1:.###} seconds", seconds, fractionalSeconds));
        }

        string resultString = string.Join(", ", parts);
        return isNegative ? "(negative) " + resultString : resultString;
    }
}
— Jho
स्रोत
0

यदि आप सेकंड की संख्या को देखते हुए, यूट्यूब के समान अवधि प्रारूप चाहते हैं

int[] duration = { 0, 4, 40, 59, 60, 61, 400, 4000, 40000, 400000 };
foreach (int d in duration)
{
    Console.WriteLine("{0, 6} -> {1, 10}", d, d > 59 ? TimeSpan.FromSeconds(d).ToString().TrimStart("00:".ToCharArray()) : string.Format("0:{0:00}", d));
}

आउटपुट:

     0 ->       0:00
     4 ->       0:04
    40 ->       0:40
    59 ->       0:59
    60 ->       1:00
    61 ->       1:01
   400 ->       6:40
  4000 ->    1:06:40
 40000 ->   11:06:40
400000 -> 4.15:06:40
— zenny
स्रोत
0

मैं "1 दिन 2 घंटे 3 मिनट" जैसे एक स्ट्रिंग लौटना चाहता था और साथ ही यह भी ध्यान रखता था कि उदाहरण के लिए दिन या मिनट्स 0 हैं और फिर उन्हें नहीं दिखाया जा रहा है। अपने जवाब के लिए जॉन राश का धन्यवाद जो मेरा मुश्किल से एक विस्तार है

TimeSpan timeLeft = New Timespan(0, 70, 0);
String.Format("{0}{1}{2}{3}{4}{5}",
    Math.Floor(timeLeft.TotalDays) == 0 ? "" : 
    Math.Floor(timeLeft.TotalDays).ToString() + " ",
    Math.Floor(timeLeft.TotalDays) == 0 ? "" : Math.Floor(timeLeft.TotalDays) == 1 ? "day " : "days ",
    timeLeft.Hours == 0 ? "" : timeLeft.Hours.ToString() + " ",
    timeLeft.Hours == 0 ? "" : timeLeft.Hours == 1 ? "hour " : "hours ",
    timeLeft.Minutes == 0 ? "" : timeLeft.Minutes.ToString() + " ",
    timeLeft.Minutes == 0 ? "" : timeLeft.Minutes == 1 ? "minute " : "minutes ");
— Piees
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.