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 eşdeğerine DateTimeOffset 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 bir tarih ve saatin belirtilen dize gösterimini DateTimeOffset eşdeğerine dönüştürür. Dize gösteriminin biçimi belirtilen biçimlerinden 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 eşdeğerine DateTimeOffset 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 eşdeğerine DateTimeOffset 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çimi, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin belirtilen dize gösterimini eşdeğerine DateTimeOffset 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 bir tarih ve saatin belirtilen dize gösterimini DateTimeOffset eşdeğerine dönüştürür. Dize gösteriminin biçimi belirtilen biçimlerinden 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 bir tarih ve saat içeren bir dize.

formats: String[]

beklenen biçimlerini inputtanımlayan bir dizi.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

İzin verilen giriş biçimini gösteren numaralandırma değerlerinin bit düzeyinde birleşimi. Belirtilmesi gereken tipik bir değerdir None.

result: DateTimeOffset

yöntemi döndürdüğünde, dönüştürme başarılı olduysa tarih ve saat inputile eşdeğeri veya dönüştürme başarısız olduysa DateTimeOffset.MinValue değerini içerirDateTimeOffset. dönüştürme işlemi, bir tarih ve saatin geçerli bir dize gösterimini içermiyorsa input veya tarafından formattanımlanan beklenen biçimde tarih ve saati içermiyorsa veya ise formats başarısız olur null. Bu parametre, başlatmadan iletilir.

Döndürülenler

Boolean

trueinput parametresi başarıyla dönüştürülürse; aksi takdirde , false.

Özel durumlar

ArgumentException

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

-veya-

NoCurrentDateDefault Desteklenmez.

-veya-

styles birbirini dışlayan DateTimeStyles değerler 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 yöntemine TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) 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

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

formats parametresi, öğeleri tek bir standart biçim tanımlayıcısı veya olası desenini tanımlayan bir veya daha fazla özel biçim tanımlayıcısı içeren bir dize dizisidirinput. 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. içindeki formats eşleşen öğe, içinde bir uzaklık bulunması gerektiğini inputbelirtmek için , zzveya zzz özel biçim tanımlayıcıları içeriyorsaz, 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 döndürür false.

Önemli

formats Birden çok biçim belirtmek için bu aşırı yüklemenin 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. Örnekte bunun bir çizimi verilmiştir.

içindeki formatsinput eşleşen öğe tarih gerektiriyorsa ancak saat içermiyorsa, sonuçta elde DateTimeOffset edilen nesneye gece yarısı (0:00:00) saati atanır. içindeki formats eşleşen öğe girişin bir saat içermesini gerektiriyorsa ancak tarih içermiyorsa, sonuçta elde edilen DateTimeOffset nesneye yerel sistemde geçerli tarih atanır. içindeki formats eşleşen öğe bir uzaklık içermesini input gerektirmiyorsa, sonuçta DateTimeOffset elde edilen nesnenin uzaklığı parametrenin styles değerine bağlıdır. içeriyorsa stylesAssumeLocal, nesneye yerel saat diliminin DateTimeOffset uzaklığı atanır. içeriyorsa stylesAssumeUniversal, eşgüdümlü Evrensel Saat (UTC) uzaklığı veya +00:00 nesnesine DateTimeOffset atanır. Hiçbir değer belirtilmemişse, yerel saat dilimi uzaklığı kullanılır.

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

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

ise formatprovidernull, CultureInfo geçerli kültüre karşılık gelen nesne 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. numaralandırmasının DateTimeStyles NoCurrentDateDefaultdışındaki tüm üyeleri desteklenir. Aşağıdaki tabloda, desteklenen her üyenin etkisi listelenmektedir.

`DateTimeStyles` Üye	Davranış
AdjustToUniversal	ayrıştırıp `input` gerekirse UTC'ye dönüştürür. Bir dizeyi ayrıştırmak ve sonra döndürülen DateTimeOffset nesnenin DateTimeOffset.ToUniversalTime yöntemini çağırmakla eşdeğerdir.
AssumeLocal	içindeki `formats` eşleşen öğe bir uzaklık değeri içermesini `input` gerektirmiyorsa, döndürülen DateTimeOffset nesneye yerel saat diliminin uzaklığı verilir. Varsayılan değer budur.
AssumeUniversal	içindeki `formatsinput` eşleşen öğe bir uzaklık değeri içermiyorsa, döndürülen DateTimeOffset nesneye UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	içindeki `formats`öğeler tarafından belirtilmeyen iç boşluk eklenmesine izin verir`input`. 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	içindeki `formats`öğeler tarafından belirtilmeyen baştaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowTrailingWhite	içindeki `formats`öğeler tarafından belirtilmeyen sondaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowWhiteSpaces	içindeki öğeler `formats`tarafından belirtilmeyen baştaki, sondaki ve iç boşlukların eklenmesine izin verir`input`. dize ayrıştırılırken içindeki eşleşen öğede `formats` belirtilmeyen tüm fazladan boşluk karakterleri yoksayılır.
None	içinde `input`ek boşluklara izin verilmediğini gösterir. Başarılı bir eşleşmenin gerçekleşmesi için içinde belirli bir öğede `formats` belirtilen boşluk tam olarak görünmelidir. Bu varsayılan davranıştır.
RoundtripKind	Yapı bir `Kind` özellik içermediğinden etkisi yokturDateTimeOffset.

Arayanlara Notlar

.NET Framework 4'te, TryParseExact ayrıştırılacak dizenin bir saat bileşeni ve uyuşmayan bir AM/PM belirteci içerip içermediğini döndürürfalse. .NET Framework 3.5 ve önceki sürümlerde AM/PM göstergesi 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 eşdeğerine DateTimeOffset 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 biçimini tanımlayan bir biçim tanımlayıcısı input.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

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

result: DateTimeOffset

Yöntem döndürdüğünde, dönüştürme başarılı olursa tarih ve saat inputile eşdeğeri, dönüştürme başarısız olursa DateTimeOffset.MinValue değerini içerirDateTimeOffset. Dönüştürme işlemi şu durumlarda başarısız olur:

Döndürülenler

Boolean

trueinput parametresi başarıyla dönüştürülürse; aksi takdirde , false.

Özel durumlar

ArgumentException

styles tanımlanmamış DateTimeStyles bir değer içerir. -or- NoCurrentDateDefault desteklenmez. -or- styles birbirini dışlayan DateTimeStyles değerler içerir.

Açıklamalar

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

format parametresi, tek bir standart biçim tanımlayıcısı veya gerekli desenini tanımlayan bir veya daha fazla özel biçim belirticisi içeren bir karakter aralığıdırinput. 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 içinde bir uzaklık bulunması inputgerektiğini belirtmek için , zzveya zzz özel biçim tanımlayıcıları içeriyorsaz, 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 döndürür false.

Tarih format içeren ancak saat içermeyen bir değer gerekiyorsa input , sonuçta elde edilen DateTimeOffset nesneye gece yarısı (0:00:00) saati atanır. Tarih içermeyen bir saat gerektiriyorsa formatinput , sonuçta elde DateTimeOffset edilen nesneye yerel sistemde geçerli tarih atanır. Bunun bir uzaklık içermesi gerekli değilseformat, sonuçta elde DateTimeOffset edilen nesnenin uzaklığı parametrenin styles değerine input bağlıdır. içeriyorsa stylesAssumeLocal, nesneye yerel saat diliminin DateTimeOffset uzaklığı atanır. içeriyorsa stylesAssumeUniversal, eşgüdümlü Evrensel Saat (UTC) uzaklığı veya +00:00 nesnesine DateTimeOffset atanır. Hiçbir değer belirtilmemişse, yerel saat dilimi uzaklığı kullanılır.

içinde kullanılan input belirli tarih ve saat simgeleri ve dizeleri parametresi tarafından formatProvider tanımlanır. Aynı durum, standart biçim belirtici dizesi ise format tam deseni input için de geçerlidir. formatProvider parametresi aşağıdakilerden biri olabilir:

CultureInfo Temel alınan kültürü temsil eden input bir nesne. DateTimeFormatInfo özelliği tarafından döndürülen nesne, CultureInfo.DateTimeFormat içinde inputizin verilen sembolleri ve standart biçimleri tanımlar.
DateTimeFormatInfo Tarih ve saat verilerinin biçimini tanımlayan nesne.

ise formatprovidernull, CultureInfo geçerli kültüre karşılık gelen nesne 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. numaralandırmasının DateTimeStyles dışındaki tüm üyeleri desteklenir NoCurrentDateDefault. Aşağıdaki tabloda, desteklenen her üyenin etkisi listelenmektedir.

`DateTimeStyles` Üye	Davranış
AdjustToUniversal	Ayrıştırıp `input` gerekirse UTC'ye dönüştürür. Bir tarih ve saat gösterimini ayrıştırma ve sonra döndürülen DateTimeOffset nesnenin DateTimeOffset.ToUniversalTime yöntemini çağırmaya eşdeğerdir.
AssumeLocal	Bunun bir uzaklık değeri içermesi `input` gerekli değilse`format`, döndürülen DateTimeOffset nesneye yerel saat diliminin uzaklığı verilir. Bu varsayılan davranıştır.
AssumeUniversal	Bunun bir uzaklık değeri içermesi `input` gerekli değilse`format`, döndürülen DateTimeOffset nesneye UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	Biçime göre belirtilmemiş iç boşluk eklenmesine izin verir `input` . Tarih ve saat bileşenleri arasında ve uzaklık dışında tek tek bileşenler içinde fazladan boşluk görünebilir ve dize ayrıştırılırken yoksayılır.
AllowLeadingWhite	tarafından `format`belirtilmeyen baştaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowTrailingWhite	tarafından `format`belirtilmeyen sondaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowWhiteSpaces	tarafından `format`belirtilmeyen baştaki, sondaki ve iç boşlukların eklenmesine izin verir`input`. dize ayrıştırılırken içinde `format` belirtilmeyen tüm fazladan boşluk karakterleri yoksayılır.
None	içinde `input`ek boşluklara izin verilmediğini gösterir. Boşluk, içinde `format`tam olarak belirtildiği gibi görünmelidir. Bu varsayılan davranıştır.
RoundtripKind	Yapı bir `Kind` özellik içermediğinden DateTimeOffset 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 eşdeğerine DateTimeOffset 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 tarihi ve saati temsil eden karakterleri içeren bir yayılma alanı.

formats: String[]

kabul edilebilir biçimlerini tanımlayan standart veya özel biçim dizeleri inputdizisi.

formatProvider: IFormatProvider

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

styles: DateTimeStyles

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

result: DateTimeOffset

Yöntem döndürdüğünde, dönüştürme başarılı olursa tarih ve saat inputile eşdeğeri veya dönüştürme başarısız olursa DateTimeOffset.MinValue değerini içerirDateTimeOffset. Dönüştürme başarısız olursa,

Döndürülenler

Boolean

trueinput parametresi başarıyla dönüştürülürse; aksi takdirde , false.

Özel durumlar

ArgumentException

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

Açıklamalar

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

formats parametresi, öğeleri tek bir standart biçim tanımlayıcısı veya olası desenini tanımlayan bir veya daha fazla özel biçim tanımlayıcısı içeren bir dize dizisidirinput. 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. içindeki eşleşen öğe içinde formats bir uzaklık bulunması gerektiğini inputbelirtmek için , zzveya zzz özel biçim tanımlayıcıları içeriyorsaz, bu uzaklık negatif bir işareti veya pozitif işareti içermelidir. İşaret eksikse ayrıştırma işlemi başarısız olur ve yöntemi döndürür false.

Önemli

formats Birden çok biçim belirtmek için bu aşırı yüklemenin parametresini kullanmak, birçok kullanıcının tarih ve saat girerken yaşadığı hayal kırıklığını 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. Örnekte bunun bir çizimi verilmiştir.

içindeki formatsinput eşleşen öğe tarih gerektiriyorsa ancak saat içermiyorsa, sonuçta elde edilen DateTimeOffset nesneye gece yarısı (0:00:00) saati atanır. içindeki formats eşleşen öğe girişin tarih değil de saat içermesini gerektiriyorsa, sonuçta elde edilen DateTimeOffset nesneye yerel sistemde geçerli tarih atanır. içindeki formats eşleşen öğe bir uzaklık içermesini input gerektirmiyorsa, sonuçta DateTimeOffset elde edilen nesnenin uzaklığı parametrenin styles değerine bağlıdır. içeriyorsa stylesDateTimeStyles.AssumeLocal, nesneye yerel saat diliminin DateTimeOffset uzaklığı atanır. içeriyorsa stylesDateTimeStyles.AssumeUniversal, eşgüdümlü Evrensel Saat (UTC) uzaklığı veya +00:00 nesnesine DateTimeOffset atanır. Hiçbir değer belirtilmemişse, yerel saat dilimi uzaklığı kullanılır.

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

CultureInfo Temel alınan kültürü temsil eden input bir nesne. DateTimeFormatInfo özelliği tarafından döndürülen nesne, CultureInfo.DateTimeFormat içindeki inputsembolleri ve biçimlendirmeyi tanımlar.
DateTimeFormatInfo Tarih ve saat verilerinin biçimini tanımlayan nesne.

ise formatprovidernull, CultureInfo geçerli kültüre karşılık gelen nesne kullanılır.

`DateTimeStyles` Üye	Davranış
AdjustToUniversal	Ayrıştırıp `input` gerekirse UTC'ye dönüştürür. Bir dizeyi ayrıştırma ve sonra döndürülen DateTimeOffset nesnenin DateTimeOffset.ToUniversalTime yöntemini çağırma ile eşdeğerdir.
AssumeLocal	içindeki `formats` eşleşen öğe bir uzaklık değeri içermesini `input` gerektirmiyorsa, döndürülen DateTimeOffset nesneye yerel saat diliminin uzaklığı verilir. Varsayılan değer budur.
AssumeUniversal	içinde `formats` eşleştirilen öğe bir uzaklık değeri içermesini `input` gerektirmiyorsa, döndürülen DateTimeOffset nesneye UTC uzaklığı verilir (+00:00).
AllowInnerWhite	içindeki `formats`öğeler tarafından belirtilmeyen iç boşluk eklenmesine izin verir`input`. Tarih ve saat bileşenleri arasında ve tek tek bileşenler içinde (uzaklık hariç) fazladan boşluk görünebilir ve dize ayrıştırılırken yoksayılır.
AllowLeadingWhite	içindeki `formats`öğeler tarafından belirtilmeyen baştaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowTrailingWhite	içindeki `formats`öğeler tarafından belirtilmeyen sondaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowWhiteSpaces	içindeki öğeler `formats`tarafından belirtilmeyen baştaki, sondaki ve iç boşlukların eklenmesine izin verir`input`. dize ayrıştırılırken içinde eşleşen öğesinde `formats` belirtilmeyen tüm fazladan boşluk karakterleri yoksayılır.
None	içinde `input`ek boşluklara izin verilmediğini gösterir. Başarılı bir eşleşmenin gerçekleşmesi için içinde belirli bir öğede `formats` belirtilen boşluk tam olarak görünmelidir. Bu varsayılan davranıştır.
RoundtripKind	Yapı bir `Kind` özellik içermediğinden DateTimeOffset hiçbir etkisi yoktur.

Şunlara uygulanır

TryParseExact(String, String, 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 tarih ve saatin belirtilen dize gösterimini eşdeğerine DateTimeOffset 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 bir tarih ve saat içeren bir dize.

format: String

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

formatProvider: IFormatProvider

hakkında inputkü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ğerdir None.

result: DateTimeOffset

yöntemi döndürdüğünde, dönüştürme başarılı olduysa tarih ve saat inputile eşdeğeri veya dönüştürme başarısız olduysa DateTimeOffset.MinValue değerini içerirDateTimeOffset. parametresi ise nullveya ve tarafından providerformat tanımlanan beklenen biçimde bir tarih ve saatin geçerli bir dize gösterimini içermiyorsa input dönüştürme başarısız olur. Bu parametre, başlatmadan iletilir.

Döndürülenler

Boolean

trueinput parametresi başarıyla dönüştürülürse; aksi takdirde , false.

Özel durumlar

ArgumentException

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

-veya-

NoCurrentDateDefault Desteklenmez.

-veya-

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

Örnekler

Aşağıdaki örnek, birkaç tarih ve saat dizesini TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) ayrıştırmak için yöntemini standart ve özel biçim tanımlayıcıları, sabit kültür ve çeşitli DateTimeStyles değerler ile 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 8601'e uyması DateTimeStyles beklenen bir dizi dizeyi ayrıştırmak için çeşitli değerler kullanır. Örnekteki çıktıda gösterildiği gibi, uygun biçimdeki dizeler aşağıdaki durumlarda ayrıştırılamaz:

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

UTC uzaklığını belirtmeyen dizelerin, yöntem çağrısında bayrağı sağlanmadığı sürece DateTimeStyles.AssumeUniversal yerel saat diliminin uzaklığının (bu örnekte Pasifik Yaz Saati diliminin uzaklığını yansıtan -07:00) olduğu varsayılır. Bu durumda, Bunların 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

Yöntemin TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) bu aşırı yüklemesi yöntemine DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) benzer, ancak dönüştürme başarısız olursa bu yöntem özel durum oluşturmaz. Parametresi tarafından belirtilen desenle tam olarak eşleşmesi gereken bir tarih ve saatin dize gösterimini ayrıştırır format . input Dize bu desenle eşleşmezse, parametresi tarafından styles tanımlanan boşluktaki bazı olası varyasyonlarla ayrıştırma işlemi başarısız olur ve yöntemi döndürürfalse.

format parametresi, tek bir standart biçim tanımlayıcısı veya gerekli desenini tanımlayan bir veya daha fazla özel biçim tanımlayıcısı içeren bir dizedirinput. 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 içinde bir uzaklık bulunması inputgerektiğini belirtmek için , zzveya zzz özel biçim tanımlayıcıları içeriyorsaz, 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 döndürür false.

CultureInfo Temel alınan kültürü temsil eden input bir nesne. DateTimeFormatInfo özelliği tarafından döndürülen nesne, CultureInfo.DateTimeFormat içinde inputizin verilen sembolleri ve standart biçimleri tanımlar.
DateTimeFormatInfo Tarih ve saat verilerinin biçimini tanımlayan nesne.

ise formatprovidernull, CultureInfo geçerli kültüre karşılık gelen nesne kullanılır.

`DateTimeStyles` Üye	Davranış
AdjustToUniversal	Ayrıştırıp `input` gerekirse UTC'ye dönüştürür. Bir dizeyi ayrıştırma ve sonra döndürülen DateTimeOffset nesnenin DateTimeOffset.ToUniversalTime yöntemini çağırma ile eşdeğerdir.
AssumeLocal	Bunun bir uzaklık değeri içermesi `input` gerekli değilse`format`, döndürülen DateTimeOffset nesneye yerel saat diliminin uzaklığı verilir. Bu varsayılan davranıştır.
AssumeUniversal	Bunun bir uzaklık değeri içermesi `input` gerekli değilse`format`, döndürülen DateTimeOffset nesneye UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	Biçime göre belirtilmemiş iç boşluk eklenmesine izin verir `input` . Tarih ve saat bileşenleri arasında ve uzaklık dışında tek tek bileşenler içinde fazladan boşluk görünebilir ve dize ayrıştırılırken yoksayılır.
AllowLeadingWhite	tarafından `format`belirtilmeyen baştaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowTrailingWhite	tarafından `format`belirtilmeyen sondaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowWhiteSpaces	tarafından `format`belirtilmeyen baştaki, sondaki ve iç boşlukların eklenmesine izin verir`input`. dize ayrıştırılırken içinde `format` belirtilmeyen tüm fazladan boşluk karakterleri yoksayılır.
None	içinde `input`ek boşluklara izin verilmediğini gösterir. Boşluk, içinde `format`tam olarak belirtildiği gibi görünmelidir. Bu varsayılan davranıştır.
RoundtripKind	Yapı bir `Kind` özellik içermediğinden DateTimeOffset hiçbir etkisi yoktur.

Arayanlara Notlar

.NET Framework 4'te, TryParseExact ayrıştırılacak dizenin bir saat bileşeni ve uyuşmayan bir AM/PM belirticisi içerip içermediğini döndürürfalse. .NET Framework 3.5 ve önceki sürümlerde AM/PM göstergesi yoksayılır.

Ayrıca bkz.

ParseExact

Şunlara uygulanır

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

Geri Bildirim

Ek kaynaklar