C# TimeSpan TicksC# TimeSpan to DateTimeC# TimeSpan ToStringC TimeSpan constructortime span意思C TimeSpan to stringC TimeSpan format自訂TimeSpan 格式字串
文章推薦指數： 80 %
下列範例說明如何使用"d" 自訂格式規範。
C# 複製. TimeSpan ts2 = new TimeSpan ...
跳到主要內容
已不再支援此瀏覽器。
請升級至MicrosoftEdge，以利用最新功能、安全性更新和技術支援。
下載MicrosoftEdge
其他資訊
目錄
結束焦點模式
語言
閱讀英文
儲存
編輯
共用
Twitter
LinkedIn
Facebook
電子郵件
WeChat
目錄
語言
語言
閱讀英文
儲存
目錄
閱讀英文
儲存
編輯
Twitter
LinkedIn
Facebook
電子郵件
WeChat
目錄
自訂TimeSpan格式字串
發行項
09/27/2021
3位參與者
此頁面有所助益嗎？
Yes
No
還有其他意見反應嗎？
系統會將意見反應傳送給Microsoft：按下[提交]按鈕，您的意見反應將用來改善Microsoft產品和服務。
隱私權原則。
送出
謝謝。
本文內容
TimeSpan格式字串會定義從格式化作業產生之TimeSpan值的字串表示。
自訂格式字串會由一或多個自訂的TimeSpan格式規範搭配任意數目的常值字元所組成。
不是標準TimeSpan格式字串的任何字串都會被視為自訂TimeSpan格式字串。
重要
自訂TimeSpan格式規範不包含預留位置分隔符號，例如分隔天與小時、小時與分鐘或是秒與小數秒的符號。
相反地，這些符號必須包含在自訂格式字串中作為字串常值。
例如，"dd\.hh\:mm"會定義句號(.)作為天與小時之間的分隔符號，並定義冒號(:)作為小時與分鐘之間的分隔符號。
自訂TimeSpan格式規範也不包括讓您區分正負時間間隔的正負號。
若要包括正負號，您必須使用條件邏輯建構格式字串。
其他字元區段包含範例。
產生TimeSpan值的字串表示時，會藉由呼叫TimeSpan.ToString方法的多載，以及藉由支援複合格式設定的方法(例如String.Format)，來產生。
如需詳細資訊，請參閱格式化類型和複合格式設定。
下列範例說明如何在格式設定作業中使用自訂格式自串。
usingSystem;
publicclassExample
{
publicstaticvoidMain()
{
TimeSpanduration=newTimeSpan(1,12,23,62);
stringoutput=null;
output="TimeofTravel:"+duration.ToString("%d")+"days";
Console.WriteLine(output);
output="TimeofTravel:"+duration.ToString(@"dd\.hh\:mm\:ss");
Console.WriteLine(output);
Console.WriteLine("TimeofTravel:{0:%d}day(s)",duration);
Console.WriteLine("TimeofTravel:{0:dd\\.hh\\:mm\\:ss}days",duration);
}
}
//Theexampledisplaysthefollowingoutput:
//TimeofTravel:1days
//TimeofTravel:01.12:24:02
//TimeofTravel:1day(s)
//TimeofTravel:01.12:24:02days
ModuleExample
PublicSubMain()
DimdurationAsNewTimeSpan(1,12,23,62)
DimoutputAsString=Nothing
output="TimeofTravel:"+duration.ToString("%d")+"days"
Console.WriteLine(output)
output="TimeofTravel:"+duration.ToString("dd\.hh\:mm\:ss")
Console.WriteLine(output)
Console.WriteLine("TimeofTravel:{0:%d}day(s)",duration)
Console.WriteLine("TimeofTravel:{0:dd\.hh\:mm\:ss}days",duration)
EndSub
EndModule
'Theexampledisplaysthefollowingoutput:
'TimeofTravel:1days
'TimeofTravel:01.12:24:02
'TimeofTravel:1day(s)
'TimeofTravel:01.12:24:02days
TimeSpan.ParseExact和TimeSpan.TryParseExact方法也會使用自訂TimeSpan格式字串，以定義剖析作業所需的輸入字串格式。
(剖析會將值的字串表示轉換成該值。
)下列範例說明如何在剖析作業中使用標準格式字串。
usingSystem;
publicclassExample
{
publicstaticvoidMain()
{
stringvalue=null;
TimeSpaninterval;
value="6";
if(TimeSpan.TryParseExact(value,"%d",null,outinterval))
Console.WriteLine("{0}-->{1}",value,interval.ToString("c"));
else
Console.WriteLine("Unabletoparse'{0}'",value);
value="16:32.05";
if(TimeSpan.TryParseExact(value,@"mm\:ss\.ff",null,outinterval))
Console.WriteLine("{0}-->{1}",value,interval.ToString("c"));
else
Console.WriteLine("Unabletoparse'{0}'",value);
value="12.035";
if(TimeSpan.TryParseExact(value,"ss\\.fff",null,outinterval))
Console.WriteLine("{0}-->{1}",value,interval.ToString("c"));
else
Console.WriteLine("Unabletoparse'{0}'",value);
}
}
//Theexampledisplaysthefollowingoutput:
//6-->6.00:00:00
//16:32.05-->00:16:32.0500000
//12.035-->00:00:12.0350000
ModuleExample
PublicSubMain()
DimvalueAsString=Nothing
DimintervalAsTimeSpan
value="6"
IfTimeSpan.TryParseExact(value,"%d",Nothing,interval)Then
Console.WriteLine("{0}-->{1}",value,interval.ToString("c"))
Else
Console.WriteLine("Unabletoparse'{0}'",value)
EndIf
value="16:32.05"
IfTimeSpan.TryParseExact(value,"mm\:ss\.ff",Nothing,interval)Then
Console.WriteLine("{0}-->{1}",value,interval.ToString("c"))
Else
Console.WriteLine("Unabletoparse'{0}'",value)
EndIf
value="12.035"
IfTimeSpan.TryParseExact(value,"ss\.fff",Nothing,interval)Then
Console.WriteLine("{0}-->{1}",value,interval.ToString("c"))
Else
Console.WriteLine("Unabletoparse'{0}'",value)
EndIf
EndSub
EndModule
'Theexampledisplaysthefollowingoutput:
'6-->6.00:00:00
'16:32.05-->00:16:32.0500000
'12.035-->00:00:12.0350000
下表描述自訂日期和時間的格式規範。
格式規範
描述
範例
"d"、"%d"
時間間隔中的完整天數。
詳細資訊："d"自訂格式規範。
newTimeSpan(6,14,32,17,685):%d-->"6"d\.hh\:mm-->"6.14:32"
"dd"-"dddddddd"
時間間隔中的完整天數，視需要填補前置零。
詳細資訊："dd"-"dddddddd"自訂格式規範。
newTimeSpan(6,14,32,17,685):ddd-->"006"dd\.hh\:mm-->"06.14:32"
"h"、"%h"
時間間隔中未計入天數部分的完整時數。
單一位數的小時數前面不會加上零。
詳細資訊："h"自訂格式規範。
newTimeSpan(6,14,32,17,685):%h-->"14"hh\:mm-->"14:32"
"hh"
時間間隔中未計入天數部分的完整時數。
一位數的小時有前置零。
詳細資訊："hh"自訂格式規範。
newTimeSpan(6,14,32,17,685):hh-->"14"newTimeSpan(6,8,32,17,685):hh-->08
"m"、"%m"
時間間隔中未納入時數或天數部分的完整分鐘數。
單一位數的分鐘數前面不會加上零。
詳細資訊："m"自訂格式規範。
newTimeSpan(6,14,8,17,685):%m-->"8"h\:m-->"14:8"
"mm"
時間間隔中未納入時數或天數部分的完整分鐘數。
一位數的分鐘有前置零。
詳細資訊："mm"自訂格式規範。
newTimeSpan(6,14,8,17,685):mm-->"08"newTimeSpan(6,8,5,17,685):d\.hh\:mm\:ss-->6.08:05:17
"s"、"%s"
時間間隔中未納入時數、天數或分鐘數部分的完整秒數。
單一位數的秒鐘數前面不會加上零。
詳細資訊："s"自訂格式規範。
TimeSpan.FromSeconds(12.965):%s-->12s\.fff-->12.965
"ss"
時間間隔中未納入時數、天數或分鐘數部分的完整秒數。
一位數的秒有前置零。
詳細資訊："ss"自訂格式規範。
TimeSpan.FromSeconds(6.965):ss-->06ss\.fff-->06.965
"f"、"%f"
時間間隔中的十分之一秒。
詳細資訊："f"自訂格式規範。
TimeSpan.FromSeconds(6.895):f-->8ss\.f-->06.8
"ff"
時間間隔中的百分之一秒。
詳細資訊："ff"自訂格式規範。
TimeSpan.FromSeconds(6.895):ff-->89ss\.ff-->06.89
"fff"
時間間隔中的毫秒。
詳細資訊："fff"自訂格式規範。
TimeSpan.FromSeconds(6.895):fff-->895ss\.fff-->06.895
"ffff"
時間間隔中的萬分之一秒。
詳細資訊："ffff"自訂格式規範。
TimeSpan.Parse("0:0:6.8954321"):ffff-->8954ss\.ffff-->06.8954
"fffff"
時間間隔中的十萬分之一秒。
詳細資訊："fffff"自訂格式規範。
TimeSpan.Parse("0:0:6.8954321"):fffff-->89543ss\.fffff-->06.89543
"ffffff"
時間間隔中的百萬分之一秒。
詳細資訊："ffffff"自訂格式規範。
TimeSpan.Parse("0:0:6.8954321"):ffffff-->895432ss\.ffffff-->06.895432
"fffffff"
時間間隔中的千萬分之一秒(或小數刻度)。
詳細資訊："fffffff"自訂格式規範。
TimeSpan.Parse("0:0:6.8954321"):fffffff-->8954321ss\.fffffff-->06.8954321
"F"、"%F"
時間間隔中的十分之一秒。
如果數字為零，則不會顯示任何內容。
詳細資訊："F"自訂格式規範。
TimeSpan.Parse("00:00:06.32"):%F:3TimeSpan.Parse("0:0:3.091"):ss\.F:03.
"FF"
時間間隔中的百分之一秒。
不包含小數點後的零或兩位數都是零的數字。
詳細資訊："FF"自訂格式規範。
TimeSpan.Parse("00:00:06.329"):FF:32TimeSpan.Parse("0:0:3.101"):ss\.FF:03.1
"FFF"
時間間隔中的毫秒。
不包含小數點後的零。
詳細資訊：
TimeSpan.Parse("00:00:06.3291"):FFF:329TimeSpan.Parse("0:0:3.1009"):ss\.FFF:03.1
"FFFF"
時間間隔中的萬分之一秒。
不包含小數點後的零。
詳細資訊："FFFF"自訂格式規範。
TimeSpan.Parse("00:00:06.32917"):FFFFF:3291TimeSpan.Parse("0:0:3.10009"):ss\.FFFF:03.1
"FFFFF"
時間間隔中的十萬分之一秒。
不包含小數點後的零。
詳細資訊："FFFFF"自訂格式規範。
TimeSpan.Parse("00:00:06.329179"):FFFFF:32917TimeSpan.Parse("0:0:3.100009"):ss\.FFFFF:03.1
"FFFFFF"
時間間隔中的百萬分之一秒。
不顯示小數點後的零。
詳細資訊："FFFFFF"自訂格式規範。
TimeSpan.Parse("00:00:06.3291791"):FFFFFF:329179TimeSpan.Parse("0:0:3.1000009"):ss\.FFFFFF:03.1
"FFFFFFF"
時間間隔中的千萬分之一秒。
不顯示小數點後的零或七位數都是零。
詳細資訊："FFFFFFF"自訂格式規範。
TimeSpan.Parse("00:00:06.3291791"):FFFFFF:3291791TimeSpan.Parse("0:0:3.1900000"):ss\.FFFFFF:03.19
'string'
常值字串分隔符號。
詳細資訊：其他字元。
newTimeSpan(14,32,17):hh':'mm':'ss-->"14:32:17"
\
逸出字元。
詳細資訊：其他字元。
newTimeSpan(14,32,17):hh\:mm\:ss-->"14:32:17"
任意字元
其他任何未逸出字元都會解譯為自訂格式規範。
詳細資訊：其他字元。
newTimeSpan(14,32,17):hh\:mm\:ss-->"14:32:17"
"D"自訂格式規範
"d"自訂格式規範會輸出TimeSpan.Days屬性的值，這代表時間間隔中的完整天數。
它會輸出TimeSpan值中的完整天數，即使該值有多個位數也一樣。
如果TimeSpan.Days屬性的值為零，此規範就會輸出"0"。
如果單獨使用"d"自訂格式規範，請指定"%d"，以免被錯誤解譯為標準格式字串。
下列範例提供說明。
TimeSpants1=newTimeSpan(16,4,3,17,250);
Console.WriteLine(ts1.ToString("%d"));
//Displays16
DimtsAsNewTimeSpan(16,4,3,17,250)
Console.WriteLine(ts.ToString("%d"))
'Displays16
下列範例說明如何使用"d"自訂格式規範。
TimeSpants2=newTimeSpan(4,3,17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));
TimeSpants3=newTimeSpan(3,4,3,17);
Console.WriteLine(ts3.ToString(@"d\.hh\:mm\:ss"));
//Theexampledisplaysthefollowingoutput:
//0.04:03:17
//3.04:03:17
Dimts2AsNewTimeSpan(4,3,17)
Console.WriteLine(ts2.ToString("d\.hh\:mm\:ss"))
Dimts3AsNewTimeSpan(3,4,3,17)
Console.WriteLine(ts3.ToString("d\.hh\:mm\:ss"))
'Theexampledisplaysthefollowingoutput:
'0.04:03:17
'3.04:03:17
回到表格
"Dd"-"dddddddd"自訂格式規範
"dd"、"ddd"、"dddd"、"ddddd"、"dddddd"、"ddddddd"和"dddddddd"自訂格式規範會輸出TimeSpan.Days屬性的值，這代表時間間隔中的完整天數。
輸出字串會包含格式規範中"d"字元數所指定的最少位數，並且視需要填補前置零。
如果天數位數超過格式規範中的"d"字元數，則結果字串中的輸出會是完整天數。
下列範例會使用這些格式規範，以顯示兩個TimeSpan值的字串表示。
第一個時間間隔的天數部分值為零，第二個時間間隔的天數部分值為365。
TimeSpants1=newTimeSpan(0,23,17,47);
TimeSpants2=newTimeSpan(365,21,19,45);
for(intctr=2;ctr<=8;ctr++)
{
stringfmt=newString('d',ctr)+@"\.hh\:mm\:ss";
Console.WriteLine("{0}-->{1:"+fmt+"}",fmt,ts1);
Console.WriteLine("{0}-->{1:"+fmt+"}",fmt,ts2);
Console.WriteLine();
}
//Theexampledisplaysthefollowingoutput:
//dd\.hh\:mm\:ss-->00.23:17:47
//dd\.hh\:mm\:ss-->365.21:19:45
//
//ddd\.hh\:mm\:ss-->000.23:17:47
//ddd\.hh\:mm\:ss-->365.21:19:45
//
//dddd\.hh\:mm\:ss-->0000.23:17:47
//dddd\.hh\:mm\:ss-->0365.21:19:45
//
//ddddd\.hh\:mm\:ss-->00000.23:17:47
//ddddd\.hh\:mm\:ss-->00365.21:19:45
//
//dddddd\.hh\:mm\:ss-->000000.23:17:47
//dddddd\.hh\:mm\:ss-->000365.21:19:45
//
//ddddddd\.hh\:mm\:ss-->0000000.23:17:47
//ddddddd\.hh\:mm\:ss-->0000365.21:19:45
//
//dddddddd\.hh\:mm\:ss-->00000000.23:17:47
//dddddddd\.hh\:mm\:ss-->00000365.21:19:45
Dimts1AsNewTimeSpan(0,23,17,47)
Dimts2AsNewTimeSpan(365,21,19,45)
ForctrAsInteger=2To8
DimfmtAsString=NewString("d"c,ctr)+"\.hh\:mm\:ss"
Console.WriteLine("{0}-->{1:"+fmt+"}",fmt,ts1)
Console.WriteLine("{0}-->{1:"+fmt+"}",fmt,ts2)
Console.WriteLine()
Next
'Theexampledisplaysthefollowingoutput:
'dd\.hh\:mm\:ss-->00.23:17:47
'dd\.hh\:mm\:ss-->365.21:19:45
'
'ddd\.hh\:mm\:ss-->000.23:17:47
'ddd\.hh\:mm\:ss-->365.21:19:45
'
'dddd\.hh\:mm\:ss-->0000.23:17:47
'dddd\.hh\:mm\:ss-->0365.21:19:45
'
'ddddd\.hh\:mm\:ss-->00000.23:17:47
'ddddd\.hh\:mm\:ss-->00365.21:19:45
'
'dddddd\.hh\:mm\:ss-->000000.23:17:47
'dddddd\.hh\:mm\:ss-->000365.21:19:45
'
'ddddddd\.hh\:mm\:ss-->0000000.23:17:47
'ddddddd\.hh\:mm\:ss-->0000365.21:19:45
'
'dddddddd\.hh\:mm\:ss-->00000000.23:17:47
'dddddddd\.hh\:mm\:ss-->00000365.21:19:45
回到表格
"H"自訂格式規範
"h"自訂格式規範會輸出TimeSpan.Hours屬性的值，這代表時間間隔中未計入天數部分的完整時數。
如果TimeSpan.Hours屬性的值為0到9，就會傳回一位數的字串值；如果TimeSpan.Hours屬性的值為10到23，則會傳回兩位數的字串值。
如果單獨使用"h"自訂格式規範，請指定"%h"，以免被錯誤解譯為標準格式字串。
下列範例提供說明。
TimeSpants=newTimeSpan(3,42,0);
Console.WriteLine("{0:%h}hours{0:%m}minutes",ts);
//Theexampledisplaysthefollowingoutput:
//3hours42minutes
DimtsAsNewTimeSpan(3,42,0)
Console.WriteLine("{0:%h}hours{0:%m}minutes",ts)
'Theexampledisplaysthefollowingoutput:
'3hours42minutes
通常在剖析作業中，只包含單一數字的輸入字串會解譯為天數。
您可以改用"%h"自訂格式規範會，將數值字串解譯為時數。
下列範例提供說明。
stringvalue="8";
TimeSpaninterval;
if(TimeSpan.TryParseExact(value,"%h",null,outinterval))
Console.WriteLine(interval.ToString("c"));
else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value);
//Theexampledisplaysthefollowingoutput:
//08:00:00
DimvalueAsString="8"
DimintervalAsTimeSpan
IfTimeSpan.TryParseExact(value,"%h",Nothing,interval)Then
Console.WriteLine(interval.ToString("c"))
Else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value)
EndIf
'Theexampledisplaysthefollowingoutput:
'08:00:00
下列範例說明如何使用"h"自訂格式規範。
TimeSpants1=newTimeSpan(14,3,17);
Console.WriteLine(ts1.ToString(@"d\.h\:mm\:ss"));
TimeSpants2=newTimeSpan(3,4,3,17);
Console.WriteLine(ts2.ToString(@"d\.h\:mm\:ss"));
//Theexampledisplaysthefollowingoutput:
//0.14:03:17
//3.4:03:17
Dimts1AsNewTimeSpan(14,3,17)
Console.WriteLine(ts1.ToString("d\.h\:mm\:ss"))
Dimts2AsNewTimeSpan(3,4,3,17)
Console.WriteLine(ts2.ToString("d\.h\:mm\:ss"))
'Theexampledisplaysthefollowingoutput:
'0.14:03:17
'3.4:03:17
回到表格
"Hh"自訂格式規範
"hh"自訂格式規範會輸出TimeSpan.Hours屬性的值，這代表時間間隔中未計入天數部分的完整時數。
對於從0到9的值，輸出字串會包含前置零。
通常在剖析作業中，只包含單一數字的輸入字串會解譯為天數。
您可以改用"hh"自訂格式規範，將數值字串解譯為時數。
下列範例提供說明。
stringvalue="08";
TimeSpaninterval;
if(TimeSpan.TryParseExact(value,"hh",null,outinterval))
Console.WriteLine(interval.ToString("c"));
else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value);
//Theexampledisplaysthefollowingoutput:
//08:00:00
DimvalueAsString="08"
DimintervalAsTimeSpan
IfTimeSpan.TryParseExact(value,"hh",Nothing,interval)Then
Console.WriteLine(interval.ToString("c"))
Else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value)
EndIf
'Theexampledisplaysthefollowingoutput:
'08:00:00
下列範例說明如何使用"hh"自訂格式規範。
TimeSpants1=newTimeSpan(14,3,17);
Console.WriteLine(ts1.ToString(@"d\.hh\:mm\:ss"));
TimeSpants2=newTimeSpan(3,4,3,17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));
//Theexampledisplaysthefollowingoutput:
//0.14:03:17
//3.04:03:17
Dimts1AsNewTimeSpan(14,3,17)
Console.WriteLine(ts1.ToString("d\.hh\:mm\:ss"))
Dimts2AsNewTimeSpan(3,4,3,17)
Console.WriteLine(ts2.ToString("d\.hh\:mm\:ss"))
'Theexampledisplaysthefollowingoutput:
'0.14:03:17
'3.04:03:17
回到表格
"M"自訂格式規範
"m"自訂格式規範會輸出TimeSpan.Minutes屬性的值，這代表時間間隔中未計入天數部分的完整分鐘數。
如果TimeSpan.Minutes屬性的值為0到9，就會傳回一位數的字串值；如果TimeSpan.Minutes屬性的值為10到59，則會傳回兩位數的字串值。
如果單獨使用"m"自訂格式規範，請指定"%m"，以免被錯誤解譯為標準格式字串。
下列範例提供說明。
TimeSpants=newTimeSpan(3,42,0);
Console.WriteLine("{0:%h}hours{0:%m}minutes",ts);
//Theexampledisplaysthefollowingoutput:
//3hours42minutes
DimtsAsNewTimeSpan(3,42,0)
Console.WriteLine("{0:%h}hours{0:%m}minutes",ts)
'Theexampledisplaysthefollowingoutput:
'3hours42minutes
通常在剖析作業中，只包含單一數字的輸入字串會解譯為天數。
您可以改用"%m"自訂格式規範，將數值字串解譯為分鐘數。
下列範例提供說明。
stringvalue="3";
TimeSpaninterval;
if(TimeSpan.TryParseExact(value,"%m",null,outinterval))
Console.WriteLine(interval.ToString("c"));
else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value);
//Theexampledisplaysthefollowingoutput:
//00:03:00
DimvalueAsString="3"
DimintervalAsTimeSpan
IfTimeSpan.TryParseExact(value,"%m",Nothing,interval)Then
Console.WriteLine(interval.ToString("c"))
Else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value)
EndIf
'Theexampledisplaysthefollowingoutput:
'00:03:00
下列範例說明如何使用"m"自訂格式規範。
TimeSpants1=newTimeSpan(0,6,32);
Console.WriteLine("{0:m\\:ss}minutes",ts1);
TimeSpants2=newTimeSpan(3,4,3,17);
Console.WriteLine("Elapsedtime:{0:m\\:ss}",ts2);
//Theexampledisplaysthefollowingoutput:
//6:32minutes
//Elapsedtime:18:44
Dimts1AsNewTimeSpan(0,6,32)
Console.WriteLine("{0:m\:ss}minutes",ts1)
Dimts2AsNewTimeSpan(0,18,44)
Console.WriteLine("Elapsedtime:{0:m\:ss}",ts2)
'Theexampledisplaysthefollowingoutput:
'6:32minutes
'Elapsedtime:18:44
回到表格
"Mm"自訂格式規範
"mm"自訂格式規範會輸出TimeSpan.Minutes屬性的值，這代表時間間隔中未包含在時數或天數部分中的完整分鐘數。
對於從0到9的值，輸出字串會包含前置零。
通常在剖析作業中，只包含單一數字的輸入字串會解譯為天數。
您可以改用"mm"自訂格式規範，將數值字串解譯為分鐘數。
下列範例提供說明。
stringvalue="07";
TimeSpaninterval;
if(TimeSpan.TryParseExact(value,"mm",null,outinterval))
Console.WriteLine(interval.ToString("c"));
else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value);
//Theexampledisplaysthefollowingoutput:
//00:07:00
DimvalueAsString="05"
DimintervalAsTimeSpan
IfTimeSpan.TryParseExact(value,"mm",Nothing,interval)Then
Console.WriteLine(interval.ToString("c"))
Else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value)
EndIf
'Theexampledisplaysthefollowingoutput:
'00:05:00
下列範例說明如何使用"mm"自訂格式規範。
TimeSpandepartTime=newTimeSpan(11,12,00);
TimeSpanarriveTime=newTimeSpan(16,28,00);
Console.WriteLine("Traveltime:{0:hh\\:mm}",
arriveTime-departTime);
//Theexampledisplaysthefollowingoutput:
//Traveltime:05:16
DimdepartTimeAsNewTimeSpan(11,12,00)
DimarriveTimeAsNewTimeSpan(16,28,00)
Console.WriteLine("Traveltime:{0:hh\:mm}",
arriveTime-departTime)
'Theexampledisplaysthefollowingoutput:
'Traveltime:05:16
回到表格
"S"自訂格式規範
"s"自訂格式規範會輸出TimeSpan.Seconds屬性的值，這代表時間間隔中未包含在時數、天數或分鐘數部分中的完整秒數。
如果TimeSpan.Seconds屬性的值為0到9，就會傳回一位數的字串值；如果TimeSpan.Seconds屬性的值為10到59，則會傳回兩位數的字串值。
如果單獨使用"s"自訂格式規範，請指定"%s"，以免被錯誤解譯為標準格式字串。
下列範例提供說明。
TimeSpants=TimeSpan.FromSeconds(12.465);
Console.WriteLine(ts.ToString("%s"));
//Theexampledisplaysthefollowingoutput:
//12
DimtsAsTimeSpan=TimeSpan.FromSeconds(12.465)
Console.WriteLine(ts.ToString("%s"))
'Theexampledisplaysthefollowingoutput:
'12
通常在剖析作業中，只包含單一數字的輸入字串會解譯為天數。
您可以改用"%s"自訂格式規範，將數值字串解譯為秒數。
下列範例提供說明。
stringvalue="9";
TimeSpaninterval;
if(TimeSpan.TryParseExact(value,"%s",null,outinterval))
Console.WriteLine(interval.ToString("c"));
else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value);
//Theexampledisplaysthefollowingoutput:
//00:00:09
DimvalueAsString="9"
DimintervalAsTimeSpan
IfTimeSpan.TryParseExact(value,"%s",Nothing,interval)Then
Console.WriteLine(interval.ToString("c"))
Else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value)
EndIf
'Theexampledisplaysthefollowingoutput:
'00:00:09
下列範例說明如何使用"s"自訂格式規範。
TimeSpanstartTime=newTimeSpan(0,12,30,15,0);
TimeSpanendTime=newTimeSpan(0,12,30,21,3);
Console.WriteLine(@"ElapsedTime:{0:s\:fff}seconds",
endTime-startTime);
//Theexampledisplaysthefollowingoutput:
//ElapsedTime:6:003seconds
DimstartTimeAsNewTimeSpan(0,12,30,15,0)
DimendTimeAsNewTimeSpan(0,12,30,21,3)
Console.WriteLine("ElapsedTime:{0:s\:fff}seconds",
endTime-startTime)
'Theexampledisplaysthefollowingoutput:
'ElapsedTime:6:003seconds
回到表格
"Ss"自訂格式規範
"ss"自訂格式規範會輸出TimeSpan.Seconds屬性的值，這代表時間間隔中未包含在時數、天數或分鐘數部分中的完整秒數。
對於從0到9的值，輸出字串會包含前置零。
通常在剖析作業中，只包含單一數字的輸入字串會解譯為天數。
您可以改用"ss"自訂格式規範，將數值字串解譯為秒數。
下列範例提供說明。
string[]values={"49","9","06"};
TimeSpaninterval;
foreach(stringvalueinvalues)
{
if(TimeSpan.TryParseExact(value,"ss",null,outinterval))
Console.WriteLine(interval.ToString("c"));
else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value);
}
//Theexampledisplaysthefollowingoutput:
//00:00:49
//Unabletoconvert'9'toatimeinterval
//00:00:06
Dimvalues()AsString={"49","9","06"}
DimintervalAsTimeSpan
ForEachvalueAsStringInvalues
IfTimeSpan.TryParseExact(value,"ss",Nothing,interval)Then
Console.WriteLine(interval.ToString("c"))
Else
Console.WriteLine("Unabletoconvert'{0}'toatimeinterval",
value)
EndIf
Next
'Theexampledisplaysthefollowingoutput:
'00:00:49
'Unabletoconvert'9'toatimeinterval
'00:00:06
下列範例說明如何使用"ss"自訂格式規範。
TimeSpaninterval1=TimeSpan.FromSeconds(12.60);
Console.WriteLine(interval1.ToString(@"ss\.fff"));
TimeSpaninterval2=TimeSpan.FromSeconds(6.485);
Console.WriteLine(interval2.ToString(@"ss\.fff"));
//Theexampledisplaysthefollowingoutput:
//12.600
//06.485
Diminterval1AsTimeSpan=TimeSpan.FromSeconds(12.60)
Console.WriteLine(interval1.ToString("ss\.fff"))
Diminterval2AsTimeSpan=TimeSpan.FromSeconds(6.485)
Console.WriteLine(interval2.ToString("ss\.fff"))
'Theexampledisplaysthefollowingoutput:
'12.600
'06.485
回到表格
"F"自訂格式規範
"f"自訂格式規範會輸出時間間隔中的十分之一秒。
在格式化作業中，會截斷其餘任何小數位數。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，輸入字串必須確切包含一個小數位數。
如果單獨使用"f"自訂格式規範，請指定"%f"，以免被錯誤解譯為標準格式字串。
下列範例會使用"f"自訂格式規範，以顯示TimeSpan值中的十分之一秒。
首先會使用"f"作為唯一的格式規範，然後再放在自訂格式字串中與"s"規範結合。
TimeSpants=newTimeSpan(1003498765432);
stringfmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
if(fmt.Length==1)fmt="%"+fmt;
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts);
}
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
Console.WriteLine("{0,10}:{1:s\\."+fmt+"}","s\\."+fmt,ts);
}
//Theexampledisplaysthefollowingoutput:
//%f:8
//ff:87
//fff:876
//ffff:8765
//fffff:87654
//ffffff:876543
//fffffff:8765432
//
//s\.f:29.8
//s\.ff:29.87
//s\.fff:29.876
//s\.ffff:29.8765
//s\.fffff:29.87654
//s\.ffffff:29.876543
//s\.fffffff:29.8765432
DimtsAsNewTimeSpan(1003498765432)
DimfmtAsString
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Iffmt.Length=1Thenfmt="%"+fmt
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts)
Next
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Console.WriteLine("{0,10}:{1:s\."+fmt+"}","s\."+fmt,ts)
Next
'Theexampledisplaysthefollowingoutput:
'%f:8
'ff:87
'fff:876
'ffff:8765
'fffff:87654
'ffffff:876543
'fffffff:8765432
'
's\.f:29.8
's\.ff:29.87
's\.fff:29.876
's\.ffff:29.8765
's\.fffff:29.87654
's\.ffffff:29.876543
's\.fffffff:29.8765432
回到表格
"Ff"自訂格式規範
"ff"自訂格式規範會輸出時間間隔中的百分之一秒。
在格式化作業中，會截斷其餘任何小數位數。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，輸入字串必須確切包含兩個小數位數。
下列範例會使用"ff"自訂格式規範，以顯示TimeSpan值中的百分之一秒。
首先會使用"ff"作為唯一的格式規範，然後再放在自訂格式字串中與"s"規範結合。
TimeSpants=newTimeSpan(1003498765432);
stringfmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
if(fmt.Length==1)fmt="%"+fmt;
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts);
}
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
Console.WriteLine("{0,10}:{1:s\\."+fmt+"}","s\\."+fmt,ts);
}
//Theexampledisplaysthefollowingoutput:
//%f:8
//ff:87
//fff:876
//ffff:8765
//fffff:87654
//ffffff:876543
//fffffff:8765432
//
//s\.f:29.8
//s\.ff:29.87
//s\.fff:29.876
//s\.ffff:29.8765
//s\.fffff:29.87654
//s\.ffffff:29.876543
//s\.fffffff:29.8765432
DimtsAsNewTimeSpan(1003498765432)
DimfmtAsString
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Iffmt.Length=1Thenfmt="%"+fmt
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts)
Next
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Console.WriteLine("{0,10}:{1:s\."+fmt+"}","s\."+fmt,ts)
Next
'Theexampledisplaysthefollowingoutput:
'%f:8
'ff:87
'fff:876
'ffff:8765
'fffff:87654
'ffffff:876543
'fffffff:8765432
'
's\.f:29.8
's\.ff:29.87
's\.fff:29.876
's\.ffff:29.8765
's\.fffff:29.87654
's\.ffffff:29.876543
's\.fffffff:29.8765432
回到表格
"Fff"自訂格式規範
"fff"自訂格式規範(有三個"f"字元)會輸出時間間隔中的毫秒。
在格式化作業中，會截斷其餘任何小數位數。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，輸入字串必須確切包含三個小數位數。
下列範例會使用"fff"自訂格式規範，以顯示TimeSpan值中的毫秒。
首先會使用"fff"作為唯一的格式規範，然後再放在自訂格式字串中與"s"規範結合。
TimeSpants=newTimeSpan(1003498765432);
stringfmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
if(fmt.Length==1)fmt="%"+fmt;
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts);
}
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
Console.WriteLine("{0,10}:{1:s\\."+fmt+"}","s\\."+fmt,ts);
}
//Theexampledisplaysthefollowingoutput:
//%f:8
//ff:87
//fff:876
//ffff:8765
//fffff:87654
//ffffff:876543
//fffffff:8765432
//
//s\.f:29.8
//s\.ff:29.87
//s\.fff:29.876
//s\.ffff:29.8765
//s\.fffff:29.87654
//s\.ffffff:29.876543
//s\.fffffff:29.8765432
DimtsAsNewTimeSpan(1003498765432)
DimfmtAsString
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Iffmt.Length=1Thenfmt="%"+fmt
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts)
Next
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Console.WriteLine("{0,10}:{1:s\."+fmt+"}","s\."+fmt,ts)
Next
'Theexampledisplaysthefollowingoutput:
'%f:8
'ff:87
'fff:876
'ffff:8765
'fffff:87654
'ffffff:876543
'fffffff:8765432
'
's\.f:29.8
's\.ff:29.87
's\.fff:29.876
's\.ffff:29.8765
's\.fffff:29.87654
's\.ffffff:29.876543
's\.fffffff:29.8765432
回到表格
"Ffff"自訂格式規範
"ffff"自訂格式規範(有四個"f"字元)會輸出時間間隔中的萬分之一秒。
在格式化作業中，會截斷其餘任何小數位數。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，輸入字串必須確切包含四個小數位數。
下列範例會使用"ffff"自訂格式規範，以顯示TimeSpan值中的萬分之一秒。
首先會使用"ffff"作為唯一的格式規範，然後再放在自訂格式字串中與"s"規範結合。
TimeSpants=newTimeSpan(1003498765432);
stringfmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
if(fmt.Length==1)fmt="%"+fmt;
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts);
}
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
Console.WriteLine("{0,10}:{1:s\\."+fmt+"}","s\\."+fmt,ts);
}
//Theexampledisplaysthefollowingoutput:
//%f:8
//ff:87
//fff:876
//ffff:8765
//fffff:87654
//ffffff:876543
//fffffff:8765432
//
//s\.f:29.8
//s\.ff:29.87
//s\.fff:29.876
//s\.ffff:29.8765
//s\.fffff:29.87654
//s\.ffffff:29.876543
//s\.fffffff:29.8765432
DimtsAsNewTimeSpan(1003498765432)
DimfmtAsString
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Iffmt.Length=1Thenfmt="%"+fmt
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts)
Next
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Console.WriteLine("{0,10}:{1:s\."+fmt+"}","s\."+fmt,ts)
Next
'Theexampledisplaysthefollowingoutput:
'%f:8
'ff:87
'fff:876
'ffff:8765
'fffff:87654
'ffffff:876543
'fffffff:8765432
'
's\.f:29.8
's\.ff:29.87
's\.fff:29.876
's\.ffff:29.8765
's\.fffff:29.87654
's\.ffffff:29.876543
's\.fffffff:29.8765432
回到表格
"Fffff"自訂格式規範
"fffff"自訂格式規範(有五個"f"字元)會輸出時間間隔中的十萬分之一秒。
在格式化作業中，會截斷其餘任何小數位數。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，輸入字串必須確切包含五個小數位數。
下列範例會使用"fffff"自訂格式規範，以顯示TimeSpan值中的十萬分之一秒。
首先會使用"fffff"作為唯一的格式規範，然後再放在自訂格式字串中與"s"規範結合。
TimeSpants=newTimeSpan(1003498765432);
stringfmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
if(fmt.Length==1)fmt="%"+fmt;
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts);
}
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
Console.WriteLine("{0,10}:{1:s\\."+fmt+"}","s\\."+fmt,ts);
}
//Theexampledisplaysthefollowingoutput:
//%f:8
//ff:87
//fff:876
//ffff:8765
//fffff:87654
//ffffff:876543
//fffffff:8765432
//
//s\.f:29.8
//s\.ff:29.87
//s\.fff:29.876
//s\.ffff:29.8765
//s\.fffff:29.87654
//s\.ffffff:29.876543
//s\.fffffff:29.8765432
DimtsAsNewTimeSpan(1003498765432)
DimfmtAsString
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Iffmt.Length=1Thenfmt="%"+fmt
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts)
Next
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Console.WriteLine("{0,10}:{1:s\."+fmt+"}","s\."+fmt,ts)
Next
'Theexampledisplaysthefollowingoutput:
'%f:8
'ff:87
'fff:876
'ffff:8765
'fffff:87654
'ffffff:876543
'fffffff:8765432
'
's\.f:29.8
's\.ff:29.87
's\.fff:29.876
's\.ffff:29.8765
's\.fffff:29.87654
's\.ffffff:29.876543
's\.fffffff:29.8765432
回到表格
"Ffffff"自訂格式規範
"ffffff"自訂格式規範(有六個"f"字元)會輸出時間間隔中的百萬分之一秒。
在格式化作業中，會截斷其餘任何小數位數。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，輸入字串必須確切包含六個小數位數。
下列範例會使用"ffffff"自訂格式規範，以顯示TimeSpan值中的百萬分之一秒。
首先會使用它作為唯一的格式規範，然後再放在自訂格式字串中與"s"規範結合。
TimeSpants=newTimeSpan(1003498765432);
stringfmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
if(fmt.Length==1)fmt="%"+fmt;
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts);
}
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
Console.WriteLine("{0,10}:{1:s\\."+fmt+"}","s\\."+fmt,ts);
}
//Theexampledisplaysthefollowingoutput:
//%f:8
//ff:87
//fff:876
//ffff:8765
//fffff:87654
//ffffff:876543
//fffffff:8765432
//
//s\.f:29.8
//s\.ff:29.87
//s\.fff:29.876
//s\.ffff:29.8765
//s\.fffff:29.87654
//s\.ffffff:29.876543
//s\.fffffff:29.8765432
DimtsAsNewTimeSpan(1003498765432)
DimfmtAsString
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Iffmt.Length=1Thenfmt="%"+fmt
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts)
Next
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Console.WriteLine("{0,10}:{1:s\."+fmt+"}","s\."+fmt,ts)
Next
'Theexampledisplaysthefollowingoutput:
'%f:8
'ff:87
'fff:876
'ffff:8765
'fffff:87654
'ffffff:876543
'fffffff:8765432
'
's\.f:29.8
's\.ff:29.87
's\.fff:29.876
's\.ffff:29.8765
's\.fffff:29.87654
's\.ffffff:29.876543
's\.fffffff:29.8765432
回到表格
"Fffffff"自訂格式規範
"fffffff"自訂格式規範(有七個"f"字元)會輸出時間間隔中的千萬分之一秒(或刻度的小數值)。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，輸入字串必須確切包含七個小數位數。
下列範例會使用"fffffff"自訂格式規範，以顯示TimeSpan值中刻度的小數值。
首先會使用它作為唯一的格式規範，然後再放在自訂格式字串中與"s"規範結合。
TimeSpants=newTimeSpan(1003498765432);
stringfmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
if(fmt.Length==1)fmt="%"+fmt;
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts);
}
Console.WriteLine();
for(intctr=1;ctr<=7;ctr++){
fmt=newString('f',ctr);
Console.WriteLine("{0,10}:{1:s\\."+fmt+"}","s\\."+fmt,ts);
}
//Theexampledisplaysthefollowingoutput:
//%f:8
//ff:87
//fff:876
//ffff:8765
//fffff:87654
//ffffff:876543
//fffffff:8765432
//
//s\.f:29.8
//s\.ff:29.87
//s\.fff:29.876
//s\.ffff:29.8765
//s\.fffff:29.87654
//s\.ffffff:29.876543
//s\.fffffff:29.8765432
DimtsAsNewTimeSpan(1003498765432)
DimfmtAsString
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Iffmt.Length=1Thenfmt="%"+fmt
Console.WriteLine("{0,10}:{1:"+fmt+"}",fmt,ts)
Next
Console.WriteLine()
Forctr=1To7
fmt=NewString("f"c,ctr)
Console.WriteLine("{0,10}:{1:s\."+fmt+"}","s\."+fmt,ts)
Next
'Theexampledisplaysthefollowingoutput:
'%f:8
'ff:87
'fff:876
'ffff:8765
'fffff:87654
'ffffff:876543
'fffffff:8765432
'
's\.f:29.8
's\.ff:29.87
's\.fff:29.876
's\.ffff:29.8765
's\.fffff:29.87654
's\.ffffff:29.876543
's\.fffffff:29.8765432
回到表格
"F"自訂格式規範
"F"自訂格式規範會輸出時間間隔中的十分之一秒。
在格式化作業中，會截斷其餘任何小數位數。
如果時間間隔十分之一秒的值為零，它就不會包含在結果字串中。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，可以視需要使用十分之一秒的位數。
如果單獨使用"F"自訂格式規範，請指定"%F"，以免被錯誤解譯為標準格式字串。
下列範例會使用"F"自訂格式規範，以顯示TimeSpan值中的十分之一秒。
它也會在剖析作業中使用此自訂格式規範。
Console.WriteLine("Formatting:");
TimeSpants1=TimeSpan.Parse("0:0:3.669");
Console.WriteLine("{0}('%F')-->{0:%F}",ts1);
TimeSpants2=TimeSpan.Parse("0:0:3.091");
Console.WriteLine("{0}('ss\\.F')-->{0:ss\\.F}",ts2);
Console.WriteLine();
Console.WriteLine("Parsing:");
string[]inputs={"0:0:03.","0:0:03.1","0:0:03.12"};
stringfmt=@"h\:m\:ss\.F";
TimeSpants3;
foreach(stringinputininputs){
if(TimeSpan.TryParseExact(input,fmt,null,outts3))
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3);
else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt);
}
//Theexampledisplaysthefollowingoutput:
//Formatting:
//00:00:03.6690000('%F')-->6
//00:00:03.0910000('ss\.F')-->03.
//
//Parsing:
//0:0:03.('h\:m\:ss\.F')-->00:00:03
//0:0:03.1('h\:m\:ss\.F')-->00:00:03.1000000
//Cannotparse0:0:03.12with'h\:m\:ss\.F'.
Console.WriteLine("Formatting:")
Dimts1AsTimeSpan=TimeSpan.Parse("0:0:3.669")
Console.WriteLine("{0}('%F')-->{0:%F}",ts1)
Dimts2AsTimeSpan=TimeSpan.Parse("0:0:3.091")
Console.WriteLine("{0}('ss\.F')-->{0:ss\.F}",ts2)
Console.WriteLine()
Console.WriteLine("Parsing:")
Diminputs()AsString={"0:0:03.","0:0:03.1","0:0:03.12"}
DimfmtAsString="h\:m\:ss\.F"
Dimts3AsTimeSpan
ForEachinputAsStringIninputs
IfTimeSpan.TryParseExact(input,fmt,Nothing,ts3)
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3)
Else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt)
EndIf
Next
'Theexampledisplaysthefollowingoutput:
'Formatting:
'00:00:03.6690000('%F')-->6
'00:00:03.0910000('ss\.F')-->03.
'
'Parsing:
'0:0:03.('h\:m\:ss\.F')-->00:00:03
'0:0:03.1('h\:m\:ss\.F')-->00:00:03.1000000
'Cannotparse0:0:03.12with'h\:m\:ss\.F'.
回到表格
"FF"自訂格式規範
"FF"自訂格式規範會輸出時間間隔中的百分之一秒。
在格式化作業中，會截斷其餘任何小數位數。
如果小數點後有任何零，這些零不會包含在結果字串中。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，可以視需要使用十分之一秒和百分之一秒的位數。
下列範例會使用"FF"自訂格式規範，以顯示TimeSpan值中的百分之一秒。
它也會在剖析作業中使用此自訂格式規範。
Console.WriteLine("Formatting:");
TimeSpants1=TimeSpan.Parse("0:0:3.697");
Console.WriteLine("{0}('FF')-->{0:FF}",ts1);
TimeSpants2=TimeSpan.Parse("0:0:3.809");
Console.WriteLine("{0}('ss\\.FF')-->{0:ss\\.FF}",ts2);
Console.WriteLine();
Console.WriteLine("Parsing:");
string[]inputs={"0:0:03.","0:0:03.1","0:0:03.127"};
stringfmt=@"h\:m\:ss\.FF";
TimeSpants3;
foreach(stringinputininputs){
if(TimeSpan.TryParseExact(input,fmt,null,outts3))
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3);
else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt);
}
//Theexampledisplaysthefollowingoutput:
//Formatting:
//00:00:03.6970000('FF')-->69
//00:00:03.8090000('ss\.FF')-->03.8
//
//Parsing:
//0:0:03.('h\:m\:ss\.FF')-->00:00:03
//0:0:03.1('h\:m\:ss\.FF')-->00:00:03.1000000
//Cannotparse0:0:03.127with'h\:m\:ss\.FF'.
Console.WriteLine("Formatting:")
Dimts1AsTimeSpan=TimeSpan.Parse("0:0:3.697")
Console.WriteLine("{0}('FF')-->{0:FF}",ts1)
Dimts2AsTimeSpan=TimeSpan.Parse("0:0:3.809")
Console.WriteLine("{0}('ss\.FF')-->{0:ss\.FF}",ts2)
Console.WriteLine()
Console.WriteLine("Parsing:")
Diminputs()AsString={"0:0:03.","0:0:03.1","0:0:03.127"}
DimfmtAsString="h\:m\:ss\.FF"
Dimts3AsTimeSpan
ForEachinputAsStringIninputs
IfTimeSpan.TryParseExact(input,fmt,Nothing,ts3)
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3)
Else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt)
EndIf
Next
'Theexampledisplaysthefollowingoutput:
'Formatting:
'00:00:03.6970000('FF')-->69
'00:00:03.8090000('ss\.FF')-->03.8
'
'Parsing:
'0:0:03.('h\:m\:ss\.FF')-->00:00:03
'0:0:03.1('h\:m\:ss\.FF')-->00:00:03.1000000
'Cannotparse0:0:03.127with'h\:m\:ss\.FF'.
回到表格
"FFF"自訂格式規範
"FFF"自訂格式規範(有三個"F"字元)會輸出時間間隔中的毫秒。
在格式化作業中，會截斷其餘任何小數位數。
如果小數點後有任何零，這些零不會包含在結果字串中。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，可以視需要使用十分之一秒、百分之一秒及千分之一秒的位數。
下列範例會使用"FFF"自訂格式規範，以顯示TimeSpan值中的千分之一秒。
它也會在剖析作業中使用此自訂格式規範。
Console.WriteLine("Formatting:");
TimeSpants1=TimeSpan.Parse("0:0:3.6974");
Console.WriteLine("{0}('FFF')-->{0:FFF}",ts1);
TimeSpants2=TimeSpan.Parse("0:0:3.8009");
Console.WriteLine("{0}('ss\\.FFF')-->{0:ss\\.FFF}",ts2);
Console.WriteLine();
Console.WriteLine("Parsing:");
string[]inputs={"0:0:03.","0:0:03.12","0:0:03.1279"};
stringfmt=@"h\:m\:ss\.FFF";
TimeSpants3;
foreach(stringinputininputs){
if(TimeSpan.TryParseExact(input,fmt,null,outts3))
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3);
else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt);
}
//Theexampledisplaysthefollowingoutput:
//Formatting:
//00:00:03.6974000('FFF')-->697
//00:00:03.8009000('ss\.FFF')-->03.8
//
//Parsing:
//0:0:03.('h\:m\:ss\.FFF')-->00:00:03
//0:0:03.12('h\:m\:ss\.FFF')-->00:00:03.1200000
//Cannotparse0:0:03.1279with'h\:m\:ss\.FFF'.
Console.WriteLine("Formatting:")
Dimts1AsTimeSpan=TimeSpan.Parse("0:0:3.6974")
Console.WriteLine("{0}('FFF')-->{0:FFF}",ts1)
Dimts2AsTimeSpan=TimeSpan.Parse("0:0:3.8009")
Console.WriteLine("{0}('ss\.FFF')-->{0:ss\.FFF}",ts2)
Console.WriteLine()
Console.WriteLine("Parsing:")
Diminputs()AsString={"0:0:03.","0:0:03.12","0:0:03.1279"}
DimfmtAsString="h\:m\:ss\.FFF"
Dimts3AsTimeSpan
ForEachinputAsStringIninputs
IfTimeSpan.TryParseExact(input,fmt,Nothing,ts3)
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3)
Else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt)
EndIf
Next
'Theexampledisplaysthefollowingoutput:
'Formatting:
'00:00:03.6974000('FFF')-->697
'00:00:03.8009000('ss\.FFF')-->03.8
'
'Parsing:
'0:0:03.('h\:m\:ss\.FFF')-->00:00:03
'0:0:03.12('h\:m\:ss\.FFF')-->00:00:03.1200000
'Cannotparse0:0:03.1279with'h\:m\:ss\.FFF'.
回到表格
"FFFF"自訂格式規範
"FFFF"自訂格式規範(有四個"F"字元)會輸出時間間隔中的萬分之一秒。
在格式化作業中，會截斷其餘任何小數位數。
如果小數點後有任何零，這些零不會包含在結果字串中。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，可以視需要使用十分之一秒、百分之一秒、千分之一秒及萬分之一秒的位數。
下列範例會使用"FFFF"自訂格式規範，以顯示TimeSpan值中的萬分之一秒。
它也會在剖析作業中使用"FFFF"自訂格式規範。
Console.WriteLine("Formatting:");
TimeSpants1=TimeSpan.Parse("0:0:3.69749");
Console.WriteLine("{0}('FFFF')-->{0:FFFF}",ts1);
TimeSpants2=TimeSpan.Parse("0:0:3.80009");
Console.WriteLine("{0}('ss\\.FFFF')-->{0:ss\\.FFFF}",ts2);
Console.WriteLine();
Console.WriteLine("Parsing:");
string[]inputs={"0:0:03.","0:0:03.12","0:0:03.12795"};
stringfmt=@"h\:m\:ss\.FFFF";
TimeSpants3;
foreach(stringinputininputs){
if(TimeSpan.TryParseExact(input,fmt,null,outts3))
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3);
else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt);
}
//Theexampledisplaysthefollowingoutput:
//Formatting:
//00:00:03.6974900('FFFF')-->6974
//00:00:03.8000900('ss\.FFFF')-->03.8
//
//Parsing:
//0:0:03.('h\:m\:ss\.FFFF')-->00:00:03
//0:0:03.12('h\:m\:ss\.FFFF')-->00:00:03.1200000
//Cannotparse0:0:03.12795with'h\:m\:ss\.FFFF'.
Console.WriteLine("Formatting:")
Dimts1AsTimeSpan=TimeSpan.Parse("0:0:3.69749")
Console.WriteLine("{0}('FFFF')-->{0:FFFF}",ts1)
Dimts2AsTimeSpan=TimeSpan.Parse("0:0:3.80009")
Console.WriteLine("{0}('ss\.FFFF')-->{0:ss\.FFFF}",ts2)
Console.WriteLine()
Console.WriteLine("Parsing:")
Diminputs()AsString={"0:0:03.","0:0:03.12","0:0:03.12795"}
DimfmtAsString="h\:m\:ss\.FFFF"
Dimts3AsTimeSpan
ForEachinputAsStringIninputs
IfTimeSpan.TryParseExact(input,fmt,Nothing,ts3)
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3)
Else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt)
EndIf
Next
'Theexampledisplaysthefollowingoutput:
'Formatting:
'00:00:03.6974900('FFFF')-->6974
'00:00:03.8000900('ss\.FFFF')-->03.8
'
'Parsing:
'0:0:03.('h\:m\:ss\.FFFF')-->00:00:03
'0:0:03.12('h\:m\:ss\.FFFF')-->00:00:03.1200000
'Cannotparse0:0:03.12795with'h\:m\:ss\.FFFF'.
回到表格
"FFFFF"自訂格式規範
"FFFFF"自訂格式規範(有五個"F"字元)會輸出時間間隔中的十萬分之一秒。
在格式化作業中，會截斷其餘任何小數位數。
如果小數點後有任何零，這些零不會包含在結果字串中。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，可以視需要使用十分之一秒、百分之一秒、千分之一秒、萬分之一秒及十萬分之一秒的位數。
下列範例會使用"FFFFF"自訂格式規範，以顯示TimeSpan值中的十萬分之一秒。
它也會在剖析作業中使用"FFFFF"自訂格式規範。
Console.WriteLine("Formatting:");
TimeSpants1=TimeSpan.Parse("0:0:3.697497");
Console.WriteLine("{0}('FFFFF')-->{0:FFFFF}",ts1);
TimeSpants2=TimeSpan.Parse("0:0:3.800009");
Console.WriteLine("{0}('ss\\.FFFFF')-->{0:ss\\.FFFFF}",ts2);
Console.WriteLine();
Console.WriteLine("Parsing:");
string[]inputs={"0:0:03.","0:0:03.12","0:0:03.127956"};
stringfmt=@"h\:m\:ss\.FFFFF";
TimeSpants3;
foreach(stringinputininputs){
if(TimeSpan.TryParseExact(input,fmt,null,outts3))
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3);
else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt);
}
//Theexampledisplaysthefollowingoutput:
//Formatting:
//00:00:03.6974970('FFFFF')-->69749
//00:00:03.8000090('ss\.FFFFF')-->03.8
//
//Parsing:
//0:0:03.('h\:m\:ss\.FFFF')-->00:00:03
//0:0:03.12('h\:m\:ss\.FFFF')-->00:00:03.1200000
//Cannotparse0:0:03.127956with'h\:m\:ss\.FFFF'.
Console.WriteLine("Formatting:")
Dimts1AsTimeSpan=TimeSpan.Parse("0:0:3.697497")
Console.WriteLine("{0}('FFFFF')-->{0:FFFFF}",ts1)
Dimts2AsTimeSpan=TimeSpan.Parse("0:0:3.800009")
Console.WriteLine("{0}('ss\.FFFFF')-->{0:ss\.FFFFF}",ts2)
Console.WriteLine()
Console.WriteLine("Parsing:")
Diminputs()AsString={"0:0:03.","0:0:03.12","0:0:03.127956"}
DimfmtAsString="h\:m\:ss\.FFFFF"
Dimts3AsTimeSpan
ForEachinputAsStringIninputs
IfTimeSpan.TryParseExact(input,fmt,Nothing,ts3)
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3)
Else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt)
EndIf
Next
'Theexampledisplaysthefollowingoutput:
'Formatting:
'00:00:03.6974970('FFFFF')-->69749
'00:00:03.8000090('ss\.FFFFF')-->03.8
'
'Parsing:
'0:0:03.('h\:m\:ss\.FFFF')-->00:00:03
'0:0:03.12('h\:m\:ss\.FFFF')-->00:00:03.1200000
'Cannotparse0:0:03.127956with'h\:m\:ss\.FFFF'.
回到表格
"FFFFFF"自訂格式規範
"FFFFFF"自訂格式規範(有六個"F"字元)會輸出時間間隔中的百萬分之一秒。
在格式化作業中，會截斷其餘任何小數位數。
如果小數點後有任何零，這些零不會包含在結果字串中。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，可以視需要使用十分之一秒、百分之一秒、千分之一秒、萬分之一秒、十萬分之一秒及百萬分之一秒的位數。
下列範例會使用"FFFFFF"自訂格式規範，以顯示TimeSpan值中的百萬分之一秒。
它也會在剖析作業中使用此自訂格式規範。
Console.WriteLine("Formatting:");
TimeSpants1=TimeSpan.Parse("0:0:3.6974974");
Console.WriteLine("{0}('FFFFFF')-->{0:FFFFFF}",ts1);
TimeSpants2=TimeSpan.Parse("0:0:3.8000009");
Console.WriteLine("{0}('ss\\.FFFFFF')-->{0:ss\\.FFFFFF}",ts2);
Console.WriteLine();
Console.WriteLine("Parsing:");
string[]inputs={"0:0:03.","0:0:03.12","0:0:03.1279569"};
stringfmt=@"h\:m\:ss\.FFFFFF";
TimeSpants3;
foreach(stringinputininputs){
if(TimeSpan.TryParseExact(input,fmt,null,outts3))
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3);
else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt);
}
//Theexampledisplaysthefollowingoutput:
//Formatting:
//00:00:03.6974974('FFFFFF')-->697497
//00:00:03.8000009('ss\.FFFFFF')-->03.8
//
//Parsing:
//0:0:03.('h\:m\:ss\.FFFFFF')-->00:00:03
//0:0:03.12('h\:m\:ss\.FFFFFF')-->00:00:03.1200000
//Cannotparse0:0:03.1279569with'h\:m\:ss\.FFFFFF'.
Console.WriteLine("Formatting:")
Dimts1AsTimeSpan=TimeSpan.Parse("0:0:3.6974974")
Console.WriteLine("{0}('FFFFFF')-->{0:FFFFFF}",ts1)
Dimts2AsTimeSpan=TimeSpan.Parse("0:0:3.8000009")
Console.WriteLine("{0}('ss\.FFFFFF')-->{0:ss\.FFFFFF}",ts2)
Console.WriteLine()
Console.WriteLine("Parsing:")
Diminputs()AsString={"0:0:03.","0:0:03.12","0:0:03.1279569"}
DimfmtAsString="h\:m\:ss\.FFFFFF"
Dimts3AsTimeSpan
ForEachinputAsStringIninputs
IfTimeSpan.TryParseExact(input,fmt,Nothing,ts3)
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3)
Else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt)
EndIf
Next
'Theexampledisplaysthefollowingoutput:
'Formatting:
'00:00:03.6974974('FFFFFF')-->697497
'00:00:03.8000009('ss\.FFFFFF')-->03.8
'
'Parsing:
'0:0:03.('h\:m\:ss\.FFFFFF')-->00:00:03
'0:0:03.12('h\:m\:ss\.FFFFFF')-->00:00:03.1200000
'Cannotparse0:0:03.1279569with'h\:m\:ss\.FFFFFF'.
回到表格
"FFFFFFF"自訂格式規範
"FFFFFFF"自訂格式規範(有七個"F"字元)會輸出時間間隔中的千萬分之一秒(或刻度的小數值)。
如果小數點後有任何零，這些零不會包含在結果字串中。
在呼叫TimeSpan.ParseExact或TimeSpan.TryParseExact方法的剖析作業中，可以視需要在輸入字串中使用七個小數位數。
下列範例會使用"FFFFFFF"自訂格式規範，以顯示TimeSpan值中的小數秒部分。
它也會在剖析作業中使用此自訂格式規範。
Console.WriteLine("Formatting:");
TimeSpants1=TimeSpan.Parse("0:0:3.6974974");
Console.WriteLine("{0}('FFFFFFF')-->{0:FFFFFFF}",ts1);
TimeSpants2=TimeSpan.Parse("0:0:3.9500000");
Console.WriteLine("{0}('ss\\.FFFFFFF')-->{0:ss\\.FFFFFFF}",ts2);
Console.WriteLine();
Console.WriteLine("Parsing:");
string[]inputs={"0:0:03.","0:0:03.12","0:0:03.1279569"};
stringfmt=@"h\:m\:ss\.FFFFFFF";
TimeSpants3;
foreach(stringinputininputs){
if(TimeSpan.TryParseExact(input,fmt,null,outts3))
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3);
else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt);
}
//Theexampledisplaysthefollowingoutput:
//Formatting:
//00:00:03.6974974('FFFFFFF')-->6974974
//00:00:03.9500000('ss\.FFFFFFF')-->03.95
//
//Parsing:
//0:0:03.('h\:m\:ss\.FFFFFFF')-->00:00:03
//0:0:03.12('h\:m\:ss\.FFFFFFF')-->00:00:03.1200000
//0:0:03.1279569('h\:m\:ss\.FFFFFFF')-->00:00:03.1279569
Console.WriteLine("Formatting:")
Dimts1AsTimeSpan=TimeSpan.Parse("0:0:3.6974974")
Console.WriteLine("{0}('FFFFFFF')-->{0:FFFFFFF}",ts1)
Dimts2AsTimeSpan=TimeSpan.Parse("0:0:3.9500000")
Console.WriteLine("{0}('ss\.FFFFFFF')-->{0:ss\.FFFFFFF}",ts2)
Console.WriteLine()
Console.WriteLine("Parsing:")
Diminputs()AsString={"0:0:03.","0:0:03.12","0:0:03.1279569"}
DimfmtAsString="h\:m\:ss\.FFFFFFF"
Dimts3AsTimeSpan
ForEachinputAsStringIninputs
IfTimeSpan.TryParseExact(input,fmt,Nothing,ts3)
Console.WriteLine("{0}('{1}')-->{2}",input,fmt,ts3)
Else
Console.WriteLine("Cannotparse{0}with'{1}'.",
input,fmt)
EndIf
Next
'Theexampledisplaysthefollowingoutput:
'Formatting:
'00:00:03.6974974('FFFFFFF')-->6974974
'00:00:03.9500000('ss\.FFFFFFF')-->03.95
'
'Parsing:
'0:0:03.('h\:m\:ss\.FFFFFFF')-->00:00:03
'0:0:03.12('h\:m\:ss\.FFFFFFF')-->00:00:03.1200000
'0:0:03.1279569('h\:m\:ss\.FFFFFFF')-->00:00:03.1279569
回到表格
其他字元
格式字串中任何其他未逸出的字元(包括空白字元)，都會解譯為自訂格式規範。
在大多數情況下，其他任何未逸出的字元都會導致FormatException。
有兩個方式可以在格式字串中納入常值字元：
用單引號(常值字串分隔符號)括住字元。
在字元前面加上反斜線("\")，這樣就會解譯為逸出字元。
亦即在C#中，格式字串必須括以@-quoted，或必須在常值字元前額外加上一道反斜線。
在某些情況下，您可能需要使用條件邏輯，才能在格式字串中包含逸出的常值。
下列範例將使用條件邏輯包含代表負時間間隔的正負號。
usingSystem;
publicclassExample
{
publicstaticvoidMain()
{
TimeSpanresult=newDateTime(2010,01,01)-DateTime.Now;
Stringfmt=(result
延伸文章資訊
- 1C# TimeSpan構造函數代碼示例- 純淨天空
本文整理匯總了C#中System.TimeSpan.TimeSpan構造函數的典型用法代碼示例。如果您正苦於以下問題：C# TimeSpan構造函數的具體用法？C# TimeSpan怎麽用？
- 2TimeSpan 建構函式(System)
將TimeSpan 結構的新執行個體初始化為指定的時數、分鐘數和秒數。 public: TimeSpan(int hours, int minutes, int seconds);. C# 複製.
- 3C# TimeSpan 計算時間差(時間間隔) - 自由手記
TimeSpan 結構表示一個時間間隔。 命名空間:System 程式集:mscorlib（在mscorlib.dll 中） 說明： 1.DateTime數值型別代表了一個從西元0.
- 4C# TimeSpan結構體代碼示例- 純淨天空
本文整理匯總了C#中System.TimeSpan結構體的典型用法代碼示例。如果您正苦於以下問題：C# TimeSpan結構體的具體用法？C# TimeSpan怎麽用？C# TimeSpan使用...
- 5自訂TimeSpan 格式字串
下列範例說明如何使用"d" 自訂格式規範。 C# 複製. TimeSpan ts2 = new TimeSpan ...
