DateTimeOffset.ParseExact Metod

public:
 static DateTimeOffset ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact(string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parametrar

Returer

Ett objekt som motsvarar det datum och den tid som finns i parametern input enligt parametrarna formats, formatProvideroch styles .

Undantag

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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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 = new 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();
   try
   {
      result = DateTimeOffset.ParseExact(input, formats, provider,
                                         DateTimeStyles.AllowWhiteSpaces);
      break;
   }
   catch (FormatException)
   {
      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 input = String.Empty
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

let mutable result = None
let mutable tries = 0
while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    let input = stdin.ReadLine()
    printfn ""
    try
        result <- 
            DateTimeOffset.ParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) 
            |> Some
    with :? FormatException ->
        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() 
    Try
       result = DateTimeOffset.ParseExact(input, formats, provider, _
                                          DateTimeStyles.AllowWhiteSpaces)
       Exit Do
    Catch e As FormatException
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End Try
 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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) parsar strängrepresentationen av ett datum som matchar något av de mönster som tilldelats parametern formats . Om strängen input inte matchar något av dessa mönster med någon av de varianter som definieras av parametern styles , genererar metoden en FormatException. Förutom att input jämföra med flera formateringsmönster 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 parameterns input möjliga mönster. När metoden anropas input måste den matcha ett av dessa mönster. 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 genererar metoden en FormatException.

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 det input 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 formatet för input, om matchande element i formats är en standardformatsspecificeraresträng. Parametern formatProvider kan vara något av följande:

• Ett CultureInfo objekt som representerar kulturen baserat på vilket input tolkas. Objektet DateTimeFormatInfo som returneras av egenskapen CultureInfo.DateTimeFormat definierar symbolerna och formateringen i input.

• Ett DateTimeFormatInfo objekt som definierar formatet för datum- och tidsdata.

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 format. 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 formats. Dessa ignoreras när strängen parsas.
AllowTrailingWhite	Tillåter input att avslutande blanksteg inte anges av formats. Dessa ignoreras när strängen parsas.
AllowWhiteSpaces	Tillåter input att inledande, avslutande och inre blanksteg inte anges av 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 formats för att en matchning ska inträffa. 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 genererar metoden ParseExact en FormatException 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

• TryParseExact
• Standardformatsträngar för datum och tid
• Anpassade formatsträngar för datum och tid

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact(string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parametrar

Returer

Ett objekt som motsvarar det datum och den tid som finns i parametern input enligt parametrarna format, formatProvideroch styles .

Undantag

Exempel

I följande exempel används DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) 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;
CultureInfo provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AssumeUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
}

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowTrailingWhite);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces |
                                      DateTimeStyles.AdjustToUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = 
        DateTimeOffset.ParseExact(dateString, format, provider,
                                  DateTimeStyles.AllowWhiteSpaces |||
                                  DateTimeStyles.AdjustToUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AssumeUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' Parse date-only value with leading white space.
' Should throw a FormatException because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowTrailingWhite)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"       
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces Or _
                                      DateTimeStyles.AdjustToUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 
' 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:

• de innehåller tomt utrymme och en lämplig DateTimeStyles flagga (till exempel DateTimeStyles.AllowWhiteSpaces inte har angetts i metodanropet.

• de innehåller datum- och tidselement som ligger utom räckhåll.

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

module parseexact_iso8601_2

open System
open System.Globalization

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" |] 

let parseWithISO8601 dateStrings styles =
    printfn $"Parsing with {styles}:"
    for dateString in dateStrings do
        try
            let date = DateTimeOffset.ParseExact(dateString, "O", null, styles)
            printfn $"""   {dateString,-35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
        with :? FormatException ->
            printfn $"   FormatException: Unable to convert '{dateString}'"

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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:");
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null, styles);
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"   FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:")
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateString, "O", Nothing, styles)
            Console.WriteLine($"   {dateString,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         catch e As FormatException
            Console.WriteLine($"   FormatException: Unable to convert '{dateString}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeLocal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'

Kommentarer

Metoden DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) parsar strängrepresentationen av ett datum, som måste vara i det format som definieras av parametern format . Det kräver också att elementen <Datum>, <Tid> och <Förskjutning> i strängrepresentationen av ett datum och en tid visas i den ordning som anges av format. Om strängen input inte matchar parameterns mönster format , med eventuella variationer som definieras av parametern styles , genererar metoden en FormatException. Metoden parsar däremot DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) strängrepresentationen av ett datum i något av formaten som identifieras av formatproviderns DateTimeFormatInfo objekt. Parse tillåter också att elementen <Datum>, <Tid> och <Förskjutning> i strängrepresentationen av ett datum och en tid visas i valfri ordning.

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 parametern 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 genererar metoden en FormatException.

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 formatet inputför , om format är en standardformatsspecificeraresträng. Parametern formatProvider kan vara något av följande:

• Ett CultureInfo objekt som representerar kulturen baserat på vilket input tolkas. Objektet DateTimeFormatInfo som returneras av egenskapen CultureInfo.DateTimeFormat definierar symbolerna och formateringen i input.

• Ett DateTimeFormatInfo objekt som definierar formatet för datum- och tidsdata.

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 standardvärdet.
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 av format. Extra tomt utrymme kan visas mellan datum- och tidskomponenter och inom enskilda komponenter 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 genererar metoden ParseExact en FormatException 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

• TryParseExact
• Standardformatsträngar för datum och tid
• Anpassade formatsträngar för datum och tid

public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parametrar

Returer

Ett objekt som motsvarar det datum och den tid som finns i parametern input enligt parametrarna format, formatProvideroch styles .

Undantag

Kommentarer

Den här metoden parsar ett teckenintervall som representerar ett datum, som måste vara i det format som definieras av parametern format . Det kräver också att elementen <Datum>, <Tid> och <Förskjutning> i strängrepresentationen av ett datum och en tid visas i den ordning som anges av format. Om input inte matchar format mönstret genererar metoden en FormatException. Metoden parsar däremot DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) strängrepresentationen av ett datum i något av formaten som identifieras av formatproviderns DateTimeFormatInfo objekt. Parse tillåter också att elementen <Datum>, <Tid> och <Förskjutning> i strängrepresentationen av ett datum och en tid visas i valfri ordning.

Parametern format är ett teckenintervall som innehåller antingen en standardformatsspecificerare med ett tecken eller en eller flera anpassade formatspecificerare som definierar det format som krävs för parametern 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 genererar metoden en FormatException.

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 tilldelas det resulterande DateTimeOffset objektet tidszonsförskjutningen för det lokala systemet.

De specifika datum- och tidssymbolerna och strängarna som används i input definieras av parametern formatProvider , liksom det exakta formatet för input om format är en standardformatsspecificerare. Parametern formatProvider kan vara något av följande:

• Ett CultureInfo objekt som representerar kulturen baserat på vilket input tolkas. Objektet DateTimeFormatInfo som returneras av dess DateTimeFormat egenskap definierar symbolerna och formateringen i input.

• Ett DateTimeFormatInfo objekt som definierar formatet för datum- och tidsdata.

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

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);

public static DateTimeOffset ParseExact(string input, string format, IFormatProvider formatProvider);

static member ParseExact : string * string * IFormatProvider -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider) As DateTimeOffset

Parametrar

Returer

Ett objekt som motsvarar det datum och den tid som finns i input enligt angivet av format och formatProvider.

Undantag

Exempel

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

string dateString, format;
DateTimeOffset result;
CultureInfo provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
dateString = "6/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
format = "ddd dd MMM yyyy h:mm tt zzz";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture.
let dateString = "06/15/2008"
let format = "d"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
let dateString = "6/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with custom specifier.
let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
let format = "ddd dd MMM yyyy h:mm tt zzz"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
let dateString = "Sun 15 Jun 2008 8:30 AM -06"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

Dim dateString, format As String  
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture

' Parse date-only value with invariant culture.
dateString = "06/15/2008"
format = "d"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date-only value without leading zero in month using "d" format.
' Should throw a FormatException because standard short date pattern of 
' invariant culture requires two-digit month.
dateString = "6/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
format = "ddd dd MMM yyyy h:mm tt zzz"        
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with offset without offset's minutes.
' Should throw a FormatException because "zzz" specifier requires leading  
' zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 
' The example displays the following output:
'    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
'    6/15/2008 is not in the correct format.
'    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
'    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

I följande exempel parsas en matris med strängar som förväntas överensstämma med ISO 8601. Som utdata från exemplet visar kan strängar med inledande eller avslutande blanksteg inte parsas korrekt, liksom strängar med datum- och tidselement som ligger utom räckhåll.

module parseexact_iso8601

open System

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.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

for dateString in dateStrings do
    try
        let date =
            DateTimeOffset.ParseExact(dateString, "O", null)

        printfn $"""{dateString, -35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
    with :? FormatException -> printfn $"FormatException: Unable to convert '{dateString}'"


// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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;

public class Example2
{
   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.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null);
            Console.WriteLine($"{dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"FormatException: Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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

Public Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "2018-08-18T12:45:16.0000000Z",
                                      "2018/08/18T12:45:16.0000000Z",
                                      "2018-18-08T12:45:16.0000000Z",
                                      " 2018-08-18T12:45:16.0000000Z ",
                                      "2018-08-18T12:45:16.0000000+02:00",
                                      "2018-08-18T12:45:16.0000000-07:00" } 
      
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateStr, "O", Nothing)
            Console.WriteLine($"{dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Catch  e As FormatException
            Console.WriteLine($"FormatException: Unable to convert '{dateStr}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
'      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
'      FormatException: 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

Metoden ParseExact(String, String, IFormatProvider) parsar strängrepresentationen av ett datum, som måste vara i det format som definieras av parametern format . Det kräver också att elementen <Datum>, <Tid> och <Förskjutning> i strängrepresentationen av ett datum och en tid visas i den ordning som anges av format. Om strängen input inte matchar den här format parametern genererar metoden en FormatException. Metoden parsar däremot DateTimeOffset.Parse(String, IFormatProvider) strängrepresentationen av ett datum i något av formaten som identifieras av formatproviderns DateTimeFormatInfo objekt. Parse tillåter också att elementen <Datum>, <Tid> och <Förskjutning> i strängrepresentationen av ett datum och en tid visas i valfri ordning.

Parametern format är en sträng som innehåller antingen en enskild standardformatsspecificerare eller en eller flera anpassade formatspecificerare som definierar det format som krävs för parametern 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 genererar metoden en FormatException.

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 tilldelas det resulterande DateTimeOffset objektet tidszonsförskjutningen för det lokala systemet.

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

• Ett CultureInfo objekt som representerar kulturen baserat på vilket input tolkas. Objektet DateTimeFormatInfo som returneras av dess DateTimeFormat egenskap definierar symbolerna och formateringen i input.

• Ett DateTimeFormatInfo objekt som definierar formatet för datum- och tidsdata.

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

Anteckningar till anropare

I .NET Framework 4 genererar metoden ParseExact en FormatException 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

• TryParseExact
• Standardformatsträngar för datum och tid
• Anpassade formatsträngar för datum och tid

public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parametrar

Returer

Ett objekt som motsvarar det datum och den tid som finns i parametern input enligt parametrarna formats, formatProvideroch styles .

Undantag

Kommentarer

Den här metoden parsar ett teckenintervall som representerar ett datum som matchar något av de mönster som tilldelats parametern formats . Om input inte matchar något av dessa mönster med någon av de varianter som definieras av parametern styles , genererar metoden en FormatException. Förutom att input jämföra med flera formateringsmönster fungerar den här överlagringen DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, 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 parameterns input möjliga mönster. När metoden anropas input måste den matcha ett av dessa mönster. 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 genererar metoden en FormatException.

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 det input 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 formatet för input, om matchande element i formats är en standardformatsspecificeraresträng. Parametern formatProvider kan vara något av följande:

• Ett CultureInfo objekt som representerar kulturen baserat på vilket input tolkas. Objektet DateTimeFormatInfo som returneras av egenskapen CultureInfo.DateTimeFormat definierar symbolerna och formateringen i input.

• Ett DateTimeFormatInfo objekt som definierar formatet för datum- och tidsdata.

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 format. 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 formats. Dessa ignoreras när strängen parsas.
AllowTrailingWhite	Tillåter input att avslutande blanksteg inte anges av formats. Dessa ignoreras när strängen parsas.
AllowWhiteSpaces	Tillåter input att inledande, avslutande och inre blanksteg inte anges av 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 formats för att en matchning ska inträffa. Det här är standardbeteendet.
RoundtripKind	Har ingen effekt eftersom DateTimeOffset strukturen inte innehåller en Kind egenskap.