DateTimeOffset.TryParseExact 方法
定义
重要
一些信息与预发行产品相关,相应产品在发行之前可能会进行重大修改。 对于此处提供的信息,Microsoft 不作任何明示或暗示的担保。
将日期和时间的指定字符串表示形式转换为其等效的 DateTimeOffset。 字符串表示形式的格式必须与指定的格式完全匹配。
重载
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) |
使用指定的格式数组、区域性特定格式信息和样式,将日期和时间的指定字符串表示形式转换为其等效的 DateTimeOffset。 字符串表示形式的格式必须与一种指定的格式完全匹配。 |
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset) |
使用指定的格式、区域性特定的格式信息和样式将字符范围中的日期和时间的表示形式转换为其等效的 DateTimeOffset。 日期和时间表示形式的格式必须与指定的格式完全匹配。 |
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) |
使用指定的格式、区域性特定的格式信息和样式将字符范围中的日期和时间的表示形式转换为其等效的 DateTimeOffset。 日期和时间表示形式的格式必须与一种指定的格式完全匹配。 |
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) |
使用指定的格式、区域性特定的格式信息和样式将日期和时间的指定字符串表示形式转换为其等效的 DateTimeOffset。 字符串表示形式的格式必须与指定的格式完全匹配。 |
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
使用指定的格式数组、区域性特定格式信息和样式,将日期和时间的指定字符串表示形式转换为其等效的 DateTimeOffset。 字符串表示形式的格式必须与一种指定的格式完全匹配。
public:
static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean
参数
- input
- String
包含要转换的日期和时间的字符串。
- formats
- String[]
一个用于定义 input
的所需格式的数组。
- formatProvider
- IFormatProvider
一个对象,提供有关 input
的区域性特定格式设置信息。
- styles
- DateTimeStyles
枚举值的一个按位组合,指示输入所允许的格式。 要指定的一个典型值为 None
。
- result
- DateTimeOffset
当方法返回时,如果转换成功,则 DateTimeOffset 包含等效于 input
的日期和时间;如果转换失败,则包含 DateTimeOffset.MinValue。 如果 input
不包含日期和时间的有效字符串表示形式,或者不包含 format
所定义的所需格式的日期和时间,或者 formats
为 null
,则转换失败。 此参数未经初始化即被传递。
返回
如果 input
参数成功转换,则为 true
;否则为 false
。
例外
styles
包括未定义的 DateTimeStyles 值。
- 或 -
不支持 NoCurrentDateDefault。
- 或 -
styles
包括互斥的 DateTimeStyles 值。
示例
以下示例为日期和时间以及偏移值的字符串表示形式定义多种输入格式,然后将用户输入的字符串传递给 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) 方法。
TextReader conIn = Console.In;
TextWriter conOut = Console.Out;
int tries = 0;
string input = String.Empty;
string[] formats = new string[] {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz",
"M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz",
"M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz",
"M/d/yy HH:m zzz", "MM/d/yy HH:m zzz",
"M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz",
"M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz",
"M/dd/yy H:m zzz", "MM/dd/yy H:m zzz",
"M/d/yy H:m zzz", "MM/d/yy H:m zzz",
"M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz",
"M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz",
"M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz",
"M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz",
"M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz",
"M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz",
"M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz",
"M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"};
IFormatProvider provider = CultureInfo.InvariantCulture.DateTimeFormat;
DateTimeOffset result;
do {
conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),");
conOut.Write("Then press Enter: ");
input = conIn.ReadLine();
conOut.WriteLine();
if (DateTimeOffset.TryParseExact(input, formats, provider,
DateTimeStyles.AllowWhiteSpaces,
out result))
{
break;
}
else
{
Console.WriteLine("Unable to parse {0}.", input);
tries++;
}
} while (tries < 3);
if (tries >= 3)
Console.WriteLine("Exiting application without parsing {0}", input);
else
Console.WriteLine("{0} was converted to {1}", input, result.ToString());
// Some successful sample interactions with the user might appear as follows:
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/08/2007 6:54 -6:00
//
// 12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/8/2007 06:54 -06:00
//
// 12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/5/07 6:54 -6:00
//
// 12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00
let mutable result = None
let mutable tries = 0
let mutable input = ""
let formats =
[| "M/dd/yyyy HH:m zzz"; "MM/dd/yyyy HH:m zzz"
"M/d/yyyy HH:m zzz"; "MM/d/yyyy HH:m zzz"
"M/dd/yy HH:m zzz"; "MM/dd/yy HH:m zzz"
"M/d/yy HH:m zzz"; "MM/d/yy HH:m zzz"
"M/dd/yyyy H:m zzz"; "MM/dd/yyyy H:m zzz"
"M/d/yyyy H:m zzz"; "MM/d/yyyy H:m zzz"
"M/dd/yy H:m zzz"; "MM/dd/yy H:m zzz"
"M/d/yy H:m zzz"; "MM/d/yy H:m zzz"
"M/dd/yyyy HH:mm zzz"; "MM/dd/yyyy HH:mm zzz"
"M/d/yyyy HH:mm zzz"; "MM/d/yyyy HH:mm zzz"
"M/dd/yy HH:mm zzz"; "MM/dd/yy HH:mm zzz"
"M/d/yy HH:mm zzz"; "MM/d/yy HH:mm zzz"
"M/dd/yyyy H:mm zzz"; "MM/dd/yyyy H:mm zzz"
"M/d/yyyy H:mm zzz"; "MM/d/yyyy H:mm zzz"
"M/dd/yy H:mm zzz"; "MM/dd/yy H:mm zzz"
"M/d/yy H:mm zzz"; "MM/d/yy H:mm zzz" |]
let provider = CultureInfo.InvariantCulture.DateTimeFormat
while tries < 3 && result.IsNone do
printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
printf "Then press Enter: "
input <- stdin.ReadLine()
printfn ""
match DateTimeOffset.TryParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) with
| true, dto ->
result <- Some dto
| _ ->
printfn $"Unable to parse {input}."
tries <- tries + 1
match result with
| Some result ->
printfn $"{input} was converted to {result}"
| None ->
printfn $"Exiting application without parsing {input}"
// Some successful sample interactions with the user might appear as follows:
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/08/2007 6:54 -6:00
//
// 12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/8/2007 06:54 -06:00
//
// 12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
// Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
// Then press Enter: 12/5/07 6:54 -6:00
//
// 12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00
Dim conIn As TextReader = Console.In
Dim conOut As TextWriter = Console.Out
Dim tries As Integer = 0
Dim input As String = String.Empty
Dim formats() As String = {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz", _
"M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz", _
"M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz", _
"M/d/yy HH:m zzz", "MM/d/yy HH:m zzz", _
"M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz", _
"M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz", _
"M/dd/yy H:m zzz", "MM/dd/yy H:m zzz", _
"M/d/yy H:m zzz", "MM/d/yy H:m zzz", _
"M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz", _
"M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz", _
"M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz", _
"M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz", _
"M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz", _
"M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz", _
"M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz", _
"M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"}
Dim provider As IFormatProvider = CultureInfo.InvariantCulture.DateTimeFormat
Dim result As DateTimeOffset
Do
conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),")
conOut.Write("Then press Enter: ")
input = conIn.ReadLine()
conOut.WriteLine()
If DateTimeOffset.TryParseExact(input, formats, provider, _
DateTimeStyles.AllowWhiteSpaces, _
result) Then
Exit Do
Else
Console.WriteLine("Unable to parse {0}.", input)
tries += 1
End If
Loop While tries < 3
If tries >= 3 Then
Console.WriteLine("Exiting application without parsing {0}", input)
Else
Console.WriteLine("{0} was converted to {1}", input, result.ToString())
End If
' Some successful sample interactions with the user might appear as follows:
' Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
' Then press Enter: 12/08/2007 6:54 -6:00
'
' 12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
'
' Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
' Then press Enter: 12/8/2007 06:54 -06:00
'
' 12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
'
' Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
' Then press Enter: 12/5/07 6:54 -6:00
'
' 12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00
注解
方法 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) 分析与分配给 formats
数组的任何一种模式匹配的日期的字符串表示形式。
input
如果字符串与参数定义styles
的任何变体的这些模式中的任何一个都不匹配,则分析操作将失败,并且该方法返回 false
。 除了与包含格式说明符的多个字符串进行比较 input
外,此重载的行为与 方法相同 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 。
参数 formats
是一个字符串数组,其元素包含一个标准格式说明符或一个或多个定义 的可能模式的 input
自定义格式说明符。 有关有效格式设置代码的详细信息,请参阅 标准日期和时间格式字符串 和 自定义日期和时间格式字符串。 如果 中的 formats
匹配元素包括 z
、 zz
或 zzz
自定义格式说明符,以指示偏移必须存在于 中 input
,则偏移量必须包含负号或正号。 如果缺少符号,则分析操作将失败,并且该方法返回 false
。
重要
formats
使用此重载的 参数指定多种格式有助于减少许多用户在输入日期和时间时遇到的挫折感。 具体而言,定义多个输入模式的功能使应用程序能够处理日期和时间表示形式,这些表示形式可以包括或缺少月份、天、小时、分钟和秒的前导零。 该示例对此进行了说明。
如果 中的 formats
匹配元素需要 input
包含日期而不是时间,则为生成的 DateTimeOffset 对象分配午夜时间 (0:00:00) 。 如果 中的 formats
匹配元素要求输入包含时间而不是日期,则为生成的 DateTimeOffset 对象分配本地系统上的当前日期。 如果 中的 formats
匹配元素不需要 input
包含偏移量,则生成的 DateTimeOffset 对象的偏移量取决于 参数的值 styles
。 如果 styles
包含 AssumeLocal,则会将本地时区的偏移量分配给 对象 DateTimeOffset 。 如果 styles
包含 AssumeUniversal,则会将协调世界时 (UTC) 偏移量或 +00:00 分配给对象 DateTimeOffset 。 如果两个值均未指定,则使用本地时区的偏移量。
中 input
使用的特定日期和时间符号和字符串由 formatProvider
参数定义。 如果 的input
formats
匹配元素是标准格式说明符字符串,则对于 的精确模式也是如此。 参数 formatProvider
可以是以下任一参数:
一个 CultureInfo 对象,该对象表示解释所基于的
input
区域性。 DateTimeFormatInfo属性CultureInfo.DateTimeFormat返回的对象定义 中的input
符号和格式。一个 DateTimeFormatInfo 定义日期和时间数据格式的 对象。
如果 formatprovider
为 null
,则 CultureInfo 使用与当前区域性对应的 对象。
参数 styles
定义是否允许在输入字符串中使用空格,指示如何分析没有显式偏移量的字符串,并支持 UTC 转换作为分析操作的一部分。 支持 枚举的所有成员 DateTimeStyles ,但 除外 NoCurrentDateDefault。 下表列出了每个受支持成员的效果。
DateTimeStyles 成员 |
行为 |
---|---|
AdjustToUniversal | 分析 input 并在必要时将其转换为 UTC。 它等效于分析字符串,然后调用 DateTimeOffset.ToUniversalTime 返回 DateTimeOffset 的 对象的 方法。 |
AssumeLocal | 如果 中的 formats 匹配元素不需要 input 包含偏移值,则会为返回 DateTimeOffset 的对象提供本地时区的偏移量。 这是默认值。 |
AssumeUniversal | 如果 中的 formats 匹配元素不需要 input 包含偏移值,则会为返回 DateTimeOffset 的对象提供 UTC 偏移量 (+00:00) 。 |
AllowInnerWhite | 允许 input 包含中元素 formats 未指定的内部空白。 除了偏移) 之外,日期和时间组件之间以及各个组件 (中可能会出现额外的空格,分析字符串时会忽略。 |
AllowLeadingWhite | 允许 input 包含 中 formats 元素未指定的前导空格。 分析字符串时,这些将被忽略。 |
AllowTrailingWhite | 允许 input 包含 中 formats 元素未指定的尾随空格。 分析字符串时,这些将被忽略。 |
AllowWhiteSpaces | 允许 input 包含中元素 formats 未指定的前导、尾随和内部空格。 分析字符串时,将忽略 中 formats 匹配元素中未指定的所有额外空白字符。 |
None | 指示 中不允许使用 input 额外的空格。 空白必须完全按照 中的 formats 特定元素中的指定显示,才能成功匹配。 此选项为默认行为。 |
RoundtripKind | 不起作用, DateTimeOffset 因为 结构不包含 Kind 属性。 |
调用方说明
在.NET Framework 4 中,TryParseExact如果要分析的字符串包含一个小时分量和一个不一致 AM/PM 指示符,则 返回 false
。 在 .NET Framework 3.5 及更早版本中,将忽略 AM/PM 指示符。
适用于
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
使用指定的格式、区域性特定的格式信息和样式将字符范围中的日期和时间的表示形式转换为其等效的 DateTimeOffset。 日期和时间表示形式的格式必须与指定的格式完全匹配。
public:
static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean
参数
- input
- ReadOnlySpan<Char>
一个范围,包含表示要转换的日期和时间的字符。
- format
- ReadOnlySpan<Char>
用于定义所需的 input
格式的格式说明符。
- formatProvider
- IFormatProvider
一个对象,提供有关 input
的区域性特定格式设置信息。
- styles
- DateTimeStyles
枚举值的一个按位组合,指示 input
所允许的格式。 要指定的一个典型值为 None。
- result
- DateTimeOffset
当方法返回时,如果转换成功,则 DateTimeOffset 包含与 的日期和时间等效的 input
;如果转换失败,则包含 DateTimeOffset.MinValue 。 如果出现以下情况,转换将失败
返回
如果 input
参数成功转换,则为 true
;否则为 false
。
例外
styles
包括未定义的 DateTimeStyles 值。
-或- NoCurrentDateDefault 不受支持。
-或- styles
包括相互排斥的 DateTimeStyles 值。
注解
此重载类似于 DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 方法,只不过此方法在转换失败时不会引发异常。 它分析必须与 参数指定的模式完全匹配的日期和时间的 format
表示形式。 如果 input
与此模式不匹配,并且参数定义了 styles
一些可能的空格变化,则分析操作将失败,方法返回 false
。
参数 format
是包含单个标准格式说明符或一个或多个定义 所需模式的自定义格式说明符的 input
字符范围。 有关有效格式设置代码的详细信息,请参阅 标准日期和时间格式字符串 和 自定义日期和时间格式字符串。 如果 format
包含 z
、 zz
或 zzz
自定义格式说明符来指示偏移必须存在于 中 input
,则偏移量必须包含负号或正号。 如果缺少符号,则分析操作将失败,并且该方法返回 false
。
如果需要 format
包含 input
日期而不是时间,则为生成的 DateTimeOffset 对象分配午夜时间 (0:00:00) 。 如果需要 format
包含 input
时间而不是日期,则为生成的 DateTimeOffset 对象分配本地系统上的当前日期。 如果 format
不需要 包含 input
偏移量,则生成的 DateTimeOffset 对象的偏移量取决于 参数的值 styles
。 如果 styles
包含 AssumeLocal,则会将本地时区的偏移量分配给 对象 DateTimeOffset 。 如果 styles
包含 AssumeUniversal,则会将协调世界时 (UTC) 偏移量或 +00:00 分配给对象 DateTimeOffset 。 如果两个值均未指定,则使用本地时区的偏移量。
中 input
使用的特定日期和时间符号和字符串由 formatProvider
参数定义。 如果 format
是标准格式说明符字符串,则对于 的精确模式input
也是如此。 参数 formatProvider
可以是以下任一参数:
一个 CultureInfo 对象,该对象表示解释所基于的
input
区域性。 DateTimeFormatInfo属性返回CultureInfo.DateTimeFormat的 对象定义 中input
允许的符号和标准格式。一个 DateTimeFormatInfo 定义日期和时间数据格式的 对象。
如果 formatprovider
为 null
,则 CultureInfo 使用与当前区域性对应的 对象。
参数 styles
定义是否允许在输入字符串中使用空格,指示如何分析没有显式偏移量的字符串,并支持 UTC 转换作为分析操作的一部分。 支持 枚举的所有成员 DateTimeStyles ,但 除外 NoCurrentDateDefault。 下表列出了每个受支持成员的效果。
DateTimeStyles 成员 |
行为 |
---|---|
AdjustToUniversal | 分析 input 并在必要时将其转换为 UTC。 它等效于分析日期和时间表示形式,然后调用 DateTimeOffset.ToUniversalTime 返回 DateTimeOffset 的 对象的 方法。 |
AssumeLocal | 如果 format 不需要包含 input 偏移值的 ,则返回 DateTimeOffset 的对象将被赋予本地时区的偏移量。 此选项为默认行为。 |
AssumeUniversal | 如果 format 不需要包含 input 偏移值,则返回 DateTimeOffset 的对象) (+00:00 的 UTC 偏移量。 |
AllowInnerWhite | 允许 input 包含未按格式指定的内部空格。 除了偏移量,还可以在日期和时间组件之间以及各个组件内显示额外的空格,并在分析字符串时被忽略。 |
AllowLeadingWhite | 允许 input 包含未指定的 format 前导空格。 分析字符串时,这些将被忽略。 |
AllowTrailingWhite | 允许 input 包含未指定的 format 尾随空格。 分析字符串时,这些将被忽略。 |
AllowWhiteSpaces | 允许 input 包含未指定的 format 前导空格、尾随空格和内部空格。 分析字符串时,将忽略中 format 未指定的所有额外空白字符。 |
None | 指示 中不允许使用 input 额外的空格。 空白必须完全按照 中的 format 指定显示。 此选项为默认行为。 |
RoundtripKind | 不起作用,因为 DateTimeOffset 结构不包含 Kind 属性。 |
适用于
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
使用指定的格式、区域性特定的格式信息和样式将字符范围中的日期和时间的表示形式转换为其等效的 DateTimeOffset。 日期和时间表示形式的格式必须与一种指定的格式完全匹配。
public:
static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean
参数
- input
- ReadOnlySpan<Char>
一个范围,包含表示要转换的日期和时间的字符。
- formats
- String[]
用于定义可接受的 input
格式的标准或自定义格式字符串的数组。
- formatProvider
- IFormatProvider
一个对象,提供有关 input
的区域性特定格式设置信息。
- styles
- DateTimeStyles
枚举值的一个按位组合,指示 input
所允许的格式。 要指定的一个典型值为 None。
- result
- DateTimeOffset
当方法返回时,如果转换成功,则 DateTimeOffset 包含与 的日期和时间等效的 input
;如果转换失败,则包含 DateTimeOffset.MinValue 。 如果出现以下情况,转换将失败
返回
如果 input
参数成功转换,则为 true
;否则为 false
。
例外
styles
包括未定义的 DateTimeStyles 值。
-或- NoCurrentDateDefault 不受支持。
-或- styles
包括相互排斥的 DateTimeStyles 值。
注解
此方法分析与分配给数组的任何一种模式匹配的日期的 formats
字符串表示形式。 如果 input
与参数定义 styles
的任何变体中的任一模式不匹配,则分析操作将失败,并且方法返回 false
。 除了与包含格式说明符的多个字符串进行比较 input
外,此重载的行为与 方法相同 DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) 。
参数 formats
是一个字符串数组,其元素包含一个标准格式说明符或一个或多个定义 的可能模式的 input
自定义格式说明符。 有关有效格式设置代码的详细信息,请参阅 标准日期和时间格式字符串 和 自定义日期和时间格式字符串。 如果 中的 formats
匹配元素包括 z
、 zz
或 zzz
自定义格式说明符,以指示偏移必须存在于 中 input
,则偏移量必须包含负号或正号。 如果缺少符号,则分析操作将失败,并且该方法返回 false
。
重要
formats
使用此重载的 参数指定多种格式有助于减少许多用户在输入日期和时间时遇到的挫折感。 具体而言,定义多个输入模式的功能使应用程序能够处理日期和时间表示形式,这些表示形式可以包括或缺少月份、天、小时、分钟和秒的前导零。 该示例对此进行了说明。
如果 中的 formats
匹配元素需要 input
包含日期而不是时间,则为生成的 DateTimeOffset 对象分配午夜时间 (0:00:00) 。 如果 中的 formats
匹配元素要求输入包含时间而不是日期,则为生成的 DateTimeOffset 对象分配本地系统上的当前日期。 如果 中的 formats
匹配元素不需要 input
包含偏移量,则生成的 DateTimeOffset 对象的偏移量取决于 参数的值 styles
。 如果 styles
包含 DateTimeStyles.AssumeLocal,则会将本地时区的偏移量分配给 对象 DateTimeOffset 。 如果 styles
包含 DateTimeStyles.AssumeUniversal,则会将协调世界时 (UTC) 偏移量或 +00:00 分配给对象 DateTimeOffset 。 如果两个值均未指定,则使用本地时区的偏移量。
中使用的 input
特定日期和时间符号由 formatProvider
参数定义。 如果 的input
formats
匹配元素是标准格式说明符字符串,则对于 的精确模式也是如此。 参数 formatProvider
可以是以下任一参数:
一个 CultureInfo 对象,该对象表示解释所基于的
input
区域性。 DateTimeFormatInfo属性CultureInfo.DateTimeFormat返回的对象定义 中的input
符号和格式。一个 DateTimeFormatInfo 定义日期和时间数据格式的 对象。
如果 formatprovider
为 null
,则 CultureInfo 使用与当前区域性对应的 对象。
参数 styles
定义是否允许在输入字符串中使用空格,指示如何分析没有显式偏移量的字符串,并支持 UTC 转换作为分析操作的一部分。 支持 枚举的所有成员 DateTimeStyles ,但 除外 NoCurrentDateDefault。 下表列出了每个受支持成员的效果。
DateTimeStyles 成员 |
行为 |
---|---|
AdjustToUniversal | 分析 input 并在必要时将其转换为 UTC。 它等效于分析字符串,然后调用 DateTimeOffset.ToUniversalTime 返回 DateTimeOffset 的 对象的 方法。 |
AssumeLocal | 如果 中的 formats 匹配元素不需要 input 包含偏移值,则会为返回 DateTimeOffset 的对象提供本地时区的偏移量。 这是默认值。 |
AssumeUniversal | 如果 中的 formats 匹配元素不需要 input 包含偏移值,则会为返回 DateTimeOffset 的对象提供 UTC 偏移量 (+00:00) 。 |
AllowInnerWhite | 允许 input 包含中元素 formats 未指定的内部空白。 除了偏移) 之外,日期和时间组件之间以及各个组件 (中可能会出现额外的空格,分析字符串时会忽略。 |
AllowLeadingWhite | 允许 input 包含 中 formats 元素未指定的前导空格。 分析字符串时,这些将被忽略。 |
AllowTrailingWhite | 允许 input 包含 中 formats 元素未指定的尾随空格。 分析字符串时,这些将被忽略。 |
AllowWhiteSpaces | 允许 input 包含中元素 formats 未指定的前导、尾随和内部空格。 分析字符串时,将忽略 中 formats 匹配元素中未指定的所有额外空白字符。 |
None | 指示 中不允许使用 input 额外的空格。 空白必须完全按照 中的 formats 特定元素中的指定显示,才能成功匹配。 此选项为默认行为。 |
RoundtripKind | 不起作用, DateTimeOffset 因为 结构不包含 Kind 属性。 |
适用于
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
- Source:
- DateTimeOffset.cs
使用指定的格式、区域性特定的格式信息和样式将日期和时间的指定字符串表示形式转换为其等效的 DateTimeOffset。 字符串表示形式的格式必须与指定的格式完全匹配。
public:
static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean
参数
- input
- String
包含要转换的日期和时间的字符串。
- format
- String
用于定义所需的 input
格式的格式说明符。
- formatProvider
- IFormatProvider
一个对象,提供有关 input
的区域性特定格式设置信息。
- styles
- DateTimeStyles
枚举值的一个按位组合,指示输入所允许的格式。 要指定的一个典型值为 None
。
- result
- DateTimeOffset
当方法返回时,如果转换成功,则 DateTimeOffset 包含等效于 input
的日期和时间;如果转换失败,则包含 DateTimeOffset.MinValue。 如果 input
参数为 null
,或者不包含 format
和 provider
所定义的所需格式的日期和时间的有效字符串表示形式,则转换失败。 此参数未经初始化即被传递。
返回
如果 input
参数成功转换,则为 true
;否则为 false
。
例外
styles
包括未定义的 DateTimeStyles 值。
- 或 -
不支持 NoCurrentDateDefault。
- 或 -
styles
包括互斥的 DateTimeStyles 值。
示例
以下示例使用 TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) 方法以及标准和自定义格式说明符、固定区域性和各种 DateTimeStyles 值来分析多个日期和时间字符串。
string dateString, format;
DateTimeOffset result;
IFormatProvider provider = CultureInfo.InvariantCulture;
// Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008";
format = "d";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
DateTimeStyles.AssumeUniversal,
out result))
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
Console.WriteLine("'{0}' is not in the correct format.", dateString);
// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
DateTimeStyles.AllowTrailingWhite,
out result))
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
Console.WriteLine("'{0}' is not in the correct format.", dateString);
// Parse date and time value, and allow all white space.
dateString = " 06/15/ 2008 15:15 -05:00";
format = "MM/dd/yyyy H:mm zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
DateTimeStyles.AllowWhiteSpaces,
out result))
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
Console.WriteLine("'{0}' is not in the correct format.", dateString);
// Parse date and time and convert to UTC.
dateString = " 06/15/2008 15:15:30 -05:00";
format = "MM/dd/yyyy H:mm:ss zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
DateTimeStyles.AllowWhiteSpaces |
DateTimeStyles.AdjustToUniversal,
out result))
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
Console.WriteLine("'{0}' is not in the correct format.", dateString);
// The example displays the following output:
// '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
// ' 06/15/2008' is not in the correct format.
// ' 06/15/ 2008 15:15 -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
// ' 06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.
let provider = CultureInfo.InvariantCulture
// Parse date-only value with invariant culture and assume time is UTC.
let dateString = "06/15/2008"
let format = "d"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal) with
| true, result ->
printfn $"'{dateString}' converts to {result}."
| _ ->
printfn $"'{dateString}' is not in the correct format."
// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite) with
| true, result ->
printfn $"'{dateString}' converts to {result}."
| _ ->
printfn $"'{dateString}' is not in the correct format."
// Parse date and time value, and allow all white space.
let dateString = " 06/15/ 2008 15:15 -05:00"
let format = "MM/dd/yyyy H:mm zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces) with
| true, result ->
printfn $"'{dateString}' converts to {result}."
| _ ->
printfn $"'{dateString}' is not in the correct format."
// Parse date and time and convert to UTC.
let dateString = " 06/15/2008 15:15:30 -05:00"
let format = "MM/dd/yyyy H:mm:ss zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.AdjustToUniversal) with
| true, result ->
printfn $"'{dateString}' converts to {result}."
| _ ->
printfn $"'{dateString}' is not in the correct format."
// The example displays the following output:
// '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
// ' 06/15/2008' is not in the correct format.
// ' 06/15/ 2008 15:15 -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
// ' 06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.
Dim dateString, format As String
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture
' Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008"
format = "d"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
DateTimeStyles.AssumeUniversal, _
result) Then
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If
' Parse date-only value with leading white space.
' Should return False because only trailing white space is
' specified in method call.
dateString = " 06/15/2008"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
DateTimeStyles.AllowTrailingWhite, _
result) Then
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If
' Parse date and time value, and allow all white space.
dateString = " 06/15/ 2008 15:15 -05:00"
format = "MM/dd/yyyy H:mm zzz"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
DateTimeStyles.AllowWhiteSpaces, _
result) Then
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If
' Parse date and time and convert to UTC.
dateString = " 06/15/2008 15:15:30 -05:00"
format = "MM/dd/yyyy H:mm:ss zzz"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
DateTimeStyles.AllowWhiteSpaces Or _
DateTimeStyles.AdjustToUniversal, _
result) Then
Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If
' The example displays the following output:
' '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
' ' 06/15/2008' is not in the correct format.
' ' 06/15/ 2008 15:15 -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
' ' 06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.
以下示例使用各种 DateTimeStyles 值来分析应符合 ISO 8601 的字符串数组。 如示例输出所示,如果出现以下情况,则无法分析格式正确的字符串:
它们包含空格,并且方法调用中未提供相应的 DateTimeStyles 标志 (,例如 DateTimeStyles.AllowWhiteSpaces 。
它们包含的日期和时间元素在范围外。
假定未指定 UTC 偏移量的字符串具有本地时区的偏移量 (在本例中为 -07:00,这将反映太平洋夏令时时区) 的偏移量,除非 DateTimeStyles.AssumeUniversal 在方法调用中提供了 标志。 在这种情况下,它们假定为世界协调时。
open System
open System.Globalization
let parseWithISO8601 dateStrings styles =
printfn $"Parsing with {styles}:"
for dateString in dateStrings do
match DateTimeOffset.TryParseExact(dateString, "O", null, styles) with
| true, date ->
printfn $""" {dateString,-35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
| _ ->
printfn $" Unable to convert '{dateString}'"
let dateStrings =
[ "2018-08-18T12:45:16.0000000Z"
"2018/08/18T12:45:16.0000000Z"
"2018-18-08T12:45:16.0000000Z"
"2018-08-18T12:45:16.0000000"
" 2018-08-18T12:45:16.0000000Z "
"2018-08-18T12:45:16.0000000+02:00"
"2018-08-18T12:45:16.0000000-07:00" ]
parseWithISO8601 dateStrings DateTimeStyles.None
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AllowWhiteSpaces
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AdjustToUniversal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeLocal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeUniversal
// The example displays the following output:
// Parsing with None:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AllowWhiteSpaces:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AdjustToUniversal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 19:45:16 +00:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 10:45:16 +00:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 19:45:16 +00:00
//
// -----
//
// Parsing with AssumeLocal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AssumeUniversal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 +00:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
string[] dateStrings = { "2018-08-18T12:45:16.0000000Z",
"2018/08/18T12:45:16.0000000Z",
"2018-18-08T12:45:16.0000000Z",
"2018-08-18T12:45:16.0000000",
" 2018-08-18T12:45:16.0000000Z ",
"2018-08-18T12:45:16.0000000+02:00",
"2018-08-18T12:45:16.0000000-07:00" };
ParseWithISO8601(dateStrings, DateTimeStyles.None);
Console.WriteLine("\n-----\n");
ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces);
Console.WriteLine("\n-----\n");
ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal);
Console.WriteLine("\n-----\n");
ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal);
Console.WriteLine("\n-----\n");
ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal); }
private static void ParseWithISO8601(string[] dateStrings, DateTimeStyles styles)
{
Console.WriteLine($"Parsing with {styles}:");
DateTimeOffset date;
foreach (var dateString in dateStrings)
{
if (DateTimeOffset.TryParseExact(dateString, "O", null, styles, out date))
{
Console.WriteLine($" {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
}
else
{
Console.WriteLine($" Unable to convert '{dateString}'");
}
}
}
}
// The example displays the following output:
// Parsing with None:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AllowWhiteSpaces:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AdjustToUniversal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 19:45:16 +00:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 10:45:16 +00:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 19:45:16 +00:00
//
// -----
//
// Parsing with AssumeLocal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
//
// -----
//
// Parsing with AssumeUniversal:
// 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
// Unable to convert '2018/08/18T12:45:16.0000000Z'
// Unable to convert '2018-18-08T12:45:16.0000000Z'
// 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 +00:00
// Unable to convert ' 2018-08-18T12:45:16.0000000Z '
// 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
// 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
Imports System.Globalization
Public Module Example
Public Sub Main()
Dim dateStrings() = { "2018-08-18T12:45:16.0000000Z",
"2018/08/18T12:45:16.0000000Z",
"2018-18-08T12:45:16.0000000Z",
"2018-08-18T12:45:16.0000000",
" 2018-08-18T12:45:16.0000000Z ",
"2018-08-18T12:45:16.0000000+02:00",
"2018-08-18T12:45:16.0000000-07:00" }
ParseWithISO8601(dateStrings, DateTimeStyles.None)
Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces)
Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal)
Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal)
Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal)
End Sub
Private Sub ParseWithISO8601(dateStrings() As String, styles As DateTimeStyles)
Console.WriteLine($"Parsing with {styles}:")
Dim dat As DateTimeOffset
For Each dateStr In dateStrings
If DateTimeOffset.TryParseExact(dateStr, "O", Nothing, styles, dat) Then
Console.WriteLine($" {dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
Else
Console.WriteLine($" Unable to convert '{dateStr}'")
End If
Next
End Sub
End Module
' The example displays the following output:
' Parsing with None:
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' Unable to convert '2018/08/18T12:45:16.0000000Z'
' Unable to convert '2018-18-08T12:45:16.0000000Z'
' 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
' Unable to convert ' 2018-08-18T12:45:16.0000000Z '
' 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
' 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
'
' -----
'
' Parsing with AllowWhiteSpaces:
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' Unable to convert '2018/08/18T12:45:16.0000000Z'
' Unable to convert '2018-18-08T12:45:16.0000000Z'
' 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
' 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
'
' -----
'
' Parsing with AdjustToUniversal:
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' Unable to convert '2018/08/18T12:45:16.0000000Z'
' Unable to convert '2018-18-08T12:45:16.0000000Z'
' 2018-08-18T12:45:16.0000000 --> 2018-08-18 19:45:16 +00:00
' Unable to convert ' 2018-08-18T12:45:16.0000000Z '
' 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 10:45:16 +00:00
' 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 19:45:16 +00:00
'
' -----
'
' Parsing with AssumeLocal:
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' Unable to convert '2018/08/18T12:45:16.0000000Z'
' Unable to convert '2018-18-08T12:45:16.0000000Z'
' 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 -07:00
' Unable to convert ' 2018-08-18T12:45:16.0000000Z '
' 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
' 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
'
' -----
'
' Parsing with AssumeUniversal:
' 2018-08-18T12:45:16.0000000Z --> 2018-08-18 12:45:16 +00:00
' Unable to convert '2018/08/18T12:45:16.0000000Z'
' Unable to convert '2018-18-08T12:45:16.0000000Z'
' 2018-08-18T12:45:16.0000000 --> 2018-08-18 12:45:16 +00:00
' Unable to convert ' 2018-08-18T12:45:16.0000000Z '
' 2018-08-18T12:45:16.0000000+02:00 --> 2018-08-18 12:45:16 +02:00
' 2018-08-18T12:45:16.0000000-07:00 --> 2018-08-18 12:45:16 -07:00
注解
方法的 TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) 此重载与 方法类似 DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) ,只不过此方法在转换失败时不会引发异常。 它分析日期和时间的字符串表示形式,该日期和时间必须与 参数指定的 format
模式完全匹配。
input
如果字符串与此模式不匹配,并且参数定义了styles
一些可能的空格变化,则分析操作将失败,并且该方法返回 false
。
参数 format
是一个字符串,其中包含一个标准格式说明符或一个或多个定义 所需模式的 input
自定义格式说明符。 有关有效格式设置代码的详细信息,请参阅 标准日期和时间格式字符串 和 自定义日期和时间格式字符串。 如果 format
包含 z
、 zz
或 zzz
自定义格式说明符来指示偏移必须存在于 中 input
,则偏移量必须包含负号或正号。 如果缺少符号,则分析操作将失败,并且该方法返回 false
。
如果需要 format
包含 input
日期而不是时间,则为生成的 DateTimeOffset 对象分配午夜时间 (0:00:00) 。 如果需要 format
包含 input
时间而不是日期,则为生成的 DateTimeOffset 对象分配本地系统上的当前日期。 如果 format
不需要 包含 input
偏移量,则生成的 DateTimeOffset 对象的偏移量取决于 参数的值 styles
。 如果 styles
包含 AssumeLocal,则会将本地时区的偏移量分配给 对象 DateTimeOffset 。 如果 styles
包含 AssumeUniversal,则会将协调世界时 (UTC) 偏移量或 +00:00 分配给对象 DateTimeOffset 。 如果两个值均未指定,则使用本地时区的偏移量。
中 input
使用的特定日期和时间符号和字符串由 formatProvider
参数定义。 如果 format
是标准格式说明符字符串,则对于 的精确模式input
也是如此。 参数 formatProvider
可以是以下任一参数:
一个 CultureInfo 对象,该对象表示解释所基于的
input
区域性。 DateTimeFormatInfo属性返回CultureInfo.DateTimeFormat的 对象定义 中input
允许的符号和标准格式。一个 DateTimeFormatInfo 定义日期和时间数据格式的 对象。
如果 formatprovider
为 null
,则 CultureInfo 使用与当前区域性对应的 对象。
参数 styles
定义是否允许在输入字符串中使用空格,指示如何分析没有显式偏移量的字符串,并支持 UTC 转换作为分析操作的一部分。 支持 枚举的所有成员 DateTimeStyles ,但 除外 NoCurrentDateDefault。 下表列出了每个受支持成员的效果。
DateTimeStyles 成员 |
行为 |
---|---|
AdjustToUniversal | 分析 input 并在必要时将其转换为 UTC。 它等效于分析字符串,然后调用 DateTimeOffset.ToUniversalTime 返回 DateTimeOffset 的 对象的 方法。 |
AssumeLocal | 如果 format 不需要包含 input 偏移值的 ,则返回 DateTimeOffset 的对象将被赋予本地时区的偏移量。 此选项为默认行为。 |
AssumeUniversal | 如果 format 不需要包含 input 偏移值,则返回 DateTimeOffset 的对象) (+00:00 的 UTC 偏移量。 |
AllowInnerWhite | 允许 input 包含未按格式指定的内部空格。 除了偏移量,还可以在日期和时间组件之间以及各个组件内显示额外的空格,并在分析字符串时被忽略。 |
AllowLeadingWhite | 允许 input 包含未指定的 format 前导空格。 分析字符串时,这些将被忽略。 |
AllowTrailingWhite | 允许 input 包含未指定的 format 尾随空格。 分析字符串时,这些将被忽略。 |
AllowWhiteSpaces | 允许 input 包含未指定的 format 前导空格、尾随空格和内部空格。 分析字符串时,将忽略中 format 未指定的所有额外空白字符。 |
None | 指示 中不允许使用 input 额外的空格。 空白必须完全按照 中的 format 指定显示。 此选项为默认行为。 |
RoundtripKind | 不起作用,因为 DateTimeOffset 结构不包含 Kind 属性。 |
调用方说明
在.NET Framework 4 中,TryParseExact如果要分析的字符串包含一个小时分量和一个不一致 AM/PM 指示符,则 返回 false
。 在 .NET Framework 3.5 及更早版本中,将忽略 AM/PM 指示符。
另请参阅
适用于
反馈
https://aka.ms/ContentUserFeedback。
即将发布:在整个 2024 年,我们将逐步淘汰作为内容反馈机制的“GitHub 问题”,并将其取代为新的反馈系统。 有关详细信息,请参阅:提交和查看相关反馈