DateTimeOffset.ParseExact Metódus

Definíció

Névtér:: System

Szerelvények:: mscorlib.dll, System.Runtime.dll

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Egy dátum és idő megadott sztring-ábrázolását konvertálja annak megfelelőjeként DateTimeOffset . A sztring-ábrázolás formátumának pontosan meg kell egyeznie egy megadott formátummal.

Túlterhelések

Name	Description
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Egy dátum és idő megadott sztring-ábrázolását a megadott formátumok, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTimeOffset annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok egyikével.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Egy dátum és idő megadott sztringképét a megadott formátum, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTimeOffset annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.
ParseExact(String, String, IFormatProvider)	Egy dátum és idő megadott sztring-ábrázolását a megadott formátum- és kultúraspecifikus formátumadatok használatával konvertálja DateTimeOffset annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	A megadott formátum, kultúraspecifikus formátumadatok és stílus használatával egy dátumot és időt DateTimeOffset ábrázoló karaktersávot alakít át annak megfelelővé. A dátum- és időábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Egy dátum és idő sztring-ábrázolását tartalmazó karaktersávot a megadott formátumok, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTimeOffset annak megfelelővé. A dátum- és időábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok egyikével.

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Egy dátum és idő megadott sztring-ábrázolását a megadott formátumok, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTimeOffset annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok egyikével.

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

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

Paraméterek

input: String

Egy sztring, amely dátumot és időt tartalmaz az átalakításhoz.

formats: String[]

Formátumjelölők tömbje, amelyek a várt formátumokat inputhatározzák meg.

formatProvider: IFormatProvider

Egy objektum, amely a kultúraspecifikus formázási inputinformációkat tartalmazza.

styles: DateTimeStyles

Az enumerálási értékek bitenkénti kombinációja, amely a megengedett formátumot inputjelzi.

Válaszok

DateTimeOffset

Olyan objektum, amely megegyezik a paraméterben input található dátummal és idővel a , formatsés formatProvider paraméterek által stylesmegadott módon.

Kivételek

ArgumentException

Az eltolás nagyobb, mint 14 óra vagy kevesebb, mint -14 óra.

-vagy-

styles nem támogatott értéket tartalmaz.

-vagy-

A styles paraméter olyan értékeket tartalmaz DateTimeStyles , amelyek nem használhatók együtt.

ArgumentNullException

input az null.

FormatException

input üres sztring ("").

-vagy-

input nem tartalmaz dátum és idő érvényes sztring-ábrázolását.

-vagy-

Egyetlen elem formats sem tartalmaz érvényes formátumkijelölőt.

-vagy-

Az óra összetevő és az AM/PM tervező input nem ért egyet.

Példák

Az alábbi példa több bemeneti formátumot határoz meg egy dátum- és idő- és eltolásérték sztring-ábrázolásához, majd átadja a felhasználó által megadott sztringet a DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metódusnak.

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

Megjegyzések

A DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metódus elemzi egy dátum sztringképét, amely megfelel a paraméterhez formats rendelt minták bármelyikének. Ha a sztring input nem egyezik meg ezen minták egyikével sem a paraméter által styles meghatározott változatokkal, a metódus egy FormatException. A több formázási mintával való input összehasonlításon kívül ez a túlterhelés ugyanúgy viselkedik, mint a DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) metódus.

A formats paraméter egy sztringtömb, amelynek elemei egyetlen szabványos formátumkijelölőt vagy egy vagy több egyéni formátumkijelölőt tartalmaznak, amelyek meghatározzák a input paraméter lehetséges mintáját. A metódus meghívásakor input meg kell egyeznie az alábbi minták egyikével. Az érvényes formázási kódokról további információt a Standard dátum- és időformátum sztringjei , valamint az egyéni dátum- és időformátum-sztringek című témakörben talál. Ha a egyeztetett elem tartalmazza formats a z, zzvagy zzz egyéni formátumjelölőket, amelyek azt jelzik, hogy eltolásnak kell lennie, inputaz eltolásnak negatív vagy pozitív előjelet kell tartalmaznia. Ha a jel hiányzik, a metódus egy FormatException.

Important

Ha ennek a túlterhelésnek a formats paraméterét több formátum megadására használja, azzal csökkentheti a sok felhasználó által a dátumok és időpontok megadásakor tapasztalt frusztrációt. A több bemeneti minta definiálásának lehetősége lehetővé teszi, hogy az alkalmazás olyan dátum- és időábrázolásokat kezeljen, amelyek hónapok, napok, órák, percek és másodpercek kezdő nulláit tartalmazhatják vagy nem. A példa ezt szemlélteti.

Ha a megfeleltetett elemhez formats dátumot, de nem időpontot kell input tartalmaznia, az eredményként DateTimeOffset kapott objektumhoz éjféli időpont (0:00:00) lesz hozzárendelve. Ha a megfeleltetett elemhez formatsinput idő kell, de dátum nem, akkor az eredményként kapott DateTimeOffset objektum a helyi rendszeren az aktuális dátumot kapja. Ha a megfeleltetett elem formats nem követeli meg, hogy input eltolást tartalmazzon, az eredményként kapott DateTimeOffset objektum eltolása a styles paraméter értékétől függ. Ha styles tartalmazza AssumeLocal, a helyi időzóna eltolása hozzá lesz rendelve az DateTimeOffset objektumhoz. Ha styles tartalmazza AssumeUniversal, az egyezményes világidő (UTC) eltolása vagy +00:00 az objektumhoz DateTimeOffset van rendelve. Ha egyik érték sincs megadva, a rendszer a helyi időzóna eltolását használja.

A megadott dátum- és időszimbólumokat és sztringeket input a formatProvider paraméter határozza meg. Ugyanez igaz a pontos formátumra input, ha az egyező elem formats egy szabványos formátumkijelölő sztring. A formatProvider paraméter a következők egyike lehet:

Egy CultureInfo olyan objektum, amely az értelmezett kultúra alapján input jeleníti meg a kultúrát. A DateTimeFormatInfo tulajdonság által CultureInfo.DateTimeFormat visszaadott objektum határozza meg a szimbólumokat és a formázást a következőben input: .
A DateTimeFormatInfo dátum- és időadatok formátumát meghatározó objektum.

Ha formatprovider igen null, akkor a rendszer az CultureInfo aktuális kultúrának megfelelő objektumot használja.

A styles paraméter meghatározza, hogy a bemeneti sztringben engedélyezett-e a szabad terület, jelzi, hogy az explicit eltolási összetevő nélküli sztringek hogyan vannak elemezve, és támogatja az UTC-konverziót az elemzési művelet részeként. Az enumerálás minden tagja DateTimeStyles támogatott, kivéve NoCurrentDateDefault. Az alábbi táblázat az egyes támogatott tagok hatását sorolja fel.

`DateTimeStyles` tag	Magatartás
AdjustToUniversal	`input` Elemzi és szükség esetén UTC-vé alakítja át. Ez egyenértékű egy sztring elemzésével, majd a DateTimeOffset.ToUniversalTime visszaadott DateTimeOffset objektum metódusának meghívásával.
AssumeLocal	Ha a megfeleltetett elem `formats` nem követeli meg, hogy `input` eltolási értéket tartalmazzon, a visszaadott DateTimeOffset objektum a helyi időzóna eltolását kapja. Ez az alapértelmezett érték.
AssumeUniversal	Ha a megfeleltetett elem `formats` nem követeli meg, hogy `input` eltolásértéket tartalmazzon, a visszaadott DateTimeOffset objektum utc-eltolást (+00:00) kap.
AllowInnerWhite	Lehetővé teszi `input` a nem megadott belső térköz hozzáadását `format`. A dátum- és időösszetevők és az egyes összetevők között (az eltolás kivételével) további üres terület jelenhet meg, és a sztring elemzésekor figyelmen kívül hagyja.
AllowLeadingWhite	Lehetővé teszi `input` a nem megadott kezdő szóközök hozzáadását `formats`. Ezek figyelmen kívül lesznek hagyva a sztring elemzésekor.
AllowTrailingWhite	Lehetővé teszi `input` a nem megadott záró szóközök hozzáadását `formats`. Ezek figyelmen kívül lesznek hagyva a sztring elemzésekor.
AllowWhiteSpaces	Lehetővé teszi `input` a bevezető, záró és belső szóközök hozzáadását `formats`. A sztring elemzésekor a rendszer figyelmen kívül hagyja az összes olyan szóköz karaktert, amely nincs megadva a megfeleltetett elemben `formats` .
None	Azt jelzi, hogy a további szabad terület nem engedélyezett.`input` A szóköznek pontosan az egyezés adott elemében megadott módon kell megjelennie `formats` . Ez az alapértelmezett viselkedés.
RoundtripKind	Nincs hatása, mert a DateTimeOffset struktúra nem tartalmaz tulajdonságot `Kind` .

Megjegyzések a hívókhoz

A .NET Framework 4-ben a ParseExact metódus FormatException ad vissza, ha az elemezni kívánt sztring tartalmaz egy óra összetevőt és egy am/pm tervezőt, amely nem egyezett meg. A .NET Framework 3.5-ös és korábbi verzióiban a rendszer figyelmen kívül hagyja az AM/PM-tervezőt.

Lásd még

A következőre érvényes:

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Egy dátum és idő megadott sztringképét a megadott formátum, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTimeOffset annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.

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

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

Paraméterek

input: String

Egy sztring, amely dátumot és időt tartalmaz az átalakításhoz.

format: String

A várt formátumát inputmeghatározó formátumjelölő.

formatProvider: IFormatProvider

Egy objektum, amely a kultúraspecifikus formázási inputinformációkat tartalmazza.

styles: DateTimeStyles

Az enumerálási értékek bitenkénti kombinációja, amely a megengedett formátumot inputjelzi.

Válaszok

DateTimeOffset

Olyan objektum, amely megegyezik a paraméterben input található dátummal és idővel a , formatés formatProvider paraméterek által stylesmegadott módon.

Kivételek

ArgumentException

Az eltolás nagyobb, mint 14 óra vagy kevesebb, mint -14 óra.

-vagy-

A styles paraméter nem támogatott értéket tartalmaz.

-vagy-

A styles paraméter olyan értékeket tartalmaz DateTimeStyles , amelyek nem használhatók együtt.

ArgumentNullException

input az null.

-vagy-

format az null.

FormatException

input üres sztring ("").

-vagy-

input nem tartalmaz dátum és idő érvényes sztring-ábrázolását.

-vagy-

format üres sztring.

-vagy-

Az óra összetevő és az AM/PM tervező input nem ért egyet.

Példák

Az alábbi példa a DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) metódust szabványos és egyéni formátumkijelölőkkel, az invariáns kultúrával és különböző DateTimeStyles értékekkel használja több dátum- és idősztring elemzéséhez.

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.

Az alábbi példa különböző DateTimeStyles értékeket használ az ISO 8601 szabványnak várhatóan megfelelő sztringek tömbjének elemzéséhez. Ahogy a példa kimenete is mutatja, a megfelelő formátumú sztringek nem elemeznek, ha:

fehér szóközt és egy megfelelő DateTimeStyles jelzőt tartalmaznak (például DateTimeStyles.AllowWhiteSpaces nem szerepel a metódushívásban).
olyan dátum- és időelemeket tartalmaznak, amelyek nem tartoznak a tartományba.

Az UTC-eltolást nem meghatározó sztringek esetében feltételezzük, hogy a helyi időzóna eltolása (ebben az esetben -07:00), kivéve, ha a DateTimeStyles.AssumeUniversal metódushívásban a jelölő szerepel. Ebben az esetben a rendszer azt feltételezi, hogy univerzális koordinált időnek minősülnek.

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'

Megjegyzések

A DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) metódus elemzi egy dátum sztringképét, amelynek a paraméter által format meghatározott formátumban kell lennie. Azt is megköveteli, hogy a <dátum és idő sztringjének Dátum>, <Idő> és <Eltolás> elemei a megadott formatsorrendben jelenjenek meg. Ha a sztring input nem egyezik meg a format paraméter mintájával, a paraméter által styles definiált variációkkal együtt a metódus egy FormatException. Ezzel szemben a DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) metódus a dátum sztring-ábrázolását elemzi a formátumszolgáltató objektuma által felismert formátumok bármelyikében DateTimeFormatInfo . Parse lehetővé teszi a <dátumok és időpontok sztringképének Dátum>, <Idő> és <Eltolás> elemeinek bármilyen sorrendben való megjelenítését.

A format paraméter egy sztring, amely egyetlen szabványos formátumkijelölőt vagy egy vagy több egyéni formátumkijelölőt tartalmaz, amelyek meghatározzák a input paraméter szükséges mintáját. Az érvényes formázási kódokról további információt a Standard dátum- és időformátum sztringjei , valamint az egyéni dátum- és időformátum-sztringek című témakörben talál. Ha format az zeltolást jelző , zzvagy zzz egyéni formátumjelölőket is tartalmaz, akkor az eltolásnak inputnegatív vagy pozitív előjelet kell tartalmaznia. Ha a jel hiányzik, a metódus egy FormatException.

Ha format dátumot input , de nem időpontot kell tartalmaznia, az eredményként kapott DateTimeOffset objektumhoz éjféli időpont lesz hozzárendelve (0:00:00). Ha format ehhez input idő szükséges, de dátumot nem, akkor az eredményként kapott DateTimeOffset objektum a helyi rendszeren az aktuális dátumot rendeli hozzá. Ha format nincs szükség eltolásra input , az eredményként kapott DateTimeOffset objektum eltolása a styles paraméter értékétől függ. Ha styles tartalmazza AssumeLocal, a helyi időzóna eltolása hozzá lesz rendelve az DateTimeOffset objektumhoz. Ha styles tartalmazza AssumeUniversal, az egyezményes világidő (UTC) eltolása vagy +00:00 az objektumhoz DateTimeOffset van rendelve. Ha egyik érték sincs megadva, a rendszer a helyi időzóna eltolását használja.

A megadott dátum- és időszimbólumokat és sztringeket input a formatProvider paraméter határozza meg. Ugyanez igaz a pontos formátumra input, ha format egy szabványos formátumkijelölő sztring. A formatProvider paraméter a következők egyike lehet:

Egy CultureInfo olyan objektum, amely az értelmezett kultúra alapján input jeleníti meg a kultúrát. A DateTimeFormatInfo tulajdonság által CultureInfo.DateTimeFormat visszaadott objektum határozza meg a szimbólumokat és a formázást a következőben input: .
A DateTimeFormatInfo dátum- és időadatok formátumát meghatározó objektum.

Ha formatprovider igen null, akkor a rendszer az CultureInfo aktuális kultúrának megfelelő objektumot használja.

A styles paraméter meghatározza, hogy engedélyezett-e szabad terület a bemeneti sztringben, jelzi, hogy az explicit eltolási összetevő nélküli sztringek hogyan lesznek elemezve, és támogatja az UTC-konverziót az elemzési művelet részeként. Az enumerálás minden tagja DateTimeStyles támogatott, kivéve NoCurrentDateDefault. Az alábbi táblázat az egyes támogatott tagok hatását sorolja fel.

`DateTimeStyles` tag	Magatartás
AdjustToUniversal	`input` Elemzi és szükség esetén UTC-vé alakítja át. Ez egyenértékű egy sztring elemzésével, majd a DateTimeOffset.ToUniversalTime visszaadott DateTimeOffset objektum metódusának meghívásával.
AssumeLocal	Ha `format` nincs szükség `input` eltolásértékre, a visszaadott DateTimeOffset objektum a helyi időzóna eltolását kapja. Ez az alapértelmezett érték.
AssumeUniversal	Ha `format` nincs szükség eltolásértékre `input` , a visszaadott DateTimeOffset objektum utc-eltolást (+00:00) kap.
AllowInnerWhite	Lehetővé teszi `input` a nem megadott belső térköz hozzáadását `format`. A dátum- és időösszetevők és az egyes összetevők között további üres terület jelenhet meg, és a sztring elemzésekor a rendszer figyelmen kívül hagyja.
AllowLeadingWhite	Lehetővé teszi `input` a nem megadott kezdő szóközök hozzáadását `format`. Ezek figyelmen kívül lesznek hagyva a sztring elemzésekor.
AllowTrailingWhite	Lehetővé teszi `input` a nem megadott záró szóközök hozzáadását `format`. Ezek figyelmen kívül lesznek hagyva a sztring elemzésekor.
AllowWhiteSpaces	Lehetővé teszi `input` a bevezető, záró és belső szóközök hozzáadását `format`. A sztring elemzésekor a rendszer figyelmen kívül hagyja az összes nem megadott `format` szóköz karaktert.
None	Azt jelzi, hogy a további szabad terület nem engedélyezett.`input` A szóköznek pontosan a megadott módon kell megjelennie.`format` Ez az alapértelmezett viselkedés.
RoundtripKind	Nincs hatása, mert a DateTimeOffset struktúra nem tartalmaz tulajdonságot `Kind` .

Megjegyzések a hívókhoz

Lásd még

A következőre érvényes:

ParseExact(String, String, IFormatProvider)

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Egy dátum és idő megadott sztring-ábrázolását a megadott formátum- és kultúraspecifikus formátumadatok használatával konvertálja DateTimeOffset annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.

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

public static DateTimeOffset ParseExact(string input, 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

Paraméterek

input: String

Egy sztring, amely dátumot és időt tartalmaz az átalakításhoz.

format: String

A várt formátumát inputmeghatározó formátumjelölő.

formatProvider: IFormatProvider

Egy objektum, amely a kultúraspecifikus formázási inputinformációkat tartalmazza.

Válaszok

DateTimeOffset

Olyan objektum, amely megegyezik a megadott dátummal és időponttal inputformatformatProvider.

Kivételek

ArgumentException

Az eltolás nagyobb, mint 14 óra vagy kevesebb, mint -14 óra.

ArgumentNullException

input az null.

-vagy-

format az null.

FormatException

input üres sztring ("").

-vagy-

input nem tartalmaz dátum és idő érvényes sztring-ábrázolását.

-vagy-

format üres sztring.

-vagy-

Az óra összetevő és az AM/PM tervező input nem ért egyet.

Példák

Az alábbi példa a DateTimeOffset.ParseExact(String, String, IFormatProvider) metódust szabványos és egyéni formátumkijelölőkkel és invariáns kultúrával használja több dátum- és idősztring elemzéséhez.

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.

Az alábbi példa olyan sztringeket elemez, amelyek várhatóan megfelelnek az ISO 8601 szabványnak. Ahogy a példa kimenete is mutatja, a kezdő vagy záró szóközökkel rendelkező sztringek nem elemezhetők sikeresen, ahogy a tartományon kívüli dátum- és időelemekkel rendelkező sztringek is.

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

Megjegyzések

A ParseExact(String, String, IFormatProvider) metódus elemzi egy dátum sztringképét, amelynek a paraméter által format meghatározott formátumban kell lennie. Azt is megköveteli, hogy a <dátum és idő sztringjének Dátum>, <Idő> és <Eltolás> elemei a megadott formatsorrendben jelenjenek meg. Ha a sztring input nem felel meg ennek a format paraméternek, a metódus egy FormatException. Ezzel szemben a DateTimeOffset.Parse(String, IFormatProvider) metódus a dátum sztring-ábrázolását elemzi a formátumszolgáltató objektuma által felismert formátumok bármelyikében DateTimeFormatInfo . Parse lehetővé teszi a <dátumok és időpontok sztringképének Dátum>, <Idő> és <Eltolás> elemeinek bármilyen sorrendben való megjelenítését.

A format paraméter egy sztring, amely egyetlen szabványos formátumkijelölőt vagy egy vagy több egyéni formátumjelölőt tartalmaz, amelyek meghatározzák a input paraméter szükséges formátumát. Az érvényes formázási kódokról további információt a Standard dátum- és időformátum sztringjei , valamint az egyéni dátum- és időformátum-sztringek című témakörben talál. Ha format az zeltolást jelző , zzvagy zzz egyéni formátumjelölőket is tartalmaz, akkor az eltolásnak inputnegatív vagy pozitív előjelet kell tartalmaznia. Ha a jel hiányzik, a metódus egy FormatException.

A megadott dátum- és időszimbólumokat és sztringeket input a formatProvider paraméter határozza meg, ahogyan az is, hogy input egy szabványos formátumkijelölő sztring pontos formátuma-eformat. A formatProvider paraméter a következők egyike lehet:

Egy CultureInfo olyan objektum, amely az értelmezett kultúra alapján input jeleníti meg a kultúrát. A DateTimeFormatInfo tulajdonsága által DateTimeFormat visszaadott objektum határozza meg a szimbólumokat és a formázást a következőben input: .
A DateTimeFormatInfo dátum- és időadatok formátumát meghatározó objektum.

Ha formatprovider igen null, akkor a rendszer az CultureInfo aktuális kultúrának megfelelő objektumot használja.

Megjegyzések a hívókhoz

Lásd még

A következőre érvényes:

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

A megadott formátum, kultúraspecifikus formátumadatok és stílus használatával egy dátumot és időt DateTimeOffset ábrázoló karaktersávot alakít át annak megfelelővé. A dátum- és időábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.

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

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

Paraméterek

input: ReadOnlySpan<Char>

Dátumot és időt jelképező karakterfedés.

format: ReadOnlySpan<Char>

Karaktertartomány, amely egy formátumjelölőt tartalmaz, amely meghatározza a várt formátumot input.

formatProvider: IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz a fájlról input.

styles: DateTimeStyles

Az enumerálási értékek bitenkénti kombinációja, amely a megengedett formátumot inputjelzi.

Válaszok

DateTimeOffset

Olyan objektum, amely megegyezik a paraméterben input található dátummal és idővel a , formatés formatProvider paraméterek által stylesmegadott módon.

Kivételek

ArgumentException

Az eltolás nagyobb, mint 14 óra vagy kevesebb, mint -14 óra. -vagy- A styles paraméter nem támogatott értéket tartalmaz. -vagy- A styles paraméter olyan értékeket tartalmaz DateTimeStyles , amelyek nem használhatók együtt.

FormatException

input üres karakter. -or- input nem tartalmaz érvényes sztringet dátum és idő ábrázolásaként. -vagy- format egy üres karakter. -vagy- Az óra összetevő és az AM/PM tervező input nem ért egyet.

Megjegyzések

Ez a metódus egy dátumot jelképező karaktertartományt elemez, amelynek a format paraméter által meghatározott formátumban kell lennie. Azt is megköveteli, hogy a <dátum és idő sztringjének Dátum>, <Idő> és <Eltolás> elemei a megadott formatsorrendben jelenjenek meg. Ha input nem egyezik a format mintával, a metódus egy FormatException. Ezzel szemben a DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) metódus a dátum sztring-ábrázolását elemzi a formátumszolgáltató objektuma által felismert formátumok bármelyikében DateTimeFormatInfo . Parse lehetővé teszi a <dátumok és időpontok sztringképének Dátum>, <Idő> és <Eltolás> elemeinek bármilyen sorrendben való megjelenítését.

A format paraméter egy karaktertartomány, amely egy karakterből álló szabványos formátumkijelölőt vagy egy vagy több egyéni formátumjelölőt tartalmaz, amelyek meghatározzák a input paraméter szükséges formátumát. Az érvényes formázási kódokról további információt a Standard dátum- és időformátum sztringjei , valamint az egyéni dátum- és időformátum-sztringek című témakörben talál. Ha format az zeltolást jelző , zzvagy zzz egyéni formátumjelölőket is tartalmaz, akkor az eltolásnak inputnegatív vagy pozitív előjelet kell tartalmaznia. Ha a jel hiányzik, a metódus egy FormatException.

A megadott dátum- és időszimbólumokat és sztringeket input a formatProvider paraméter határozza meg, ahogyan az is, hogy input a szabványos formátumjelölő pontos formátuma-eformat. A formatProvider paraméter a következők egyike lehet:

Egy CultureInfo olyan objektum, amely az értelmezett kultúra alapján input jeleníti meg a kultúrát. A DateTimeFormatInfo tulajdonsága által DateTimeFormat visszaadott objektum határozza meg a szimbólumokat és a formázást a következőben input: .
A DateTimeFormatInfo dátum- és időadatok formátumát meghatározó objektum.

Ha formatprovider igen null, akkor a rendszer az CultureInfo aktuális kultúrának megfelelő objektumot használja.

A következőre érvényes:

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

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Forrás:: DateTimeOffset.cs

Egy dátum és idő sztring-ábrázolását tartalmazó karaktersávot a megadott formátumok, kultúraspecifikus formátumadatok és stílus használatával konvertálja DateTimeOffset annak megfelelővé. A dátum- és időábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok egyikével.

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

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

Paraméterek

input: ReadOnlySpan<Char>

Egy olyan karaktertartomány, amely dátumot és időt tartalmaz az átalakításhoz.

formats: String[]

Formátumjelölők tömbje, amelyek a várt formátumokat inputhatározzák meg.

formatProvider: IFormatProvider

Egy objektum, amely a kultúraspecifikus formázási inputinformációkat tartalmazza.

styles: DateTimeStyles

Az enumerálási értékek bitenkénti kombinációja, amely a megengedett formátumot inputjelzi.

Válaszok

DateTimeOffset

Olyan objektum, amely megegyezik a paraméterben input található dátummal és idővel a , formatsés formatProvider paraméterek által stylesmegadott módon.

Kivételek

ArgumentException

Az eltolás nagyobb, mint 14 óra vagy kevesebb, mint -14 óra. -or- styles nem támogatott értéket tartalmaz. -vagy- A styles paraméter olyan értékeket tartalmaz DateTimeStyles , amelyek nem használhatók együtt.

FormatException

input üres karakter. -or- input nem tartalmaz érvényes sztringet dátum és idő ábrázolásaként. -or- Egyetlen elem formats sem tartalmaz érvényes formátumkijelölőt. -vagy- Az óra összetevő és az AM/PM tervező input nem ért egyet.

Megjegyzések

Ez a metódus a paraméterhez hozzárendelt minták bármelyikével egyező dátumot ábrázoló karaktertartományt formats elemez. Ha input ezek közül egyik sem egyezik meg a paraméter által styles definiált változatokkal, a metódus egy FormatException. A több formázási mintával való input összehasonlításon kívül ez a túlterhelés ugyanúgy viselkedik, mint a DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) metódus.

Important

Egy CultureInfo olyan objektum, amely az értelmezett kultúra alapján input jeleníti meg a kultúrát. A DateTimeFormatInfo tulajdonság által CultureInfo.DateTimeFormat visszaadott objektum határozza meg a szimbólumokat és a formázást a következőben input: .
A DateTimeFormatInfo dátum- és időadatok formátumát meghatározó objektum.

Ha formatprovider igen null, akkor a rendszer az CultureInfo aktuális kultúrának megfelelő objektumot használja.

`DateTimeStyles` tag	Magatartás
AdjustToUniversal	`input` Elemzi és szükség esetén UTC-vé alakítja át. Ez egyenértékű egy sztring elemzésével, majd a DateTimeOffset.ToUniversalTime visszaadott DateTimeOffset objektum metódusának meghívásával.
AssumeLocal	Ha a megfeleltetett elem `formats` nem követeli meg, hogy `input` eltolási értéket tartalmazzon, a visszaadott DateTimeOffset objektum a helyi időzóna eltolását kapja. Ez az alapértelmezett érték.
AssumeUniversal	Ha a megfeleltetett elem `formats` nem követeli meg, hogy `input` eltolásértéket tartalmazzon, a visszaadott DateTimeOffset objektum utc-eltolást (+00:00) kap.
AllowInnerWhite	Lehetővé teszi `input` a nem megadott belső térköz hozzáadását `format`. A dátum- és időösszetevők és az egyes összetevők között (az eltolás kivételével) további üres terület jelenhet meg, és a sztring elemzésekor figyelmen kívül hagyja.
AllowLeadingWhite	Lehetővé teszi `input` a nem megadott kezdő szóközök hozzáadását `formats`. Ezek figyelmen kívül lesznek hagyva a sztring elemzésekor.
AllowTrailingWhite	Lehetővé teszi `input` a nem megadott záró szóközök hozzáadását `formats`. Ezek figyelmen kívül lesznek hagyva a sztring elemzésekor.
AllowWhiteSpaces	Lehetővé teszi `input` a bevezető, záró és belső szóközök hozzáadását `formats`. A sztring elemzésekor a rendszer figyelmen kívül hagyja az összes olyan szóköz karaktert, amely nincs megadva a megfeleltetett elemben `formats` .
None	Azt jelzi, hogy a további szabad terület nem engedélyezett.`input` A szóköznek pontosan az egyezés adott elemében megadott módon kell megjelennie `formats` . Ez az alapértelmezett viselkedés.
RoundtripKind	Nincs hatása, mert a DateTimeOffset struktúra nem tartalmaz tulajdonságot `Kind` .

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?