DateTimeOffset.TryParseExact Metod

Definition

Namnområde:
System
Sammansättningar:
mscorlib.dll, System.Runtime.dll
Sammansättning:
mscorlib.dll
Sammansättning:
System.Runtime.dll
Sammansättning:
netstandard.dll

Konverterar den angivna strängrepresentationen av ett datum och en tid till motsvarande DateTimeOffset . Formatet för strängrepresentationen måste matcha ett angivet format exakt.

Överlagringar

Name Description
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTimeOffset motsvarighet med hjälp av den angivna matrisen med format, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha ett av de angivna formaten exakt.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)

Konverterar representationen av ett datum och en tid i ett teckenintervall till dess DateTimeOffset motsvarighet med det angivna formatet, kulturspecifik formatinformation och formatmall. Formatet för datum- och tidsrepresentationen måste matcha det angivna formatet exakt.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Konverterar representationen av ett datum och en tid i ett teckenintervall till dess DateTimeOffset motsvarighet med hjälp av angivna format, kulturspecifik formatinformation och formatmall. Formatet för datum- och tidsrepresentationen måste matcha ett av de angivna formaten exakt.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTimeOffset motsvarighet med det angivna formatet, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha det angivna formatet exakt.

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTimeOffset motsvarighet med hjälp av den angivna matrisen med format, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha ett av de angivna formaten exakt.

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);
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

Parametrar

input
String

En sträng som innehåller ett datum och en tid som ska konverteras.

formats
String[]

En matris som definierar de förväntade formaten för input.

formatProvider
IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om input.

styles
DateTimeStyles

En bitvis kombination av uppräkningsvärden som anger det tillåtna formatet för indata. Ett typiskt värde att ange är None.

result
DateTimeOffset

När metoden returnerar innehåller motsvarande DateTimeOffset datum och tid inputför , om konverteringen lyckades, eller DateTimeOffset.MinValue, om konverteringen misslyckades. Konverteringen misslyckas om den input inte innehåller en giltig strängrepresentation av ett datum och en tid, eller om den inte innehåller datum och tid i det förväntade format som definierats av formats, eller om formats är null. Den här parametern skickas oinitierad.

Returer

Boolean

trueom parametern input har konverterats, annars . false

Undantag

ArgumentException

styles innehåller ett odefinierat DateTimeStyles värde.

-eller-

NoCurrentDateDefault stöds inte.

-eller-

styles omfattar ömsesidigt uteslutande DateTimeStyles värden.

Exempel

I följande exempel definieras flera indataformat för strängrepresentationen av ett datum- och tids- och förskjutningsvärde och skickar sedan strängen som anges av användaren till TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) metoden.

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

Kommentarer

Metoden TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) parsar strängrepresentationen av ett datum som matchar något av de mönster som tilldelats till matrisen formats . Om strängen input inte matchar något av dessa mönster med eventuella variationer som definierats av parametern styles misslyckas parsningsåtgärden och metoden returnerar false. Förutom att input jämföra med flera strängar som innehåller formatspecificerare fungerar den här överlagringen DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) identiskt med metoden.

Parametern formats är en strängmatris vars element innehåller antingen en standardformatsspecificerare eller en eller flera anpassade formatspecificerare som definierar det möjliga mönstret för input. Mer information om giltiga formateringskoder finns i Formatsträngar för standarddatum och tid och anpassade datum- och tidsformatsträngar. Om det matchade elementet i formats innehåller zzz, eller zzz anpassade formatspecificerare för att indikera att en förskjutning måste finnas i input, måste förskjutningen innehålla antingen ett negativt tecken eller ett positivt tecken. Om tecknet saknas misslyckas parsningsåtgärden och metoden returnerar false.

Important

Om du använder parametern för den här överbelastningen formats för att ange flera format kan du minska frustrationen som många användare upplever när de anger datum och tider. I synnerhet gör möjligheten att definiera flera indatamönster att ett program kan hantera datum- och tidsrepresentationer som antingen kan innehålla eller sakna inledande nollor i månader, dagar, timmar, minuter och sekunder. Exemplet visar en bild av detta.

Om det matchade elementet i formats kräver att det input innehåller ett datum men inte en tid tilldelas det resulterande DateTimeOffset objektet en tid på midnatt (0:00:00). Om det matchade elementet i formats kräver att indata innehåller en tid men inte ett datum tilldelas det resulterande DateTimeOffset objektet det aktuella datumet i det lokala systemet. Om det matchade elementet i formats inte kräver att det input innehåller en förskjutning beror förskjutningen av det resulterande DateTimeOffset objektet på parameterns styles värde. Om styles inkluderar AssumeLocaltilldelas förskjutningen av den lokala tidszonen DateTimeOffset till objektet. Om styles inkluderar AssumeUniversaltilldelas utc-förskjutningen (Coordinated Universal Time) eller +00:00 objektet DateTimeOffset . Om inget av värdena anges används förskjutningen av den lokala tidszonen.

De specifika datum- och tidssymbolerna och strängarna som används i input definieras av parametern formatProvider . Detsamma gäller för det exakta mönstret för input om matchande element i formats är en standardformatsspecificeraresträng. Parametern formatProvider kan vara något av följande:

Om formatprovider är nullanvänds det CultureInfo objekt som motsvarar den aktuella kulturen.

Parametern styles definierar om tomt utrymme tillåts i indatasträngen, anger hur strängar utan en explicit förskjutningskomponent parsas och stöder UTC-konvertering som en del av parsningsåtgärden. Alla medlemmar i DateTimeStyles uppräkningen stöds förutom NoCurrentDateDefault. I följande tabell visas effekten av varje medlem som stöds.

DateTimeStyles medlem Behavior
AdjustToUniversal Parsar input och konverterar den vid behov till UTC. Det motsvarar parsning av en sträng och anropar sedan metoden för DateTimeOffset.ToUniversalTime det returnerade DateTimeOffset objektet.
AssumeLocal Om det matchade elementet i formats inte kräver att det input innehåller ett förskjutningsvärde får det returnerade DateTimeOffset objektet förskjutningen för den lokala tidszonen. Det här är standardvärdet.
AssumeUniversal Om det matchade elementet i formats inte kräver att det input innehåller ett förskjutningsvärde får det returnerade DateTimeOffset objektet UTC-förskjutningen (+00:00).
AllowInnerWhite Tillåter input att det inre blanksteget inte anges av elementen i formats. Extra tomt utrymme kan visas mellan datum- och tidskomponenter och inom enskilda komponenter (förutom förskjutningen) och ignoreras när strängen parsas.
AllowLeadingWhite Tillåter input att inledande blanksteg inte anges av elementen i formats. Dessa ignoreras när strängen parsas.
AllowTrailingWhite Tillåter input att avslutande blanksteg inte anges av elementen i formats. Dessa ignoreras när strängen parsas.
AllowWhiteSpaces Tillåter input att inledande, avslutande och inre blanksteg inte anges av elementen i formats. Alla extra blankstegstecken som inte anges i det matchade elementet i formats ignoreras när strängen parsas.
None Anger att ytterligare blanksteg inte tillåts i input. Tomt utrymme måste visas exakt som det anges i ett visst element i formats för att en lyckad matchning ska ske. Det här är standardbeteendet.
RoundtripKind Har ingen effekt eftersom DateTimeOffset strukturen inte innehåller en Kind egenskap.

Anteckningar till anropare

I .NET Framework 4 returnerar TryParseExactfalse om strängen som ska parsas innehåller en timkomponent och en AM/PM-designator som inte är överens. I .NET Framework 3.5 och tidigare versioner ignoreras AM/PM-designatorn.

Gäller för

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)

Konverterar representationen av ett datum och en tid i ett teckenintervall till dess DateTimeOffset motsvarighet med det angivna formatet, kulturspecifik formatinformation och formatmall. Formatet för datum- och tidsrepresentationen måste matcha det angivna formatet exakt.

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);
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

Parametrar

input
ReadOnlySpan<Char>

Ett intervall som innehåller de tecken som representerar ett datum och en tid som ska konverteras.

format
ReadOnlySpan<Char>

En formatspecificerare som definierar det format som krävs för input.

formatProvider
IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om input.

styles
DateTimeStyles

En bitvis kombination av uppräkningsvärden som anger det tillåtna formatet för input. Ett typiskt värde att ange är None.

result
DateTimeOffset

När metoden returnerar innehåller motsvarande DateTimeOffset datum och tid inputför , om konverteringen lyckades, eller DateTimeOffset.MinValue om konverteringen misslyckades. Konverteringen misslyckas om

Returer

Boolean

trueom parametern input har konverterats, annars . false

Undantag

ArgumentException

styles innehåller ett odefinierat DateTimeStyles värde. -or- NoCurrentDateDefault stöds inte. - eller - styles innehåller ömsesidigt uteslutande DateTimeStyles värden.

Kommentarer

Den här överlagringen DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) liknar metoden, förutom att den här metoden inte utlöser ett undantag om konverteringen misslyckas. Den parsar representationen av ett datum och en tid som exakt måste matcha det mönster som anges av parametern format . Om input inte matchar det här mönstret, med vissa möjliga variationer i tomt utrymme som definieras av parametern styles , misslyckas parsningsåtgärden och metoden returnerar false.

Parametern format är ett teckenintervall som innehåller antingen en standardformatsspecificerare eller en eller flera anpassade formatspecificerare som definierar det obligatoriska mönstret för input. Mer information om giltiga formateringskoder finns i Formatsträngar för standarddatum och tid och anpassade datum- och tidsformatsträngar. Om format innehåller z, zz, eller zzz anpassade formatspecificerare för att indikera att en förskjutning måste finnas i input, måste förskjutningen innehålla antingen ett negativt tecken eller ett positivt tecken. Om tecknet saknas misslyckas parsningsåtgärden och metoden returnerar false.

Om format kräver att input det innehåller ett datum men inte en tid tilldelas det resulterande DateTimeOffset objektet en tid på midnatt (0:00:00). Om format kräver som input innehåller en tid men inte ett datum tilldelas det resulterande DateTimeOffset objektet det aktuella datumet i det lokala systemet. Om format inte kräver att det input innehåller en förskjutning beror förskjutningen av det resulterande DateTimeOffset objektet på parameterns styles värde. Om styles inkluderar AssumeLocaltilldelas förskjutningen av den lokala tidszonen DateTimeOffset till objektet. Om styles inkluderar AssumeUniversaltilldelas utc-förskjutningen (Coordinated Universal Time) eller +00:00 objektet DateTimeOffset . Om inget av värdena anges används förskjutningen av den lokala tidszonen.

De specifika datum- och tidssymbolerna och strängarna som används i input definieras av parametern formatProvider . Detsamma gäller för det exakta mönstret för input om format är en standardformatsspecificeraresträng. Parametern formatProvider kan vara något av följande:

Om formatprovider är nullanvänds det CultureInfo objekt som motsvarar den aktuella kulturen.

Parametern styles definierar om tomt utrymme tillåts i indatasträngen, anger hur strängar utan en explicit förskjutningskomponent parsas och stöder UTC-konvertering som en del av parsningsåtgärden. Alla medlemmar i DateTimeStyles uppräkningen stöds förutom NoCurrentDateDefault. I följande tabell visas effekten av varje medlem som stöds.

DateTimeStyles medlem Behavior
AdjustToUniversal Parsar input och konverterar den vid behov till UTC. Det motsvarar parsning av en datum- och tidsrepresentation och anropar sedan metoden för DateTimeOffset.ToUniversalTime det returnerade DateTimeOffset objektet.
AssumeLocal Om format inte kräver att det input innehåller ett förskjutningsvärde får det returnerade DateTimeOffset objektet förskjutningen av den lokala tidszonen. Det här är standardbeteendet.
AssumeUniversal Om format inte kräver att det input innehåller ett förskjutningsvärde får det returnerade DateTimeOffset objektet UTC-förskjutningen (+00:00).
AllowInnerWhite Tillåter input att det inre blanksteget inte anges i formatet. Extra tomt utrymme kan visas mellan datum- och tidskomponenter och inom enskilda komponenter, förutom förskjutningen, och ignoreras när strängen parsas.
AllowLeadingWhite Tillåter input att inledande blanksteg inte anges av format. Dessa ignoreras när strängen parsas.
AllowTrailingWhite Tillåter input att avslutande blanksteg inte anges av format. Dessa ignoreras när strängen parsas.
AllowWhiteSpaces Tillåter input att inledande, avslutande och inre blanksteg inte anges av format. Alla extra blankstegstecken som inte anges i format ignoreras när strängen parsas.
None Anger att ytterligare blanksteg inte tillåts i input. Tomt utrymme måste visas exakt som det anges i format. Det här är standardbeteendet.
RoundtripKind Har ingen effekt eftersom DateTimeOffset strukturen inte innehåller en Kind egenskap.

Gäller för

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

Konverterar representationen av ett datum och en tid i ett teckenintervall till dess DateTimeOffset motsvarighet med hjälp av angivna format, kulturspecifik formatinformation och formatmall. Formatet för datum- och tidsrepresentationen måste matcha ett av de angivna formaten exakt.

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);
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

Parametrar

input
ReadOnlySpan<Char>

Ett intervall som innehåller de tecken som representerar ett datum och en tid som ska konverteras.

formats
String[]

En matris med standard- eller anpassade formatsträngar som definierar acceptabla format för input.

formatProvider
IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om input.

styles
DateTimeStyles

En bitvis kombination av uppräkningsvärden som anger det tillåtna formatet för input. Ett typiskt värde att ange är None.

result
DateTimeOffset

När metoden returnerar innehåller motsvarande DateTimeOffset datum och tid inputför , om konverteringen lyckades, eller DateTimeOffset.MinValue om konverteringen misslyckades. Konverteringen misslyckas om

Returer

Boolean

trueom parametern input har konverterats, annars . false

Undantag

ArgumentException

styles innehåller ett odefinierat DateTimeStyles värde. -or- NoCurrentDateDefault stöds inte. - eller - styles innehåller ömsesidigt uteslutande DateTimeStyles värden.

Kommentarer

Den här metoden parsar strängrepresentationen av ett datum som matchar något av de mönster som tilldelats matrisen formats . Om input inte matchar något av dessa mönster med eventuella variationer som definierats av parametern styles misslyckas parsningsåtgärden och metoden returnerar false. Förutom att input jämföra med flera strängar som innehåller formatspecificerare fungerar den här överlagringen DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) identiskt med metoden.

Parametern formats är en strängmatris vars element innehåller antingen en standardformatsspecificerare eller en eller flera anpassade formatspecificerare som definierar det möjliga mönstret för input. Mer information om giltiga formateringskoder finns i Formatsträngar för standarddatum och tid och anpassade datum- och tidsformatsträngar. Om det matchade elementet i formats innehåller zzz, eller zzz anpassade formatspecificerare för att indikera att en förskjutning måste finnas i input, måste förskjutningen innehålla antingen ett negativt tecken eller ett positivt tecken. Om tecknet saknas misslyckas parsningsåtgärden och metoden returnerar false.

Important

Om du använder parametern för den här överbelastningen formats för att ange flera format kan du minska frustrationen som många användare upplever när de anger datum och tider. I synnerhet gör möjligheten att definiera flera indatamönster att ett program kan hantera datum- och tidsrepresentationer som antingen kan innehålla eller sakna inledande nollor i månader, dagar, timmar, minuter och sekunder. Exemplet visar en bild av detta.

Om det matchade elementet i formats kräver att det input innehåller ett datum men inte en tid tilldelas det resulterande DateTimeOffset objektet en tid på midnatt (0:00:00). Om det matchade elementet i formats kräver att indata innehåller en tid men inte ett datum tilldelas det resulterande DateTimeOffset objektet det aktuella datumet i det lokala systemet. Om det matchade elementet i formats inte kräver att det input innehåller en förskjutning beror förskjutningen av det resulterande DateTimeOffset objektet på parameterns styles värde. Om styles inkluderar DateTimeStyles.AssumeLocaltilldelas förskjutningen av den lokala tidszonen DateTimeOffset till objektet. Om styles inkluderar DateTimeStyles.AssumeUniversaltilldelas utc-förskjutningen (Coordinated Universal Time) eller +00:00 objektet DateTimeOffset . Om inget av värdena anges används förskjutningen av den lokala tidszonen.

De specifika datum- och tidssymbolerna som används i input definieras av parametern formatProvider . Detsamma gäller för det exakta mönstret för input om matchande element i formats är en standardformatsspecificeraresträng. Parametern formatProvider kan vara något av följande:

Om formatprovider är nullanvänds det CultureInfo objekt som motsvarar den aktuella kulturen.

Parametern styles definierar om tomt utrymme tillåts i indatasträngen, anger hur strängar utan en explicit förskjutningskomponent parsas och stöder UTC-konvertering som en del av parsningsåtgärden. Alla medlemmar i DateTimeStyles uppräkningen stöds förutom NoCurrentDateDefault. I följande tabell visas effekten av varje medlem som stöds.

DateTimeStyles medlem Behavior
AdjustToUniversal Parsar input och konverterar den vid behov till UTC. Det motsvarar parsning av en sträng och anropar sedan metoden för DateTimeOffset.ToUniversalTime det returnerade DateTimeOffset objektet.
AssumeLocal Om det matchade elementet i formats inte kräver att det input innehåller ett förskjutningsvärde får det returnerade DateTimeOffset objektet förskjutningen för den lokala tidszonen. Det här är standardvärdet.
AssumeUniversal Om det matchade elementet i formats inte kräver att det input innehåller ett förskjutningsvärde får det returnerade DateTimeOffset objektet UTC-förskjutningen (+00:00).
AllowInnerWhite Tillåter input att det inre blanksteget inte anges av elementen i formats. Extra tomt utrymme kan visas mellan datum- och tidskomponenter och inom enskilda komponenter (förutom förskjutningen) och ignoreras när strängen parsas.
AllowLeadingWhite Tillåter input att inledande blanksteg inte anges av elementen i formats. Dessa ignoreras när strängen parsas.
AllowTrailingWhite Tillåter input att avslutande blanksteg inte anges av elementen i formats. Dessa ignoreras när strängen parsas.
AllowWhiteSpaces Tillåter input att inledande, avslutande och inre blanksteg inte anges av elementen i formats. Alla extra blankstegstecken som inte anges i det matchade elementet i formats ignoreras när strängen parsas.
None Anger att ytterligare blanksteg inte tillåts i input. Tomt utrymme måste visas exakt som det anges i ett visst element i formats för att en lyckad matchning ska ske. Det här är standardbeteendet.
RoundtripKind Har ingen effekt eftersom DateTimeOffset strukturen inte innehåller en Kind egenskap.

Gäller för

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Konverterar den angivna strängrepresentationen av ett datum och en tid till dess DateTimeOffset motsvarighet med det angivna formatet, kulturspecifik formatinformation och formatmall. Formatet för strängrepresentationen måste matcha det angivna formatet exakt.

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);
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

Parametrar

input
String

En sträng som innehåller ett datum och en tid som ska konverteras.

format
String

En formatspecificerare som definierar det format som krävs för input.

formatProvider
IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om input.

styles
DateTimeStyles

En bitvis kombination av uppräkningsvärden som anger det tillåtna formatet för indata. Ett typiskt värde att ange är None.

result
DateTimeOffset

När metoden returnerar innehåller motsvarande DateTimeOffset datum och tid inputför , om konverteringen lyckades, eller DateTimeOffset.MinValue, om konverteringen misslyckades. Konverteringen misslyckas om parametern input är null, eller inte innehåller en giltig strängrepresentation av ett datum och en tid i det förväntade format som definieras av format och provider. Den här parametern skickas oinitierad.

Returer

Boolean

trueom parametern input har konverterats, annars . false

Undantag

ArgumentException

styles innehåller ett odefinierat DateTimeStyles värde.

-eller-

NoCurrentDateDefault stöds inte.

-eller-

styles omfattar ömsesidigt uteslutande DateTimeStyles värden.

Exempel

I följande exempel används TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) metoden med standard- och anpassade formatspecificerare, den invarianta kulturen och olika DateTimeStyles värden för att parsa flera datum- och tidssträngar.

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.

I följande exempel används en mängd DateTimeStyles olika värden för att parsa en matris med strängar som förväntas överensstämma med ISO 8601. Som utdata från exemplet visar kan strängar som är i rätt format inte parsa om:

Strängar som inte anger en UTC-förskjutning antas ha förskjutningen av den lokala tidszonen (i det här fallet -07:00, vilket återspeglar förskjutningen av Pacific Daylight Time-zonen) såvida inte DateTimeStyles.AssumeUniversal flaggan anges i metodanropet. I så fall antas de vara universell koordinerad tid.

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

Kommentarer

Den här överlagringen TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) av metoden liknar DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) metoden, förutom att den här metoden inte utlöser ett undantag om konverteringen misslyckas. Den parsar strängrepresentationen av ett datum och en tid som exakt måste matcha det mönster som anges av parametern format . Om strängen input inte matchar det här mönstret, med vissa möjliga variationer i tomt utrymme som definieras av parametern styles , misslyckas parsningsåtgärden och metoden returnerar false.

Parametern format är en sträng som innehåller antingen en enskild standardformatsspecificerare eller en eller flera anpassade formatspecificerare som definierar det obligatoriska mönstret för input. Mer information om giltiga formateringskoder finns i Formatsträngar för standarddatum och tid och anpassade datum- och tidsformatsträngar. Om format innehåller z, zz, eller zzz anpassade formatspecificerare för att indikera att en förskjutning måste finnas i input, måste förskjutningen innehålla antingen ett negativt tecken eller ett positivt tecken. Om tecknet saknas misslyckas parsningsåtgärden och metoden returnerar false.

Om format kräver att input det innehåller ett datum men inte en tid tilldelas det resulterande DateTimeOffset objektet en tid på midnatt (0:00:00). Om format kräver som input innehåller en tid men inte ett datum tilldelas det resulterande DateTimeOffset objektet det aktuella datumet i det lokala systemet. Om format inte kräver att det input innehåller en förskjutning beror förskjutningen av det resulterande DateTimeOffset objektet på parameterns styles värde. Om styles inkluderar AssumeLocaltilldelas förskjutningen av den lokala tidszonen DateTimeOffset till objektet. Om styles inkluderar AssumeUniversaltilldelas utc-förskjutningen (Coordinated Universal Time) eller +00:00 objektet DateTimeOffset . Om inget av värdena anges används förskjutningen av den lokala tidszonen.

De specifika datum- och tidssymbolerna och strängarna som används i input definieras av parametern formatProvider . Detsamma gäller för det exakta mönstret för input om format är en standardformatsspecificeraresträng. Parametern formatProvider kan vara något av följande:

Om formatprovider är nullanvänds det CultureInfo objekt som motsvarar den aktuella kulturen.

Parametern styles definierar om tomt utrymme tillåts i indatasträngen, anger hur strängar utan en explicit förskjutningskomponent parsas och stöder UTC-konvertering som en del av parsningsåtgärden. Alla medlemmar i DateTimeStyles uppräkningen stöds förutom NoCurrentDateDefault. I följande tabell visas effekten av varje medlem som stöds.

DateTimeStyles medlem Behavior
AdjustToUniversal Parsar input och konverterar den vid behov till UTC. Det motsvarar parsning av en sträng och anropar sedan metoden för DateTimeOffset.ToUniversalTime det returnerade DateTimeOffset objektet.
AssumeLocal Om format inte kräver att det input innehåller ett förskjutningsvärde får det returnerade DateTimeOffset objektet förskjutningen av den lokala tidszonen. Det här är standardbeteendet.
AssumeUniversal Om format inte kräver att det input innehåller ett förskjutningsvärde får det returnerade DateTimeOffset objektet UTC-förskjutningen (+00:00).
AllowInnerWhite Tillåter input att det inre blanksteget inte anges i formatet. Extra tomt utrymme kan visas mellan datum- och tidskomponenter och inom enskilda komponenter, förutom förskjutningen, och ignoreras när strängen parsas.
AllowLeadingWhite Tillåter input att inledande blanksteg inte anges av format. Dessa ignoreras när strängen parsas.
AllowTrailingWhite Tillåter input att avslutande blanksteg inte anges av format. Dessa ignoreras när strängen parsas.
AllowWhiteSpaces Tillåter input att inledande, avslutande och inre blanksteg inte anges av format. Alla extra blankstegstecken som inte anges i format ignoreras när strängen parsas.
None Anger att ytterligare blanksteg inte tillåts i input. Tomt utrymme måste visas exakt som det anges i format. Det här är standardbeteendet.
RoundtripKind Har ingen effekt eftersom DateTimeOffset strukturen inte innehåller en Kind egenskap.

Anteckningar till anropare

I .NET Framework 4 returnerar TryParseExactfalse om strängen som ska parsas innehåller en timkomponent och en AM/PM-designator som inte är överens. I .NET Framework 3.5 och tidigare versioner ignoreras AM/PM-designatorn.

Se även

Gäller för