DateTimeOffset.ParseExact 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

ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Belirtilen biçimleri, 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çimlerinden biriyle tam olarak eşleşmelidir.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	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.
ParseExact(String, String, IFormatProvider)	Belirtilen biçim ve kültüre özgü biçim bilgilerini 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.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stili kullanarak tarih ve saati temsil eden karakter aralığını eşdeğerine DateTimeOffset dönüştürür. Tarih ve saat gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Belirtilen biçimleri, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin dize gösterimini içeren karakter aralığını 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.

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

Belirtilen biçimleri, 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çimlerinden biriyle tam olarak eşleşmelidir.

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

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

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

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

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

Parametreler

input: String

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

formats: String[]

beklenen biçimlerini tanımlayan biçim tanımlayıcıları 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.

Döndürülenler

DateTimeOffset

, formatProviderve parametreleri tarafından formatsbelirtildiği gibi parametresinde input yer alan tarih ve styles saate eşdeğer bir nesne.

Özel durumlar

ArgumentException

Uzaklık 14 saatten fazla veya -14 saatten azdır.

-veya-

styles desteklenmeyen bir değer içerir.

-veya-

styles parametresi birlikte kullanılamayabilecek değerler içeriyorDateTimeStyles.

ArgumentNullException

input, null değeridir.

FormatException

input boş bir dizedir ("").

-veya-

input tarih ve saatin geçerli dize gösterimini içermez.

-veya-

öğesi formats geçerli bir biçim tanımlayıcısı içermiyor.

-veya-

içindeki saat bileşeni ve AM/PM göstergesi input aynı fikirde değildir.

Ö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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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 = new DateTimeOffset();

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

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

let mutable result = None
let mutable tries = 0
while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    let input = stdin.ReadLine()
    printfn ""
    try
        result <- 
            DateTimeOffset.ParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) 
            |> Some
    with :? FormatException ->
        printfn $"Unable to parse {input}."
        tries <- tries + 1

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

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

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

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

Açıklamalar

yöntemi, DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) parametreye atanan desenlerden herhangi biriyle eşleşen bir tarihin dize gösterimini formats ayrıştırır. input Dize, parametresi tarafından styles tanımlanan varyasyonlardan herhangi biriyle bu desenlerden herhangi biriyle eşleşmiyorsa, yöntemi bir FormatExceptionoluşturur. Birden çok biçimlendirme desenine input kıyasla 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 parametrenin olası desenini tanımlayan bir veya daha fazla özel biçim tanımlayıcısı içeren bir dize dizisidirinput. Yöntemi çağrıldığında, input bu desenlerden biriyle eşleşmesi gerekir. 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 yöntemi bir FormatExceptionoluşturur.

Ö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 formats input 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 için tarih değil de saat bulunması gerekiyorsa input , sonuçta elde DateTimeOffset edilen 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 styles AssumeLocal, nesneye yerel saat diliminin uzaklığı atanır DateTimeOffset . içeriyorsa styles 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 ve dizeleri parametresi tarafından formatProvider tanımlanır. Eşleşen öğesi formats standart biçim tanımlayıcı dizesiyse, tam biçimi inputiç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 bir nesne.

ise formatprovider null, 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ı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çindeki `formats` `input` eşleşen öğe bir uzaklık değeri içermiyorsa, döndürülen DateTimeOffset nesneye UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	tarafından `format`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	tarafından `formats`belirtilmeyen baştaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowTrailingWhite	tarafından `formats`belirtilmeyen sondaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowWhiteSpaces	tarafından `formats`belirtilmeyen baştaki, sondaki ve iç boşlukların dahil edilmesini sağlar`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. Eşleşmenin gerçekleşmesi için boşluk belirli bir öğesinde `formats` tam olarak belirtildiği gibi 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 yöntemi, ParseExact ayrıştırılacak dizenin bir saat bileşeni ve uyuşmayan bir AM/PM belirteci içeriyorsa bir oluştururFormatException. .NET Framework 3.5 ve önceki sürümlerde AM/PM göstergesi yoksayılır.

Ayrıca bkz.

Şunlara uygulanır

ParseExact(String, String, IFormatProvider, DateTimeStyles)

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 DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

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

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

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

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

Parametreler

input: String

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

format: String

beklenen 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.

Döndürülenler

DateTimeOffset

, formatProviderve parametreleri tarafından formatbelirtildiği gibi parametresinde input yer alan tarih ve styles saate eşdeğer bir nesne.

Özel durumlar

ArgumentException

Uzaklık 14 saatten fazla veya -14 saatten azdır.

-veya-

styles parametresi desteklenmeyen bir değer içeriyor.

-veya-

styles parametresi birlikte kullanılamayabilecek değerler içeriyorDateTimeStyles.

ArgumentNullException

input, null değeridir.

-veya-

format, null değeridir.

FormatException

input boş bir dizedir ("").

-veya-

input tarih ve saatin geçerli dize gösterimini içermez.

-veya-

format boş bir dizedir.

-veya-

içindeki saat bileşeni ve AM/PM göstergesi input aynı fikirde değildir.

Örnekler

Aşağıdaki örnek, birkaç tarih ve saat dizesini DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) 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ğerlerle kullanır.

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

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

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

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

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

let provider = CultureInfo.InvariantCulture

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

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

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

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

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

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

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

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

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

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

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ığı belirtmeyen dizelerin, yöntem çağrısında bayrağı sağlanmadığı sürece DateTimeStyles.AssumeUniversal yerel saat diliminin uzaklığının (bu örnekte -07:00) olduğu varsayılır. Bu durumda, Bunların Evrensel Eşgüdümlü Zaman olduğu varsayılır.

module parseexact_iso8601_2

open System
open System.Globalization

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

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

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


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

using System;
using System.Globalization;

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

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

Imports System.Globalization

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

   Private Sub ParseWithISO8601(dateStrings() As String, styles As DateTimeStyles)
      Console.WriteLine($"Parsing with {styles}:")
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateString, "O", Nothing, styles)
            Console.WriteLine($"   {dateString,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         catch e As FormatException
            Console.WriteLine($"   FormatException: Unable to convert '{dateString}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeLocal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'

Açıklamalar

DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) yöntemi, parametre tarafından tanımlanan biçimde olması gereken bir tarihin dize gösterimini format ayrıştırır. Ayrıca, bir tarih ve <Offset> saatin dize gösteriminin , <Time>ve öğelerinin tarafından formatbelirtilen sırada gösterilmesini gerektirir<Date>. input Dize parametrenin deseniyle format eşleşmiyorsa ve parametresi tarafından styles tanımlanan varyasyonlarla eşleşmiyorsa, yöntemi bir FormatExceptionoluşturur. Buna karşılık yöntemi, DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) biçim sağlayıcısının DateTimeFormatInfo nesnesi tarafından tanınan biçimlerden herhangi birinde bir tarihin dize gösterimini ayrıştırır. Parseayrıca, bir tarih ve <Offset> saatin dize gösteriminin , <Time>ve öğelerinin herhangi bir sırada görünmesini sağlar<Date>.

format parametresi, tek bir standart biçim tanımlayıcısı veya parametrenin 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ını içeriyorsaz, bu uzaklık negatif bir işaret veya pozitif işareti içermelidir. İşaret eksikse yöntemi bir FormatExceptionoluşturur.

Bunun bir tarih içermesini input gerektiriyorsa 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 format input , sonuçta elde edilen DateTimeOffset nesneye yerel sistemde geçerli tarih atanır. Bunun format bir uzaklık içermesini input gerektirmiyorsa, sonuçta DateTimeOffset elde edilen nesnenin uzaklığı parametrenin styles değerine bağlıdır. içeriyorsa styles AssumeLocal, nesneye yerel saat diliminin uzaklığı atanır DateTimeOffset . içeriyorsa styles 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 ve dizeleri parametresi tarafından formatProvider tanımlanır. Aynı durum, standart biçim belirtici dizesiyseformat, tam biçimi inputiçin de 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 bir nesne.

ise formatprovider null, 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ürmesini 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ırma ve sonra döndürülen DateTimeOffset nesnenin DateTimeOffset.ToUniversalTime yöntemini çağırma ile eşdeğerdir.
AssumeLocal	Bunun `format` 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	Bir `format` uzaklık değeri içermesini `input` gerektirmiyorsa, döndürülen DateTimeOffset nesneye UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	tarafından `format`belirtilmeyen iç boşluk eklenmesine izin verir`input`. Tarih ve saat bileşenleri arasında ve 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 dahil edilmesini sağlar`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 tam olarak içinde `format`belirtildiği gibi görünmelidir. Bu varsayılan davranıştır.
RoundtripKind	Yapı bir `Kind` özellik içermediğinden etkisi yokturDateTimeOffset.

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

ParseExact(String, String, IFormatProvider)

Belirtilen biçim ve kültüre özgü biçim bilgilerini 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 DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);

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

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

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

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

Parametreler

input: String

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

format: String

beklenen 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.

Döndürülenler

DateTimeOffset

ve formatProvidertarafından format belirtildiği şekilde içinde input bulunan tarih ve saate eşdeğer bir nesne.

Özel durumlar

ArgumentException

Uzaklık 14 saatten fazla veya -14 saatten azdır.

ArgumentNullException

input, null değeridir.

-veya-

format, null değeridir.

FormatException

input boş bir dizedir ("").

-veya-

input bir tarih ve saatin geçerli dize gösterimini içermez.

-veya-

format boş bir dizedir.

-veya-

içindeki saat bileşeni ve AM/PM göstergesi input aynı fikirde değildir.

Örnekler

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

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

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

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

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

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

let provider = CultureInfo.InvariantCulture

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

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

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

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

// The example displays the following output:
//    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

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

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

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

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

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

Aşağıdaki örnek , ISO 8601'e uyması beklenen dize dizisini ayrıştırmaktadır. Örneğin çıktısının gösterdiği gibi, baştaki veya sondaki boşlukları olan dizeler, tarih ve saat öğeleri aralık dışında olan dizelerde olduğu gibi başarıyla ayrıştırılamaz.

module parseexact_iso8601

open System

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

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

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


// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//      2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//      2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

using System;

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

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

Açıklamalar

ParseExact(String, String, IFormatProvider) yöntemi, parametre tarafından tanımlanan biçimde olması gereken bir tarihin dize gösterimini ayrıştırırformat. Ayrıca, <Date>bir tarih ve <Offset> saatin dize gösteriminin , <Time>ve öğelerinin tarafından formatbelirtilen sırada gösterilmesini gerektirir. Dize bu format parametreyle input eşleşmiyorsa, yöntemi bir FormatExceptionoluşturur. Buna karşılık yöntemi, DateTimeOffset.Parse(String, IFormatProvider) biçim sağlayıcısının DateTimeFormatInfo nesnesi tarafından tanınan biçimlerden herhangi birinde bir tarihin dize gösterimini ayrıştırır. Parseayrıca, bir tarih ve <Offset> saatin dize gösteriminin , <Time>ve öğelerinin herhangi bir sırada görünmesini sağlar<Date>.

format parametresi, tek bir standart biçim tanımlayıcısı veya parametrenin gerekli biçimini 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. içinde bir uzaklık bulunması inputgerektiğini belirtmek için , zzveya zzz özel biçim tanımlayıcıları içeriyorsa format z, bu uzaklık negatif işareti veya pozitif işareti içermelidir. İşaret eksikse yöntemi bir FormatExceptionoluşturur.

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 format input , sonuçta elde DateTimeOffset edilen nesneye yerel sistemde geçerli tarih atanır. Bunun bir uzaklık içermesi input gerekli değilseformat, sonuçta elde DateTimeOffset edilen nesneye yerel sistemin saat dilimi uzaklığı atanır.

içinde kullanılan input belirli tarih ve saat simgeleri ve dizeleri, standart biçim tanımlayıcı dizesi ise format tam biçimi input olduğu gibi parametresi tarafından formatProvider tanımlanır. formatProvider parametresi aşağıdakilerden biri olabilir:

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

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

Arayanlara Notlar

.NET Framework 4'te yöntemi, ParseExact ayrıştırılacak dizenin bir saat bileşeni ve anlaşmada olmayan bir AM/PM belirteci içermesi durumunda bir oluştururFormatException. .NET Framework 3.5 ve önceki sürümlerde AM/PM göstergesi yoksayılır.

Ayrıca bkz.

Şunlara uygulanır

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

Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stili kullanarak tarih ve saati temsil eden karakter aralığını 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 DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

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

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

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

Parametreler

input: ReadOnlySpan<Char>

Tarih ve saati temsil eden karakter aralığı.

format: ReadOnlySpan<Char>

beklenen biçimini inputtanımlayan bir biçim tanımlayıcısı içeren karakter aralığı.

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.

Döndürülenler

DateTimeOffset

, formatProviderve parametreleri tarafından formatbelirtildiği gibi parametresinde input yer alan tarih ve styles saate eşdeğer bir nesne.

Özel durumlar

ArgumentException

Uzaklık 14 saatten fazla veya -14 saatten azdır. -or- styles parametresi desteklenmeyen bir değer içeriyor. -or- styles parametresi birlikte kullanılamayabilecek değerler içeriyor DateTimeStyles .

FormatException

input boş bir karakter aralığıdır. -or- input tarih ve saatin geçerli bir dize gösterimini içermez. -veya- format boş bir karakter aralığıdır. -veya- içinde saat bileşeni ve AM/PM göstergesi input kabul etmez.

Açıklamalar

Bu yöntem, parametre tarafından tanımlanan biçimde olması gereken bir tarihi temsil eden karakter aralığını ayrıştırır format . Ayrıca, <Date>bir tarih ve <Offset> saatin dize gösteriminin , <Time>ve öğelerinin tarafından formatbelirtilen sırada gösterilmesini gerektirir. Desenle input format eşleşmiyorsa, yöntemi bir FormatExceptionoluşturur. Buna karşılık yöntemi, DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) biçim sağlayıcısının DateTimeFormatInfo nesnesi tarafından tanınan biçimlerden herhangi birinde bir tarihin dize gösterimini ayrıştırır. Parseayrıca, bir tarih ve <Offset> saatin dize gösteriminin , <Time>ve öğelerinin herhangi bir sırada görünmesini sağlar<Date>.

format parametresi, tek karakterli standart biçim tanımlayıcısı veya parametrenin gerekli biçimini 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. içinde bir uzaklık bulunması inputgerektiğini belirtmek için , zzveya zzz özel biçim tanımlayıcıları içeriyorsa format z, bu uzaklık negatif işareti veya pozitif işareti içermelidir. İşaret eksikse yöntemi bir FormatExceptionoluşturur.

içinde kullanılan input belirli tarih ve saat simgeleri ve dizeleri, standart biçim tanımlayıcısı ise format tam biçimi input olduğu gibi parametresi tarafından formatProvider tanımlanır. formatProvider parametresi aşağıdakilerden biri olabilir:

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

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

Şunlara uygulanır

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

Belirtilen biçimleri, kültüre özgü biçim bilgilerini ve stili kullanarak bir tarih ve saatin dize gösterimini içeren karakter aralığını 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 DateTimeOffset ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

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

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

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

Parametreler

input: ReadOnlySpan<Char>

Dönüştürülecek tarih ve saati içeren karakter aralığı.

formats: String[]

beklenen biçimlerini inputtanımlayan biçim tanımlayıcıları dizisi.

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.

Döndürülenler

DateTimeOffset

, formatProviderve parametreleri tarafından formatsbelirtildiği gibi parametresinde input yer alan tarih ve styles saate eşdeğer bir nesne.

Özel durumlar

ArgumentException

Uzaklık 14 saatten fazla veya -14 saatten azdır. -or- styles desteklenmeyen bir değer içerir. -or- styles parametresi birlikte kullanılamayabilecek değerler içeriyor DateTimeStyles .

FormatException

input boş bir karakter aralığıdır. -or- input tarih ve saatin geçerli bir dize gösterimini içermez. -or- Öğesinin formats hiçbir öğesi geçerli bir biçim tanımlayıcısı içermiyor. -veya- içindeki saat bileşeni ve AM/PM göstergesi input aynı fikirde değildir.

Açıklamalar

Bu yöntem, parametreye atanan formats desenlerden herhangi biriyle eşleşen bir tarihi temsil eden bir karakter aralığını ayrıştırır. input Bu desenlerden herhangi birini parametresi tarafından styles tanımlanan varyasyonlardan herhangi biriyle eşleşmiyorsa, yöntemi bir FormatExceptionoluşturur. Bu aşırı yükleme, birden çok biçimlendirme deseni ile karşılaştırmanın input yanı sıra yöntemiyle DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) aynı şekilde davranır.

formats parametresi, öğeleri tek bir standart biçim tanımlayıcısı veya parametrenin olası desenini tanımlayan bir veya daha fazla özel biçim tanımlayıcısı içeren bir dize dizisidirinput. Yöntemi çağrıldığında, input bu desenlerden biriyle eşleşmesi gerekir. 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şaret veya pozitif işareti içermelidir. İşaret eksikse yöntemi bir FormatExceptionoluşturur.

Ö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.

içindeki formats input 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 input eşleşen öğe tarih değil de saat 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 styles AssumeLocal, nesneye yerel saat diliminin DateTimeOffset uzaklığı atanır. içeriyorsa styles 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.

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 formatprovider null, 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 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çindeki `formats` `input` eşleşen öğe bir uzaklık değeri içermiyorsa, döndürülen DateTimeOffset nesneye UTC uzaklığı (+00:00) verilir.
AllowInnerWhite	tarafından `format`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	tarafından `formats`belirtilmeyen baştaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowTrailingWhite	tarafından `formats`belirtilmeyen sondaki boşlukların eklenmesine izin verir`input`. Dize ayrıştırılırken bunlar gözardı edilir.
AllowWhiteSpaces	tarafından `formats`belirtilmeyen baştaki, sondaki ve iç boşlukların dahil edilmesini sağlar`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. Eşleşmenin gerçekleşmesi için boşluk belirli bir öğesinde `formats` tam olarak belirtildiği gibi görünmelidir. Bu varsayılan davranıştır.
RoundtripKind	Yapı bir `Kind` özellik içermediğinden etkisi yokturDateTimeOffset.

Şunlara uygulanır

DateTimeOffset.ParseExact Yöntem

Tanım

Aşırı Yüklemeler

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

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

ParseExact(String, String, IFormatProvider)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Şunlara uygulanır

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

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Şunlara uygulanır

Ek kaynaklar