TimeSpan.TryParseExact Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan y devuelve un valor que indica si la conversión se realizó correctamente. El formato de la representación de cadena debe coincidir exactamente con un formato ya especificado.
Sobrecargas
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) |
Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato y los estilos especificados, así como la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. |
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan) |
Convierte la representación de intervalo especificado de un intervalo de tiempo en su equivalente de TimeSpan, usando los formatos y los estilos especificados, así como la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados. |
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan) |
Convierte la representación de intervalo especificada de un intervalo de tiempo en su valor TimeSpan equivalente mediante el formato, la información de formato específica de la referencia cultural y los estilos especificados, y devuelve un valor que indica si la conversión se ha realizado correctamente. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. |
TryParseExact(String, String[], IFormatProvider, TimeSpan) |
Convierte la representación de cadena especificada de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato especificado, así como la información de formatos específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados. |
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) |
Convierte la representación de cadena especificada de un intervalo de tiempo en su equivalente de TimeSpan, usando los formatos y los estilos especificados, así como la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados. |
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) |
Convierte la representación de intervalo especificada de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato especificado, así como la información de formatos específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados. |
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) |
Convierte la representación de intervalo especificada de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato especificado, así como la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. |
TryParseExact(String, String, IFormatProvider, TimeSpan) |
Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato especificado, así como la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. |
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato y los estilos especificados, así como la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el 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);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, 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
Cadena que especifica el intervalo de tiempo que se va a convertir.
- format
- String
Cadena de formato estándar o personalizado que define el formato requerido de input
.
- formatProvider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural.
- styles
- TimeSpanStyles
Uno o varios valores de enumeración que indican el estilo de input
.
- result
- TimeSpan
El resultado que devuelve este método contiene un objeto que representa el intervalo de tiempo especificado por input
, o Zero si la conversión no se realizó correctamente. Este parámetro se pasa sin inicializar.
Devoluciones
true
si input
se convirtió correctamente; en caso contrario, false
.
Ejemplos
En el ejemplo siguiente se usa el ParseExact(String, String, IFormatProvider) método para analizar varias representaciones de cadena de intervalos de tiempo mediante varias cadenas de formato y referencias culturales. También usa el TimeSpanStyles.AssumeNegative valor para interpretar cada cadena como un intervalo de tiempo negativo. La salida del ejemplo muestra que el TimeSpanStyles.AssumeNegative estilo afecta al valor devuelto solo cuando se usa con cadenas de formato personalizado.
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
Comentarios
El TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) método analiza la representación de cadena de un intervalo de tiempo, que debe estar en el formato definido por el format
parámetro , salvo que se omiten los caracteres de espacio en blanco inicial y final. Este método es similar al ParseExact(String, String, IFormatProvider, TimeSpanStyles) método , salvo que no produce una excepción si se produce un error en la conversión.
El format
parámetro es una cadena que contiene un único especificador de formato estándar o uno o varios especificadores de formato personalizado que definen el formato necesario de input
. Para obtener más información sobre las cadenas de formato válidas, vea Cadenas de formato TimeSpan estándar y Cadenas de formato TimeSpan personalizadas.
El formatProvider
parámetro es una IFormatProvider implementación que proporciona información específica de la referencia cultural sobre el formato de la cadena devuelta si format
es una cadena de formato estándar. El formatProvider
parámetro puede ser cualquiera de los siguientes:
Objeto CultureInfo que representa la referencia cultural cuyas convenciones de formato se reflejarán en la cadena devuelta. El DateTimeFormatInfo objeto devuelto por la CultureInfo.DateTimeFormat propiedad define el formato de la cadena devuelta.
Objeto DateTimeFormatInfo que define el formato de la cadena devuelta.
Objeto personalizado que implementa la IFormatProvider interfaz . Su IFormatProvider.GetFormat método devuelve un DateTimeFormatInfo objeto que proporciona información de formato.
Si formatProvider
es null
, se usa el DateTimeFormatInfo objeto asociado a la referencia cultural actual.
El styles
parámetro afecta a la interpretación de las cadenas analizadas mediante cadenas de formato personalizado. Determina si input
se interpreta como un intervalo de tiempo negativo solo si hay un signo negativo (TimeSpanStyles.None) o si siempre se interpreta como un intervalo de tiempo negativo (TimeSpanStyles.AssumeNegative). Si TimeSpanStyles.AssumeNegative no se usa, format
debe incluir un símbolo de signo negativo literal (como "\-") para analizar correctamente un intervalo de tiempo negativo.
Consulte también
Se aplica a
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
Convierte la representación de intervalo especificado de un intervalo de tiempo en su equivalente de TimeSpan, usando los formatos y los estilos especificados, así como la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los 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);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, 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>
Un intervalo que contiene los caracteres que representan un intervalo de tiempo que se va a convertir.
- formats
- String[]
Una matriz de cadenas de formato estándar o personalizado que definen los formatos aceptables de input
.
- formatProvider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural.
- styles
- TimeSpanStyles
Uno o varios valores de enumeración que indican el estilo de input
.
- result
- TimeSpan
El resultado que devuelve este método contiene un objeto que representa el intervalo de tiempo especificado por input
, o Zero si la conversión no se realizó correctamente. Este parámetro se pasa sin inicializar.
Devoluciones
true
si input
se convirtió correctamente; en caso contrario, false
.
Se aplica a
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
Convierte la representación de intervalo especificada de un intervalo de tiempo en su valor TimeSpan equivalente mediante el formato, la información de formato específica de la referencia cultural y los estilos especificados, y devuelve un valor que indica si la conversión se ha realizado correctamente. El formato de la representación de cadena debe coincidir exactamente con el 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);
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>
Un intervalo que contiene los caracteres que representan un intervalo de tiempo que se va a convertir.
- format
- ReadOnlySpan<Char>
Un intervalo que contiene los caracteres que representan una cadena de formato estándar o personalizado que define el formato aceptable de input
.
- formatProvider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural.
- styles
- TimeSpanStyles
Uno o varios valores de enumeración que indican el estilo de input
.
- result
- TimeSpan
El resultado que devuelve este método contiene un objeto que representa el intervalo de tiempo especificado por input
, o Zero si la conversión no se realizó correctamente. Este parámetro se pasa sin inicializar.
Devoluciones
true
si input
se convirtió correctamente; en caso contrario, false
.
Se aplica a
TryParseExact(String, String[], IFormatProvider, TimeSpan)
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
Convierte la representación de cadena especificada de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato especificado, así como la información de formatos específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los 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);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, 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
Cadena que especifica el intervalo de tiempo que se va a convertir.
- formats
- String[]
Una matriz de cadenas de formato estándar o personalizado que definen los formatos aceptables de input
.
- formatProvider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural.
- result
- TimeSpan
El resultado que devuelve este método contiene un objeto que representa el intervalo de tiempo especificado por input
, o Zero si la conversión no se realizó correctamente. Este parámetro se pasa sin inicializar.
Devoluciones
true
si input
se convirtió correctamente; en caso contrario, false
.
Ejemplos
En el ejemplo siguiente se llama al TryParseExact(String, String[], IFormatProvider, TimeSpan) método para convertir cada elemento de una matriz de cadenas en un TimeSpan valor. En el ejemplo se interpretan las cadenas mediante las convenciones de formato de la referencia cultural Francés - Francia ("fr-FR"). Las cadenas pueden representar un intervalo de tiempo en el formato corto general o en el formato largo general.
Además, el ejemplo cambia la forma en que los métodos de análisis de intervalo de tiempo interpretan un solo dígito. Normalmente, un solo dígito se interpreta como el número de días en un intervalo de tiempo. En su lugar, la %h
cadena de formato personalizado se usa para interpretar un solo dígito como el número de horas. Para que este cambio sea efectivo, tenga en cuenta que la %h
cadena de formato personalizado debe preceder a las demás cadenas de formato de la formats
matriz.
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
Comentarios
El TryParseExact(String, String[], IFormatProvider, TimeSpan) método analiza la representación de cadena de un intervalo de tiempo, que debe estar en el formato definido por una de las cadenas de formato especificadas por el formats
parámetro , salvo que se omiten los caracteres de espacio en blanco inicial y final. Este método es similar al ParseExact(String, String[], IFormatProvider) método , salvo que no produce una excepción si se produce un error en la conversión.
El formats
parámetro es una matriz de cadenas cuyos elementos constan de un único especificador de formato estándar o de uno o varios especificadores de formato personalizado que definen el formato necesario de input
. Para obtener más información sobre las cadenas de formato válidas, vea Cadenas de formato TimeSpan estándar y Cadenas de formato TimeSpan personalizadas. input
debe corresponder exactamente a un miembro de formats
para que la operación de análisis se realice correctamente. La operación de análisis intenta coincidir input
con cada elemento a formats
partir del primer elemento de la matriz.
Importante
El TryParseExact método usa las convenciones de la referencia cultural especificada por el formatProvider
parámetro solo si la cadena de formato utilizada para analizar input
es una cadena de formato estándar TimeSpan cuyo valor es "g" o "G". Las cadenas de formato estándar "c", "t" y "T" usan las convenciones de formato de la referencia cultural invariable. Las cadenas de formato personalizado definen el formato preciso de la cadena de entrada y usan caracteres literales para separar los componentes de un intervalo de tiempo.
El formatProvider
parámetro es una IFormatProvider implementación que proporciona información específica de la referencia cultural sobre el formato de la cadena devuelta si la cadena de formato utilizada para analizar input
es una cadena de formato estándar. El formatProvider
parámetro puede ser cualquiera de los siguientes:
Objeto CultureInfo que representa la referencia cultural cuyas convenciones de formato se van a reflejar en la cadena devuelta. El DateTimeFormatInfo objeto devuelto por la CultureInfo.DateTimeFormat propiedad define el formato de la cadena devuelta.
Objeto DateTimeFormatInfo que define el formato de la cadena devuelta.
Objeto personalizado que implementa la IFormatProvider interfaz . Su IFormatProvider.GetFormat método devuelve un DateTimeFormatInfo objeto que proporciona información de formato.
Si formatProvider
es null
, se usa el DateTimeFormatInfo objeto asociado a la referencia cultural actual.
Consulte también
Se aplica a
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
Convierte la representación de cadena especificada de un intervalo de tiempo en su equivalente de TimeSpan, usando los formatos y los estilos especificados, así como la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los 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);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.TimeSpanStyles styles, 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
Cadena que especifica el intervalo de tiempo que se va a convertir.
- formats
- String[]
Una matriz de cadenas de formato estándar o personalizado que definen los formatos aceptables de input
.
- formatProvider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural.
- styles
- TimeSpanStyles
Uno o varios valores de enumeración que indican el estilo de input
.
- result
- TimeSpan
El resultado que devuelve este método contiene un objeto que representa el intervalo de tiempo especificado por input
, o Zero si la conversión no se realizó correctamente. Este parámetro se pasa sin inicializar.
Devoluciones
true
si input
se convirtió correctamente; en caso contrario, false
.
Ejemplos
En el ejemplo siguiente se llama al TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) método para convertir cada elemento de una matriz de cadenas en un TimeSpan valor. Las cadenas pueden representar un intervalo de tiempo en el formato corto general o en el formato largo general.
Además, el ejemplo cambia la forma en que los métodos de análisis de intervalo de tiempo interpretan un solo dígito. Normalmente, un solo dígito se interpreta como el número de días en un intervalo de tiempo. En su lugar, la %h
cadena de formato personalizado se usa para interpretar un solo dígito como el número de horas. Para que este cambio sea efectivo, tenga en cuenta que la %h
cadena de formato personalizado debe preceder a las demás cadenas de formato de la formats
matriz. Tenga en cuenta también de la salida que la TimeSpanStyles.AssumeNegative marca especificada en la llamada al método solo se usa al analizar una cadena con este especificador de formato.
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
Comentarios
El TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) método analiza la representación de cadena de un intervalo de tiempo, que debe estar en el formato definido por una de las cadenas de formato especificadas por el formats
parámetro, excepto que se omiten los caracteres de espacio en blanco inicial y final. Este método es similar al ParseExact(String, String[], IFormatProvider, TimeSpanStyles) método , salvo que no produce una excepción si se produce un error en la conversión.
El formats
parámetro es una matriz de cadenas cuyos elementos constan de un único especificador de formato estándar, o uno o varios especificadores de formato personalizado que definen el formato necesario de input
. Para obtener más información sobre las cadenas de formato válidas, vea Cadenas de formato TimeSpan estándar y Cadenas de formato TimeSpan personalizados. input
debe corresponder exactamente a un miembro de formats
para que la operación de análisis se realice correctamente. La operación de análisis intenta coincidir input
con cada elemento a formats
partir del primer elemento de la matriz.
Importante
El ParseExact método usa las convenciones de la referencia cultural especificada por el formatProvider
parámetro solo si la cadena de formato utilizada para analizar input
es una cadena de formato estándar TimeSpan cuyo valor es "g" o "G". Las cadenas de formato estándar "c", "t" y "T" usan las convenciones de formato de la referencia cultural invariable. Las cadenas de formato personalizado definen el formato preciso de la cadena de entrada y usan caracteres literales para separar los componentes de un intervalo de tiempo.
El formatProvider
parámetro es una IFormatProvider implementación que proporciona información específica de la referencia cultural sobre el formato de la cadena devuelta si la cadena de formato utilizada para analizar input
es una cadena de formato estándar. El formatProvider
parámetro puede ser cualquiera de los siguientes:
Objeto CultureInfo que representa la referencia cultural cuyas convenciones de formato se van a reflejar en la cadena devuelta. El DateTimeFormatInfo objeto devuelto por la CultureInfo.DateTimeFormat propiedad define el formato de la cadena devuelta.
Objeto DateTimeFormatInfo que define el formato de la cadena devuelta.
Objeto personalizado que implementa la IFormatProvider interfaz . Su IFormatProvider.GetFormat método devuelve un DateTimeFormatInfo objeto que proporciona información de formato.
Si formatProvider
es null
, se usa el DateTimeFormatInfo objeto asociado a la referencia cultural actual.
El styles
parámetro afecta a la interpretación de las cadenas que se analizan mediante cadenas de formato personalizado. Determina si input
se interpreta como un intervalo de tiempo negativo solo si hay un signo negativo (TimeSpanStyles.None) o si siempre se interpreta como un intervalo de tiempo negativo (TimeSpanStyles.AssumeNegative). Si TimeSpanStyles.AssumeNegative no se usa, format
debe incluir un símbolo de signo negativo literal (como "\-") para analizar correctamente un intervalo de tiempo negativo.
Consulte también
Se aplica a
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
Convierte la representación de intervalo especificada de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato especificado, así como la información de formatos específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los 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);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, 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>
Un intervalo que contiene los caracteres que representan un intervalo de tiempo que se va a convertir.
- formats
- String[]
Una matriz de cadenas de formato estándar o personalizado que definen los formatos aceptables de input
.
- formatProvider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural.
- result
- TimeSpan
El resultado que devuelve este método contiene un objeto que representa el intervalo de tiempo especificado por input
, o Zero si la conversión no se realizó correctamente. Este parámetro se pasa sin inicializar.
Devoluciones
true
si input
se convirtió correctamente; en caso contrario, false
.
Se aplica a
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
Convierte la representación de intervalo especificada de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato especificado, así como la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el 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);
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>
Un intervalo que contiene los caracteres que representan un intervalo de tiempo que se va a convertir.
- format
- ReadOnlySpan<Char>
Un intervalo que contiene los caracteres que representan una cadena de formato estándar o personalizado que define el formato aceptable de input
.
- formatProvider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural.
- result
- TimeSpan
El resultado que devuelve este método contiene un objeto que representa el intervalo de tiempo especificado por input
, o Zero si la conversión no se realizó correctamente. Este parámetro se pasa sin inicializar.
Devoluciones
true
si input
se convirtió correctamente; en caso contrario, false
.
Se aplica a
TryParseExact(String, String, IFormatProvider, TimeSpan)
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
- Source:
- TimeSpan.cs
Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato especificado, así como la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el 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);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, 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
Cadena que especifica el intervalo de tiempo que se va a convertir.
- format
- String
Cadena de formato estándar o personalizado que define el formato requerido de input
.
- formatProvider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural.
- result
- TimeSpan
El resultado que devuelve este método contiene un objeto que representa el intervalo de tiempo especificado por input
, o Zero si la conversión no se realizó correctamente. Este parámetro se pasa sin inicializar.
Devoluciones
true
si input
se convirtió correctamente; en caso contrario, false
.
Ejemplos
En el ejemplo siguiente se usa el TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) método para analizar varias representaciones de cadena de intervalos de tiempo mediante varias cadenas de formato y referencias culturales.
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
Comentarios
El TryParseExact(String, String, IFormatProvider, TimeSpan) método analiza la representación de cadena de un intervalo de tiempo, que debe estar en el formato definido por el format
parámetro, excepto que se omiten los caracteres de espacio en blanco iniciales y finales. Este método es similar al ParseExact(String, String, IFormatProvider) método , salvo que no produce una excepción si se produce un error en la conversión.
El format
parámetro es una cadena que contiene un único especificador de formato estándar o uno o varios especificadores de formato personalizado que definen el formato necesario de input
. Para obtener más información sobre las cadenas de formato válidas, vea Cadenas de formato TimeSpan estándar y Cadenas de formato TimeSpan personalizados.
Importante
El TryParseExact(String, String, IFormatProvider, TimeSpan) método usa las convenciones de la referencia cultural especificada por el formatProvider
parámetro solo si format
es una cadena de formato estándar TimeSpan cuyo valor es "g" o "G". Las cadenas de formato estándar "c", "t" y "T" usan las convenciones de formato de la referencia cultural invariable. Las cadenas de formato personalizado definen el formato preciso de la cadena de entrada y usan caracteres literales para separar los componentes de un intervalo de tiempo.
El formatProvider
parámetro es una IFormatProvider implementación que proporciona información específica de la referencia cultural sobre el formato de la cadena devuelta si format
es una cadena de formato estándar. El formatProvider
parámetro puede ser cualquiera de los siguientes:
Objeto CultureInfo que representa la referencia cultural cuyas convenciones de formato se van a reflejar en la cadena devuelta. El DateTimeFormatInfo objeto devuelto por la CultureInfo.DateTimeFormat propiedad define el formato de la cadena devuelta.
Objeto DateTimeFormatInfo que define el formato de la cadena devuelta.
Objeto personalizado que implementa la IFormatProvider interfaz . Su IFormatProvider.GetFormat método devuelve un DateTimeFormatInfo objeto que proporciona información de formato.
Si formatProvider
es null
, se usa el DateTimeFormatInfo objeto asociado a la referencia cultural actual.
Consulte también
Se aplica a
Comentarios
https://aka.ms/ContentUserFeedback.
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea:Enviar y ver comentarios de