TimeSpan.TryParse 方法

定义

命名空间:: System

程序集:: netstandard.dll, System.Runtime.dll

程序集:: System.Runtime.dll

程序集:: netstandard.dll

程序集:: mscorlib.dll, System.Runtime.dll

程序集:: mscorlib.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

将时间间隔的指定字符串表示形式转换为等效 TimeSpan 值，并返回一个值，该值指示转换是否成功。

重载

名称	说明
TryParse(ReadOnlySpan<Char>, TimeSpan)	将时间间隔的跨度表示形式转换为等效 TimeSpan 值，并返回一个值，该值指示转换是否成功。
TryParse(String, TimeSpan)	将时间间隔的字符串表示形式转换为等效 TimeSpan 值，并返回一个值，该值指示转换是否成功。
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	使用指定的区域性特定的格式设置信息将时间间隔的跨度表示形式转换为等效 TimeSpan 格式，并返回一个值，该值指示转换是否成功。
TryParse(String, IFormatProvider, TimeSpan)	使用指定的区域性特定的格式设置信息将时间间隔的字符串表示形式转换为等效 TimeSpan 格式，并返回一个值，该值指示转换是否成功。

TryParse(ReadOnlySpan<Char>, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

将时间间隔的跨度表示形式转换为等效 TimeSpan 值，并返回一个值，该值指示转换是否成功。

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] TimeSpan % result);

public static bool TryParse(ReadOnlySpan<char> s, out TimeSpan result);

static member TryParse : ReadOnlySpan<char> * TimeSpan -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As TimeSpan) As Boolean

参数

s: ReadOnlySpan<Char>

包含表示要转换的时间间隔的字符的范围。

result: TimeSpan

此方法返回时，包含一个对象，该对象表示指定的 s时间间隔，或者 Zero 转换失败。此参数未初始化传递。

Boolean

true 如果 s 已成功转换，则为：否则为 false。如果参数为false或s具有无效格式，则此操作返回null一个小于 Empty 或大于 TimeSpan.MaxValue 的时间间隔，或者至少有一天、小时、分钟或秒组件超出其有效范围。

适用于

TryParse(String, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

将时间间隔的字符串表示形式转换为等效 TimeSpan 值，并返回一个值，该值指示转换是否成功。

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] TimeSpan % result);

public static bool TryParse(string s, out TimeSpan result);

public static bool TryParse(string? s, out TimeSpan result);

static member TryParse : string * TimeSpan -> bool

Public Shared Function TryParse (s As String, ByRef result As TimeSpan) As Boolean

参数

s: String

一个字符串，指定要转换的时间间隔。

result: TimeSpan

此方法返回时，包含一个对象，该对象表示指定的 s时间间隔，或者 Zero 转换失败。此参数未初始化传递。

Boolean

示例

下面的示例使用TryParse该方法从有效TimeSpan字符串创建TimeSpan对象，并指示分析操作何时失败，因为时间跨度字符串无效。

using System;

public class TryParse
{
   private static void ParseTimeSpan(string intervalStr)
   {
      // Write the first part of the output line.
      Console.Write( "{0,20}   ", intervalStr );

      // Parse the parameter, and then convert it back to a string.
      TimeSpan intervalVal; 
      if (TimeSpan.TryParse(intervalStr, out intervalVal)) 
      {
         string intervalToStr = intervalVal.ToString();
  
         // Pad the end of the TimeSpan string with spaces if it 
         // does not contain milliseconds.
         int pIndex = intervalToStr.IndexOf(':');
         pIndex = intervalToStr.IndexOf('.', pIndex);
         if (pIndex < 0)
            intervalToStr += "        ";
   
         Console.WriteLine("{0,21}", intervalToStr);
         // Handle failure of TryParse method.
      }
      else
      {
         Console.WriteLine("Parse operation failed.");
      }
   } 
   
   public static void Main()
   {
        Console.WriteLine( "{0,20}   {1,21}", 
            "String to Parse", "TimeSpan" );    
        Console.WriteLine( "{0,20}   {1,21}", 
            "---------------", "---------------------" );    

        ParseTimeSpan("0");
        ParseTimeSpan("14");
        ParseTimeSpan("1:2:3");
        ParseTimeSpan("0:0:0.250");
        ParseTimeSpan("10.20:30:40.50");
        ParseTimeSpan("99.23:59:59.9999999");
        ParseTimeSpan("0023:0059:0059.0099");
        ParseTimeSpan("23:0:0");
        ParseTimeSpan("24:0:0");
        ParseTimeSpan("0:59:0");
        ParseTimeSpan("0:60:0");
        ParseTimeSpan("0:0:59");
        ParseTimeSpan("0:0:60");
        ParseTimeSpan("10:");
        ParseTimeSpan("10:0");
        ParseTimeSpan(":10");
        ParseTimeSpan("0:10");
        ParseTimeSpan("10:20:");
        ParseTimeSpan("10:20:0");
        ParseTimeSpan(".123");
        ParseTimeSpan("0.12:00");
        ParseTimeSpan("10.");
        ParseTimeSpan("10.12");
        ParseTimeSpan("10.12:00");
   }
}
//            String to Parse                TimeSpan
//            ---------------   ---------------------
//                          0        00:00:00
//                         14     14.00:00:00
//                      1:2:3        01:02:03
//                  0:0:0.250        00:00:00.2500000
//             10.20:30:40.50     10.20:30:40.5000000
//        99.23:59:59.9999999     99.23:59:59.9999999
//        0023:0059:0059.0099        23:59:59.0099000
//                     23:0:0        23:00:00
//                     24:0:0   Parse operation failed.
//                     0:59:0        00:59:00
//                     0:60:0   Parse operation failed.
//                     0:0:59        00:00:59
//                     0:0:60   Parse operation failed.
//                        10:   Parse operation failed.
//                       10:0        10:00:00
//                        :10   Parse operation failed.
//                       0:10        00:10:00
//                     10:20:   Parse operation failed.
//                    10:20:0        10:20:00
//                       .123   Parse operation failed.
//                    0.12:00        12:00:00
//                        10.   Parse operation failed.
//                      10.12   Parse operation failed.
//                   10.12:00     10.12:00:00

open System

let parseTimeSpan intervalStr =
    // Write the first part of the output line.
    printf $"%20s{intervalStr}   "

    // Parse the parameter, and then convert it back to a string.
    match TimeSpan.TryParse intervalStr with
    | true, intervalVal ->
        let intervalToStr = string intervalVal

        // Pad the end of the TimeSpan string with spaces if it 
        // does not contain milliseconds.
        let pIndex = intervalToStr.IndexOf ':'
        let pIndex = intervalToStr.IndexOf('.', pIndex)
        let intervalToStr =
            if pIndex < 0 then
                intervalToStr + "        "
            else intervalStr
        printfn $"{intervalToStr,21}"
        // Handle failure of TryParse method.
    | _ ->
        printfn "Parse operation failed."

printfn "%20s   %21s" "String to Parse" "TimeSpan"
printfn "%20s   %21s" "---------------" "---------------------"

parseTimeSpan "0"
parseTimeSpan "14"
parseTimeSpan "1:2:3"
parseTimeSpan "0:0:0.250"
parseTimeSpan "10.20:30:40.50"
parseTimeSpan "99.23:59:59.9999999"
parseTimeSpan "0023:0059:0059.0099"
parseTimeSpan "23:0:0"
parseTimeSpan "24:0:0"
parseTimeSpan "0:59:0"
parseTimeSpan "0:60:0"
parseTimeSpan "0:0:59"
parseTimeSpan "0:0:60"
parseTimeSpan "10:"
parseTimeSpan "10:0"
parseTimeSpan ":10"
parseTimeSpan "0:10"
parseTimeSpan "10:20:"
parseTimeSpan "10:20:0"
parseTimeSpan ".123"
parseTimeSpan "0.12:00"
parseTimeSpan "10."
parseTimeSpan "10.12"
parseTimeSpan "10.12:00"
//            String to Parse                TimeSpan
//            ---------------   ---------------------
//                          0        00:00:00
//                         14     14.00:00:00
//                      1:2:3        01:02:03
//                  0:0:0.250        00:00:00.2500000
//             10.20:30:40.50     10.20:30:40.5000000
//        99.23:59:59.9999999     99.23:59:59.9999999
//        0023:0059:0059.0099        23:59:59.0099000
//                     23:0:0        23:00:00
//                     24:0:0   Parse operation failed.
//                     0:59:0        00:59:00
//                     0:60:0   Parse operation failed.
//                     0:0:59        00:00:59
//                     0:0:60   Parse operation failed.
//                        10:   Parse operation failed.
//                       10:0        10:00:00
//                        :10   Parse operation failed.
//                       0:10        00:10:00
//                     10:20:   Parse operation failed.
//                    10:20:0        10:20:00
//                       .123   Parse operation failed.
//                    0.12:00        12:00:00
//                        10.   Parse operation failed.
//                      10.12   Parse operation failed.
//                   10.12:00     10.12:00:00

Module TryParse
    Sub ParseTimeSpan(intervalStr As String)
        ' Write the first part of the output line.
        Console.Write("{0,20}   ", intervalStr)

        ' Parse the parameter, and then convert it back to a string.
        Dim intervalVal As TimeSpan
        If TimeSpan.TryParse(intervalStr, intervalVal) Then
            Dim intervalToStr As String = intervalVal.ToString()

            ' Pad the end of the TimeSpan string with spaces if it 
            ' does not contain milliseconds.
            Dim pIndex As Integer = intervalToStr.IndexOf(":"c)
            pIndex = intervalToStr.IndexOf("."c, pIndex)
            If pIndex < 0 Then intervalToStr &= "        "

            Console.WriteLine("{0,21}", intervalToStr)
            ' Handle failure of TryParse method.
        Else
            Console.WriteLine("Parse operation failed.")
        End If
    End Sub

    Public Sub Run()
        Console.WriteLine("{0,20}   {1,21}",
            "String to Parse", "TimeSpan")
        Console.WriteLine("{0,20}   {1,21}",
            "---------------", "---------------------")

        ParseTimeSpan("0")
        ParseTimeSpan("14")
        ParseTimeSpan("1:2:3")
        ParseTimeSpan("0:0:0.250")
        ParseTimeSpan("10.20:30:40.50")
        ParseTimeSpan("99.23:59:59.9999999")
        ParseTimeSpan("0023:0059:0059.0099")
        ParseTimeSpan("23:0:0")
        ParseTimeSpan("24:0:0")
        ParseTimeSpan("0:59:0")
        ParseTimeSpan("0:60:0")
        ParseTimeSpan("0:0:59")
        ParseTimeSpan("0:0:60")
        ParseTimeSpan("10:")
        ParseTimeSpan("10:0")
        ParseTimeSpan(":10")
        ParseTimeSpan("0:10")
        ParseTimeSpan("10:20:")
        ParseTimeSpan("10:20:0")
        ParseTimeSpan(".123")
        ParseTimeSpan("0.12:00")
        ParseTimeSpan("10.")
        ParseTimeSpan("10.12")
        ParseTimeSpan("10.12:00")
    End Sub
End Module

' This example generates the following output:
'            String to Parse                TimeSpan
'            ---------------   ---------------------
'                          0        00:00:00
'                         14     14.00:00:00
'                      1:2:3        01:02:03
'                  0:0:0.250        00:00:00.2500000
'             10.20:30:40.50     10.20:30:40.5000000
'        99.23:59:59.9999999     99.23:59:59.9999999
'        0023:0059:0059.0099        23:59:59.0099000
'                     23:0:0        23:00:00
'                     24:0:0   Parse operation failed.
'                     0:59:0        00:59:00
'                     0:60:0   Parse operation failed.
'                     0:0:59        00:00:59
'                     0:0:60   Parse operation failed.
'                        10:   Parse operation failed.
'                       10:0        10:00:00
'                        :10   Parse operation failed.
'                       0:10        00:10:00
'                     10:20:   Parse operation failed.
'                    10:20:0        10:20:00
'                       .123   Parse operation failed.
'                    0.12:00        12:00:00
'                        10.   Parse operation failed.
'                      10.12   Parse operation failed.
'                   10.12:00     10.12:00:00

注解

TryParse（System.String，System.TimeSpan@）方法

该方法 TimeSpan.TryParse(String, TimeSpan) 与该方法类似 TimeSpan.Parse(String) ，只是转换失败时不会引发异常。

该 s 参数包含采用以下格式的时间间隔规范：

[ws][-]{ d | d.hh:mm[:ss[.ff]] | hh:mm[:ss[.ff]] }[ws]

方括号（[ 和 ]）中的元素是可选的。需要从大括号（{ 和 }）括起来的替代项列表中选择一个，并用垂直条（|）分隔。下表对每个元素进行了描述。

元素	Description
ws	可选空格。
-	一个用于表示负 TimeSpan 的可选减号。
d	天，范围为 0 到 10675199。
.	用于区分天与小时的文化敏感符号。固定格式使用句点（“.”）字符。
hh	小时，范围为 0 到 23。
:	区分区域性的时间分隔符。固定格式使用冒号 (":") 字符。
毫米	分钟，范围为 0 到 59。
ss	可选秒，范围为 0 到 59。
.	用于将秒与秒的小数部分分开的区域性敏感符号。固定格式使用句点（“.”）字符。
ff	可选小数秒，由一到七位十进制数字组成。

s的组件必须共同指定一个时间间隔，该时间间隔大于或等于TimeSpan.MinValue且小于或等于TimeSpan.MaxValue。

Parse(String) 方法会使用针对当前区域性的每个特定于区域性的格式来尝试解析 s。

TryParse(String, IFormatProvider, TimeSpan) 方法

该方法 TryParse(String, IFormatProvider, TimeSpan) 与该方法类似 Parse(String, IFormatProvider) ，只是转换失败时不会引发异常。

该 input 参数包含采用以下格式的时间间隔规范：

[ws][-]{ d | d.hh:mm[:ss[.ff]] | hh:mm[:ss[.ff]] }[ws]

方括号（[ 和 ]）中的元素是可选的。需要从大括号（{ 和 }）括起来的替代项列表中选择一个，并用垂直条（|）分隔。下表对每个元素进行了描述。

元素	Description
ws	可选空格。
-	一个用于表示负 TimeSpan 的可选减号。
d	天，范围为 0 到 10675199。
.	用于区分天与小时的文化敏感符号。固定格式使用句点（“.”）字符。
hh	小时，范围为 0 到 23。
:	区分区域性的时间分隔符。固定格式使用冒号 (":") 字符。
毫米	分钟，范围为 0 到 59。
ss	可选秒，范围为 0 到 59。
.	用于将秒与秒的小数部分分开的区域性敏感符号。固定格式使用句点（“.”）字符。
ff	可选小数秒，由一到七位十进制数字组成。

input 的组件必须统一指定一个大于或等于 TimeSpan.MinValue 且小于或等于 TimeSpan.MaxValue 的时间间隔。

TryParse(String, IFormatProvider, TimeSpan) 方法会通过使用由 input 指定的针对区域性的每种特定于区域性的格式来尝试解析 formatProvider。

formatProvider 参数是一个 IFormatProvider 实现，它提供了有关返回字符串的格式的特定于区域性的信息。该 formatProvider 参数可以是以下任一参数：

一个 CultureInfo 对象，表示其格式约定将反映在返回的字符串中的区域性。 DateTimeFormatInfo属性返回CultureInfo.DateTimeFormat的对象定义返回的字符串的格式。
定义返回字符串格式的DateTimeFormatInfo对象。
一个实现 IFormatProvider 接口的自定义对象。其 IFormatProvider.GetFormat 方法返回一个 DateTimeFormatInfo 提供格式设置信息的对象。

如果 formatProvider 是 null，则使用与当前区域性关联的 DateTimeFormatInfo 对象。

适用于

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

使用指定的区域性特定的格式设置信息将时间间隔的跨度表示形式转换为等效 TimeSpan 格式，并返回一个值，该值指示转换是否成功。

public:
 static bool TryParse(ReadOnlySpan<char> input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result) = ISpanParsable<TimeSpan>::TryParse;

public:
 static bool TryParse(ReadOnlySpan<char> input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);

public static bool TryParse(ReadOnlySpan<char> input, IFormatProvider? formatProvider, out TimeSpan result);

public static bool TryParse(ReadOnlySpan<char> input, IFormatProvider formatProvider, out TimeSpan result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * TimeSpan -> bool

Public Shared Function TryParse (input As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

参数

input: ReadOnlySpan<Char>

包含表示要转换的时间间隔的字符的范围。

formatProvider: IFormatProvider

提供区域性特定的格式设置信息的对象。

result: TimeSpan

此方法返回时，包含一个对象，该对象表示指定的 input时间间隔，或者 Zero 转换失败。此参数未初始化传递。

Boolean

true 如果 input 已成功转换，则为：否则为 false。如果参数为false或input具有无效格式，则此操作返回null一个小于 Empty 或大于 TimeSpan.MaxValue 的时间间隔，或者至少有一天、小时、分钟或秒组件超出其有效范围。

适用于

TryParse(String, IFormatProvider, TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

使用指定的区域性特定的格式设置信息将时间间隔的字符串表示形式转换为等效 TimeSpan 格式，并返回一个值，该值指示转换是否成功。

public:
 static bool TryParse(System::String ^ input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);

public:
 static bool TryParse(System::String ^ input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result) = IParsable<TimeSpan>::TryParse;

public static bool TryParse(string input, IFormatProvider formatProvider, out TimeSpan result);

public static bool TryParse(string? input, IFormatProvider? formatProvider, out TimeSpan result);

static member TryParse : string * IFormatProvider * TimeSpan -> bool

Public Shared Function TryParse (input As String, formatProvider As IFormatProvider, ByRef result As TimeSpan) As Boolean

参数

input: String

一个字符串，指定要转换的时间间隔。

formatProvider: IFormatProvider

提供区域性特定的格式设置信息的对象。

result: TimeSpan

此方法返回时，包含一个对象，该对象表示指定的 input时间间隔，或者 Zero 转换失败。此参数未初始化传递。

Boolean

示例

以下示例定义 CultureInfo 对象的数组，并使用调用 TryParse(String, IFormatProvider, TimeSpan) 方法中的每个对象来分析字符串数组中的元素。该示例说明了特定区域性的约定如何影响格式设置操作。

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values = { "6", "6:12", "6:12:14", "6:12:14:45", 
                          "6.12:14:45", "6:12:14:45.3448", 
                          "6:12:14:45,3448", "6:34:14:45" };
      CultureInfo[] cultures = { new CultureInfo("en-US"), 
                                 new CultureInfo("ru-RU"),
                                 CultureInfo.InvariantCulture };
      
      string header = String.Format("{0,-17}", "String");
      foreach (CultureInfo culture in cultures)
         header += culture.Equals(CultureInfo.InvariantCulture) ? 
                      String.Format("{0,20}", "Invariant") :
                      String.Format("{0,20}", culture.Name);

      Console.WriteLine(header);
      Console.WriteLine();
      
      foreach (string value in values)
      {
         Console.Write("{0,-17}", value);
         foreach (CultureInfo culture in cultures)
         {
            TimeSpan interval = new TimeSpan();
            if (TimeSpan.TryParse(value, culture, out interval))
               Console.Write("{0,20}", interval.ToString("c"));
            else
               Console.Write("{0,20}", "Unable to Parse");
         }
         Console.WriteLine();                                
      }
   }
}
// The example displays the following output:
//    String                          en-US               ru-RU           Invariant
//    
//    6                          6.00:00:00          6.00:00:00          6.00:00:00
//    6:12                         06:12:00            06:12:00            06:12:00
//    6:12:14                      06:12:14            06:12:14            06:12:14
//    6:12:14:45                 6.12:14:45          6.12:14:45          6.12:14:45
//    6.12:14:45                 6.12:14:45          6.12:14:45          6.12:14:45
//    6:12:14:45.3448    6.12:14:45.3448000     Unable to Parse  6.12:14:45.3448000
//    6:12:14:45,3448       Unable to Parse  6.12:14:45.3448000     Unable to Parse
//    6:34:14:45            Unable to Parse     Unable to Parse     Unable to Parse

open System
open System.Globalization

let values = 
    [| "6"; "6:12"; "6:12:14"; "6:12:14:45" 
       "6.12:14:45"; "6:12:14:45.3448" 
       "6:12:14:45,3448"; "6:34:14:45" |]
let cultures = 
    [| CultureInfo "en-US" 
       CultureInfo "ru-RU"
       CultureInfo.InvariantCulture |] 

let mutable header = String.Format("{0,-17}", "String")
for culture in cultures do
    header <- 
        if culture.Equals CultureInfo.InvariantCulture then
            String.Format("{0,20}", "Invariant")
        else
            String.Format("{0,20}", culture.Name)

printfn $"{header}\n"

for value in values do
    printf $"{value,-17}"
    for culture in cultures do
        match TimeSpan.TryParse(value, culture) with
        | true, interval -> 
            printfn $"{interval,20:c}"
        | _ ->
            printfn "%20s" "Unable to Parse"
// The example displays the following output:
//    String                          en-US               ru-RU           Invariant
//    
//    6                          6.00:00:00          6.00:00:00          6.00:00:00
//    6:12                         06:12:00            06:12:00            06:12:00
//    6:12:14                      06:12:14            06:12:14            06:12:14
//    6:12:14:45                 6.12:14:45          6.12:14:45          6.12:14:45
//    6.12:14:45                 6.12:14:45          6.12:14:45          6.12:14:45
//    6:12:14:45.3448    6.12:14:45.3448000     Unable to Parse  6.12:14:45.3448000
//    6:12:14:45,3448       Unable to Parse  6.12:14:45.3448000     Unable to Parse
//    6:34:14:45            Unable to Parse     Unable to Parse     Unable to Parse

Dim values() As String = {"6", "6:12", "6:12:14", "6:12:14:45",
                         "6.12:14:45", "6:12:14:45.3448",
                         "6:12:14:45,3448", "6:34:14:45"}
Dim cultures() As CultureInfo = {New CultureInfo("en-US"),
                                New CultureInfo("ru-RU"),
                                CultureInfo.InvariantCulture}

Dim header As String = String.Format("{0,-17}", "String")
For Each culture As CultureInfo In cultures
    header += If(culture.Equals(CultureInfo.InvariantCulture),
              String.Format("{0,20}", "Invariant"),
              String.Format("{0,20}", culture.Name))
Next
Console.WriteLine(header)
Console.WriteLine()

For Each value As String In values
    Console.Write("{0,-17}", value)
    For Each culture As CultureInfo In cultures
        Dim interval As New TimeSpan()
        If TimeSpan.TryParse(value, culture, interval) Then
            Console.Write("{0,20}", interval.ToString("c"))
        Else
            Console.Write("{0,20}", "Unable to Parse")
        End If
    Next
    Console.WriteLine()
Next

' The example displays the following output:
'    String                          en-US               ru-RU           Invariant
'    
'    6                          6.00:00:00          6.00:00:00          6.00:00:00
'    6:12                         06:12:00            06:12:00            06:12:00
'    6:12:14                      06:12:14            06:12:14            06:12:14
'    6:12:14:45                 6.12:14:45          6.12:14:45          6.12:14:45
'    6.12:14:45                 6.12:14:45          6.12:14:45          6.12:14:45
'    6:12:14:45.3448    6.12:14:45.3448000     Unable to Parse  6.12:14:45.3448000
'    6:12:14:45,3448       Unable to Parse  6.12:14:45.3448000     Unable to Parse
'    6:34:14:45            Unable to Parse     Unable to Parse     Unable to Parse

注解

TryParse（System.String，System.TimeSpan@）方法

该方法 TimeSpan.TryParse(String, TimeSpan) 与该方法类似 TimeSpan.Parse(String) ，只是转换失败时不会引发异常。

该 s 参数包含采用以下格式的时间间隔规范：

[ws][-]{ d | d.hh:mm[:ss[.ff]] | hh:mm[:ss[.ff]] }[ws]

方括号（[ 和 ]）中的元素是可选的。需要从大括号（{ 和 }）括起来的替代项列表中选择一个，并用垂直条（|）分隔。下表对每个元素进行了描述。

元素	Description
ws	可选空格。
-	一个用于表示负 TimeSpan 的可选减号。
d	天，范围为 0 到 10675199。
.	用于区分天与小时的文化敏感符号。固定格式使用句点（“.”）字符。
hh	小时，范围为 0 到 23。
:	区分区域性的时间分隔符。固定格式使用冒号 (":") 字符。
毫米	分钟，范围为 0 到 59。
ss	可选秒，范围为 0 到 59。
.	用于将秒与秒的小数部分分开的区域性敏感符号。固定格式使用句点（“.”）字符。
ff	可选小数秒，由一到七位十进制数字组成。

s的组件必须共同指定一个时间间隔，该时间间隔大于或等于TimeSpan.MinValue且小于或等于TimeSpan.MaxValue。

Parse(String) 方法会使用针对当前区域性的每个特定于区域性的格式来尝试解析 s。

TryParse(String, IFormatProvider, TimeSpan) 方法

该方法 TryParse(String, IFormatProvider, TimeSpan) 与该方法类似 Parse(String, IFormatProvider) ，只是转换失败时不会引发异常。

该 input 参数包含采用以下格式的时间间隔规范：

[ws][-]{ d | d.hh:mm[:ss[.ff]] | hh:mm[:ss[.ff]] }[ws]

方括号（[ 和 ]）中的元素是可选的。需要从大括号（{ 和 }）括起来的替代项列表中选择一个，并用垂直条（|）分隔。下表对每个元素进行了描述。

元素	Description
ws	可选空格。
-	一个用于表示负 TimeSpan 的可选减号。
d	天，范围为 0 到 10675199。
.	用于区分天与小时的文化敏感符号。固定格式使用句点（“.”）字符。
hh	小时，范围为 0 到 23。
:	区分区域性的时间分隔符。固定格式使用冒号 (":") 字符。
毫米	分钟，范围为 0 到 59。
ss	可选秒，范围为 0 到 59。
.	用于将秒与秒的小数部分分开的区域性敏感符号。固定格式使用句点（“.”）字符。
ff	可选小数秒，由一到七位十进制数字组成。

input 的组件必须统一指定一个大于或等于 TimeSpan.MinValue 且小于或等于 TimeSpan.MaxValue 的时间间隔。

TryParse(String, IFormatProvider, TimeSpan) 方法会通过使用由 input 指定的针对区域性的每种特定于区域性的格式来尝试解析 formatProvider。

formatProvider 参数是一个 IFormatProvider 实现，它提供了有关返回字符串的格式的特定于区域性的信息。该 formatProvider 参数可以是以下任一参数：

一个 CultureInfo 对象，表示其格式约定将反映在返回的字符串中的区域性。 DateTimeFormatInfo属性返回CultureInfo.DateTimeFormat的对象定义返回的字符串的格式。
定义返回字符串格式的DateTimeFormatInfo对象。
一个实现 IFormatProvider 接口的自定义对象。其 IFormatProvider.GetFormat 方法返回一个 DateTimeFormatInfo 提供格式设置信息的对象。

如果 formatProvider 是 null，则使用与当前区域性关联的 DateTimeFormatInfo 对象。

适用于

反馈

此页面是否有帮助？

TimeSpan.TryParse 方法

定义

重载

TryParse(ReadOnlySpan<Char>, TimeSpan)

参数

返回

适用于

TryParse(String, TimeSpan)

参数

返回

示例

注解

TryParse（System.String，System.TimeSpan@） 方法

TryParse(String, IFormatProvider, TimeSpan) 方法

适用于

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

参数

返回

适用于

TryParse(String, IFormatProvider, TimeSpan)

参数

返回

示例

注解

TryParse（System.String，System.TimeSpan@） 方法

TryParse(String, IFormatProvider, TimeSpan) 方法

适用于

反馈

TryParse（System.String，System.TimeSpan@）方法

TryParse（System.String，System.TimeSpan@）方法