DateTimeFormatInfo sınıfı

Uyarı

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 tür DateTimeFormatInfo nesnesinin nasıl örnekleneceği açıklanmaktadı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:

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:

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($"{ci.Name} from CreateSpecificCulture: {dtfi.IsReadOnly}");

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

// Retrieve a culture by calling the GetCultureInfo method.
ci = System.Globalization.CultureInfo.GetCultureInfo("en-AU");
dtfi = ci.DateTimeFormat;
Console.WriteLine($"{ci.Name} from GetCultureInfo: {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($"{ci.Name} from GetInstance: {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ız dili için nötr bir kültürdür ve fr-FR kültürünün üst öğesidir. 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 bu kültürün CultureInfo.Parent özelliği tarafından döndürülen DateTimeFormatInfo nesnesini alarak, nötr bir kültürün CultureInfo.DateTimeFormat nesnesini elde edebilirsiniz. Ana kültür sabit kültürü temsil etmediği sürece, döndürülen DateTimeFormatInfo nesne okuma/yazma özelliklerine sahip 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($"{neutral.Name} from Parent property: {dtfi.IsReadOnly}");

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

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

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

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

// Instantiate a DateTimeFormatInfo object by calling GetInstance.
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr");
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(neutral);
Console.WriteLine($"{neutral.Name} from GetInstance: {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, DateTimeFormatInfo nesnesini genel değerlerle doldurmak yerine, nötr kültürün bir alt kümesi olan belirli bir kültürün biçimlendirme kurallarını yansıtan bir DateTimeFormatInfo nesnesi döndürür. Ö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 {prop.Name} array for {name} and {ci.Name}");
                        break;
                    }

                    for (int ctr = 0; ctr < nList.Count; ctr++)
                    {
                        if (!nList[ctr].Equals(sList[ctr]))
                        {
                            match = false;
                            Console.WriteLine($"   {prop.Name} value different for {name} and {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 {name} and {ci.Name}");
                            match = false;
                            break;
                        }

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

        Console.WriteLine();
    }
}

Geçerli kültür için bir DateTimeFormatInfo nesnesi oluşturun.

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

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:

Aşağıdaki örnek, okuma/yazma DateTimeFormatInfo nesnesini oluşturmanın her bir yolunu 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 DilDateTimeFormatInfoişlemleri biçimlendirme ve ayrıştırma işlemlerinde kullanılan bazı ö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. Önceki bölümlerde açıklanan yöntemlerle elde edilen tüm DateTimeFormatInfo nesneleri, bu kullanıcı geçersiz kılmalarını yansıtır. Bu istenmeyen bir durum olduğunda, NumberFormatInfo oluşturucusunu çağırıp CultureInfo.CultureInfo(String, Boolean) bağımsız değişkeni için false değerini sağlayarak kullanıcı geçersiz kılmalarını yansıtmayan (ve salt okunur yerine okuma/yazma) bir useUserOverride nesne oluşturabilirsiniz. Aşağıdaki örnek, geçerli kültürü İngilizce (Birleşik Devletler) olan ve uzun zaman biçimi varsayılan olarak h:mm:ss tt'den HH:mm:ss'ye değiştirilmiş bir sistemi göstermektedir.

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:      {culture.Name}");
        Console.WriteLine($"User Overrides:    {culture.UseUserOverride}");
        Console.WriteLine($"Long Time Pattern: {culture.DateTimeFormat.LongTimePattern}\n");

        culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
        Console.WriteLine($"Culture Name:      {culture.Name}");
        Console.WriteLine($"User Overrides:    {culture.UseUserOverride}");
        Console.WriteLine($"Long Time Pattern: {culture.DateTimeFormat.LongTimePattern}\n");
    }
}
// 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 DateTimeFormatInfo nesnelerle ilişkili nesneler için CultureInfo 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.

  • Yerine geçen kültürler. 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 DateTimeFormatInfo nesnelerine yansıtılmasını kontrol edebilirsiniz. Aşağıdaki tabloda, bir DateTimeFormatInfo nesnenin nasıl alınabileceği listelenir ve elde edilen nesnenin kullanıcı geçersiz kılmalarını yansıtıp yansıtmadığı gösterilir.

CultureInfo ve DateTimeFormatInfo nesnesinin kaynağı Kullanıcı ayarlamalarını yansıtır
CultureInfo.CurrentCulture.DateTimeFormat özellik Evet
DateTimeFormatInfo.CurrentInfo özellik Evet
CultureInfo.CreateSpecificCulture yöntem Evet
CultureInfo.GetCultureInfo yöntem Hayır
CultureInfo.CultureInfo(String) Oluşturucu Evet
CultureInfo.CultureInfo(String, Boolean) Oluşturucu Parametrenin useUserOverride değerine bağlıdır

Aksi bir gereklilik yoksa, istemci uygulamalarında kullanıcı girişini biçimlendirmek ve ayrıştırmak veya verileri görüntülemek için DateTimeFormatInfo nesnesini kullanırken kullanıcı geçersiz kılmalarına saygı göstermelisiniz. Sunucu uygulamaları veya katılımsız uygulamalar için bunu yapmamalı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:

Tüm tarih ve saat biçimlendirme işlemleri bir IFormatProvider uygulamayı kullanır. Arabirim, tek bir yöntem içerir: IFormatProviderIFormatProvider.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öntem, ya o türün bir örneğini ya da türün bir örneğini sağlayamıyorsa null döndürür. .NET, tarihleri ve saatleri biçimlendirmek için iki IFormatProvider uygulama içerir:

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

Aşağıdaki örnek, biçimlendirme işlemlerinde IFormatProvider arabirimi ile DateTimeFormatInfo sınıfı arasındaki ilişkiyi gösterir. Biçimlendirme işlemi tarafından istenen nesnenin türünü görüntüleyen IFormatProvider yöntemine sahip özel bir GetFormat uygulamasını tanımlar. Bir DateTimeFormatInfo nesnesi talep ediliyorsa, yöntem geçerli kültür için DateTimeFormatInfo nesnesini sağlar. Örnekteki çıktıda gösterildiği gibi, Decimal.ToString(IFormatProvider) yöntemi biçimlendirme bilgileri sağlamak için bir DateTimeFormatInfo nesnesi talep ederken, String.Format(IFormatProvider, String, Object[]) yöntemi hem NumberFormatInfo ve DateTimeFormatInfo nesnelerini hem de bir ICustomFormatter uygulaması talep eder.

using System;
using System.Globalization;

public class CurrentCultureFormatProvider : IFormatProvider
{
    public Object GetFormat(Type formatType)
    {
        Console.WriteLine($"Requesting an object of type {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:

"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 veya AbbreviatedMonthGenitiveNames, 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 göstergesinin ilk karakterini eklemek için.
"tt" (özel biçim belirtici) AMDesignator veya PMDesignator, sonuç dizesine AM/PM belirleyicisinin tamamını 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:

  1. Biçimlendirme kurallarını değiştirmek istediğiniz bir DateTimeFormatInfo nesnenin okuma/yazma kopyasını oluşturun.

  2. İ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.)

  3. Biçimlendirme yöntemleri çağrılarında DateTimeFormatInfo bağımsız değişkeni olarak oluşturduğunuz özel IFormatProvider nesneyi kullanın.

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

  • Özel bir kültürü (benzersiz bir adla var olan kültürleri destekleyen bir kültürü) veya değiştirme kültürünü (belirli bir kültür yerine kullanılan kültürü) tanımlamak için CultureAndRegionInfoBuilder sınıfını kullanabilirsiniz. .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 sonuç dizesini bir DateTime.ParseExact 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 (Amerika Birleşik Devletleri) kültürünün ilişkili ShortDatePattern özelliğini varsayılan "M/d/yyyy" olan biçimden "yyyy'-"MM"-"dd" biçimine değiştirir ve ShortDatePattern özelliği değişmeden önce ve sonra tarihi görüntülemek için "d" standart biçim dizesini 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($"{dtfi.ShortDatePattern}: {dateValue.ToString("d", enUS)}\n");

        // Modify the short date pattern.
        dtfi.ShortDatePattern = "yyyy-MM-dd";
        Console.WriteLine("After modifying DateTimeFormatInfo object: ");
        Console.WriteLine($"{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: {dateValue.ToString("g", frFR)}");

        // Modify the date separator.
        dtfi.DateSeparator = "-";
        Console.WriteLine($"After modifying the DateSeparator property: {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ündeki uzun tarih desenini kısaltarak önce bir veya iki karakterlik bir gün adı kısaltması, 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($"{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($"{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, LongDatePattern özelliğindeki bir değişiklik FullDateTimePattern özelliğini de etkiler, 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, FullDateTimePattern özelliği değiştirildikten sonra özgün özel biçim dizesini LongDatePattern özelliğine yeniden atar.

12 saatlik saatten 24 saatlik saate değiştirme

.NET'teki birçok kültür için zaman, 12 saatlik sistem 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>\s*t+\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]+)$ Eğer openAMPM grubunun eşleşmesi varsa, "h" harfini bir veya daha fazla kez eşleştirin, ardından "h" veya "t" olmayan bir veya daha fazla karakterle devam edin. Eşleşme, dizenin sonunda sona erer. "h" sonrasında yakalanan tüm karakterler nonHours adında bir yakalama grubuna eklenir.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) 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 son olarak sıfır veya daha fazla boşluk karakteri eşleştirin. Son olarak, "t" harfinin bir veya daha fazla tekrarını eşleştirin. "h" sonrasında ve boşluklar ile "t" öncesinde yakalanan tüm karakterler, nonHours adlı bir yakalama grubuna dahil edilir.

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:

  • "D" (uzun tarih) standart biçim dizesi, doğrudan LongDatePattern özelliğine eşlenir.

  • Tam tarih / kısa saat gösterimi sağlayan "f" standart biçim dizesi, LongDatePattern ve ShortTimePattern özellikleri tarafından üretilen alt dizeleri birleştirerek bir sonuç dizesi oluşturur.

  • "FullDateTimePattern" özelliğine doğrudan eşlenen "F" (tam tarih / uzun zaman) standart biçim dizesi. Bu özellik değerini açıkça ayarlamadığımızdan, LongDatePattern ve LongTimePattern özellikleri birleştirilerek dinamik olarak oluşturuluyor.

Ö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 GetEraName yöntemiyle döndürüldüğü için, bir değişmez dize 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 bir DateTime veya DateTimeOffset değerine dönüştürmeyi içerir. Bu türlerin her ikisi de ayrıştırma işlemlerini desteklemek için , Parse, TryParseve ParseExact yöntemlerini içerirTryParseExact. 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 fırlatır, TryParse ve TryParseExact ise false döndürür.

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. DateTimeStyles veya Parse yöntemini çağırdığınızda bir TryParse değeri sağlamazsanız, varsayılan DateTimeStyles.AllowWhiteSpaces değeri, DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite ve DateTimeStyles.AllowInnerWhite bayraklarını içeren bir bileş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 , , DateTime.Parseve DateTime.TryParsegibi DateTimeOffset.ParseExactDateTimeOffset.TryParseExactayrış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 {culture.Name} culture.");
            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 '{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ına sahip bir DateTimeFormatInfo nesne tarafından ayrıştırıldığında, ayrıştırma yöntemi bir FormatException istisna atar çünkü 14'ü yılın son iki basamağı olarak değil, ayın numarası olarak değerlendirir.

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($"{culture.Name} culture reflects user overrides: {culture.UseUserOverride}");
                DateTime occasion = DateTime.Parse(inputDate, culture);
                Console.WriteLine($"'{inputDate}' --> {occasion.ToString("D", CultureInfo.InvariantCulture)}");
            }
            catch (FormatException)
            {
                Console.WriteLine($"Unable to parse '{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 işlemek için, InvariantInfo özelliği tarafından döndürülen değişmez kültürün kurallarını kullanarak verileri oluşturmalı ve ayrıştırmalısınız. 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; çünkü veriler, sadece seri hale getirilmiş iş parçacığının kültürel ayarlarıyla aynı olan bir iş parçacığında başarılı bir şekilde 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 kullanan ve geçerli kültürü en-US olan bir sistemde tarih ve saati serileştirir.

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: {originalDate:F}");
        Console.WriteLine($"Current Culture:   {CultureInfo.CurrentCulture.Name}");
        Console.WriteLine($"Time Zone:         {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 sistemdeki verileri deseriyalize eder. Geri yüklenen tarih, UTC'nin sekiz saat gerisinden bir saat ilerisine kadar olan saat dilimi ayarlamasını yansıtan özgün tarihten dokuz saat daha 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: {restoredDate:F}");
        Console.WriteLine($"Current Culture:   {CultureInfo.CurrentCulture.Name}");
        Console.WriteLine($"Time Zone:         {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
  • Last updated on