TimeSpan.TryParseExact Método

Definição

Espaço de Nomes:: System

Assemblagens:: mscorlib.dll, System.Runtime.dll

Assemblagem:: mscorlib.dll

Assemblagem:: System.Runtime.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente e devolve um valor que indica se a conversão teve sucesso. O formato da representação da cadeia deve corresponder exatamente a um formato especificado.

Sobrecargas

Name	Description
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando o formato especificado, informação de formato específica para cultura e estilos. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Converte a representação do intervalo de tempo especificada para o seu TimeSpan equivalente, utilizando os formatos especificados, informação de formato específica para cultura e estilos. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)	Converte a representação do intervalo de tempo especificada para o seu TimeSpan equivalente usando o formato especificado, informação de formato específica da cultura e estilos, e retorna um valor que indica se a conversão foi bem-sucedida. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.
TryParseExact(String, String[], IFormatProvider, TimeSpan)	Converte a representação de cadeias especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando os formatos especificados e a informação de formato específica da cultura. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Converte a representação de strings especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando os formatos especificados, informação de formato específica para cultura e estilos. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)	Converte a representação de espaço especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando os formatos especificados e a informação de formato específica da cultura. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Converte a representação de expansão especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando o formato especificado e a informação de formato específica da cultura. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.
TryParseExact(String, String, IFormatProvider, TimeSpan)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando o formato especificado e a informação específica de formato da cultura. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando o formato especificado, informação de formato específica para cultura e estilos. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.

public:
 static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);

public static bool TryParseExact(string input, string format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);

static member TryParseExact : string * string * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool

Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Parâmetros

input: String

Uma cadeia que especifica o intervalo de tempo a converter.

format: String

Uma cadeia de formato padrão ou personalizada que define o formato exigido de input.

formatProvider: IFormatProvider

Um objeto que forneça informação de formatação específica para cada cultura.

styles: TimeSpanStyles

Um ou mais valores de enumeração que indicam o estilo de input.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por input, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

true se input foi convertido com sucesso; caso contrário, false.

Exemplos

O exemplo seguinte utiliza o ParseExact(String, String, IFormatProvider) método para analisar várias representações de cadeias de intervalos de tempo usando várias cadeias de formatos e culturas. Também utiliza o TimeSpanStyles.AssumeNegative valor para interpretar cada cadeia como um intervalo de tempo negativo. A saída do exemplo ilustra que o TimeSpanStyles.AssumeNegative estilo afeta o valor de retorno apenas quando é usado com strings de formato personalizadas.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture = null;
      
      // Parse hour:minute value with custom format specifier.
      intervalString = "17:14";
      format = "h\\:mm";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48";
      format = "g";
      culture = CultureInfo.InvariantCulture;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153";
      format = @"h\:mm\:ss\.fff";
      culture = null;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);   

      // Parse days:hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);   
            
      // Parse days:hours:minute.second value with a custom format specifier.     
      intervalString = "3:17:14:48.153";
      format = @"d\:hh\:mm\:ss\.fff";
      culture = null;
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48,153";
      format = "G";
      culture = new CultureInfo("fr-FR");
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 culture, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      if (TimeSpan.TryParseExact(intervalString, format, 
                                 null, TimeSpanStyles.AssumeNegative, out interval))
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval);
      else   
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format);
   }
}
// The example displays the following output:
//    '17:14' (h\:mm) --> -17:14:00
//    '17:14:48' (g) --> 17:14:48
//    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
//    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
//    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
//    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
//    '12' (c) --> 12.00:00:00
//    '12' (%h) --> -12:00:00
//    '12' (%s) --> -00:00:12

open System
open System.Globalization

do
    // Parse hour:minute value with custom format specifier.
    let intervalString = "17:14"
    let format = "h\\:mm"
    let culture = CultureInfo.CurrentCulture
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse hour:minute:second value with "g" specifier.
    let intervalString = "17:14:48"
    let format = "g"
    let culture = CultureInfo.InvariantCulture
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse hours:minute.second value with custom format specifier.     
    let intervalString = "17:14:48.153"
    let format = @"h\:mm\:ss\.fff"
    let culture = null
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->
        printfn $"Unable to parse '{intervalString}' using format {format}"    

    // Parse days:hours:minute.second value with "G" specifier 
    // and current (en-US) culture.     
    let intervalString = "3:17:14:48.153"
    let format = "G"
    let culture = CultureInfo.CurrentCulture
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}"    
        
    // Parse days:hours:minute.second value with a custom format specifier.     
    let intervalString = "3:17:14:48.153"
    let format = @"d\:hh\:mm\:ss\.fff"
    let culture = null
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse days:hours:minute.second value with "G" specifier 
    // and fr-FR culture.     
    let intervalString = "3:17:14:48,153"
    let format = "G"
    let culture = new CultureInfo("fr-FR")
    match TimeSpan.TryParseExact(intervalString, format, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 

    // Parse a single number using the "c" standard format string. 
    let intervalString = "12"
    let format = "c"
    match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse a single number using the "%h" custom format string. 
    let format = "%h"
    match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
    
    // Parse a single number using the "%s" custom format string. 
    let format = "%s"
    match TimeSpan.TryParseExact(intervalString, format, null, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"'{intervalString}' ({format}) --> {interval}"
    | _ ->   
        printfn $"Unable to parse '{intervalString}' using format {format}" 
// The example displays the following output:
//    '17:14' (h\:mm) --> -17:14:00
//    '17:14:48' (g) --> 17:14:48
//    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
//    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
//    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
//    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
//    '12' (c) --> 12.00:00:00
//    '12' (%h) --> -12:00:00
//    '12' (%s) --> -00:00:12

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim intervalString, format As String
      Dim interval As TimeSpan
      Dim culture As CultureInfo = Nothing
      
      ' Parse hour:minute value with custom format specifier.
      intervalString = "17:14"
      format = "h\:mm"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If
      
      ' Parse hour:minute:second value with "g" specifier.
      intervalString = "17:14:48"
      format = "g"
      culture = CultureInfo.InvariantCulture
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If
      
      ' Parse hours:minute.second value with custom format specifier.     
      intervalString = "17:14:48.153"
      format = "h\:mm\:ss\.fff"
      culture = Nothing
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 

      ' Parse days:hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "3:17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
            
      ' Parse days:hours:minute.second value with a custom format specifier.     
      intervalString = "3:17:14:48.153"
      format = "d\:hh\:mm\:ss\.fff"
      culture = Nothing
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' Parse days:hours:minute.second value with "G" specifier 
      ' and fr-FR culture.     
      intervalString = "3:17:14:48,153"
      format = "G"
      culture = New CultureInfo("fr-FR")
      If TimeSpan.TryParseExact(intervalString, format, 
                                culture, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)
      End If 

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      If TimeSpan.TryParseExact(intervalString, format, 
                                Nothing, TimeSpanStyles.AssumeNegative, interval) Then
         Console.WriteLine("'{0}' ({1}) --> {2}", intervalString, format, interval)
      Else
         Console.WriteLine("Unable to parse '{0}' using format {1}",
                           intervalString, format)   
      End If 
   End Sub
End Module
' The example displays the following output:
'    '17:14' (h\:mm) --> -17:14:00
'    '17:14:48' (g) --> 17:14:48
'    '17:14:48.153' (h\:mm\:ss\.fff) --> -17:14:48.1530000
'    '3:17:14:48.153' (G) --> 3.17:14:48.1530000
'    '3:17:14:48.153' (d\:hh\:mm\:ss\.fff) --> -3.17:14:48.1530000
'    '3:17:14:48,153' (G) --> 3.17:14:48.1530000
'    '12' (c) --> 12.00:00:00
'    '12' (%h) --> -12:00:00
'    '12' (%s) --> -00:00:12

Observações

O TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) método analisa a representação da cadeia de um intervalo de tempo, que deve estar no formato definido pelo format parâmetro, exceto que os caracteres de espaço em branco inicial e final são ignorados. Este método é semelhante ao ParseExact(String, String, IFormatProvider, TimeSpanStyles) método, exceto que não lança exceção se a conversão falhar.

O format parâmetro é uma cadeia que contém ou um único especificador de formato padrão, ou um ou mais especificadores de formato personalizados que definem o formato necessário de input. Para mais informações sobre cadeias de formatos válidas, consulte Cadeias de Formato Padrão TimeSpan e Cadeias de Formato TimeSpan Personalizadas.

O formatProvider parâmetro é uma IFormatProvider implementação que fornece informação específica da cultura sobre o formato da cadeia devolvida se format for uma cadeia de formato padrão. O formatProvider parâmetro pode ser qualquer um dos seguintes:

Um CultureInfo objeto que representa a cultura cujas convenções de formatação devem ser refletidas na cadeia de caracteres retornada. O DateTimeFormatInfo objeto retornado pela CultureInfo.DateTimeFormat propriedade define a formatação da cadeia de caracteres retornada.
Um DateTimeFormatInfo objeto que define a formatação da cadeia de caracteres retornada.
Um objeto personalizado que implementa a IFormatProvider interface. O método IFormatProvider.GetFormat retorna um objeto DateTimeFormatInfo que fornece informações de formatação.

Se formatProvider é null, o objeto DateTimeFormatInfo associado à cultura atual é usado.

O styles parâmetro afeta a interpretação de cadeias analisadas usando strings de formato personalizado. Determina se input é interpretado como um intervalo de tempo negativo apenas se estiver presente um sinal negativo (TimeSpanStyles.None), ou se é sempre interpretado como um intervalo de tempo negativo (TimeSpanStyles.AssumeNegative). Se TimeSpanStyles.AssumeNegative não for usado, format deve incluir um símbolo literal de sinal negativo (como "\-") para analisar com sucesso um intervalo de tempo negativo.

Ver também

Aplica-se a

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Converte a representação do intervalo de tempo especificada para o seu TimeSpan equivalente, utilizando os formatos especificados, informação de formato específica para cultura e estilos. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);

public static bool TryParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);

static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool

Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Parâmetros

input: ReadOnlySpan<Char>

Um intervalo que contém os caracteres que representam um intervalo de tempo a converter.

formats: String[]

Um array de cadeias de formatos padrão ou personalizados que definem os formatos aceitáveis de input.

formatProvider: IFormatProvider

Um objeto que fornece informação de formatação específica para cada cultura.

styles: TimeSpanStyles

Um ou mais valores de enumeração que indicam o estilo de input.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por input, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

true se input foi convertido com sucesso; caso contrário, false.

Aplica-se a

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)

Converte a representação do intervalo de tempo especificada para o seu TimeSpan equivalente usando o formato especificado, informação de formato específica da cultura e estilos, e retorna um valor que indica se a conversão foi bem-sucedida. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);

public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);

static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool

Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Parâmetros

input: ReadOnlySpan<Char>

Um intervalo que contém os caracteres que representam um intervalo de tempo a converter.

format: ReadOnlySpan<Char>

Um span contendo as características que representam uma cadeia de formato padrão ou personalizada que define o formato aceitável de input.

formatProvider: IFormatProvider

Um objeto que fornece informação de formatação específica para cada cultura.

styles: TimeSpanStyles

Um ou mais valores de enumeração que indicam o estilo de input.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por input, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

true se input foi convertido com sucesso; caso contrário, false.

Aplica-se a

TryParseExact(String, String[], IFormatProvider, TimeSpan)

Converte a representação de cadeias especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando os formatos especificados e a informação de formato específica da cultura. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.

public:
 static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);

public static bool TryParseExact(string input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);

static member TryParseExact : string * string[] * IFormatProvider * TimeSpan -> bool

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

Parâmetros

input: String

Uma cadeia que especifica o intervalo de tempo a converter.

formats: String[]

Um array de cadeias de formatos padrão ou personalizados que definem os formatos aceitáveis de input.

formatProvider: IFormatProvider

Um objeto que forneça informação de formatação específica para cada cultura.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por input, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

true se input foi convertido com sucesso; caso contrário, false.

Exemplos

O exemplo seguinte chama o TryParseExact(String, String[], IFormatProvider, TimeSpan) método para converter cada elemento de um array de cadeias num TimeSpan valor. O exemplo interpreta as cadeias usando as convenções de formatação da cultura francês-francesa ("fr-FR"). As cadeias podem representar um intervalo de tempo tanto no formato geral curto como no formato geral longo.

Além disso, o exemplo altera a forma como os métodos de análise sintática em intervalos de tempo interpretam um único dígito. Normalmente, um único dígito é interpretado como o número de dias num intervalo de tempo. Em vez disso, a %h cadeia de formato personalizada é usada para interpretar um único dígito como o número de horas. Para que esta alteração seja eficaz, note-se que a %h string de formato personalizada deve preceder as outras strings de formato no formats array.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "3", "16:42", "1:6:52:35.0625", 
                          "1:6:52:35,0625" }; 
      string[] formats = { "g", "G", "%h"};
      TimeSpan interval;
      CultureInfo culture = new CultureInfo("fr-FR");
      
      // Parse each string in inputs using formats and the fr-FR culture.
      foreach (string input in inputs) {
         if(TimeSpan.TryParseExact(input, formats, culture, out interval))
            Console.WriteLine("{0} --> {1:c}", input, interval);
         else
            Console.WriteLine("Unable to parse {0}", input);   
      }
   }
}
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       1:6:52:35,0625 --> 1.06:52:35.0625000

open System
open System.Globalization

let inputs = 
    [| "3"; "16:42"; "1:6:52:35.0625" 
       "1:6:52:35,0625" |] 
let formats = [| "g"; "G"; "%h" |]
let culture = CultureInfo "fr-FR"

// Parse each string in inputs using formats and the fr-FR culture.
for input in inputs do
    match TimeSpan.TryParseExact(input, formats, culture) with
    | true, interval ->
        printfn $"{input} --> {interval:c}"
    | _ ->
        printfn $"Unable to parse {input}"
// The example displays the following output:
//       3 --> 03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       1:6:52:35,0625 --> 1.06:52:35.0625000

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim inputs() As String = { "3", "16:42", "1:6:52:35.0625", 
                                 "1:6:52:35,0625" } 
      Dim formats() As String = { "%h", "g", "G" }
      Dim interval As TimeSpan
      Dim culture As New CultureInfo("fr-FR")
      
      ' Parse each string in inputs using formats and the fr-FR culture.
      For Each input As String In inputs
         If TimeSpan.TryParseExact(input, formats, culture, interval) Then
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Else
            Console.WriteLine("Unable to parse {0}", input)   
         End If            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> 03:00:00
'       16:42 --> 16:42:00
'       Unable to parse 1:6:52:35.0625
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Observações

O TryParseExact(String, String[], IFormatProvider, TimeSpan) método analisa a representação de cadeias de um intervalo de tempo, que deve estar no formato definido por uma das cadeias de formato especificadas pelo formats parâmetro, exceto que os caracteres de espaço em branco inicial e final são ignorados. Este método é semelhante ao ParseExact(String, String[], IFormatProvider) método, exceto que não lança exceção se a conversão falhar.

O formats parâmetro é um array de strings cujos elementos consistem num único especificador de formato padrão, ou num ou mais especificadores de formato personalizados que definem o formato necessário de input. Para mais informações sobre cadeias de formatos válidas, consulte Cadeias de Formato Padrão TimeSpan e Cadeias de Formato TimeSpan Personalizadas. input deve corresponder exatamente a um membro de formats para que a operação de análise sintética tenha sucesso. A operação de análise sintática tenta corresponder input a cada elemento começando formats pelo primeiro elemento do array.

Importante

O TryParseExact método utiliza as convenções da cultura especificadas pelo formatProvider parâmetro apenas se a cadeia de formato usada para analisar input for uma cadeia de formato padrão TimeSpan cujo valor seja "g" ou "G". As strings de formato padrão "c", "t" e "T" usam as convenções de formatação da cultura invariante. As strings de formato personalizadas definem o formato preciso da cadeia de entrada e usam caracteres literais para separar os componentes de um intervalo de tempo.

O formatProvider parâmetro é uma IFormatProvider implementação que fornece informação específica da cultura sobre o formato da cadeia devolvida se a cadeia de formato usada para analisar input for uma cadeia de formato padrão. O formatProvider parâmetro pode ser qualquer um dos seguintes:

Um CultureInfo objeto que representa a cultura cujas convenções de formatação devem ser refletidas na cadeia de caracteres retornada. O DateTimeFormatInfo objeto retornado pela CultureInfo.DateTimeFormat propriedade define a formatação da cadeia de caracteres retornada.
Um DateTimeFormatInfo objeto que define a formatação da cadeia de caracteres retornada.
Um objeto personalizado que implementa a IFormatProvider interface. O método IFormatProvider.GetFormat retorna um objeto DateTimeFormatInfo que fornece informações de formatação.

Se formatProvider é null, o objeto DateTimeFormatInfo associado à cultura atual é usado.

Ver também

Aplica-se a

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Converte a representação de strings especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando os formatos especificados, informação de formato específica para cultura e estilos. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.

public:
 static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::TimeSpanStyles styles, [Runtime::InteropServices::Out] TimeSpan % result);

public static bool TryParseExact(string input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out TimeSpan result);

static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.TimeSpanStyles * TimeSpan -> bool

Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As TimeSpanStyles, ByRef result As TimeSpan) As Boolean

Parâmetros

input: String

Uma cadeia que especifica o intervalo de tempo a converter.

formats: String[]

Um array de cadeias de formatos padrão ou personalizados que definem os formatos aceitáveis de input.

formatProvider: IFormatProvider

Um objeto que fornece informação de formatação específica para cada cultura.

styles: TimeSpanStyles

Um ou mais valores de enumeração que indicam o estilo de input.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por input, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

true se input foi convertido com sucesso; caso contrário, false.

Exemplos

O exemplo seguinte chama o TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) método para converter cada elemento de um array de cadeias num TimeSpan valor. As cadeias podem representar um intervalo de tempo tanto no formato geral curto como no formato geral longo.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "3", "16:42", "1:6:52:35.0625", 
                          "1:6:52:35,0625" }; 
      string[] formats = { "%h", "g", "G" };
      TimeSpan interval;
      CultureInfo culture = new CultureInfo("fr-FR");
      
      // Parse each string in inputs using formats and the fr-FR culture.
      foreach (string input in inputs) {
         if(TimeSpan.TryParseExact(input, formats, culture, 
                                   TimeSpanStyles.AssumeNegative, out interval))
            Console.WriteLine("{0} --> {1:c}", input, interval);
         else
            Console.WriteLine("Unable to parse {0}", input);   
      }
   }
}
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       1:6:52:35,0625 --> 1.06:52:35.0625000

open System
open System.Globalization

let inputs = 
    [| "3"; "16:42"; "1:6:52:35.0625" 
       "1:6:52:35,0625" |]
let formats = [| "%h"; "g"; "G" |]
let culture = CultureInfo "fr-FR"

// Parse each string in inputs using formats and the fr-FR culture.
for input in inputs do
    match TimeSpan.TryParseExact(input, formats, culture, TimeSpanStyles.AssumeNegative) with
    | true, interval ->
        printfn $"{input} --> {interval:c}"
    | _ ->
        printfn $"Unable to parse {input}"
// The example displays the following output:
//       3 --> -03:00:00
//       16:42 --> 16:42:00
//       Unable to parse 1:6:52:35.0625
//       1:6:52:35,0625 --> 1.06:52:35.0625000

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim inputs() As String = { "3", "16:42", "1:6:52:35.0625", 
                                 "1:6:52:35,0625" } 
      Dim formats() As String = { "%h", "g", "G" }
      Dim interval As TimeSpan
      Dim culture As New CultureInfo("de-DE")
      
      ' Parse each string in inputs using formats and the fr-FR culture.
      For Each input As String In inputs
         If TimeSpan.TryParseExact(input, formats, culture, 
                                   TimeSpanStyles.AssumeNegative, interval) Then
            Console.WriteLine("{0} --> {1:c}", input, interval)   
         Else
            Console.WriteLine("Unable to parse {0}", input)   
         End If            
      Next
   End Sub
End Module
' The example displays the following output:
'       3 --> -03:00:00
'       16:42 --> 16:42:00
'       Unable to parse 1:6:52:35.0625
'       1:6:52:35,0625 --> 1.06:52:35.0625000

Observações

O TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) método analisa a representação de cadeias de um intervalo de tempo, que deve estar no formato definido por uma das cadeias de formato especificadas pelo formats parâmetro, exceto que os caracteres de espaço em branco inicial e final são ignorados. Este método é semelhante ao ParseExact(String, String[], IFormatProvider, TimeSpanStyles) método, exceto que não lança exceção se a conversão falhar.

Importante

O ParseExact método utiliza as convenções da cultura especificadas pelo formatProvider parâmetro apenas se a cadeia de formato usada para analisar input for uma cadeia de formato padrão TimeSpan cujo valor seja "g" ou "G". As strings de formato padrão "c", "t" e "T" usam as convenções de formatação da cultura invariante. As strings de formato personalizadas definem o formato preciso da cadeia de entrada e usam caracteres literais para separar os componentes de um intervalo de tempo.

Um CultureInfo objeto que representa a cultura cujas convenções de formatação devem ser refletidas na cadeia de caracteres retornada. O DateTimeFormatInfo objeto retornado pela CultureInfo.DateTimeFormat propriedade define a formatação da cadeia de caracteres retornada.
Um DateTimeFormatInfo objeto que define a formatação da cadeia de caracteres retornada.
Um objeto personalizado que implementa a IFormatProvider interface. O método IFormatProvider.GetFormat retorna um objeto DateTimeFormatInfo que fornece informações de formatação.

Se formatProvider é null, o objeto DateTimeFormatInfo associado à cultura atual é usado.

O styles parâmetro afeta a interpretação das strings que são analisadas usando strings de formato personalizado. Determina se input é interpretado como um intervalo de tempo negativo apenas se estiver presente um sinal negativo (TimeSpanStyles.None), ou se é sempre interpretado como um intervalo de tempo negativo (TimeSpanStyles.AssumeNegative). Se TimeSpanStyles.AssumeNegative não for usado, format deve incluir um símbolo literal de sinal negativo (como "\-") para analisar com sucesso um intervalo de tempo negativo.

Ver também

Aplica-se a

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)

Converte a representação de espaço especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando os formatos especificados e a informação de formato específica da cultura. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);

public static bool TryParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);

static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * TimeSpan -> bool

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

Parâmetros

input: ReadOnlySpan<Char>

Um intervalo que contém os caracteres que representam um intervalo de tempo a converter.

formats: String[]

Um array de cadeias de formatos padrão ou personalizados que definem os formatos aceitáveis de input.

formatProvider: IFormatProvider

Um objeto que fornece informação de formatação específica para cada cultura.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por input, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

true se input foi convertido com sucesso; caso contrário, false.

Aplica-se a

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Converte a representação de expansão especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando o formato especificado e a informação de formato específica da cultura. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.

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

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

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

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

Parâmetros

input: ReadOnlySpan<Char>

Um intervalo que contém os caracteres que representam um intervalo de tempo a converter.

format: ReadOnlySpan<Char>

Um span contendo os caracteres que representam uma cadeia de formatos padrão ou personalizada que define o formato aceitável de input.

formatProvider: IFormatProvider

Um objeto que fornece informação de formatação específica para cada cultura.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por input, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

true se input foi convertido com sucesso; caso contrário, false.

Aplica-se a

TryParseExact(String, String, IFormatProvider, TimeSpan)

Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando o formato especificado e a informação específica de formato da cultura. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.

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

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

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

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

Parâmetros

input: String

Uma cadeia que especifica o intervalo de tempo a converter.

format: String

Uma cadeia de formato padrão ou personalizada que define o formato exigido de input.

formatProvider: IFormatProvider

Um objeto que fornece informação de formatação específica para cada cultura.

result: TimeSpan

Quando este método retorna, contém um objeto que representa o intervalo de tempo especificado por input, ou Zero se a conversão falhou. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

true se input foi convertido com sucesso; caso contrário, false.

Exemplos

O exemplo seguinte utiliza o TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) método para analisar várias representações de cadeias de intervalos de tempo usando várias cadeias de formatos e culturas.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string intervalString, format;
      TimeSpan interval;
      CultureInfo culture;
      
      // Parse hour:minute value with "g" specifier current culture.
      intervalString = "17:14";
      format = "g";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48";
      format = "G";
      culture = CultureInfo.InvariantCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);

      // Parse days:hours:minute.second value with "G" specifier 
      // and current (en-US) culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = CultureInfo.CurrentCulture;
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
            
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48.153";
      format = "G";
      culture = new CultureInfo("fr-FR");
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse days:hours:minute.second value with "G" specifier 
      // and fr-FR culture.     
      intervalString = "3:17:14:48,153";
      format = "G";
      if (TimeSpan.TryParseExact(intervalString, format, culture, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);

      // Parse a single number using the "c" standard format string. 
      intervalString = "12";
      format = "c";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse a single number using the "%h" custom format string. 
      format = "%h";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
      
      // Parse a single number using the "%s" custom format string. 
      format = "%s";
      if (TimeSpan.TryParseExact(intervalString, format, null, out interval))
         Console.WriteLine("'{0}' --> {1}", intervalString, interval);
      else
         Console.WriteLine("Unable to parse {0}", intervalString);
   }
}
// The example displays the following output:
//       '17:14' --> 17:14:00
//       Unable to parse 17:14:48
//       Unable to parse 17:14:48.153
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       Unable to parse 3:17:14:48.153
//       '3:17:14:48,153' --> 3.17:14:48.1530000
//       '12' --> 12.00:00:00
//       '12' --> 12:00:00
//       '12' --> 00:00:12

open System
open System.Globalization

do
    // Parse hour:minute value with "g" specifier current culture.
    let intervalString = "17:14"
    let format = "g"
    let culture = CultureInfo.CurrentCulture
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse hour:minute:second value with "G" specifier.
    let intervalString = "17:14:48"
    let format = "G"
    let culture = CultureInfo.InvariantCulture
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse hours:minute.second value with "G" specifier 
    // and current (en-US) culture.     
    let intervalString = "17:14:48.153"
    let format = "G"
    let culture = CultureInfo.CurrentCulture
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"

    // Parse days:hours:minute.second value with "G" specifier 
    // and current (en-US) culture.     
    let intervalString = "3:17:14:48.153"
    let format = "G"
    let culture = CultureInfo.CurrentCulture
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
        
    // Parse days:hours:minute.second value with "G" specifier 
    // and fr-FR culture.     
    let intervalString = "3:17:14:48.153"
    let format = "G"
    let culture = new CultureInfo("fr-FR")
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse days:hours:minute.second value with "G" specifier 
    // and fr-FR culture.     
    let intervalString = "3:17:14:48,153"
    let format = "G"
    match TimeSpan.TryParseExact(intervalString, format, culture) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"

    // Parse a single number using the "c" standard format string. 
    let intervalString = "12"
    let format = "c"
    match TimeSpan.TryParseExact(intervalString, format, null) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse a single number using the "%h" custom format string. 
    let format = "%h"
    match TimeSpan.TryParseExact(intervalString, format, null) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
    
    // Parse a single number using the "%s" custom format string. 
    let format = "%s"
    match TimeSpan.TryParseExact(intervalString, format, null) with
    | true, interval ->
        printfn $"'{intervalString}' --> {interval}"
    | _ ->
        printfn $"Unable to parse {intervalString}"
// The example displays the following output:
//       '17:14' --> 17:14:00
//       Unable to parse 17:14:48
//       Unable to parse 17:14:48.153
//       '3:17:14:48.153' --> 3.17:14:48.1530000
//       Unable to parse 3:17:14:48.153
//       '3:17:14:48,153' --> 3.17:14:48.1530000
//       '12' --> 12.00:00:00
//       '12' --> 12:00:00
//       '12' --> 00:00:12

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim intervalString, format As String
      Dim interval As TimeSpan
      Dim culture As CultureInfo
      
      ' Parse hour:minute value with "g" specifier current culture.
      intervalString = "17:14"
      format = "g"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse hour:minute:second value with "G" specifier.
      intervalString = "17:14:48"
      format = "G"
      culture = CultureInfo.InvariantCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' Parse hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' Parse days:hours:minute.second value with "G" specifier 
      ' and current (en-US) culture.     
      intervalString = "3:17:14:48.153"
      format = "G"
      culture = CultureInfo.CurrentCulture
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
            
      ' Parse days:hours:minute.second value with "G" specifier 
      ' and fr-FR culture.     
      intervalString = "3:17:14:48.153"
      format = "G"
      culture = New CultureInfo("fr-FR")
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse days:hours:minute.second value with "G" specifier 
      ' and fr-FR culture.     
      intervalString = "3:17:14:48,153"
      format = "G"
      culture = New CultureInfo("fr-FR")
      If TimeSpan.TryParseExact(intervalString, format, culture, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If

      ' Parse a single number using the "c" standard format string. 
      intervalString = "12"
      format = "c"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse a single number using the "%h" custom format string. 
      format = "%h"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval)
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
      
      ' Parse a single number using the "%s" custom format string. 
      format = "%s"
      If TimeSpan.TryParseExact(intervalString, format, Nothing, interval) Then
         Console.WriteLine("'{0}' --> {1}", intervalString, interval)
      Else
         Console.WriteLine("Unable to parse {0}", intervalString)
      End If
   End Sub
End Module
' The example displays the following output:
'       '17:14' --> 17:14:00
'       Unable to parse 17:14:48
'       Unable to parse 17:14:48.153
'       '3:17:14:48.153' --> 3.17:14:48.1530000
'       Unable to parse 3:17:14:48.153
'       '3:17:14:48,153' --> 3.17:14:48.1530000
'       '12' --> 12.00:00:00
'       '12' --> 12:00:00
'       '12' --> 00:00:12

Observações

O TryParseExact(String, String, IFormatProvider, TimeSpan) método analisa a representação da cadeia de um intervalo de tempo, que deve estar no formato definido pelo format parâmetro, exceto que os caracteres de espaço em branco inicial e final são ignorados. Este método é semelhante ao ParseExact(String, String, IFormatProvider) método, exceto que não lança exceção se a conversão falhar.

Importante

O TryParseExact(String, String, IFormatProvider, TimeSpan) método utiliza as convenções da cultura especificadas pelo formatProvider parâmetro apenas se format for uma cadeia de formato padrão TimeSpan cujo valor seja "g" ou "G". As strings de formato padrão "c", "t" e "T" usam as convenções de formatação da cultura invariante. As strings de formato personalizadas definem o formato preciso da cadeia de entrada e usam caracteres literais para separar os componentes de um intervalo de tempo.

Um CultureInfo objeto que representa a cultura cujas convenções de formatação devem ser refletidas na cadeia de caracteres retornada. O DateTimeFormatInfo objeto retornado pela CultureInfo.DateTimeFormat propriedade define a formatação da cadeia de caracteres retornada.
Um DateTimeFormatInfo objeto que define a formatação da cadeia de caracteres retornada.
Um objeto personalizado que implementa a IFormatProvider interface. O método IFormatProvider.GetFormat retorna um objeto DateTimeFormatInfo que fornece informações de formatação.

Se formatProvider é null, o objeto DateTimeFormatInfo associado à cultura atual é usado.

Ver também

Aplica-se a

Comentários

Esta página foi útil?