DateTimeOffset.TryParseExact Yöntem

Başvuru

Tanım

Ad Alanı:: System

Bütünleştirilmiş Kod:: System.Runtime.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Bir tarih ve saatin belirtilen dize gösterimini DateTimeOffset eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.

Aşırı Yüklemeler

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	Belirtilen biçim dizisini, kültüre özgü biçim bilgilerini ve stili kullanarak tarih ve saatin belirtilen dize gösterimini DateTimeOffset eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)	Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stili kullanarak bir karakter aralığındaki tarih ve saatin gösterimini DateTimeOffset eşdeğerine dönüştürür. Tarih ve saat gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	Belirtilen biçimleri, kültüre özgü biçim bilgilerini ve stili kullanarak bir karakter aralığındaki tarih ve saatin gösterimini DateTimeOffset eşdeğerine dönüştürür. Tarih ve saat gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)	Belirtilen biçim, kültüre özgü biçim bilgileri ve stil kullanarak tarih ve saatin belirtilen dize gösterimini DateTimeOffset eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.

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

Kaynak:: DateTimeOffset.cs

Kaynak:: DateTimeOffset.cs

Kaynak:: DateTimeOffset.cs

Belirtilen biçim dizisini, kültüre özgü biçim bilgilerini ve stili kullanarak tarih ve saatin belirtilen dize gösterimini DateTimeOffset eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.

public:
 static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

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

Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parametreler

input: String

Dönüştürülecek tarih ve saati içeren dize.

formats: String[]

beklenen inputbiçimlerini tanımlayan bir dizi.

formatProvider: IFormatProvider

inputhakkında kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

styles: DateTimeStyles

İzin verilen giriş biçimini gösteren sabit listesi değerlerinin bit düzeyinde birleşimi. Belirtilmesi gereken tipik bir değer None.

result: DateTimeOffset

Yöntem döndürdüğünde, dönüştürme başarılı olduysa tarih ve saatine eşdeğer veya dönüştürme başarısız olduysa DateTimeOffset.MinValueiçerir. input geçerli bir tarih ve saat dize gösterimi içermiyorsa veya formatstarafından tanımlanan beklenen biçimde tarih ve saat içermiyorsa veya formatsnullise dönüştürme başarısız olur. Bu parametre başlatılmamış olarak geçirilir.

Döndürülenler

Boolean

input parametresinin başarıyla dönüştürüldüğünü true; aksi takdirde, false.

Özel durumlar

ArgumentException

styles tanımlanmamış bir DateTimeStyles değeri içerir.

-veya-

NoCurrentDateDefault desteklenmez.

-veya-

styles birbirini dışlayan DateTimeStyles değerleri içerir.

Örnekler

Aşağıdaki örnek, tarih ve saat ile uzaklık değerinin dize gösterimi için birden çok giriş biçimi tanımlar ve ardından kullanıcı tarafından girilen dizeyi TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) yöntemine geçirir.

TextReader conIn = Console.In;
TextWriter conOut = Console.Out;
int tries = 0;
string input = String.Empty;

string[] formats = new string[] {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz",
                                 "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz",
                                 "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz",
                                 "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz",
                                 "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz",
                                 "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz",
                                 "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz",
                                 "M/d/yy H:m zzz", "MM/d/yy H:m zzz",
                                 "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz",
                                 "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz",
                                 "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz",
                                 "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz",
                                 "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz",
                                 "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz",
                                 "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz",
                                 "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"};
IFormatProvider provider = CultureInfo.InvariantCulture.DateTimeFormat;
DateTimeOffset result;

do {
   conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),");
   conOut.Write("Then press Enter: ");
   input = conIn.ReadLine();
   conOut.WriteLine();
   if (DateTimeOffset.TryParseExact(input, formats, provider,
                                   DateTimeStyles.AllowWhiteSpaces,
                                   out result))
   {
      break;
   }
   else
   {
      Console.WriteLine("Unable to parse {0}.", input);
      tries++;
   }
} while (tries < 3);
if (tries >= 3)
   Console.WriteLine("Exiting application without parsing {0}", input);
else
   Console.WriteLine("{0} was converted to {1}", input, result.ToString());
// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

let mutable result = None    
let mutable tries = 0
let mutable input = ""

let formats = 
    [| "M/dd/yyyy HH:m zzz"; "MM/dd/yyyy HH:m zzz"
       "M/d/yyyy HH:m zzz"; "MM/d/yyyy HH:m zzz"
       "M/dd/yy HH:m zzz"; "MM/dd/yy HH:m zzz"
       "M/d/yy HH:m zzz"; "MM/d/yy HH:m zzz"
       "M/dd/yyyy H:m zzz"; "MM/dd/yyyy H:m zzz"
       "M/d/yyyy H:m zzz"; "MM/d/yyyy H:m zzz"
       "M/dd/yy H:m zzz"; "MM/dd/yy H:m zzz"
       "M/d/yy H:m zzz"; "MM/d/yy H:m zzz"
       "M/dd/yyyy HH:mm zzz"; "MM/dd/yyyy HH:mm zzz"
       "M/d/yyyy HH:mm zzz"; "MM/d/yyyy HH:mm zzz"
       "M/dd/yy HH:mm zzz"; "MM/dd/yy HH:mm zzz"
       "M/d/yy HH:mm zzz"; "MM/d/yy HH:mm zzz"
       "M/dd/yyyy H:mm zzz"; "MM/dd/yyyy H:mm zzz"
       "M/d/yyyy H:mm zzz"; "MM/d/yyyy H:mm zzz"
       "M/dd/yy H:mm zzz"; "MM/dd/yy H:mm zzz"
       "M/d/yy H:mm zzz"; "MM/d/yy H:mm zzz" |]
let provider = CultureInfo.InvariantCulture.DateTimeFormat

while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    input <- stdin.ReadLine()
    printfn ""
    match DateTimeOffset.TryParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) with
    | true, dto ->
        result <- Some dto
    | _ ->
        printfn $"Unable to parse {input}."
    tries <- tries + 1

match result with
| Some result ->
    printfn $"{input} was converted to {result}"
| None ->
    printfn $"Exiting application without parsing {input}"

// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

 Dim conIn As TextReader = Console.In
 Dim conOut As TextWriter = Console.Out
 Dim tries As Integer = 0
 Dim input As String = String.Empty
 Dim formats() As String = {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz", _
                            "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz", _
                            "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz", _
                            "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz", _                                 
                            "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz", _
                            "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz", _
                            "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz", _
                            "M/d/yy H:m zzz", "MM/d/yy H:m zzz", _                               
                            "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz", _
                            "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz", _
                            "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz", _
                            "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz", _                                 
                            "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz", _
                            "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz", _
                            "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz", _
                            "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"}   
 Dim provider As IFormatProvider = CultureInfo.InvariantCulture.DateTimeFormat
 Dim result As DateTimeOffset

 Do 
    conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),")
    conOut.Write("Then press Enter: ")
    input = conIn.ReadLine()
    conOut.WriteLine() 
    If DateTimeOffset.TryParseExact(input, formats, provider, _
                                    DateTimeStyles.AllowWhiteSpaces, _
                                    result) Then
       Exit Do
    Else
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End If
 Loop While tries < 3
 If tries >= 3 Then
    Console.WriteLine("Exiting application without parsing {0}", input)
 Else
    Console.WriteLine("{0} was converted to {1}", input, result.ToString())                                                     
 End If 
 ' Some successful sample interactions with the user might appear as follows:
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/08/2007 6:54 -6:00
 '    
 '    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00         
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/8/2007 06:54 -06:00
 '    
 '    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/5/07 6:54 -6:00
 '    
 '    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

Açıklamalar

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) yöntemi, formats dizisine atanan desenlerden herhangi biriyle eşleşen bir tarihin dize gösterimini ayrıştırır. input dizesi bu desenlerden herhangi biriyle styles parametresi tarafından tanımlanan varyasyonlarla eşleşmiyorsa, ayrıştırma işlemi başarısız olur ve yöntemi falsedöndürür. input biçim tanımlayıcıları içeren birden çok dizeyle karşılaştırmanın yanı sıra, bu aşırı yükleme DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) yöntemiyle aynı şekilde davranır.

formats parametresi, öğeleri tek bir standart biçim tanımlayıcısı veya olası inputdesenini tanımlayan bir veya daha fazla özel biçim tanımlayıcısı içeren bir dize dizisidir. Geçerli biçimlendirme kodları hakkında ayrıntılı bilgi için bkz. Standart Tarih ve Saat Biçim Dizeleri ve Özel Tarih ve Saat Biçim Dizeleri. formats'daki eşleşen öğe z, zzveya zzz özel biçim tanımlayıcıları içeriyorsa, inputiçinde bir uzaklık bulunması gerektiğini belirtmek için bu uzaklık negatif veya pozitif bir işaret içermelidir. İşaret eksikse ayrıştırma işlemi başarısız olur ve yöntemi falsedöndürür.

Önemli

Birden çok biçim belirtmek için bu aşırı yüklemenin formats parametresini kullanmak, birçok kullanıcının tarih ve saat girerken yaşadığı sıkıntıyı azaltmaya yardımcı olabilir. Özellikle birden çok giriş deseni tanımlama özelliği, bir uygulamanın ay, gün, saat, dakika ve saniye cinsinden baştaki sıfırları içerebilen veya eksik olan tarih ve saat gösterimlerini işlemesini sağlar. Örnek, bunun bir çizimini sağlar.

formats'daki eşleşen öğe, input bir tarih içermesini gerektiriyorsa ancak saat içermiyorsa, sonuçta elde edilen DateTimeOffset nesnesine gece yarısı (0:00:00) saati atanır. formats'daki eşleşen öğe girişin bir saat içermesini gerektiriyorsa ancak tarih içermiyorsa, sonuçta elde edilen DateTimeOffset nesnesine yerel sistemde geçerli tarih atanır. formats'daki eşleşen öğe, input bir uzaklık içermesini gerektirmiyorsa, sonuçta elde edilen DateTimeOffset nesnesinin uzaklığı styles parametresinin değerine bağlıdır. styles AssumeLocaliçeriyorsa, yerel saat diliminin uzaklığı DateTimeOffset nesnesine atanır. styles AssumeUniversaliçeriyorsa, DateTimeOffset nesnesine Eşgüdümlü Evrensel Saat (UTC) uzaklığı veya +00:00 atanır. Hiçbir değer belirtilmezse, yerel saat diliminin uzaklığı kullanılır.

input kullanılan belirli tarih ve saat simgeleri ve dizeleri formatProvider parametresi tarafından tanımlanır. aynı, formats eşleşen öğesi standart biçim tanımlayıcı dizesiyse input kesin deseni için de geçerlidir. formatProvider parametresi aşağıdakilerden biri olabilir:

input yorumlandığı kültürü temsil eden CultureInfo nesnesi. CultureInfo.DateTimeFormat özelliği tarafından döndürülen DateTimeFormatInfo nesnesi, inputiçindeki simgeleri ve biçimlendirmeyi tanımlar.
Tarih ve saat verilerinin biçimini tanımlayan DateTimeFormatInfo nesnesi.

formatprovider nullise, geçerli kültüre karşılık gelen CultureInfo nesnesi kullanılır.

styles parametresi giriş dizesinde boşluklara izin verilip verilmeyeceğini tanımlar, açık uzaklık bileşeni olmayan dizelerin nasıl ayrıştırılıp ayrıştırılmadığını gösterir ve ayrıştırma işleminin bir parçası olarak UTC dönüştürmeyi destekler. DateTimeStyles numaralandırmasının NoCurrentDateDefaultdışındaki tüm üyeleri desteklenir. Aşağıdaki tabloda desteklenen her üyenin etkisi listelenmektedir.

`DateTimeStyles` üye	Davranış
AdjustToUniversal	`input` ayrıştırıp gerekirse UTC'ye dönüştürür. Bir dizeyi ayrıştırma ve sonra döndürülen DateTimeOffset nesnesinin DateTimeOffset.ToUniversalTime yöntemini çağırmaya eşdeğerdir.
AssumeLocal	`formats`'daki eşleşen öğe, `input` bir uzaklık değeri içermesini gerektirmiyorsa, döndürülen DateTimeOffset nesnesine yerel saat diliminin uzaklığı verilir. Bu varsayılan değerdir.
AssumeUniversal	`formats`'daki eşleşen öğe, `input` bir uzaklık değeri içermesini gerektirmiyorsa, döndürülen DateTimeOffset nesnesine UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	`input` `formats`öğeleri tarafından belirtilmeyen iç boşluklar eklemesine izin verir. Tarih ve saat bileşenleri arasında ve tek tek bileşenlerde (uzaklık hariç) fazladan boşluk görünebilir ve dize ayrıştırılırken yoksayılır.
AllowLeadingWhite	`input` `formats`öğeleri tarafından belirtilmeyen baştaki boşlukları eklemesine izin verir. Dize ayrıştırılırken bunlar yoksayılır.
AllowTrailingWhite	`input` `formats`öğeleri tarafından belirtilmeyen sondaki boşlukları eklemesine izin verir. Dize ayrıştırılırken bunlar yoksayılır.
AllowWhiteSpaces	`input` `formats`öğeleri tarafından belirtilmeyen baştaki, sondaki ve iç boşlukları içermesine izin verir. `formats` eşleşen öğesinde belirtilmeyen tüm fazladan boşluk karakterleri, dize ayrıştırılırken yoksayılır.
None	`input`içinde ek boşluklara izin verilmediğini gösterir. Başarılı bir eşleşmenin gerçekleşmesi için boşluk `formats`'daki belirli bir öğede tam olarak belirtildiği gibi görünmelidir. Bu, varsayılan davranıştır.
RoundtripKind	DateTimeOffset yapısı bir `Kind` özelliği içermediğinden hiçbir etkisi yoktur.

Arayanlara Notlar

.NET Framework 4'te, ayrıştırılacak dizenin bir saat bileşeni ve sözleşmede olmayan bir/PM belirleyicisi içermesi durumunda TryParseExactfalse döndürür. .NET Framework 3.5 ve önceki sürümlerinde/PM belirleyicisi yoksayılır.

Şunlara uygulanır

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

Kaynak:: DateTimeOffset.cs

Kaynak:: DateTimeOffset.cs

Kaynak:: DateTimeOffset.cs

Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stili kullanarak bir karakter aralığındaki tarih ve saatin gösterimini DateTimeOffset eşdeğerine dönüştürür. Tarih ve saat gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

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

Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parametreler

input: ReadOnlySpan<Char>

Dönüştürülecek tarih ve saati temsil eden karakterleri içeren bir yayılma alanı.

format: ReadOnlySpan<Char>

gerekli inputbiçimini tanımlayan biçim tanımlayıcısı.

formatProvider: IFormatProvider

inputhakkında kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

styles: DateTimeStyles

inputizin verilen biçimini gösteren sabit listesi değerlerinin bit düzeyinde birleşimi. Belirtilmesi gereken tipik bir değer None.

result: DateTimeOffset

Yöntem döndürdüğünde, dönüştürme başarılı olduysa tarih ve saatine eşdeğer veya dönüştürme başarısız olursa DateTimeOffset.MinValue içerir. Dönüştürme başarısız oluyorsa,

Döndürülenler

Boolean

input parametresinin başarıyla dönüştürüldüğünü true; aksi takdirde, false.

Özel durumlar

ArgumentException

styles tanımlanmamış bir DateTimeStyles değeri içerir. -veya- NoCurrentDateDefault desteklenmez. -veya- styles birbirini dışlayan DateTimeStyles değerleri içerir.

Açıklamalar

Bu aşırı yükleme, DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) yöntemine benzer, ancak dönüştürme başarısız olursa bu yöntem bir özel durum oluşturmaz. format parametresi tarafından belirtilen desenle tam olarak eşleşmesi gereken bir tarih ve saatin gösterimini ayrıştırır. input bu desenle eşleşmiyorsa, styles parametresi tarafından tanımlanan boşluktaki bazı olası varyasyonlarla ayrıştırma işlemi başarısız olur ve yöntemi falsedöndürür.

format parametresi, tek bir standart biçim tanımlayıcısı veya gerekli inputdesenini tanımlayan bir veya daha fazla özel biçim tanımlayıcısı içeren bir karakter aralığıdır. Geçerli biçimlendirme kodları hakkında ayrıntılı bilgi için bkz. Standart Tarih ve Saat Biçim Dizeleri ve Özel Tarih ve Saat Biçim Dizeleri. format z, zzveya inputiçinde bir uzaklık bulunması gerektiğini belirtmek için özel biçim tanımlayıcıları zzz, bu uzaklık negatif işareti veya pozitif işareti içermelidir. İşaret eksikse ayrıştırma işlemi başarısız olur ve yöntemi falsedöndürür.

format input bir tarih içermesini gerektiriyorsa ancak saat içermiyorsa, sonuçta elde edilen DateTimeOffset nesnesine gece yarısı (0:00:00) saati atanır. format input bir saat içermesini gerektiriyorsa ancak tarih içermiyorsa, sonuçta elde edilen DateTimeOffset nesnesine yerel sistemde geçerli tarih atanır. format, input bir uzaklık içermesini gerektirmiyorsa, sonuçta elde edilen DateTimeOffset nesnesinin uzaklığı styles parametresinin değerine bağlıdır. styles AssumeLocaliçeriyorsa, yerel saat diliminin uzaklığı DateTimeOffset nesnesine atanır. styles AssumeUniversaliçeriyorsa, DateTimeOffset nesnesine Eşgüdümlü Evrensel Saat (UTC) uzaklığı veya +00:00 atanır. Hiçbir değer belirtilmezse, yerel saat diliminin uzaklığı kullanılır.

input kullanılan belirli tarih ve saat simgeleri ve dizeleri formatProvider parametresi tarafından tanımlanır. format standart biçim tanımlayıcı dizesiyse, input kesin deseni için de aynı durum geçerlidir. formatProvider parametresi aşağıdakilerden biri olabilir:

input yorumlandığı kültürü temsil eden CultureInfo nesnesi. CultureInfo.DateTimeFormat özelliği tarafından döndürülen DateTimeFormatInfo nesnesi, input'de izin verilen simgeleri ve standart biçimleri tanımlar.
Tarih ve saat verilerinin biçimini tanımlayan DateTimeFormatInfo nesnesi.

formatprovider nullise, geçerli kültüre karşılık gelen CultureInfo nesnesi kullanılır.

styles parametresi giriş dizesinde boş alana izin verilip verilmeyeceğini tanımlar, açık uzaklık bileşeni olmayan dizelerin nasıl ayrıştırılıp ayrıştırılmadığını gösterir ve ayrıştırma işleminin bir parçası olarak UTC dönüştürmeyi destekler. DateTimeStyles numaralandırmasının NoCurrentDateDefaultdışındaki tüm üyeleri desteklenir. Aşağıdaki tabloda desteklenen her üyenin etkisi listelenmektedir.

`DateTimeStyles` üye	Davranış
AdjustToUniversal	`input` ayrıştırıp gerekirse UTC'ye dönüştürür. Bir tarih ve saat gösterimini ayrıştırmak ve sonra döndürülen DateTimeOffset nesnesinin DateTimeOffset.ToUniversalTime yöntemini çağırmaya eşdeğerdir.
AssumeLocal	`format`, `input` bir uzaklık değeri içermesini gerektirmiyorsa, döndürülen DateTimeOffset nesnesine yerel saat diliminin uzaklığı verilir. Bu, varsayılan davranıştır.
AssumeUniversal	`format`, `input` bir uzaklık değeri içermesini gerektirmiyorsa, döndürülen DateTimeOffset nesnesine UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	`input` biçime göre belirtilmeyen iç boşluk eklemesine izin verir. Tarih ve saat bileşenleri arasında ve uzaklık dışında tek tek bileşenlerde fazladan boşluk görünebilir ve dize ayrıştırılırken yoksayılır.
AllowLeadingWhite	`input` `format`tarafından belirtilmeyen baştaki boşlukları eklemesine izin verir. Dize ayrıştırılırken bunlar yoksayılır.
AllowTrailingWhite	`input` `format`tarafından belirtilmeyen sondaki boşlukları eklemesine izin verir. Dize ayrıştırılırken bunlar yoksayılır.
AllowWhiteSpaces	`input` `format`tarafından belirtilmeyen baştaki, sondaki ve iç boşlukları içermesine izin verir. dize ayrıştırılırken `format` içinde belirtilmeyen tüm fazladan boşluk karakterleri yoksayılır.
None	`input`içinde ek boşluklara izin verilmediğini gösterir. Boşluk, `format`içinde tam olarak belirtildiği gibi görünmelidir. Bu, varsayılan davranıştır.
RoundtripKind	DateTimeOffset yapısı bir `Kind` özelliği içermediğinden hiçbir etkisi yoktur.

Şunlara uygulanır

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

Kaynak:: DateTimeOffset.cs

Kaynak:: DateTimeOffset.cs

Kaynak:: DateTimeOffset.cs

Belirtilen biçimleri, kültüre özgü biçim bilgilerini ve stili kullanarak bir karakter aralığındaki tarih ve saatin gösterimini DateTimeOffset eşdeğerine dönüştürür. Tarih ve saat gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

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

Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parametreler

input: ReadOnlySpan<Char>

Dönüştürülecek tarih ve saati temsil eden karakterleri içeren bir yayılma alanı.

formats: String[]

inputkabul edilebilir biçimlerini tanımlayan standart veya özel biçim dizeleri dizisi.

formatProvider: IFormatProvider

inputhakkında kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

styles: DateTimeStyles

inputizin verilen biçimini gösteren sabit listesi değerlerinin bit düzeyinde birleşimi. Belirtilmesi gereken tipik bir değer None.

result: DateTimeOffset

Döndürülenler

Boolean

input parametresinin başarıyla dönüştürüldüğünü true; aksi takdirde, false.

Özel durumlar

ArgumentException

styles tanımlanmamış bir DateTimeStyles değeri içerir. -veya- NoCurrentDateDefault desteklenmez. -veya- styles birbirini dışlayan DateTimeStyles değerleri içerir.

Açıklamalar

Bu yöntem, formats dizisine atanan desenlerden herhangi biriyle eşleşen bir tarihin dize gösterimini ayrıştırır. input bu desenlerden herhangi biriyle styles parametresi tarafından tanımlanan varyasyonlarla eşleşmiyorsa ayrıştırma işlemi başarısız olur ve yöntemi falsedöndürür. input biçim tanımlayıcıları içeren birden çok dizeyle karşılaştırmanın yanı sıra, bu aşırı yükleme DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) yöntemiyle aynı şekilde davranır.

Önemli

formats'daki eşleşen öğe, input bir tarih içermesini gerektiriyorsa ancak saat içermiyorsa, sonuçta elde edilen DateTimeOffset nesnesine gece yarısı (0:00:00) saati atanır. formats'daki eşleşen öğe girişin bir saat içermesini gerektiriyorsa ancak tarih içermiyorsa, sonuçta elde edilen DateTimeOffset nesnesine yerel sistemde geçerli tarih atanır. formats'daki eşleşen öğe, input bir uzaklık içermesini gerektirmiyorsa, sonuçta elde edilen DateTimeOffset nesnesinin uzaklığı styles parametresinin değerine bağlıdır. styles DateTimeStyles.AssumeLocaliçeriyorsa, yerel saat diliminin uzaklığı DateTimeOffset nesnesine atanır. styles DateTimeStyles.AssumeUniversaliçeriyorsa, DateTimeOffset nesnesine Eşgüdümlü Evrensel Saat (UTC) uzaklığı veya +00:00 atanır. Hiçbir değer belirtilmezse, yerel saat diliminin uzaklığı kullanılır.

input kullanılan belirli tarih ve saat simgeleri formatProvider parametresi tarafından tanımlanır. aynı, formats eşleşen öğesi standart biçim tanımlayıcı dizesiyse input kesin deseni için de geçerlidir. formatProvider parametresi aşağıdakilerden biri olabilir:

input yorumlandığı kültürü temsil eden CultureInfo nesnesi. CultureInfo.DateTimeFormat özelliği tarafından döndürülen DateTimeFormatInfo nesnesi, inputiçindeki simgeleri ve biçimlendirmeyi tanımlar.
Tarih ve saat verilerinin biçimini tanımlayan DateTimeFormatInfo nesnesi.

formatprovider nullise, geçerli kültüre karşılık gelen CultureInfo nesnesi kullanılır.

`DateTimeStyles` üye	Davranış
AdjustToUniversal	`input` ayrıştırıp gerekirse UTC'ye dönüştürür. Bir dizeyi ayrıştırma ve sonra döndürülen DateTimeOffset nesnesinin DateTimeOffset.ToUniversalTime yöntemini çağırmaya eşdeğerdir.
AssumeLocal	`formats`'daki eşleşen öğe, `input` bir uzaklık değeri içermesini gerektirmiyorsa, döndürülen DateTimeOffset nesnesine yerel saat diliminin uzaklığı verilir. Bu varsayılan değerdir.
AssumeUniversal	`formats`'daki eşleşen öğe, `input` bir uzaklık değeri içermesini gerektirmiyorsa, döndürülen DateTimeOffset nesnesine UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	`input` `formats`öğeleri tarafından belirtilmeyen iç boşluklar eklemesine izin verir. Tarih ve saat bileşenleri arasında ve tek tek bileşenlerde (uzaklık hariç) fazladan boşluk görünebilir ve dize ayrıştırılırken yoksayılır.
AllowLeadingWhite	`input` `formats`öğeleri tarafından belirtilmeyen baştaki boşlukları eklemesine izin verir. Dize ayrıştırılırken bunlar yoksayılır.
AllowTrailingWhite	`input` `formats`öğeleri tarafından belirtilmeyen sondaki boşlukları eklemesine izin verir. Dize ayrıştırılırken bunlar yoksayılır.
AllowWhiteSpaces	`input` `formats`öğeleri tarafından belirtilmeyen baştaki, sondaki ve iç boşlukları içermesine izin verir. `formats` eşleşen öğesinde belirtilmeyen tüm fazladan boşluk karakterleri, dize ayrıştırılırken yoksayılır.
None	`input`içinde ek boşluklara izin verilmediğini gösterir. Başarılı bir eşleşmenin gerçekleşmesi için boşluk `formats`'daki belirli bir öğede tam olarak belirtildiği gibi görünmelidir. Bu, varsayılan davranıştır.
RoundtripKind	DateTimeOffset yapısı bir `Kind` özelliği içermediğinden hiçbir etkisi yoktur.

Şunlara uygulanır

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

Kaynak:: DateTimeOffset.cs

Kaynak:: DateTimeOffset.cs

Kaynak:: DateTimeOffset.cs

Belirtilen biçim, kültüre özgü biçim bilgileri ve stil kullanarak tarih ve saatin belirtilen dize gösterimini DateTimeOffset eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.

public:
 static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

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

Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parametreler

input: String

Dönüştürülecek tarih ve saati içeren dize.

format: String

gerekli inputbiçimini tanımlayan biçim tanımlayıcısı.

formatProvider: IFormatProvider

inputhakkında kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

styles: DateTimeStyles

İzin verilen giriş biçimini gösteren sabit listesi değerlerinin bit düzeyinde birleşimi. Belirtilmesi gereken tipik bir değer None.

result: DateTimeOffset

Yöntem döndürdüğünde, dönüştürme başarılı olduysa tarih ve saatine eşdeğer veya dönüştürme başarısız olduysa DateTimeOffset.MinValueiçerir. input parametresi nullise veya format ve providertarafından tanımlanan beklenen biçimde bir tarih ve saatin geçerli dize gösterimini içermiyorsa dönüştürme başarısız olur. Bu parametre başlatılmamış olarak geçirilir.

Döndürülenler

Boolean

input parametresinin başarıyla dönüştürüldüğünü true; aksi takdirde, false.

Özel durumlar

ArgumentException

styles tanımlanmamış bir DateTimeStyles değeri içerir.

-veya-

NoCurrentDateDefault desteklenmez.

-veya-

styles birbirini dışlayan DateTimeStyles değerleri içerir.

Örnekler

Aşağıdaki örnek, birkaç tarih ve saat dizesini ayrıştırmak için standart ve özel biçim tanımlayıcıları, sabit kültür ve çeşitli DateTimeStyles değerleriyle TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) yöntemini kullanır.

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

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

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowTrailingWhite,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00";
format = "MM/dd/yyyy H:mm zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowWhiteSpaces,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00";
format = "MM/dd/yyyy H:mm:ss zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                DateTimeStyles.AllowWhiteSpaces |
                                DateTimeStyles.AdjustToUniversal,
                                out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture and assume time is UTC.
let dateString = "06/15/2008"
let format = "d"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time value, and allow all white space.
let dateString = " 06/15/   2008  15:15    -05:00"
let format = "MM/dd/yyyy H:mm zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time and convert to UTC.
let dateString = "  06/15/2008 15:15:30 -05:00"
let format = "MM/dd/yyyy H:mm:ss zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.AdjustToUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

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

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

' Parse date-only value with leading white space.
' Should return False because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowTrailingWhite, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00"
format = "MM/dd/yyyy H:mm zzz"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00"   
format = "MM/dd/yyyy H:mm:ss zzz"       
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces Or _
                                DateTimeStyles.AdjustToUniversal, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 
' The example displays the following output:
'    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
'    ' 06/15/2008' is not in the correct format.
'    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
'    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

Aşağıdaki örnek, iso 8601uyması beklenen dize dizisini ayrıştırmak için çeşitli değerleri kullanır. Örnekteki çıktıda gösterildiği gibi, uygun biçimdeki dizeler aşağıdaki durumlarda ayrıştırılamaz:

bunlar boşluk içerir ve uygun bir DateTimeStyles bayrağı (DateTimeStyles.AllowWhiteSpaces gibi yöntem çağrısında sağlanmamıştır.
bunlar, aralık dışında olan tarih ve saat öğelerini içerir.

UTC uzaklığını belirtmeyen dizelerin, yöntem çağrısında DateTimeStyles.AssumeUniversal bayrağı sağlanmadığı sürece yerel saat diliminin uzaklığını (bu örnekte Pasifik Yaz Saati diliminin uzaklığını yansıtan -07:00) olduğu varsayılır. Bu durumda, Evrensel Eşgüdümlü Zaman olduğu varsayılır.

open System
open System.Globalization

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

let dateStrings = 
    [ "2018-08-18T12:45:16.0000000Z"
      "2018/08/18T12:45:16.0000000Z"
      "2018-18-08T12:45:16.0000000Z"
      "2018-08-18T12:45:16.0000000"
      " 2018-08-18T12:45:16.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

parseWithISO8601 dateStrings DateTimeStyles.None
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AllowWhiteSpaces
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AdjustToUniversal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeLocal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeUniversal

// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = { "2018-08-18T12:45:16.0000000Z",
                               "2018/08/18T12:45:16.0000000Z",
                               "2018-18-08T12:45:16.0000000Z",
                               "2018-08-18T12:45:16.0000000",                               
                               " 2018-08-18T12:45:16.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal);   }

   private static void ParseWithISO8601(string[] dateStrings, DateTimeStyles styles)
   {   
      Console.WriteLine($"Parsing with {styles}:");
      DateTimeOffset date;
      foreach (var dateString in dateStrings)
      {
         if (DateTimeOffset.TryParseExact(dateString, "O", null, styles, out date))
         {
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         else
         {
            Console.WriteLine($"   Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateStrings() = { "2018-08-18T12:45:16.0000000Z",
                            "2018/08/18T12:45:16.0000000Z",
                            "2018-18-08T12:45:16.0000000Z",
                            "2018-08-18T12:45:16.0000000",                               
                            " 2018-08-18T12:45:16.0000000Z ",
                            "2018-08-18T12:45:16.0000000+02:00",
                            "2018-08-18T12:45:16.0000000-07:00" } 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal)   
   End Sub

   Private Sub ParseWithISO8601(dateStrings() As String, styles As DateTimeStyles)
      Console.WriteLine($"Parsing with {styles}:")
      Dim dat As DateTimeOffset
      For Each dateStr In dateStrings
         If DateTimeOffset.TryParseExact(dateStr, "O", Nothing, styles, dat) Then
            Console.WriteLine($"   {dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Else
            Console.WriteLine($"   Unable to convert '{dateStr}'")
         End If   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
'
'      -----
'
'      Parsing with AssumeLocal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AssumeUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Açıklamalar

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) yönteminin bu aşırı yüklemesi, dönüştürme başarısız olursa bu yöntemin özel durum oluşturmaması dışında DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) yöntemine benzer. format parametresi tarafından belirtilen desenle tam olarak eşleşmesi gereken bir tarih ve saatin dize gösterimini ayrıştırır. input dizesi bu desenle eşleşmiyorsa ve styles parametresi tarafından tanımlanan bazı olası boşluk varyasyonlarıyla, ayrıştırma işlemi başarısız olur ve yöntemi falsedöndürür.

format parametresi, gerekli inputdesenini tanımlayan tek bir standart biçim tanımlayıcısı veya bir veya daha fazla özel biçim tanımlayıcısı içeren bir dizedir. Geçerli biçimlendirme kodları hakkında ayrıntılı bilgi için bkz. Standart Tarih ve Saat Biçim Dizeleri ve Özel Tarih ve Saat Biçim Dizeleri. format z, zzveya inputiçinde bir uzaklık bulunması gerektiğini belirtmek için özel biçim tanımlayıcıları zzz, bu uzaklık negatif işareti veya pozitif işareti içermelidir. İşaret eksikse ayrıştırma işlemi başarısız olur ve yöntemi falsedöndürür.

input yorumlandığı kültürü temsil eden CultureInfo nesnesi. CultureInfo.DateTimeFormat özelliği tarafından döndürülen DateTimeFormatInfo nesnesi, input'de izin verilen simgeleri ve standart biçimleri tanımlar.
Tarih ve saat verilerinin biçimini tanımlayan DateTimeFormatInfo nesnesi.

formatprovider nullise, geçerli kültüre karşılık gelen CultureInfo nesnesi kullanılır.

`DateTimeStyles` üye	Davranış
AdjustToUniversal	`input` ayrıştırıp gerekirse UTC'ye dönüştürür. Bir dizeyi ayrıştırma ve sonra döndürülen DateTimeOffset nesnesinin DateTimeOffset.ToUniversalTime yöntemini çağırmaya eşdeğerdir.
AssumeLocal	`format`, `input` bir uzaklık değeri içermesini gerektirmiyorsa, döndürülen DateTimeOffset nesnesine yerel saat diliminin uzaklığı verilir. Bu, varsayılan davranıştır.
AssumeUniversal	`format`, `input` bir uzaklık değeri içermesini gerektirmiyorsa, döndürülen DateTimeOffset nesnesine UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	`input` biçime göre belirtilmeyen iç boşluk eklemesine izin verir. Tarih ve saat bileşenleri arasında ve uzaklık dışında tek tek bileşenlerde fazladan boşluk görünebilir ve dize ayrıştırılırken yoksayılır.
AllowLeadingWhite	`input` `format`tarafından belirtilmeyen baştaki boşlukları eklemesine izin verir. Dize ayrıştırılırken bunlar yoksayılır.
AllowTrailingWhite	`input` `format`tarafından belirtilmeyen sondaki boşlukları eklemesine izin verir. Dize ayrıştırılırken bunlar yoksayılır.
AllowWhiteSpaces	`input` `format`tarafından belirtilmeyen baştaki, sondaki ve iç boşlukları içermesine izin verir. dize ayrıştırılırken `format` içinde belirtilmeyen tüm fazladan boşluk karakterleri yoksayılır.
None	`input`içinde ek boşluklara izin verilmediğini gösterir. Boşluk, `format`içinde tam olarak belirtildiği gibi görünmelidir. Bu, varsayılan davranıştır.
RoundtripKind	DateTimeOffset yapısı bir `Kind` özelliği içermediğinden hiçbir etkisi yoktur.

Arayanlara Notlar

Ayrıca bkz.

ParseExact

Şunlara uygulanır

Aracılığıyla paylaş

DateTimeOffset.TryParseExact Yöntem

Tanım

Aşırı Yüklemeler

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

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Şunlara uygulanır

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

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Şunlara uygulanır

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

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Şunlara uygulanır

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

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

Ek kaynaklar