DateTimeFormatInfo sınıfı

Makale
12/30/2023

Bu makale, bu API'nin başvuru belgelerine ek açıklamalar sağlar.

sınıfının özellikleri DateTimeFormatInfo , aşağıdaki gibi tarih ve saat değerlerini biçimlendirmek veya ayrıştırma için kültüre özgü bilgiler içerir:

Tarih değerlerini biçimlendirmek için kullanılan desenler.
Zaman değerlerini biçimlendirmek için kullanılan desenler.
Haftanın günlerinin adları.
Yılın aylarının adları.
Zaman değerlerinde kullanılan A.M. ve P.M. belirleyicileri.
Tarihlerin ifade edildiği takvim.

DateTimeFormatInfo nesnesinin örneğini oluşturma

Nesne DateTimeFormatInfo sabit kültürün, belirli bir kültürün, nötr kültürün veya geçerli kültürün biçimlendirme kurallarını temsil edebilir. Bu bölümde her nesne türünün DateTimeFormatInfo nasıl başlatılacağı açıklanmıştır.

Sabit kültür için bir DateTimeFormatInfo nesnesi örneği oluşturma

Sabit kültür, kültüre duyarlı olmayan bir kültürü temsil eder. İngilizce dilini temel alır, ancak belirli bir İngilizce konuşulan ülkeye/bölgeye dayalı değildir. Belirli kültürlerin verileri dinamik olabilir ve yeni kültürel kuralları veya kullanıcı tercihlerini yansıtacak şekilde değişebilir, ancak sabit kültürün verileri değişmez. Sabit kültürün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesnenin örneğini aşağıdaki yollarla oluşturabilirsiniz:

özelliğinin değerini InvariantInfo alarak. Döndürülen DateTimeFormatInfo nesne salt okunur.
Parametresiz DateTimeFormatInfo oluşturucuyu çağırarak. Döndürülen DateTimeFormatInfo nesne okuma/yazma işlemidir.
özelliği tarafından CultureInfo.InvariantCulture döndürülen nesneden CultureInfo özelliğinin değerini DateTimeFormat alarak. Döndürülen DateTimeFormatInfo nesne salt okunur.

Aşağıdaki örnek, sabit kültürü temsil eden bir DateTimeFormatInfo nesne örneği oluşturmak için bu yöntemlerin her birini kullanır. Ardından nesnenin salt okunur olup olmadığını gösterir.

System.Globalization.DateTimeFormatInfo dtfi;

dtfi = System.Globalization.DateTimeFormatInfo.InvariantInfo;
Console.WriteLine(dtfi.IsReadOnly);

dtfi = new System.Globalization.DateTimeFormatInfo();
Console.WriteLine(dtfi.IsReadOnly);

dtfi = System.Globalization.CultureInfo.InvariantCulture.DateTimeFormat;
Console.WriteLine(dtfi.IsReadOnly);
// The example displays the following output:
//       True
//       False
//       True

Belirli bir kültür için DateTimeFormatInfo nesnesinin örneğini oluşturma

Belirli bir kültür, belirli bir ülkede/bölgede konuşulan bir dili temsil eder. Örneğin en-US, Birleşik Devletler konuşulan İngilizce dilini temsil eden belirli bir kültürdür ve en-CA, Kanada'da konuşulan İngilizce dilini temsil eden belirli bir kültürdür. Belirli bir DateTimeFormatInfo kültürün biçimlendirme kurallarını temsil eden bir nesnenin örneğini aşağıdaki yollarla oluşturabilirsiniz:

yöntemini çağırarak CultureInfo.GetCultureInfo(String) ve döndürülen CultureInfo nesnenin CultureInfo.DateTimeFormat özelliğinin değerini alarak. Döndürülen DateTimeFormatInfo nesne salt okunur.
Statik GetInstance yöntemine nesnesini almak istediğiniz kültürü DateTimeFormatInfo temsil eden bir CultureInfo nesne geçirerek. Döndürülen DateTimeFormatInfo nesne okuma/yazma işlemidir.
Statik CultureInfo.CreateSpecificCulture yöntemi çağırarak ve döndürülen CultureInfo nesnenin CultureInfo.DateTimeFormat özelliğinin değerini alarak. Döndürülen DateTimeFormatInfo nesne okuma/yazma işlemidir.
Sınıf oluşturucuyu CultureInfo.CultureInfo çağırarak ve döndürülen CultureInfo nesnenin CultureInfo.DateTimeFormat özelliğinin değerini alarak. Döndürülen DateTimeFormatInfo nesne okuma/yazma işlemidir.

Aşağıdaki örnek, bir DateTimeFormatInfo nesnenin örneğini oluşturmak için bu yollardan her birini gösterir ve sonuçta elde edilen nesnenin salt okunur olup olmadığını gösterir.

System.Globalization.CultureInfo ci = null;
System.Globalization.DateTimeFormatInfo dtfi = null;

// Instantiate a culture using CreateSpecificCulture.
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-US");
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from CreateSpecificCulture: {1}", ci.Name, dtfi.IsReadOnly);

// Instantiate a culture using the CultureInfo constructor.
ci = new System.Globalization.CultureInfo("en-CA");
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from CultureInfo constructor: {1}", ci.Name, dtfi.IsReadOnly);

// Retrieve a culture by calling the GetCultureInfo method.
ci = System.Globalization.CultureInfo.GetCultureInfo("en-AU");
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from GetCultureInfo: {1}", ci.Name, dtfi.IsReadOnly);

// Instantiate a DateTimeFormatInfo object by calling DateTimeFormatInfo.GetInstance.
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(ci);
Console.WriteLine("{0} from GetInstance: {1}", ci.Name, dtfi.IsReadOnly);

// The example displays the following output:
//      en-US from CreateSpecificCulture: False
//      en-CA from CultureInfo constructor: False
//      en-AU from GetCultureInfo: True
//      en-GB from GetInstance: False

Nötr bir kültür için DateTimeFormatInfo nesnesinin örneğini oluşturma

Tarafsız bir kültür, bir ülkeden/bölgeden bağımsız bir kültürü veya dili temsil eder; genellikle bir veya daha fazla belirli kültürün üst öğesidir. Örneğin Fr, Fransızca dili ve fr-FR kültürünün üst öğesi için nötr bir kültürdür. Nötr kültürün DateTimeFormatInfo biçimlendirme kurallarını temsil eden bir nesnenin örneğini, belirli bir kültürün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesne oluşturduğunuz şekilde oluşturabilirsiniz. Ayrıca, belirli bir kültürün DateTimeFormatInfo özelliğinden nötr bir kültür alarak ve özelliği tarafından CultureInfo.DateTimeFormat döndürülen nesneyi alarak nötr bir kültürün CultureInfo.Parent DateTimeFormatInfo nesnesini alabilirsiniz. Üst kültür sabit kültürü temsil etmediği sürece, döndürülen DateTimeFormatInfo nesne okuma/yazma olur. Aşağıdaki örnek, nötr bir kültürü temsil eden bir DateTimeFormatInfo nesnenin örneğini oluşturmanın bu yollarını göstermektedir.

System.Globalization.CultureInfo specific, neutral;
System.Globalization.DateTimeFormatInfo dtfi;

// Instantiate a culture by creating a specific culture and using its Parent property.
specific = System.Globalization.CultureInfo.GetCultureInfo("fr-FR");
neutral = specific.Parent;
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly);

dtfi = System.Globalization.CultureInfo.GetCultureInfo("fr-FR").Parent.DateTimeFormat;
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a neutral culture using the CultureInfo constructor.
neutral = new System.Globalization.CultureInfo("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from CultureInfo constructor: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a culture using CreateSpecificCulture.
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from CreateSpecificCulture: {1}", neutral.Name, dtfi.IsReadOnly);

// Retrieve a culture by calling the GetCultureInfo method.
neutral = System.Globalization.CultureInfo.GetCultureInfo("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from GetCultureInfo: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a DateTimeFormatInfo object by calling GetInstance.
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr");
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(neutral);
Console.WriteLine("{0} from GetInstance: {1}", neutral.Name, dtfi.IsReadOnly);

// The example displays the following output:
//       fr from Parent property: False
//       fr from Parent property: False
//       fr from CultureInfo constructor: False
//       fr-FR from CreateSpecificCulture: False
//       fr from GetCultureInfo: True
//       fr-FR from GetInstance: False

Ancak tarafsız bir kültür, belirli bir ülkeden/bölgeden bağımsız olduğundan kültüre özgü biçimlendirme bilgilerine sahip değildir. .NET, nesneyi genel değerlerle doldurmak DateTimeFormatInfo yerine, nötr kültürün alt öğesi olan belirli bir kültürün biçimlendirme kurallarını yansıtan bir nesne döndürür DateTimeFormatInfo . Örneğin, DateTimeFormatInfo nötr en kültür nesnesi en-US kültürünün biçimlendirme kurallarını yansıtır ve DateTimeFormatInfo fr kültürüne yönelik nesne fr-FR kültürünün biçimlendirme kurallarını yansıtır.

Nötr bir kültürün hangi belirli kültürün biçimlendirme kurallarını temsil ettiği belirlemek için aşağıdaki gibi bir kod kullanabilirsiniz. Örnek, nötr bir kültürün DateTimeFormatInfo özelliklerini belirli bir alt kültürün özellikleriyle karşılaştırmak için yansımayı kullanır. İki takvimin aynı takvim türünde olması ve Gregoryen takvimler için özelliklerinin aynı değerlere sahip olması durumunda GregorianCalendar.CalendarType denk olduğunu kabul eder.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;

public class InstantiateEx6
{
    public static void Main()
    {
        // Get all the neutral cultures
        List<String> names = new List<String>();
        Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                      culture => names.Add(culture.Name));
        names.Sort();
        foreach (var name in names)
        {
            // Ignore the invariant culture.
            if (name == "") continue;

            ListSimilarChildCultures(name);
        }
    }

    private static void ListSimilarChildCultures(String name)
    {
        // Create the neutral DateTimeFormatInfo object.
        DateTimeFormatInfo dtfi = CultureInfo.GetCultureInfo(name).DateTimeFormat;
        // Retrieve all specific cultures of the neutral culture.
        CultureInfo[] cultures = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures),
                                 culture => culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase));
        // Create an array of DateTimeFormatInfo properties
        PropertyInfo[] properties = typeof(DateTimeFormatInfo).GetProperties(BindingFlags.Instance | BindingFlags.Public);
        bool hasOneMatch = false;

        foreach (var ci in cultures)
        {
            bool match = true;
            // Get the DateTimeFormatInfo for a specific culture.
            DateTimeFormatInfo specificDtfi = ci.DateTimeFormat;
            // Compare the property values of the two.
            foreach (var prop in properties)
            {
                // We're not interested in the value of IsReadOnly.
                if (prop.Name == "IsReadOnly") continue;

                // For arrays, iterate the individual elements to see if they are the same.
                if (prop.PropertyType.IsArray)
                {
                    IList nList = (IList)prop.GetValue(dtfi, null);
                    IList sList = (IList)prop.GetValue(specificDtfi, null);
                    if (nList.Count != sList.Count)
                    {
                        match = false;
                        Console.WriteLine("   Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name);
                        break;
                    }

                    for (int ctr = 0; ctr < nList.Count; ctr++)
                    {
                        if (!nList[ctr].Equals(sList[ctr]))
                        {
                            match = false;
                            Console.WriteLine("   {0} value different for {1} and {2}", prop.Name, name, ci.Name);
                            break;
                        }
                    }

                    if (!match) break;
                }
                // Get non-array values.
                else
                {
                    Object specificValue = prop.GetValue(specificDtfi);
                    Object neutralValue = prop.GetValue(dtfi);

                    // Handle comparison of Calendar objects.
                    if (prop.Name == "Calendar")
                    {
                        // The cultures have a different calendar type.
                        if (specificValue.ToString() != neutralValue.ToString())
                        {
                            Console.WriteLine("   Different calendar types for {0} and {1}", name, ci.Name);
                            match = false;
                            break;
                        }

                        if (specificValue is GregorianCalendar)
                        {
                            if (((GregorianCalendar)specificValue).CalendarType != ((GregorianCalendar)neutralValue).CalendarType)
                            {
                                Console.WriteLine("   Different Gregorian calendar types for {0} and {1}", name, ci.Name);
                                match = false;
                                break;
                            }
                        }
                    }
                    else if (!specificValue.Equals(neutralValue))
                    {
                        match = false;
                        Console.WriteLine("   Different {0} values for {1} and {2}", prop.Name, name, ci.Name);
                        break;
                    }
                }
            }
            if (match)
            {
                Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'",
                                  name, ci.Name);
                hasOneMatch = true;
            }
        }
        if (!hasOneMatch)
            Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name);

        Console.WriteLine();
    }
}

Geçerli kültür için bir DateTimeFormatInfo nesnesi örneği oluşturma

Geçerli kültürün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesnenin örneğini aşağıdaki yollarla oluşturabilirsiniz:

özelliğinin değerini CurrentInfo alarak. Döndürülen DateTimeFormatInfo nesne salt okunur.
özelliği tarafından CultureInfo.CurrentCulture döndürülen nesneden CultureInfo özelliğinin değerini DateTimeFormat alarak. Döndürülen DateTimeFormatInfo nesne salt okunur.
yöntemini geçerli kültürü temsil eden bir CultureInfo nesneyle çağırarakGetInstance. Döndürülen DateTimeFormatInfo nesne salt okunur.

Aşağıdaki örnek, geçerli kültürün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesne örneği oluşturmak için bu yöntemlerin her birini kullanır. Ardından nesnenin salt okunur olup olmadığını gösterir.

DateTimeFormatInfo dtfi;

dtfi = DateTimeFormatInfo.CurrentInfo;
Console.WriteLine(dtfi.IsReadOnly);

dtfi = CultureInfo.CurrentCulture.DateTimeFormat;
Console.WriteLine(dtfi.IsReadOnly);

dtfi = DateTimeFormatInfo.GetInstance(CultureInfo.CurrentCulture);
Console.WriteLine(dtfi.IsReadOnly);
// The example displays the following output:
//     True
//     True
//     True

Geçerli kültürün kurallarını şu yollardan biriyle temsil eden yazılabilir DateTimeFormatInfo bir nesne oluşturabilirsiniz:

Önceki üç yoldan herhangi birinde bir DateTimeFormatInfo nesneyi alıp döndürülen DateTimeFormatInfo nesnede Clone yöntemini çağırarak. Bu, özgün DateTimeFormatInfo nesnenin özelliğinin falseolması dışında IsReadOnly bir kopyasını oluşturur.
geçerli kültürü temsil eden bir CultureInfo nesne oluşturmak için yöntemini çağırarak CultureInfo.CreateSpecificCulture ve sonra nesnesini almak DateTimeFormatInfo için özelliğini CultureInfo.DateTimeFormat kullanarak.

Aşağıdaki örnek, okuma/yazma DateTimeFormatInfo nesnesinin her örneğini gösterir ve özelliğinin IsReadOnly değerini görüntüler.

using System;
using System.Globalization;

public class InstantiateEx1
{
    public static void Main()
    {
        DateTimeFormatInfo current1 = DateTimeFormatInfo.CurrentInfo;
        current1 = (DateTimeFormatInfo)current1.Clone();
        Console.WriteLine(current1.IsReadOnly);

        CultureInfo culture2 = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name);
        DateTimeFormatInfo current2 = culture2.DateTimeFormat;
        Console.WriteLine(current2.IsReadOnly);
    }
}
// The example displays the following output:
//       False
//       False

Windows'da kullanıcı, Denetim Masası'daki Bölge ve Dil uygulaması aracılığıyla işlemleri biçimlendirme ve ayrıştırma işlemlerinde kullanılan bazı DateTimeFormatInfo özellik değerlerini geçersiz kılabilir. Örneğin, kültürü İngilizce (Birleşik Devletler) olan bir kullanıcı, varsayılan 12 saatlik saat (h:mm:ss tt) yerine 24 saatlik bir saat (SS:mm:ss biçiminde) kullanarak uzun zaman değerlerini görüntülemeyi seçebilir. Daha DateTimeFormatInfo önce açıklanan yollarla alınan nesnelerin tümü bu kullanıcı geçersiz kılmalarını yansıtır. Bu istenmeyen bir durumsa, oluşturucuyu çağırarak CultureInfo.CultureInfo(String, Boolean) ve bağımsız değişken için useUserOverride değerini sağlayarak kullanıcı geçersiz kılmalarını yansıtmayan (NumberFormatInfove salt okunur yerine okuma/yazma) bir false nesne oluşturabilirsiniz. Aşağıdaki örnekte, geçerli kültürü İngilizce (Birleşik Devletler) olan ve uzun zaman deseni varsayılan h:mm:ss tt olan HH:mm:ss olarak değiştirilmiş bir sistem için bu gösterilmektedir.

using System;
using System.Globalization;

public class InstantiateEx3
{
    public static void Main()
    {
        CultureInfo culture;
        DateTimeFormatInfo dtfi;

        culture = CultureInfo.CurrentCulture;
        dtfi = culture.DateTimeFormat;
        Console.WriteLine("Culture Name:      {0}", culture.Name);
        Console.WriteLine("User Overrides:    {0}", culture.UseUserOverride);
        Console.WriteLine("Long Time Pattern: {0}\n", culture.DateTimeFormat.LongTimePattern);

        culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
        Console.WriteLine("Culture Name:      {0}", culture.Name);
        Console.WriteLine("User Overrides:    {0}", culture.UseUserOverride);
        Console.WriteLine("Long Time Pattern: {0}\n", culture.DateTimeFormat.LongTimePattern);
    }
}
// The example displays the following output:
//       Culture Name:      en-US
//       User Overrides:    True
//       Long Time Pattern: HH:mm:ss
//
//       Culture Name:      en-US
//       User Overrides:    False
//       Long Time Pattern: h:mm:ss tt

DateTimeFormatInfo ve dinamik veri

Sınıf tarafından sağlanan tarih ve saat değerlerini biçimlendirmek için kültüre DateTimeFormatInfo özgü veriler, sınıfın CultureInfo sağladığı kültürel veriler gibi dinamiktir. Belirli CultureInfo nesnelerle ilişkili nesneler için DateTimeFormatInfo değerlerin kararlılığı hakkında hiçbir varsayımda bulunmamalısınız. Yalnızca sabit kültür ve ilişkili DateTimeFormatInfo nesnesi tarafından sağlanan veriler kararlıdır. Diğer veriler, uygulama oturumları arasında veya uygulamanız çalışırken bile değişebilir. Dört önemli değişiklik kaynağı vardır:

Sistem güncelleştirmeleri. Tercih edilen takvim veya özel tarih ve saat biçimleri gibi kültürel tercihler zaman içinde değişir. Bu durumda, Windows Update belirli bir kültür için DateTimeFormatInfo özellik değerinde değişiklikler içerir.
Değişim kültürleri. sınıfı, CultureAndRegionInfoBuilder mevcut bir kültürün verilerini değiştirmek için kullanılabilir.
Özellik değerlerinde basamaklı değişiklikler. Kültürle ilgili bir dizi özellik çalışma zamanında değişebilir ve bu da verilerin değişmesine neden olur DateTimeFormatInfo . Örneğin, geçerli kültür program aracılığıyla veya kullanıcı eylemi aracılığıyla değiştirilebilir. Bu durumda, DateTimeFormatInfo özelliği tarafından CurrentInfo döndürülen nesne geçerli kültürle ilişkilendirilmiş bir nesneye dönüşür. Benzer şekilde, bir kültürün takvimi değişebilir ve bu da çok sayıda DateTimeFormatInfo özellik değerinde değişiklik olmasına neden olabilir.
Kullanıcı tercihleri. Uygulamanızın kullanıcıları, Denetim Masası'deki bölgesel ve dil seçenekleri aracılığıyla geçerli sistem kültürüyle ilişkili bazı değerleri geçersiz kılmayı seçebilir. Örneğin, kullanıcılar tarihi farklı bir biçimde görüntülemeyi seçebilir. CultureInfo.UseUserOverride özelliği olarak trueayarlanırsa, nesnenin DateTimeFormatInfo özellikleri de kullanıcı ayarlarından alınır. Kullanıcı ayarları nesneyle ilişkili kültürle CultureInfo uyumsuzsa (örneğin, seçilen takvim özelliği tarafından OptionalCalendars belirtilen takvimlerden biri değilse), yöntemlerin sonuçları ve özelliklerin değerleri tanımlanmamış olur.

Tutarsız veri olasılığını en aza indirmek için, nesne oluşturulduğunda nesnenin DateTimeFormatInfo tüm kullanıcı tarafından geçersiz kılınabilir özellikleri başlatılır. Nesne oluşturma veya kullanıcı geçersiz kılma işlemi atomik olmadığından ve nesne oluşturma sırasında ilgili değerler değişebileceğinden tutarsızlık olasılığı hala vardır. Ancak, bu durum son derece nadir olmalıdır.

Kullanıcı geçersiz kılmalarının sistem kültürüyle aynı kültürü temsil eden nesnelere DateTimeFormatInfo yansıtılıp yansıtılmayacağını denetleyebilirsiniz. Aşağıdaki tabloda, bir DateTimeFormatInfo nesnenin alınabileceği yollar listelenir ve sonuçta elde edilen nesnenin kullanıcı geçersiz kılmalarını yansıtıp yansıtmadığı gösterilir.

CultureInfo ve DateTimeFormatInfo nesnesinin kaynağı	Düşünceler kullanıcı geçersiz kılmaları
`CultureInfo.CurrentCulture.DateTimeFormat` Özellik	Yes
DateTimeFormatInfo.CurrentInfo Özellik	Yes
CultureInfo.CreateSpecificCulture Yöntem	Yes
CultureInfo.GetCultureInfo Yöntem	Hayır
CultureInfo.CultureInfo(String) Oluşturucu	Yes
CultureInfo.CultureInfo(String, Boolean) Oluşturucu	Parametrenin `useUserOverride` değerine bağlıdır

Aksini yapmak için zorlayıcı bir neden yoksa, istemci uygulamalarında kullanıcı girişini biçimlendirmek ve ayrıştırmak veya verileri görüntülemek için nesnesini kullanırken DateTimeFormatInfo kullanıcı geçersiz kılmalarına dikkat etmelisiniz. Sunucu uygulamaları veya katılımsız uygulamalar için bunu yapmalısınız. Ancak, dize biçiminde tarih ve saat verilerini kalıcı hale getirmek için nesnesini açıkça veya örtük olarak kullanıyorsanız DateTimeFormatInfo , sabit kültürün biçimlendirme kurallarını yansıtan bir DateTimeFormatInfo nesne kullanmanız veya kültürden bağımsız olarak kullanacağınız özel bir tarih ve saat biçimi dizesi belirtmeniz gerekir.

Tarihleri ve saatleri biçimlendirme

Nesne DateTimeFormatInfo , tüm tarih ve saat biçimlendirme işlemlerinde örtük veya açıkça kullanılır. Bunlar aşağıdaki yöntemlere yapılan çağrıları içerir:

ve DateTimeOffset.ToString(String)gibi DateTime.ToString() tüm tarih ve saat biçimlendirme yöntemleri.
Birincil bileşik biçimlendirme yöntemi olan String.Format.
ve StringBuilder.AppendFormat(String, Object[])gibi Console.WriteLine(String, Object[]) diğer bileşik biçimlendirme yöntemleri.

Tüm tarih ve saat biçimlendirme işlemleri bir IFormatProvider uygulamayı kullanır. Arabirimi tek IFormatProvider bir yöntem içerir: IFormatProvider.GetFormat(Type). Bu geri çağırma yöntemine, biçimlendirme bilgileri sağlamak için gereken türü temsil eden bir Type nesne geçirilir. yöntemi, bu türün bir örneğini veya null türün bir örneğini sağlayamıyorsa döndürür. .NET, tarihleri ve saatleri biçimlendirmek için iki IFormatProvider uygulama içerir:

Belirli CultureInfo bir kültürü (veya belirli bir ülkede/bölgede belirli bir dili) temsil eden sınıfı. Bir tarih ve saat biçimlendirme işleminde yöntemi, CultureInfo.GetFormat özelliğiyle CultureInfo.DateTimeFormat ilişkili nesneyi döndürürDateTimeFormatInfo.
sınıfı DateTimeFormatInfo , ilişkili kültürünün biçimlendirme kuralları hakkında bilgi sağlar. DateTimeFormatInfo.GetFormat yöntemi kendi örneğini döndürür.

Bir biçimlendirme yöntemine açıkça bir IFormatProvider uygulama sağlanmazsa, CultureInfo geçerli kültürü temsil eden özellik tarafından CultureInfo.CurrentCulture döndürülen nesne kullanılır.

Aşağıdaki örnek, biçimlendirme işlemlerinde arabirim ile sınıf arasındaki IFormatProvider ilişkiyi DateTimeFormatInfo gösterir. Yöntemi biçimlendirme işlemi tarafından istenen nesnenin türünü görüntüleyen özel IFormatProvider bir uygulama GetFormat tanımlar. Bir DateTimeFormatInfo nesne istiyorsa, yöntemi geçerli kültür için nesnesini sağlar DateTimeFormatInfo . Örnekteki çıktıda gösterildiği gibi, Decimal.ToString(IFormatProvider) yöntem biçimlendirme bilgileri sağlamak için bir DateTimeFormatInfo nesnesine istekte bulunurkenString.Format(IFormatProvider, String, Object[]), yöntem hem nesne hem DateTimeFormatInfo de uygulama ICustomFormatter isteğinde bulunurNumberFormatInfo.

using System;
using System.Globalization;

public class CurrentCultureFormatProvider : IFormatProvider
{
    public Object GetFormat(Type formatType)
    {
        Console.WriteLine("Requesting an object of type {0}",
                          formatType.Name);
        if (formatType == typeof(NumberFormatInfo))
            return NumberFormatInfo.CurrentInfo;
        else if (formatType == typeof(DateTimeFormatInfo))
            return DateTimeFormatInfo.CurrentInfo;
        else
            return null;
    }
}

public class FormatProviderEx1
{
    public static void Main()
    {
        DateTime dateValue = new DateTime(2013, 5, 28, 13, 30, 0);
        string value = dateValue.ToString("F", new CurrentCultureFormatProvider());
        Console.WriteLine(value);
        Console.WriteLine();
        string composite = String.Format(new CurrentCultureFormatProvider(),
                                         "Date: {0:d}   Amount: {1:C}   Description: {2}",
                                         dateValue, 1264.03m, "Service Charge");
        Console.WriteLine(composite);
        Console.WriteLine();
    }
}
// The example displays output like the following:
//       Requesting an object of type DateTimeFormatInfo
//       Tuesday, May 28, 2013 1:30:00 PM
//
//       Requesting an object of type ICustomFormatter
//       Requesting an object of type DateTimeFormatInfo
//       Requesting an object of type NumberFormatInfo
//       Date: 5/28/2013   Amount: $1,264.03   Description: Service Charge

Dizeleri ve DateTimeFormatInfo özelliklerini biçimlendirme

nesnesi, DateTimeFormatInfo tarih ve saat değerleriyle biçimlendirme işlemlerinde kullanılan üç tür özellik içerir:

Takvimle ilgili özellikler. , , DayNamesve MonthNamesgibi AbbreviatedMonthNames AbbreviatedDayNamesözellikler, kültür tarafından kullanılan ve özelliği tarafından Calendar tanımlanan takvimle ilişkilendirilir. Bu özellikler uzun tarih ve saat biçimleri için kullanılır.
Standart tanımlı sonuç dizesi üreten özellikler. RFC1123Pattern, SortableDateTimePatternve UniversalSortableDateTimePattern özellikleri, uluslararası standartlar tarafından tanımlanan sonuç dizelerini üreten özel biçim dizeleri içerir. Bu özellikler salt okunur ve değiştirilemez.
Kültüre duyarlı sonuç dizelerini tanımlayan özellikler. ve ShortDatePatterngibi FullDateTimePattern bazı özellikler, sonuç dizesinin biçimini belirten özel biçim dizeleri içerir. , DateSeparator, PMDesignatorve TimeSeparatorgibi AMDesignatordiğerleri, bir sonuç dizesine dahil edilebilecek kültüre duyarlı simgeler veya alt dizeler tanımlar.

"d", "D", "f" ve "F" gibi standart tarih ve saat biçim dizeleri, belirli DateTimeFormatInfo biçim deseni özelliklerine karşılık gelen diğer adlardır. Özel tarih ve saat biçimi dizelerinin çoğu, bir biçimlendirme işleminin sonuç akışına ekleyen dizelerle veya alt dizelerle ilgilidir. Aşağıdaki tabloda standart ve özel tarih ve saat biçimi tanımlayıcıları ve bunların ilişkili DateTimeFormatInfo özellikleri listeledik. Bu biçim tanımlayıcılarını kullanma hakkında ayrıntılı bilgi için bkz . Standart Tarih ve Saat Biçim Dizeleri ve Özel Tarih ve Saat Biçimi Dizeleri. Her standart biçim dizesinin, değeri özel bir DateTimeFormatInfo tarih ve saat biçim dizesi olan bir özelliğe karşılık geldiğini unutmayın. Bu özel biçim dizesindeki tek tek tanımlayıcılar da diğer DateTimeFormatInfo özelliklere karşılık gelir. Tabloda yalnızca DateTimeFormatInfo standart biçim dizelerinin diğer ad olduğu özellikler listelenir ve bu diğer ad özelliklerine atanmış özel biçim dizeleri tarafından erişilebilen özellikler listelenmez. Ayrıca, tabloda yalnızca özelliklere DateTimeFormatInfo karşılık gelen özel biçim tanımlayıcıları listelenir.

Biçim belirteci	İlişkili özellikler
"d" (kısa tarih; standart biçim dizesi)	ShortDatePattern, sonuç dizesinin genel biçimini tanımlamak için.
"D" (uzun tarih; standart biçim dizesi)	LongDatePattern, sonuç dizesinin genel biçimini tanımlamak için.
"f" (tam tarih / kısa saat; standart biçim dizesi)	LongDatePattern, sonuç dizesinin tarih bileşeninin biçimini tanımlamak için. ShortTimePattern, sonuç dizesinin zaman bileşeninin biçimini tanımlamak için.
"F" (tam tarih / uzun saat; standart biçim dizesi)	LongDatePattern, sonuç dizesinin tarih bileşeninin biçimini tanımlamak için. LongTimePattern, sonuç dizesinin zaman bileşeninin biçimini tanımlamak için.
"g" (genel tarih / kısa saat; standart biçim dizesi)	ShortDatePattern, sonuç dizesinin tarih bileşeninin biçimini tanımlamak için. ShortTimePattern, sonuç dizesinin zaman bileşeninin biçimini tanımlamak için.
"G" (genel tarih / uzun saat; standart biçim dizesi)	ShortDatePattern, sonuç dizesinin tarih bileşeninin biçimini tanımlamak için. LongTimePattern, sonuç dizesinin zaman bileşeninin biçimini tanımlamak için.
"M", "m" (ay/gün; standart biçim dizesi)	MonthDayPattern, sonuç dizesinin genel biçimini tanımlamak için.
"O", "o" (gidiş dönüş tarihi/saati; standart biçim dizesi)	Yok.
"R", "r" (RFC1123; standart biçim dizesi)	RFC1123Pattern, RFC 1123 standardına uygun bir sonuç dizesi tanımlamak için. Özelliği salt okunurdur.
"s" (sıralanabilir tarih/saat; standart biçim dizesi)	SortableDateTimePattern, ISO 8601 standardına uygun bir sonuç dizesi tanımlamak için. Özelliği salt okunurdur.
"t" (kısa süre; standart biçim dizesi)	ShortTimePattern, sonuç dizesinin genel biçimini tanımlamak için.
"T" (uzun süre; standart biçim dizesi)	LongTimePattern, sonuç dizesinin genel biçimini tanımlamak için.
"u" (evrensel sıralanabilir tarih/saat; standart biçim dizesi)	UniversalSortableDateTimePattern, eşgüdümlü evrensel saat için ISO 8601 standardına uyan bir sonuç dizesi tanımlamak için. Özelliği salt okunurdur.
"U" (evrensel tam tarih/saat; standart biçim dizesi)	FullDateTimePattern, sonuç dizesinin genel biçimini tanımlamak için.
"Y", "y" (yıl ayı; standart biçim dizesi)	YearMonthPattern, sonuç dizesinin genel biçimini tanımlamak için.
"ddd" (özel biçim tanımlayıcısı)	AbbreviatedDayNames, sonuç dizesine haftanın gününün kısaltılmış adını eklemek için.
"g", "gg" (özel biçim tanımlayıcısı)	Sonuç dizesine GetEraName dönem adını eklemek için yöntemini çağırır.
"MMM" (özel biçim belirtici)	AbbreviatedMonthNames, sonuç dizesine kısaltılmış ay adını eklemek için.
"MMMM" (özel biçim tanımlayıcısı)	MonthNames veya MonthGenitiveNames, sonuç dizesine tam ay adını eklemek için.
"t" (özel biçim belirtici)	AMDesignator veya PMDesignator, sonuç dizesine AM/PM belirleyicisinin ilk karakterini eklemek için.
"tt" (özel biçim belirtici)	AMDesignator veya PMDesignator, sonuç dizesine tam AM/PM belirleyicisini eklemek için.
":" (özel biçim tanımlayıcısı)	TimeSeparator, sonuç dizesine zaman ayırıcısını eklemek için.
"/" (özel biçim belirtici)	DateSeparator, sonuç dizesine tarih ayırıcısını eklemek için.

DateTimeFormatInfo özelliklerini değiştirme

Yazılabilir DateTimeFormatInfo bir nesnenin ilişkili özelliklerini değiştirerek tarih ve saat biçim dizeleriyle üretilen sonuç dizesini değiştirebilirsiniz. Bir DateTimeFormatInfo nesnenin yazılabilir olup olmadığını belirlemek için özelliğini kullanın IsReadOnly . Bir DateTimeFormatInfo nesneyi bu şekilde özelleştirmek için:

Biçimlendirme kurallarını değiştirmek istediğiniz bir DateTimeFormatInfo nesnenin okuma/yazma kopyasını oluşturun.
İstenen sonuç dizesini üretmek için kullanılan özelliği veya özellikleri değiştirin. (Biçimlendirme yöntemlerinin sonuç dizelerini tanımlamak için özellikleri nasıl kullandığı DateTimeFormatInfo hakkında bilgi için önceki Dizeleri biçimlendirme ve DateTimeFormatInfo özellikleri bölümüne bakın.)
Biçimlendirme yöntemleri çağrılarında bağımsız değişken olarak IFormatProvider oluşturduğunuz özel DateTimeFormatInfo nesneyi kullanın.

Sonuç dizesinin biçimini değiştirmenin iki yolu daha vardır:

sınıfını CultureAndRegionInfoBuilder kullanarak özel bir kültür (benzersiz bir ada sahip olan ve var olan kültürleri destekleyen bir kültür) veya bir değiştirme kültürü (belirli bir kültür yerine kullanılan kültür) tanımlayabilirsiniz. .NET tarafından desteklenen herhangi bir CultureInfo nesne gibi bu kültüre program aracılığıyla kaydedebilir ve erişebilirsiniz.
Sonuç dizesi kültüre duyarlı değilse ve önceden tanımlanmış bir biçimi izlemiyorsa, özel bir tarih ve saat biçim dizesi kullanabilirsiniz. Örneğin, tarih ve saat verilerini YYYYMMDDHmmss biçiminde serileştiriyorsanız, özel biçim dizesini yöntemine DateTime.ToString(String) geçirerek sonuç dizesini oluşturabilir ve yöntemini çağırarak DateTime.ParseExact sonuç dizesini bir DateTime değere dönüştürebilirsiniz.

Kısa tarih desenini değiştirme

Aşağıdaki örnek, "d" (kısa tarih) standart biçim dizesi tarafından üretilen bir sonuç dizesinin biçimini değiştirir. En-US veya İngilizce (Birleşik Devletler) kültürünün ilişkili ShortDatePattern özelliğini varsayılan "M/d/y" olan "yy'-"MM"-"dd" olarak değiştirir ve özelliğin hem önceki hem de sonraki tarihini görüntülemek için "d" standart biçim dizesini ShortDatePattern kullanır.

using System;
using System.Globalization;

public class Example1
{
    public static void Main()
    {
        DateTime dateValue = new DateTime(2013, 8, 18);
        CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
        DateTimeFormatInfo dtfi = enUS.DateTimeFormat;

        Console.WriteLine("Before modifying DateTimeFormatInfo object: ");
        Console.WriteLine("{0}: {1}\n", dtfi.ShortDatePattern,
                                      dateValue.ToString("d", enUS));

        // Modify the short date pattern.
        dtfi.ShortDatePattern = "yyyy-MM-dd";
        Console.WriteLine("After modifying DateTimeFormatInfo object: ");
        Console.WriteLine("{0}: {1}", dtfi.ShortDatePattern,
                                      dateValue.ToString("d", enUS));
    }
}
// The example displays the following output:
//       Before modifying DateTimeFormatInfo object:
//       M/d/yyyy: 8/18/2013
//
//       After modifying DateTimeFormatInfo object:
//       yyyy-MM-dd: 2013-08-18

Tarih ayırıcı karakterini değiştirme

Aşağıdaki örnek, fr-FR kültürünün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesnedeki tarih ayırıcı karakterini değiştirir. Örnek, özelliğin hem önce hem de sonra değiştirildiği tarihi görüntülemek için "g" standart biçim dizesini DateSeparator kullanır.

using System;
using System.Globalization;

public class Example3
{
    public static void Main()
    {
        DateTime dateValue = new DateTime(2013, 08, 28);
        CultureInfo frFR = CultureInfo.CreateSpecificCulture("fr-FR");
        DateTimeFormatInfo dtfi = frFR.DateTimeFormat;

        Console.WriteLine("Before modifying DateSeparator property: {0}",
                          dateValue.ToString("g", frFR));

        // Modify the date separator.
        dtfi.DateSeparator = "-";
        Console.WriteLine("After modifying the DateSeparator property: {0}",
                          dateValue.ToString("g", frFR));
    }
}
// The example displays the following output:
//       Before modifying DateSeparator property: 28/08/2013 00:00
//       After modifying the DateSeparator property: 28-08-2013 00:00

Gün adı kısaltmalarını ve uzun tarih desenini değiştirme

Bazı durumlarda, genellikle tam gün ve ay adının yanı sıra ayın ve yılın gün sayısını gösteren uzun tarih deseni çok uzun olabilir. Aşağıdaki örnek, en-US kültürünün uzun tarih desenini kısaltarak bir karakter veya iki karakterlik bir gün adı kısaltması ve ardından gün numarası, ay adı kısaltması ve yıl döndürür. Bunu, diziye AbbreviatedDayNames daha kısa gün adı kısaltmaları atayarak ve özelliğine atanan özel biçim dizesini LongDatePattern değiştirerek yapar. Bu, "D" ve "f" standart biçim dizeleri tarafından döndürülen sonuç dizelerini etkiler.

using System;
using System.Globalization;

public class Example2
{
    public static void Main()
    {
        DateTime value = new DateTime(2013, 7, 9);
        CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
        DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
        String[] formats = { "D", "F", "f" };

        // Display date before modifying properties.
        foreach (var fmt in formats)
            Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));

        Console.WriteLine();

        // We don't want to change the FullDateTimePattern, so we need to save it.
        String originalFullDateTimePattern = dtfi.FullDateTimePattern;

        // Modify day name abbreviations and long date pattern.
        dtfi.AbbreviatedDayNames = new String[] { "Su", "M", "Tu", "W", "Th", "F", "Sa" };
        dtfi.LongDatePattern = "ddd dd-MMM-yyyy";
        dtfi.FullDateTimePattern = originalFullDateTimePattern;
        foreach (var fmt in formats)
            Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));
    }
}
// The example displays the following output:
//       D: Tuesday, July 9, 2013
//       F: Tuesday, July 9, 2013 12:00:00 AM
//       f: Tuesday, July 9, 2013 12:00 AM
//
//       D: Tu 09-Jul-2013
//       F: Tuesday, July 9, 2013 12:00:00 AM
//       f: Tu 09-Jul-2013 12:00 AM

Normalde, özelliğindeki LongDatePattern değişiklik de özelliğini etkiler FullDateTimePattern ve bu da "F" standart biçim dizesi tarafından döndürülen sonuç dizesini tanımlar. Özgün tam tarih ve saat desenini korumak için, örnek özellik değiştirildikten sonra özelliğe atanan özgün özel biçim dizesini FullDateTimePattern yeniden atayın LongDatePattern .

12 saatlik saatten 24 saatlik saate değiştirme

.NET'teki birçok kültür için zaman, 12 saatlik bir saat ve am/PM göstergesi kullanılarak ifade edilir. Aşağıdaki örnek, 12 saatlik bir saat kullanan herhangi bir ReplaceWith24HourClock saat biçimini 24 saatlik saat kullanan bir biçimle değiştiren bir yöntem tanımlar.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example5
{
    public static void Main()
    {
        CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
        DateTimeFormatInfo dtfi = enUS.DateTimeFormat;

        Console.WriteLine("Original Property Values:");
        Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern);
        Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern);
        Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern);
        Console.WriteLine();

        dtfi.LongTimePattern = ReplaceWith24HourClock(dtfi.LongTimePattern);
        dtfi.ShortTimePattern = ReplaceWith24HourClock(dtfi.ShortTimePattern);

        Console.WriteLine("Modififed Property Values:");
        Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern);
        Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern);
        Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern);
    }

    private static string ReplaceWith24HourClock(string fmt)
    {
        string pattern = @"^(?<openAMPM>\s*t+\s*)? " +
                         @"(?(openAMPM) h+(?<nonHours>[^ht]+)$ " +
                         @"| \s*h+(?<nonHours>[^ht]+)\s*t+)";
        return Regex.Replace(fmt, pattern, "HH${nonHours}",
                             RegexOptions.IgnorePatternWhitespace);
    }
}
// The example displays the following output:
//       Original Property Values:
//       ShortTimePattern: h:mm tt
//       LongTimePattern: h:mm:ss tt
//       FullDateTimePattern: dddd, MMMM dd, yyyy h:mm:ss tt
//
//       Modififed Property Values:
//       ShortTimePattern: HH:mm
//       LongTimePattern: HH:mm:ss
//       FullDateTimePattern: dddd, MMMM dd, yyyy HH:mm:ss

Örnek, biçim dizesini değiştirmek için normal bir ifade kullanır. Normal ifade deseni @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) aşağıdaki gibi tanımlanır:

Desen	Açıklama
`^`	Eşleşmeye dizenin başında başlayın.
`(?<openAMPM>\st+\s)?`	Sıfır veya daha fazla boşluk karakterinin sıfır veya bir oluşumunu, ardından bir veya daha fazla kez "t" harfini ve ardından sıfır veya daha fazla boşluk karakterini eşleştirin. Bu yakalama grubu olarak adlandırılır `openAMPM`.
`(?(openAMPM) h+(?<nonHours>[^ht]+)$`	Grubun eşleşmesi `openAMPM` varsa, "h" harfini bir veya daha fazla kez eşleştirin ve ardından "h" veya "t" olmayan bir veya daha fazla karakter ekleyin. Eşleşme, dizenin sonunda sona erer. "h" sonrasında yakalanan tüm karakterler adlı `nonHours`bir yakalama grubuna eklenir.
`\| \sh+(?<nonHours>[^ht]+)\st+)`	`openAMPM` Grubun eşleşmesi yoksa, "h" harfini bir veya daha fazla kez eşleştirin, ardından "h" veya "t" olmayan bir veya daha fazla karakter ve ardından sıfır veya daha fazla boşluk karakteri ekleyin. Son olarak, "t" harfinin bir veya daha fazla tekrarını eşleştirin. "h" sonrasında ve beyaz boşluklar ve "t" öncesinde yakalanan tüm karakterler adlı `nonHours`bir yakalama grubuna eklenir.

nonHours Yakalama grubu, özel bir tarih ve saat biçimi dizesinin dakika ve muhtemelen ikinci bileşenini ve herhangi bir zaman ayırıcı sembollerini içerir. Değiştirme düzeni HH${nonHours} , "HH" alt dizesini bu öğelere ekler.

Bir tarihte dönemi görüntüleme ve değiştirme

Aşağıdaki örnek, en-US kültürünün biçimlendirme kurallarını temsil eden bir nesnenin özelliğine LongDatePattern "g" özel biçim tanımlayıcısını ekler. Bu ekleme aşağıdaki üç standart biçim dizesini etkiler:

Doğrudan özelliğine LongDatePattern eşlenen "D" (uzun tarih) standart biçim dizesi.
ve ShortTimePattern özellikleri tarafından LongDatePattern üretilen alt dizeleri birleştirir bir sonuç dizesi üreten "f" (tam tarih /kısa saat) standart biçim dizesi.
Doğrudan özelliğine eşlenen FullDateTimePattern "F" (tam tarih /uzun saat) standart biçim dizesi. Bu özellik değerini açıkça ayarlamadığımız için ve LongTimePattern özellikleri birleşerek LongDatePattern dinamik olarak oluşturulur.

Örnekte ayrıca takviminde tek bir dönem bulunan bir kültürün dönem adının nasıl değiştirileceği de gösterilmektedir. Bu durumda, en-US kültürü bir GregorianCalendar nesneyle temsil edilen Gregoryen takvimi kullanır. sınıfı GregorianCalendar , A.D. (Anno Domini) olarak adlandırdığı tek bir dönemi destekler. Örnek, özelliğine atanan FullDateTimePattern biçim dizesindeki "g" özel biçim tanımlayıcısını değişmez değer dizesiyle değiştirerek dönem adını C.E. (Common Era) olarak değiştirir. Dönem adı genellikle .NET veya işletim sistemi tarafından sağlanan kültür tablolarındaki özel verilerden yöntemi tarafından GetEraName döndürülür çünkü değişmez dizenin kullanılması gerekir.

using System;
using System.Globalization;

public class Example4
{
    public static void Main()
    {
        DateTime dateValue = new DateTime(2013, 5, 18, 13, 30, 0);
        String[] formats = { "D", "f", "F" };

        CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
        DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
        String originalLongDatePattern = dtfi.LongDatePattern;

        // Display the default form of three long date formats.
        foreach (var fmt in formats)
            Console.WriteLine(dateValue.ToString(fmt, dtfi));

        Console.WriteLine();

        // Modify the long date pattern.
        dtfi.LongDatePattern = originalLongDatePattern + " g";
        foreach (var fmt in formats)
            Console.WriteLine(dateValue.ToString(fmt, dtfi));

        Console.WriteLine();

        // Change A.D. to C.E. (for Common Era)
        dtfi.LongDatePattern = originalLongDatePattern + @" 'C.E.'";
        foreach (var fmt in formats)
            Console.WriteLine(dateValue.ToString(fmt, dtfi));
    }
}
// The example displays the following output:
//       Saturday, May 18, 2013
//       Saturday, May 18, 2013 1:30 PM
//       Saturday, May 18, 2013 1:30:00 PM
//
//       Saturday, May 18, 2013 A.D.
//       Saturday, May 18, 2013 A.D. 1:30 PM
//       Saturday, May 18, 2013 A.D. 1:30:00 PM
//
//       Saturday, May 18, 2013 C.E.
//       Saturday, May 18, 2013 C.E. 1:30 PM
//       Saturday, May 18, 2013 C.E. 1:30:00 PM

Tarih ve saat dizelerini ayrıştırma

Ayrıştırma, bir tarih ve saatin dize gösterimini veya DateTimeOffset değerine dönüştürmeyi DateTime içerir. Bu türlerin her ikisi de ayrıştırma işlemlerini desteklemek için , TryParse, ParseExactve TryParseExact yöntemlerini içerirParse. Parse ve TryParse yöntemleri, çeşitli biçimlere sahip olabilecek bir dizeyi dönüştürürken ParseExact ve TryParseExact dizenin tanımlı bir biçime veya biçime sahip olmasını gerektirir. Ayrıştırma işlemi başarısız olursa Parse ve ParseExact bir özel durum oluşturursa ve TryParseTryParseExact döndürür false.

Ayrıştırma yöntemleri, ayrıştırılacak dizede hangi stil öğelerinin (baştaki, sondaki veya iç boşluk gibi) bulunabileceğini ve ayrıştırılan dizenin veya eksik öğelerin nasıl yorumlanabileceğini belirlemek için örtük olarak veya açıkça bir DateTimeStyles numaralandırma değeri kullanır. veya TryParse yöntemini çağırdığınızda Parse bir DateTimeStyles değer sağlamazsanız, varsayılan DateTimeStyles.AllowWhiteSpacesdeğer , DateTimeStyles.AllowTrailingWhiteve DateTimeStyles.AllowInnerWhite bayraklarını içeren DateTimeStyles.AllowLeadingWhitebileşik stildir. ParseExact ve TryParseExact yöntemleri için varsayılan değerdirDateTimeStyles.None; giriş dizesi tam olarak belirli bir özel tarih ve saat biçimi dizesine karşılık gelir.

Ayrıştırma yöntemleri ayrıca ayrıştırılacak dizede gerçekleşebilecek belirli simgeleri ve desenleri tanımlayan bir DateTimeFormatInfo nesneyi örtük olarak veya açıkça kullanır. Bir DateTimeFormatInfo nesne sağlamazsanız, geçerli kültürün DateTimeFormatInfo nesnesi varsayılan olarak kullanılır. Tarih ve saat dizelerini ayrıştırma hakkında daha fazla bilgi için , , DateTimeOffset.ParseExactve DateTimeOffset.TryParseExactgibi DateTime.Parse DateTime.TryParseayrıştırma yöntemlerine bakın.

Aşağıdaki örnekte tarih ve saat dizelerini ayrıştırma işleminin kültüre duyarlı yapısı gösterilmektedir. en-US, en-GB, fr-FR ve fi-FI kültürlerinin kurallarını kullanarak iki tarih dizesini ayrıştırmaya çalışır. En-US kültüründe 18/8/2014 olarak yorumlanan tarih, diğer üç kültürde bir FormatException özel durum oluşturur çünkü 18 ay sayısı olarak yorumlanır. 2/1/2015, ABD kültüründe ilk ayın ikinci günü olarak ayrıştırılır, ancak kalan kültürlerde ikinci ayın ilk günü olarak ayrıştırılır.

using System;
using System.Globalization;

public class ParseEx1
{
    public static void Main()
    {
        string[] dateStrings = { "08/18/2014", "01/02/2015" };
        string[] cultureNames = { "en-US", "en-GB", "fr-FR", "fi-FI" };

        foreach (var cultureName in cultureNames)
        {
            CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
            Console.WriteLine("Parsing strings using the {0} culture.",
                              culture.Name);
            foreach (var dateStr in dateStrings)
            {
                try
                {
                    Console.WriteLine(String.Format(culture,
                                      "   '{0}' --> {1:D}", dateStr,
                                      DateTime.Parse(dateStr, culture)));
                }
                catch (FormatException)
                {
                    Console.WriteLine("   Unable to parse '{0}'", dateStr);
                }
            }
        }
    }
}
// The example displays the following output:
//       Parsing strings using the en-US culture.
//          '08/18/2014' --> Monday, August 18, 2014
//          '01/02/2015' --> Friday, January 02, 2015
//       Parsing strings using the en-GB culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> 01 February 2015
//       Parsing strings using the fr-FR culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> dimanche 1 février 2015
//       Parsing strings using the fi-FI culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> 1. helmikuuta 2015

Tarih ve saat dizeleri genellikle iki nedenle ayrıştırılır:

Kullanıcı girişini bir tarih ve saat değerine dönüştürmek için.
Tarih ve saat değerini gidiş dönüş yapmak için; başka bir ifadeyle, daha önce dize olarak seri hale getirilmiş bir tarih ve saat değerini seri durumdan çıkarmak için.

Aşağıdaki bölümlerde bu iki işlem daha ayrıntılı olarak açıklanmıştır.

Kullanıcı dizelerini ayrıştırma

Kullanıcı tarafından tarih ve saat dizeleri girişini ayrıştırdığınızda, kullanıcının yapmış olabileceği özelleştirmeler de dahil olmak üzere her zaman kullanıcının kültürel ayarlarını yansıtan bir DateTimeFormatInfo nesne örneği oluşturmanız gerekir. Aksi takdirde, tarih ve saat nesnesi yanlış değerlere sahip olabilir. Kullanıcı kültürel özelleştirmelerini yansıtan bir DateTimeFormatInfo nesnenin örneğini oluşturma hakkında bilgi için DateTimeFormatInfo ve dinamik veriler bölümüne bakın.

Aşağıdaki örnekte, kullanıcı kültürel ayarlarını yansıtan bir ayrıştırma işlemi ile olmayan bir ayrıştırma işlemi arasındaki fark gösterilmektedir. Bu durumda, varsayılan sistem kültürü en-US'dir, ancak kullanıcı kısa tarih desenini varsayılan "M/d/y" yerine "yy/AA/gg" olarak değiştirmek için Denetim Masası, Bölge ve Dil'i kullanmıştır. Kullanıcı kullanıcı ayarlarını yansıtan bir dize girdiğinde ve dize kullanıcı ayarlarını da yansıtan bir DateTimeFormatInfo nesne tarafından ayrıştırıldığında (geçersiz kılmalar), ayrıştırma işlemi doğru bir sonuç döndürür. Ancak, dize standart en-US kültürel ayarlarını yansıtan bir DateTimeFormatInfo nesne tarafından ayrıştırıldığında, ayrıştırma yöntemi bir FormatException özel durum oluşturur çünkü 14'leri yılın son iki basamağını değil ayın sayısı olarak yorumlar.

using System;
using System.Globalization;

public class ParseEx2
{
    public static void Main()
    {
        string inputDate = "14/05/10";

        CultureInfo[] cultures = { CultureInfo.GetCultureInfo("en-US"),
                                 CultureInfo.CreateSpecificCulture("en-US") };

        foreach (var culture in cultures)
        {
            try
            {
                Console.WriteLine("{0} culture reflects user overrides: {1}",
                                  culture.Name, culture.UseUserOverride);
                DateTime occasion = DateTime.Parse(inputDate, culture);
                Console.WriteLine("'{0}' --> {1}", inputDate,
                                  occasion.ToString("D", CultureInfo.InvariantCulture));
            }
            catch (FormatException)
            {
                Console.WriteLine("Unable to parse '{0}'", inputDate);
            }
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//       en-US culture reflects user overrides: False
//       Unable to parse '14/05/10'
//
//       en-US culture reflects user overrides: True
//       '14/05/10' --> Saturday, 10 May 2014

Tarih ve saat verilerini seri hale getirme ve seri durumdan çıkarma

Seri hale getirilmiş tarih ve saat verilerinin gidiş dönüş olması beklenir; diğer bir ifadeyle, serileştirilmiş ve seri durumdan çıkarılmış tüm değerler aynı olmalıdır. Tarih ve saat değeri zaman içindeki tek bir anı temsil ederse, seri durumdan çıkarılmış değer, geri yüklendiği sistemin kültüründen veya saat diliminden bağımsız olarak aynı anı temsil etmelidir. Gidiş dönüş tarih ve saat verilerini başarıyla almak için, verileri oluşturmak ve ayrıştırmak için özelliği tarafından döndürülen sabit kültürün InvariantInfo kurallarını kullanmanız gerekir. Biçimlendirme ve ayrıştırma işlemleri hiçbir zaman varsayılan kültürün kurallarını yansıtmamalıdır. Varsayılan kültürel ayarları kullanırsanız verilerin taşınabilirliği kesinlikle sınırlıdır; başarılı bir şekilde seri durumdan çıkarılabilir, yalnızca kültürel ayarları seri hale getirildiği iş parçacığının ayarlarıyla aynı olan bir iş parçacığında seri durumdan çıkarılabilir. Bazı durumlarda bu, verilerin aynı sistemde başarıyla seri hale getirilemeyeceği ve seri durumdan çıkarılamayacağı anlamına gelir.

Tarih ve saat değerinin saat bileşeni önemliyse, "o" veya "r" standart biçim dizesi kullanılarak UTC'ye dönüştürülmeli ve seri hale getirilmelidir. Zaman verileri daha sonra bir ayrıştırma yöntemi çağrılarak ve bağımsız değişken kültürle provider birlikte uygun biçim dizesi geçirilerek geri yüklenebilir.

Aşağıdaki örnek, bir tarih ve saat değerini yuvarlama işlemini gösterir. ABD Pasifik saatini gözlemleyen ve geçerli kültürü en-US olan bir sistemde tarih ve saati seri hale getirir.

using System;
using System.Globalization;
using System.IO;

public class SerializeEx1
{
    public static void Main()
    {
        StreamWriter sw = new StreamWriter(@".\DateData.dat");
        // Define a date and time to serialize.
        DateTime originalDate = new DateTime(2014, 08, 18, 08, 16, 35);
        // Display information on the date and time.
        Console.WriteLine("Date to serialize: {0:F}", originalDate);
        Console.WriteLine("Current Culture:   {0}",
                          CultureInfo.CurrentCulture.Name);
        Console.WriteLine("Time Zone:         {0}",
                          TimeZoneInfo.Local.DisplayName);
        // Convert the date value to UTC.
        DateTime utcDate = originalDate.ToUniversalTime();
        // Serialize the UTC value.
        sw.Write(utcDate.ToString("o", DateTimeFormatInfo.InvariantInfo));
        sw.Close();
    }
}
// The example displays the following output:
//       Date to serialize: Monday, August 18, 2014 8:16:35 AM
//       Current Culture:   en-US
//       Time Zone:         (UTC-08:00) Pacific Time (US & Canada)

Brüksel, Kopenhag, Madrid ve Paris saat dilimindeki ve mevcut kültürü fr-FR olan bir sistemle ilgili verileri seri durumdan çıkartır. Geri yüklenen tarih, utc'nin sekiz saat gerisinden UTC'nin bir saat ilerisine kadar olan saat dilimi ayarlamasını yansıtan özgün tarihten dokuz saat sonradır. Hem özgün tarih hem de geri yüklenen tarih, zaman içinde aynı anı temsil eden bir tarihtir.

using System;
using System.Globalization;
using System.IO;

public class SerializeEx2
{
    public static void Main()
    {
        // Open the file and retrieve the date string.
        StreamReader sr = new StreamReader(@".\DateData.dat");
        String dateValue = sr.ReadToEnd();

        // Parse the date.
        DateTime parsedDate = DateTime.ParseExact(dateValue, "o",
                              DateTimeFormatInfo.InvariantInfo);
        // Convert it to local time.
        DateTime restoredDate = parsedDate.ToLocalTime();
        // Display information on the date and time.
        Console.WriteLine("Deserialized date: {0:F}", restoredDate);
        Console.WriteLine("Current Culture:   {0}",
                          CultureInfo.CurrentCulture.Name);
        Console.WriteLine("Time Zone:         {0}",
                          TimeZoneInfo.Local.DisplayName);
    }
}
// The example displays the following output:
//    Deserialized date: lundi 18 août 2014 17:16:35
//    Current Culture:   fr-FR
//    Time Zone:         (UTC+01:00) Brussels, Copenhagen, Madrid, Paris