DateTimeFormatInfo Sınıf

Tanım

Ad Alanı:: System.Globalization

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

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

Bütünleştirilmiş Kod:: System.Globalization.dll

Bütünleştirilmiş Kod:: System.Runtime.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Kaynak:: DateTimeFormatInfo.cs

Kaynak:: DateTimeFormatInfo.cs

Kaynak:: DateTimeFormatInfo.cs

Kaynak:: DateTimeFormatInfo.cs

Kaynak:: DateTimeFormatInfo.cs

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Tarih ve saat değerlerinin biçimi hakkında kültüre özgü bilgiler sağlar.

public ref class DateTimeFormatInfo sealed : IFormatProvider

public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider

public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider, System::Runtime::Serialization::ISerializable

public sealed class DateTimeFormatInfo : IFormatProvider

public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider

[System.Serializable]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider, System.Runtime.Serialization.ISerializable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider

type DateTimeFormatInfo = class
    interface IFormatProvider

type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider

[<System.Serializable>]
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
    interface ISerializable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider

Public NotInheritable Class DateTimeFormatInfo
Implements IFormatProvider

Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider

Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider, ISerializable

Devralma: Object
DateTimeFormatInfo

Öznitelikler: SerializableAttribute ComVisibleAttribute

Uygulamalar: IFormatProvider ICloneable ISerializable

Örnekler

Aşağıdaki örnek, İngilizce (Birleşik Devletler) kültürü için DateTimeFormatInfo nesnesinin özelliklerini almak için yansımayı kullanır. Özel biçim dizeleri içeren ve biçimlendirilmiş tarihleri görüntülemek için bu dizeleri kullanan özelliklerin değerini görüntüler.

using System;
using System.Globalization;
using System.Reflection;

public class FormatExample1
{
   public static void Run()
   {
      // Get the properties of an en-US DateTimeFormatInfo object.
      DateTimeFormatInfo dtfi = CultureInfo.GetCultureInfo("en-US").DateTimeFormat;
      Type typ = dtfi.GetType();
      PropertyInfo[] props = typ.GetProperties();
      DateTime value = new DateTime(2012, 5, 28, 11, 35, 0);

      foreach (var prop in props) {
         // Is this a format pattern-related property?
         if (prop.Name.Contains("Pattern")) {
            string fmt = prop.GetValue(dtfi, null).ToString();
            Console.WriteLine("{0,-33} {1} \n{2,-37}Example: {3}\n",
                              prop.Name + ":", fmt, "",
                              value.ToString(fmt));
         }
      }
   }
}
// The example displays the following output:
//    FullDateTimePattern:              dddd, MMMM dd, yyyy h:mm:ss tt
//                                         Example: Monday, May 28, 2012 11:35:00 AM
//
//    LongDatePattern:                  dddd, MMMM dd, yyyy
//                                         Example: Monday, May 28, 2012
//
//    LongTimePattern:                  h:mm:ss tt
//                                         Example: 11:35:00 AM
//
//    MonthDayPattern:                  MMMM dd
//                                         Example: May 28
//
//    RFC1123Pattern:                   ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
//                                         Example: Mon, 28 May 2012 11:35:00 GMT
//
//    ShortDatePattern:                 M/d/yyyy
//                                         Example: 5/28/2012
//
//    ShortTimePattern:                 h:mm tt
//                                         Example: 11:35 AM
//
//    SortableDateTimePattern:          yyyy'-'MM'-'dd'T'HH':'mm':'ss
//                                         Example: 2012-05-28T11:35:00
//
//    UniversalSortableDateTimePattern: yyyy'-'MM'-'dd HH':'mm':'ss'Z'
//                                         Example: 2012-05-28 11:35:00Z
//
//    YearMonthPattern:                 MMMM, yyyy
//                                         Example: May, 2012

Imports System.Globalization
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get the properties of an en-US DateTimeFormatInfo object.
      Dim dtfi As DateTimeFormatInfo = CultureInfo.GetCultureInfo("en-US").DateTimeFormat
      Dim typ As Type = dtfi.GetType()
      Dim props() As PropertyInfo = typ.GetProperties()
      Dim value As Date = #05/28/2012 11:35AM# 
      
      For Each prop In props
         ' Is this a format pattern-related property?
         If prop.Name.Contains("Pattern") Then
            Dim fmt As String = CStr(prop.GetValue(dtfi, Nothing))
            Console.WriteLine("{0,-33} {1} {2}{3,-37}Example: {4}", 
                              prop.Name + ":", fmt, vbCrLf, "",
                              value.ToString(fmt)) 
            Console.WriteLine()
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    FullDateTimePattern:              dddd, MMMM dd, yyyy h:mm:ss tt
'                                         Example: Monday, May 28, 2012 11:35:00 AM
'    
'    LongDatePattern:                  dddd, MMMM dd, yyyy
'                                         Example: Monday, May 28, 2012
'    
'    LongTimePattern:                  h:mm:ss tt
'                                         Example: 11:35:00 AM
'    
'    MonthDayPattern:                  MMMM dd
'                                         Example: May 28
'    
'    RFC1123Pattern:                   ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
'                                         Example: Mon, 28 May 2012 11:35:00 GMT
'    
'    ShortDatePattern:                 M/d/yyyy
'                                         Example: 5/28/2012
'    
'    ShortTimePattern:                 h:mm tt
'                                         Example: 11:35 AM
'    
'    SortableDateTimePattern:          yyyy'-'MM'-'dd'T'HH':'mm':'ss
'                                         Example: 2012-05-28T11:35:00
'    
'    UniversalSortableDateTimePattern: yyyy'-'MM'-'dd HH':'mm':'ss'Z'
'                                         Example: 2012-05-28 11:35:00Z
'    
'    YearMonthPattern:                 MMMM, yyyy
'                                         Example: May, 2012

Açıklamalar

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 duyarsız 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:

InvariantInfo özelliğinin değerini alarak. Döndürülen DateTimeFormatInfo nesnesi salt okunurdur.
Parametresiz DateTimeFormatInfo oluşturucuyu çağırarak. Döndürülen DateTimeFormatInfo nesnesi okuma/yazma özelliğine sahiptir.
DateTimeFormat özelliği tarafından döndürülen CultureInfo nesnesinden CultureInfo.InvariantCulture özelliğinin değerini alarak. Döndürülen DateTimeFormatInfo nesnesi salt okunurdur.

Aşağıdaki örnek, sabit kültürü temsil eden bir DateTimeFormatInfo nesnesi ö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 ABD'de 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 kültürün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesnesinin örneğini aşağıdaki yollarla oluşturabilirsiniz:

CultureInfo.GetCultureInfo(String) yöntemini çağırarak ve döndürülen CultureInfo nesnesinin CultureInfo.DateTimeFormat özelliğinin değerini alarak. Döndürülen DateTimeFormatInfo nesnesi salt okunurdur.
Statik GetInstance yöntemine, nesnesini almak istediğiniz kültürü temsil eden bir CultureInfo DateTimeFormatInfo nesnesi geçirerek. Döndürülen DateTimeFormatInfo nesnesi okuma/yazma özelliğine sahiptir.
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 nesnesi okuma/yazma özelliğine sahiptir.
CultureInfo.CultureInfo sınıf kurucusunu çağırarak ve döndürülen CultureInfo nesnesinin CultureInfo.DateTimeFormat özelliğinin değerini elde ederek. Döndürülen DateTimeFormatInfo nesnesi okuma/yazma özelliğine sahiptir.

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, nötr en kültürünün DateTimeFormatInfo nesnesi en-US kültürün biçimlendirme kurallarını, fr kültürünün DateTimeFormatInfo nesnesi de fr-FR kültürü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:

CurrentInfo özelliğinin değerini alarak. Döndürülen DateTimeFormatInfo nesnesi salt okunurdur.
DateTimeFormat özelliği tarafından döndürülen CultureInfo nesnesinden CultureInfo.CurrentCulture özelliğinin değerini alarak. Döndürülen DateTimeFormatInfo nesnesi salt okunurdur.
Geçerli kültürü temsil eden bir GetInstance nesneyle CultureInfo metodunu çağırarak. Döndürülen DateTimeFormatInfo nesnesi salt okunurdur.

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 birini kullanarak bir DateTimeFormatInfo nesnesi elde edip, alınan Clone nesnesinde DateTimeFormatInfo yöntemini çağırın. Bu, özgün DateTimeFormatInfo nesnesinin bir kopyasını oluşturur; ancak IsReadOnly özelliği false şeklindedir.
CultureInfo.CreateSpecificCulture yöntemini çağırarak geçerli kültürü temsil eden bir CultureInfo nesnesi oluşturun ve daha sonra CultureInfo.DateTimeFormat nesnesini almak için DateTimeFormatInfo özelliğini kullanın.

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 CultureInfo nesneler için 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. CultureAndRegionInfoBuilder sınıfı, 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 döndürülen CurrentInfo nesnesi geçerli kültürle ilişkili 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 nesnesinin 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ğı	Kullanıcı ayar değişikliklerini yansıtır
`CultureInfo.CurrentCulture.DateTimeFormat` özellik	Evet
DateTimeFormatInfo.CurrentInfo özellik	Evet
CultureInfo.CreateSpecificCulture yöntemi	Evet
CultureInfo.GetCultureInfo yöntemi	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 yöntemleri, DateTime.ToString() ve DateTimeOffset.ToString(String) gibi.
Birincil bileşik biçimlendirme yöntemi olan String.Format.
Diğer bileşik biçimlendirme yöntemleri, örneğin Console.WriteLine(String, Object[]) ve StringBuilder.AppendFormat(String, Object[]) gibi.

Tüm tarih ve saat biçimlendirme işlemleri bir IFormatProvider uygulamayı kullanır. IFormatProvider arabirimi IFormatProvider.GetFormat(Type)tek bir yöntem içerir. 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:

Belirli bir kültürü (veya belirli bir ülkede/bölgede belirli bir dili) temsil eden CultureInfo sınıfı. Bir tarih ve saat biçimlendirme işleminde, CultureInfo.GetFormat yöntemi, DateTimeFormatInfo özelliği ile ilişkili CultureInfo.DateTimeFormat nesnesini döndürür.
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 ö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 istediğinden, String.Format(IFormatProvider, String, Object[]) yöntemi NumberFormatInfo ve DateTimeFormatInfo nesnelerinin yanı sıra bir ICustomFormatter uygulaması da istemektedir.

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(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. Kültürün kullandığı ve AbbreviatedDayNames özelliğiyle tanımlanan takvimle ilişkilendirilen özellikler arasında AbbreviatedMonthNames, DayNames, MonthNames ve Calendar bulunur. 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 FullDateTimePatterngibi ShortDatePattern bazı özellikler, sonuç dizesinin biçimini belirten özel biçim dizeleri içerir. , AMDesignator, DateSeparatorve PMDesignatorgibi TimeSeparatordiğ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 tanımlayıcısı	İ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)	None.
"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:

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 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("Modified 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
//
//       Modified 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:

Pattern	Description
`^`	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]+)$`	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.
`\| \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 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 oluşabilen belirli simgeleri ve desenleri tanımlayan bir DateTimeFormatInfo nesnesini ö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.ParseExact DateTimeOffset.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ı (geçersiz kılmaları) da yansıtan bir DateTimeFormatInfo nesnesi tarafından ayrıştırıldığında, 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

Oluşturucular

Name	Description
DateTimeFormatInfo()	Sınıfının kültürden bağımsız (sabit) yeni bir yazılabilir örneğini DateTimeFormatInfo başlatır.

Özellikler

Name	Description
AbbreviatedDayNames	Haftanın günlerinin kültüre özgü kısaltılmış adlarını içeren tek boyutlu bir tür String dizisi alır veya ayarlar.
AbbreviatedMonthGenitiveNames	Geçerli DateTimeFormatInfo nesneyle ilişkili kısaltılmış ay adlarından oluşan bir dize dizisi alır veya ayarlar.
AbbreviatedMonthNames	Ayların kültüre özgü kısaltılmış adlarını içeren tek boyutlu bir dize dizisi alır veya ayarlar.
AMDesignator	Dize belirleyicisini "ante meridiem" (öğlenden önce) olan saatler için alır veya ayarlar.
Calendar	Geçerli kültür için kullanılacak takvimi alır veya ayarlar.
CalendarWeekRule	Yılın ilk takvim haftasını belirlemek için hangi kuralın kullanıldığını belirten bir değer alır veya ayarlar.
CurrentInfo	Geçerli kültüre göre değerleri biçimlendiren salt DateTimeFormatInfo okunur bir nesne alır.
DateSeparator	Bir tarihin bileşenlerini (yıl, ay ve gün) ayıran dizeyi alır veya ayarlar.
DayNames	Haftanın günlerinin kültüre özgü tam adlarını içeren tek boyutlu bir dize dizisi alır veya ayarlar.
FirstDayOfWeek	Haftanın ilk gününü alır veya ayarlar.
FullDateTimePattern	Uzun bir tarih ve uzun saat değeri için özel biçim dizesini alır veya ayarlar.
InvariantInfo	Kültürden bağımsız (sabit) varsayılan salt DateTimeFormatInfo okunur nesneyi alır.
IsReadOnly	Nesnenin DateTimeFormatInfo salt okunur olup olmadığını gösteren bir değer alır.
LongDatePattern	Uzun bir tarih değeri için özel biçim dizesini alır veya ayarlar.
LongTimePattern	Uzun bir süre için özel biçim dizesini alır veya ayarlar.
MonthDayPattern	Ay ve gün değeri için özel biçim dizesini alır veya ayarlar.
MonthGenitiveNames	Geçerli DateTimeFormatInfo nesneyle ilişkili ay adlarından oluşan bir dize dizisi alır veya ayarlar.
MonthNames	Ayların kültüre özgü tam adlarını içeren tek boyutlu bir tür String dizisi alır veya ayarlar.
NativeCalendarName	Geçerli DateTimeFormatInfo nesneyle ilişkili takvimin yerel adını alır.
PMDesignator	Dize belirleyicisini "post meridiem" (öğlenden sonra) olan saatler için alır veya ayarlar.
RFC1123Pattern	Internet Engineering Task Force (IETF) Request for Comments (RFC) 1123 belirtimini temel alan bir zaman değeri için özel biçim dizesini alır.
ShortDatePattern	Kısa bir tarih değeri için özel biçim dizesini alır veya ayarlar.
ShortestDayNames	Geçerli DateTimeFormatInfo nesneyle ilişkili en kısa kısaltılmış gün adlarından oluşan bir dize dizisi alır veya ayarlar.
ShortTimePattern	Kısa bir süre değeri için özel biçim dizesini alır veya ayarlar.
SortableDateTimePattern	Sıralanabilir bir tarih ve saat değeri için özel biçim dizesini alır.
TimeSeparator	Zaman bileşenlerini(saat, dakika ve saniye) ayıran dizeyi alır veya ayarlar.
UniversalSortableDateTimePattern	ISO 8601 tarafından tanımlandığı gibi evrensel, sıralanabilir bir tarih ve saat dizesi için özel biçim dizesini alır.
YearMonthPattern	Bir yıl ve ay değeri için özel biçim dizesini alır veya ayarlar.

Yöntemler

Name	Description
Clone()	öğesinin sığ bir kopyasını DateTimeFormatInfooluşturur.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetAbbreviatedDayName(DayOfWeek)	Geçerli DateTimeFormatInfo nesneyle ilişkili kültüre göre, haftanın belirtilen gününün kültüre özgü kısaltılmış adını döndürür.
GetAbbreviatedEraName(Int32)	Bir kısaltma varsa, belirtilen dönemin kısaltılmış adını içeren dizeyi döndürür.
GetAbbreviatedMonthName(Int32)	Geçerli DateTimeFormatInfo nesneyle ilişkili kültüre göre belirtilen ayın kültüre özgü kısaltılmış adını döndürür.
GetAllDateTimePatterns()	Tarih ve saat değerlerinin biçimlendirilebildiği tüm standart desenleri döndürür.
GetAllDateTimePatterns(Char)	Belirtilen standart biçim dizesi kullanılarak tarih ve saat değerlerinin biçimlendirilebildiği tüm desenleri döndürür.
GetDayName(DayOfWeek)	Geçerli DateTimeFormatInfo nesneyle ilişkilendirilmiş kültüre göre haftanın belirtilen gününün kültüre özgü tam adını döndürür.
GetEra(String)	Belirtilen dönemi temsil eden tamsayıyı döndürür.
GetEraName(Int32)	Belirtilen dönemin adını içeren dizeyi döndürür.
GetFormat(Type)	Tarih ve saat biçimlendirme hizmeti sağlayan belirtilen türde bir nesne döndürür.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetInstance(IFormatProvider)	DateTimeFormatInfo Belirtilen IFormatProviderile ilişkili nesneyi döndürür.
GetMonthName(Int32)	Geçerli DateTimeFormatInfo nesneyle ilişkili kültüre göre belirtilen ayın kültüre özgü tam adını döndürür.
GetShortestDayName(DayOfWeek)	Geçerli DateTimeFormatInfo nesneyle ilişkili haftanın belirtilen günü için en kısa kısaltılmış gün adını alır.
GetType()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
ReadOnly(DateTimeFormatInfo)	Salt DateTimeFormatInfo okunur sarmalayıcı döndürür.
SetAllDateTimePatterns(String[], Char)	Belirtilen standart biçim dizesine karşılık gelen özel tarih ve saat biçim dizelerini ayarlar.
ToString()	Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object)

Belirtik Arabirim Kullanımları

Name	Description
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	SerializationInfo dosyasını hedef nesneyi seri hale getirmek için gereken verilerle doldurur.

Şunlara uygulanır

Ayrıca bkz.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?