DateTimeOffset.TryParseExact Yöntem

Tanım

Ad Alanı:: System

Bütünleştirilmiş Kodlar:: mscorlib.dll, System.Runtime.dll

Bütünleştirilmiş Kodlar:: netstandard.dll, System.Runtime.dll

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

Name	Description
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 eşdeğerine DateTimeOffset 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 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

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 eşdeğerine DateTimeOffset 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 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 sabit listesi değerlerinin bit düzeyinde birleşimi. 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 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 formatstanımlanan beklenen biçimde tarih ve saat içermiyorsa formats veya ise başarısız oluyor.null Bu parametre başlatılmamış olarak geçirilir.

Döndürülenler

Boolean

true input 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ını içeriyorsaz, bu uzaklık negatif bir işaret 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. Örnek, bunun bir çizimini sağlar.

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 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 elde DateTimeOffset 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 belirtilmezse, yerel saat diliminin 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 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 dışındaki tüm üyeleri desteklenir NoCurrentDateDefault. Aşağıdaki tabloda desteklenen her üyenin etkisi listelenmektedir.

`DateTimeStyles` üye	Davranış
AdjustToUniversal	Ayrıştırır ve, gerekirse `input` 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. Bu varsayılan değerdir.
AssumeUniversal	içindeki `formats` eşleşen öğe bir uzaklık değeri içermesini `input` gerektirmiyorsa, 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 yoksayılır.
AllowTrailingWhite	içindeki `formats`öğeler tarafından belirtilmeyen sondaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar yoksayılır.
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 hiçbir etkisi DateTimeOffset yoktur.

Arayanlara Notlar

.NET Framework 4'te, TryParseExact ayrıştırılacak dizenin bir saat bileşeni ve sözleşmede olmayan bir/PM belirteci içerip içermediğini döndürür false . .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

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 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 veya dönüştürme başarısız olursa DateTimeOffset.MinValue değerini içerirDateTimeOffset. Dönüştürme başarısız oluyorsa,

Döndürülenler

Boolean

true input 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 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 bir ö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 tanımlayıcısı 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. uzaklık format değerinin ziçinde inputbulunması gerektiğini belirtmek için , zzveya zzz özel biçim tanımlayıcılarını içeriyorsa, 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 içermesini input gerektiriyor ancak saat içermiyorsaformat, 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 edilen DateTimeOffset nesneye yerel sistemde geçerli tarih atanır. Bunun format bir uzaklık içermesini input gerektirmiyorsa, sonuçta elde DateTimeOffset 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 belirtilmezse, yerel saat diliminin 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 olup olmadığının inputformat kesin deseni için de geçerlidir. formatProvider parametresi aşağıdakilerden biri olabilir:

CultureInfo Yorumlanan kültürü temsil eden input 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şluk bulunup bulunmadığını 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ır ve, gerekirse `input` UTC'ye dönüştürür. Tarih ve saat gösterimini ayrıştırma ve ardından döndürülen DateTimeOffset nesnenin DateTimeOffset.ToUniversalTime yöntemini çağırmaya eşdeğerdir.
AssumeLocal	Bir uzaklık değeri içermesini `input` gerektirmezse`format`, döndürülen DateTimeOffset nesneye yerel saat diliminin uzaklığı verilir. Bu, varsayılan davranıştır.
AssumeUniversal	Bunun `format` bir uzaklık değeri içermesini `input` gerektirmiyorsa, döndürülen DateTimeOffset nesneye UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	Biçime göre belirtilmeyen iç boşluk eklenmesine izin verir `input` . 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	tarafından `format`belirtilmeyen baştaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar yoksayılır.
AllowTrailingWhite	tarafından `format`belirtilmeyen sondaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar yoksayılır.
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 ek 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

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 tarih ve saati temsil eden karakterleri içeren bir yayılma alanı.

formats: String[]

kabul edilebilir biçimlerini tanımlayan standart veya özel biçim dizelerinden oluşan bir inputdizi.

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

Döndürülenler

Boolean

true input 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ştirmezse, 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.

Önemli

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 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 elde DateTimeOffset 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 belirtilmezse, yerel saat diliminin 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 Yorumlanan kültürü temsil eden input 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ır ve, gerekirse `input` 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. Bu varsayılan değerdir.
AssumeUniversal	içindeki `formats` eşleşen öğe bir uzaklık değeri içermesini `input` gerektirmiyorsa, 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 yoksayılır.
AllowTrailingWhite	içindeki `formats`öğeler tarafından belirtilmeyen sondaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar yoksayılır.
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 hiçbir etkisi DateTimeOffset yoktur.

Şunlara uygulanır

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

Kaynak:: DateTimeOffset.cs

Kaynak:: DateTimeOffset.cs

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 tarih ve saati içeren dize.

format: String

gerekli biçimini tanımlayan 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ö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 olduysa DateTimeOffset.MinValue değerini içerirDateTimeOffset. parametresi ise nullveya ve providertarafından format tanımlanan beklenen biçimde bir tarih ve saatin geçerli dize gösterimini içermiyorsa input dönüştürme başarısız olur. Bu parametre başlatılmamış olarak geçirilir.

Döndürülenler

Boolean

true input 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ıyla, sabit kültürle ve çeşitli DateTimeStyles değerlerle 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.
bunlar, aralık dışında olan tarih ve saat öğelerini içerir.

UTC uzaklığını belirtmeyen dizelerin, yöntem çağrısında bayrak sağlanmadığı sürece DateTimeStyles.AssumeUniversal 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

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 bir ö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şmiyorsa, 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. uzaklık format değerinin ziçinde inputbulunması gerektiğini belirtmek için , zzveya zzz özel biçim tanımlayıcılarını içeriyorsa, 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 Yorumlanan kültürü temsil eden input 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ır ve, gerekirse `input` 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	Bir uzaklık değeri içermesini `input` gerektirmezse`format`, döndürülen DateTimeOffset nesneye yerel saat diliminin uzaklığı verilir. Bu, varsayılan davranıştır.
AssumeUniversal	Bunun `format` bir uzaklık değeri içermesini `input` gerektirmiyorsa, döndürülen DateTimeOffset nesneye UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	Biçime göre belirtilmeyen iç boşluk eklenmesine izin verir `input` . 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	tarafından `format`belirtilmeyen baştaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar yoksayılır.
AllowTrailingWhite	tarafından `format`belirtilmeyen sondaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar yoksayılır.
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 ek 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

Ayrıca bkz.

ParseExact

Şunlara uygulanır

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

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

Geri Bildirim