DateTimeFormatInfo Sınıf

Tanım

Tarih ve saat değerlerinin biçimi hakkında kültüre özgü bilgiler sağlar.Provides culture-specific information about the format of date and time values.

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.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
type DateTimeFormatInfo = class
    interface IFormatProvider
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
    interface ISerializable
Public NotInheritable Class DateTimeFormatInfo
Implements IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider, ISerializable
Devralma
DateTimeFormatInfo
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki örnek, Ingilizce (Birleşik Devletler) kültürü için DateTimeFormatInfo nesnesinin özelliklerini almak için yansıma kullanır.The following example uses reflection to get the properties of the DateTimeFormatInfo object for the English (United States) culture. Özel biçim dizelerini içeren bu özelliklerin değerini görüntüler ve bu dizeleri biçimlendirilen tarihleri görüntüleyecek şekilde kullanır.It displays the value of those properties that contain custom format strings and uses those strings to display formatted dates.

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

public class Example
{
   public static void Main()
   {
      // 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

DateTimeFormatInfo sınıfının özellikleri, aşağıdaki gibi tarih ve saat değerlerini biçimlendirme veya ayrıştırma için kültüre özgü bilgiler içerir:The properties of the DateTimeFormatInfo class contain culture-specific information for formatting or parsing date and time values such as the following:

  • Tarih değerlerini biçimlendirmek için kullanılan desenler.The patterns used to format date values.

  • Zaman değerlerini biçimlendirmek için kullanılan desenler.The patterns used to format time values.

  • Haftanın günlerinin adları.The names of the days of the week.

  • Yılın aylarının adları.The names of the months of the year.

  • A.M.The A.M. ve Pasifikand P.M. zaman değerlerinde kullanılan göstergeler.designators used in time values.

  • Tarihlerin ifade edildiği takvim.The calendar in which dates are expressed.

Bu bölümde:In this section:

Bir DateTimeFormatInfo nesnesini örneklemeInstantiating a DateTimeFormatInfo object

DateTimeFormatInfo nesnesi, sabit kültürün biçimlendirme kurallarını, belirli bir kültürü, nötr kültürü veya geçerli kültürü temsil edebilir.A DateTimeFormatInfo object can represent the formatting conventions of the invariant culture, a specific culture, a neutral culture, or the current culture. Bu bölümde, her bir DateTimeFormatInfo nesne türünün örneğini oluşturma açıklanmaktadır.This section discusses how to instantiate each type of DateTimeFormatInfo object.

Sabit kültür için bir DateTimeFormatInfo nesnesi örneklemeInstantiating a DateTimeFormatInfo object for the invariant culture

Sabit kültür, kültüre duyarlı olmayan bir kültürü temsil eder.The invariant culture represents a culture that is culture-insensitive. İngilizce dilini temel alır, ancak herhangi bir Ingilizce-konuşma ülkesine/bölgesine uygulanmaz.It is based on the English language, but not on any specific English-speaking country/region. Belirli kültürlerin verileri dinamik olabilir ve yeni kültürel kuralları veya Kullanıcı tercihlerini yansıtacak şekilde değişseler de, sabit kültürün verileri değişmez.Although the data of specific cultures can be dynamic and can change to reflect new cultural conventions or user preferences, the data of the invariant culture does not change. Aşağıdaki yollarla, sabit kültürün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesnesi örneğini oluşturabilirsiniz:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

Aşağıdaki örnek, sabit kültürü temsil eden bir DateTimeFormatInfo nesnesi örneğini oluşturmak için bu yöntemlerin her birini kullanır.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the invariant culture. Ardından nesnenin salt okunurdur.It then indicates whether the object is read-only.

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      
Dim dtfi As System.Globalization.DateTimeFormatInfo

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 bir DateTimeFormatInfo nesnesi örneklemeInstantiating a DateTimeFormatInfo object for a specific culture

Belirli bir kültür, belirli bir ülkede/bölgede konuşulan bir dili temsil eder.A specific culture represents a language that is spoken in a particular country/region. Örneğin, en-US, Birleşik Devletler konuşulan Ingilizce dili temsil eden özel bir kültürdür ve en-CA, Kanada 'da konuşulan Ingilizce dili temsil eden belirli bir kültürdür.For example, en-US is a specific culture that represents the English language spoken in the United States, and en-CA is a specific culture that represents the English language spoken in Canada. Aşağıdaki yollarla belirli bir kültürün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesnesi örneğini oluşturabilirsiniz:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

Aşağıdaki örnek, bir DateTimeFormatInfo nesnesi örneğini oluşturma ve elde edilen nesnenin salt okunurdur olduğunu gösteren bu yolların her birini gösterir.The following example illustrates each of these ways to instantiate a DateTimeFormatInfo object and indicates whether the resulting object is read-only.

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

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

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

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

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

// The example displays the following output:
//      en-US from CreateSpecificCulture: False
//      en-CA from CultureInfo constructor: False
//      en-AU from GetCultureInfo: True
//      en-GB from GetInstance: False
Dim ci As System.Globalization.CultureInfo = Nothing
Dim dtfi As System.Globalization.DateTimeFormatInfo = Nothing

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

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

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


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

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

Bağımsız kültür için bir DateTimeFormatInfo nesnesi örneklemeInstantiating a DateTimeFormatInfo object for a neutral culture

Nötr kültür bir ülke/bölgeden bağımsız bir kültürü veya dili temsil eder; genellikle bir veya daha fazla belirli kültürlerin üst öğesidir.A neutral culture represents a culture or language that is independent of a country/region; it is typically the parent of one or more specific cultures. Örneğin fr, Fransızca dili ve fr-FR kültürünün üst öğesi için nötr bir kültür.For example, Fr is a neutral culture for the French language and the parent of the fr-FR culture. Belirli bir kültürün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesnesi oluşturduğunuz yollarla, nötr bir kültürün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesnesi örneğini oluşturabilirsiniz.You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a neutral culture in the same ways that you create a DateTimeFormatInfo object that represents the formatting conventions of a specific culture. Ayrıca, belirli bir kültürün CultureInfo.Parent özelliğinden bağımsız bir kültür alarak ve CultureInfo.DateTimeFormat özelliği tarafından döndürülen DateTimeFormatInfo nesnesini alarak bağımsız bir kültürün DateTimeFormatInfo nesnesini alabilirsiniz.In addition, you can retrieve a neutral culture's DateTimeFormatInfo object by retrieving a neutral culture from a specific culture's CultureInfo.Parent property and retrieving the DateTimeFormatInfo object returned by its CultureInfo.DateTimeFormat property. Üst kültür sabit kültürü temsil etmediği için döndürülen DateTimeFormatInfo nesnesi okuma/yazma olur.Unless the parent culture represents the invariant culture, the returned DateTimeFormatInfo object is read/write. Aşağıdaki örnekte, nötr kültürü temsil eden bir DateTimeFormatInfo nesnesini örnekleyen bu yollar gösterilmektedir.The following example illustrates these ways of instantiating a DateTimeFormatInfo object that represents a neutral culture.

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

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

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

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

 // The example displays the following output:
 //       fr from Parent property: False
 //       fr from Parent property: False
 //       fr from CultureInfo constructor: False
 //       fr-FR from CreateSpecificCulture: False
 //       fr from GetCultureInfo: True
 //       fr-FR from GetInstance: False      
 Dim specific, neutral As System.Globalization.CultureInfo
 Dim dtfi As System.Globalization.DateTimeFormatInfo

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

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

 ' Instantiate a culture using CreateSpecificCulture. 
 neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr")
 dtfi = neutral.DateTimeFormat
 Console.WriteLine("{0} from CreateSpecificCulture: {1}", neutral.Name, dtfi.IsReadOnly)
 
 ' Retrieve a culture by calling the GetCultureInfo method.
 neutral = System.Globalization.CultureInfo.GetCultureInfo("fr")
 dtfi = neutral.DateTimeFormat
 Console.WriteLine("{0} from GetCultureInfo: {1}", neutral.Name, dtfi.IsReadOnly)
 
 ' Instantiate a DateTimeFormatInfo object by calling GetInstance.  
 neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr")
 dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(neutral)
 Console.WriteLine("{0} from GetInstance: {1}", neutral.Name, dtfi.IsReadOnly)

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

Not

.NET Framework 1,0 sürümleri .NET Framework 3.5.NET Framework 3.5ile, bir nötr kültürün biçimlendirme kurallarını yansıtan bir DateTimeFormatInfo nesnesini almaya çalışmak, bir NotSupportedException özel durumu oluşturur.In the .NET Framework versions 1.0 through .NET Framework 3.5.NET Framework 3.5, trying to retrieve a DateTimeFormatInfo object that reflects the formatting conventions of a neutral culture throws a NotSupportedException exception.

Ancak, nötr kültür belirli bir ülke/bölgeden bağımsız olduğu için kültüre özgü biçimlendirme bilgilerine sahip değildir.However, a neutral culture lacks culture-specific formatting information, because it is independent of a specific country/region. DateTimeFormatInfo nesnesi genel değerlerle doldurulmasının yerine .NET Framework, nötr kültürün bir alt öğesi olan belirli bir kültürün biçimlendirme kurallarını yansıtan bir DateTimeFormatInfo nesnesi döndürür.Instead of populating the DateTimeFormatInfo object with generic values, the .NET Framework returns a DateTimeFormatInfo object that reflects the formatting conventions of a specific culture that is a child of the neutral culture. Örneğin, nötr en kültür için DateTimeFormatInfo nesnesi, en-US kültürün biçimlendirme kurallarını yansıtır ve FR kültürü için DateTimeFormatInfo nesnesi fr-FR kültürünün biçimlendirme kurallarını yansıtır.For example, the DateTimeFormatInfo object for the neutral en culture reflects the formatting conventions of the en-US culture, and the DateTimeFormatInfo object for the fr culture reflects the formatting conventions of the fr-FR culture.

Bağımsız bir kültürün hangi belirli kültürün biçimlendirme kurallarını temsil ettiğini öğrenmek için aşağıdaki gibi kodu kullanabilirsiniz.You can use code like the following to determine which specific culture's formatting conventions a neutral culture represents. Örnek, bir nötr kültürün DateTimeFormatInfo özelliklerini belirli bir alt kültürün özellikleriyle karşılaştırmak için yansıma kullanır.The example uses reflection to compare the DateTimeFormatInfo properties of a neutral culture with the properties of a specific child culture. Aynı takvim türü ve Gregoryen takvimleri için, GregorianCalendar.CalendarType özelliklerinde aynı değerler varsa iki takvimi eşdeğer olacak şekilde değerlendirir.It considers two calendars to be equivalent if they are the same calendar type and, for Gregorian calendars, if their GregorianCalendar.CalendarType properties have identical values.

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

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

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

      foreach (var ci in cultures) {
         bool match = true;     
         // Get the DateTimeFormatInfo for a specific culture.
         DateTimeFormatInfo specificDtfi = ci.DateTimeFormat;
         // Compare the property values of the two.
         foreach (var prop in properties) {
            // We're not interested in the value of IsReadOnly.     
            if (prop.Name == "IsReadOnly") continue;
            
            // For arrays, iterate the individual elements to see if they are the same.
            if (prop.PropertyType.IsArray) { 
               IList nList = (IList) prop.GetValue(dtfi, null);
               IList sList = (IList) prop.GetValue(specificDtfi, null);
               if (nList.Count != sList.Count) {
                  match = false;
Console.WriteLine("   Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name);
                  break;
               } 

               for (int ctr = 0; ctr < nList.Count; ctr++) {
                  if (! nList[ctr].Equals(sList[ctr])) { 
                     match = false;
Console.WriteLine("   {0} value different for {1} and {2}", prop.Name, name, ci.Name);                     
                     break;
                  }     
               }
               
               if (! match) break;
            }
            // Get non-array values.
            else {
               Object specificValue = prop.GetValue(specificDtfi);
               Object neutralValue = prop.GetValue(dtfi);
                               
               // Handle comparison of Calendar objects.
               if (prop.Name == "Calendar") { 
                  // The cultures have a different calendar type.
                  if (specificValue.ToString() != neutralValue.ToString()) {
Console.WriteLine("   Different calendar types for {0} and {1}", name, ci.Name);
                     match = false;
                     break;
                  }
                   
                  if (specificValue is GregorianCalendar) {
                     if (((GregorianCalendar) specificValue).CalendarType != ((GregorianCalendar) neutralValue).CalendarType) {
Console.WriteLine("   Different Gregorian calendar types for {0} and {1}", name, ci.Name);
                        match = false;
                        break;
                     }
                  }
               }
               else if (! specificValue.Equals(neutralValue)) {
                  match = false;
Console.WriteLine("   Different {0} values for {1} and {2}", prop.Name, name, ci.Name);                  
                  break;   
               }
            }        
         }
         if (match) {
            Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'", 
                              name, ci.Name);
            hasOneMatch = true;
         }                                       
      }
      if (! hasOneMatch)
         Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name);            

      Console.WriteLine();
   }
}
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get all the neutral cultures
      Dim names As New List(Of String)
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    Sub(culture) names.Add(culture.Name))
      names.Sort()
      For Each name In names
         ' Ignore the invariant culture.
         If name = "" Then Continue For
         
         ListSimilarChildCultures(name)        
      Next
   End Sub

   Private Sub ListSimilarChildCultures(name As String)
      ' Create the neutral DateTimeFormatInfo object.
      Dim dtfi As DateTimeFormatInfo = CultureInfo.GetCultureInfo(name).DateTimeFormat
      ' Retrieve all specific cultures of the neutral culture.
      Dim cultures() As CultureInfo = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures), 
                               Function(culture) culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase))
      ' Create an array of DateTimeFormatInfo properties
      Dim properties() As PropertyInfo = GetType(DateTimeFormatInfo).GetProperties(BindingFlags.Instance Or BindingFlags.Public)
      Dim hasOneMatch As Boolean = False

      For Each ci In cultures
         Dim match As Boolean = True     
         ' Get the DateTimeFormatInfo for a specific culture.
         Dim specificDtfi As DateTimeFormatInfo = ci.DateTimeFormat
         ' Compare the property values of the two.
         For Each prop In properties
            ' We're not interested in the value of IsReadOnly.     
            If prop.Name = "IsReadOnly" Then Continue For
            
            ' For arrays, iterate the individual elements to see if they are the same.
            If prop.PropertyType.IsArray Then 
               Dim nList As IList = CType(prop.GetValue(dtfi, Nothing), IList)
               Dim sList As IList = CType(prop.GetValue(specificDtfi, Nothing), IList)
               If nList.Count <> sList.Count Then
                  match = false
Console.WriteLine("   Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name)
                  Exit For
               End If 

               For ctr As Integer = 0 To nList.Count - 1
                  If Not nList(ctr).Equals(sList(ctr)) 
                     match = false
Console.WriteLine("   {0} value different for {1} and {2}", prop.Name, name, ci.Name)                     
                     Exit For
                  End If     
               Next
               
               If Not match Then Exit For
            ' Get non-array values.
            Else
               Dim specificValue As Object = prop.GetValue(specificDtfi)
               Dim neutralValue As Object = prop.GetValue(dtfi)
                               
               ' Handle comparison of Calendar objects.
               If prop.Name = "Calendar" Then 
                  ' The cultures have a different calendar type.
                  If specificValue.ToString() <> neutralValue.ToString() Then
Console.WriteLine("   Different calendar types for {0} and {1}", name, ci.Name)
                     match = False
                     Exit For
                  End If
                   
                  If TypeOf specificValue Is GregorianCalendar Then
                     If CType(specificValue, GregorianCalendar).CalendarType <> CType(neutralValue, GregorianCalendar).CalendarType Then
Console.WriteLine("   Different Gregorian calendar types for {0} and {1}", name, ci.Name)
                        match = False
                        Exit For
                     End If
                  End If
               Else If Not specificValue.Equals(neutralValue) Then
                  match = false
Console.WriteLine("   Different {0} values for {1} and {2}", prop.Name, name, ci.Name)                  
                  Exit For   
               End If
            End If        
         Next
         If match Then
            Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'", 
                                      name, ci.Name)
            hasOneMatch = True
         End If                                       
      Next
      If Not hasOneMatch Then
         Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name)            
      End If
      
      Console.WriteLine()
   End Sub
End Module

Geçerli kültür için bir DateTimeFormatInfo nesnesi örneklemeInstantiating a DateTimeFormatInfo object for the current culture

Geçerli kültürün biçimlendirme kurallarını aşağıdaki yollarla temsil eden bir DateTimeFormatInfo nesnesi örneği oluşturabilirsiniz:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture in the following ways:

Aşağıdaki örnek, geçerli kültürün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesnesi örneğini oluşturmak için bu yöntemlerin her birini kullanır.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture. Ardından nesnenin salt okunurdur.It then indicates whether the object is read-only.

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
Dim dtfi As DateTimeFormatInfo

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

Şu yollarla geçerli iş parçacığı kültürünün kurallarını temsil eden yazılabilir bir DateTimeFormatInfo nesnesi oluşturabilirsiniz:You can create a writable DateTimeFormatInfo object that represents the conventions of the current thread culture in one of these ways:

Aşağıdaki örnek, okuma/yazma DateTimeFormatInfo nesnesini örneketmenin her bir yolunu gösterir ve IsReadOnly özelliğinin değerini görüntüler.The following example illustrates each way of instantiating a read/write DateTimeFormatInfo object and displays the value of its IsReadOnly property.

using System;
using System.Globalization;

public class Example
{
   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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As DateTimeFormatInfo = DateTimeFormatInfo.CurrentInfo
      current1 = CType(current1.Clone(), DateTimeFormatInfo)
      Console.WriteLine(current1.IsReadOnly)

      Dim culture2 As CultureInfo = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name)
      Dim current2 As DateTimeFormatInfo = culture2.DateTimeFormat
      Console.WriteLine(current2.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       False
'       False

Windows 'ta Kullanıcı, Denetim Masası 'ndaki bölge ve dil uygulaması aracılığıyla biçimlendirme ve ayrıştırma işlemlerinde kullanılan bazı DateTimeFormatInfo özellik değerlerini geçersiz kılabilir.In Windows, the user can override some of the DateTimeFormatInfo property values used in formatting and parsing operations through the Region and Language application in Control Panel. Örneğin, kültürü Ingilizce (Birleşik Devletler) olan bir Kullanıcı, varsayılan 12 saatlik saat yerine (HH: mm: ss biçiminde), uzun zaman değerlerini 24 saatlik bir saat (SS: DD: ss biçiminde) kullanarak görüntülemeyi seçebilir.For example, a user whose culture is English (United States) might choose to display long time values using a 24-hour clock (in the format HH:mm:ss) instead of the default 12-hour clock (in the format h:mm:ss tt). Daha önce tüm bu kullanıcı geçersiz kılmalarını yansıtan DateTimeFormatInfo nesneleri alındı.The DateTimeFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Bu kullanım dışı ise, CultureInfo.CultureInfo(String, Boolean) oluşturucusunu çağırarak ve useUserOverride bağımsız değişkeni için false değeri sağlayarak Kullanıcı geçersiz kılmalarını yansıtmayan (ve ayrıca salt okuma/yazma) bir NumberFormatInfo nesnesi oluşturabilirsiniz.If this is undesirable, you can create a NumberFormatInfo object that does not reflect user overrides (and is also read/write instead of read-only) by calling the CultureInfo.CultureInfo(String, Boolean) constructor and supplying a value of false for the useUserOverride argument. Aşağıdaki örnek, geçerli kültürün Ingilizce (Birleşik Devletler) ve uzun zaman deseninin varsayılan s:DD: ss TT, ss: DD: SS olarak değiştirildiği bir sistem için bunu gösterir.The following example illustrates this for a system whose current culture is English (United States) and whose long time pattern has been changed from the default of h:mm:ss tt to HH:mm:ss.

using System;
using System.Globalization;

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

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim dtfi As DateTimeFormatInfo
      
      culture = CultureInfo.CurrentCulture
      dtfi = culture.DateTimeFormat
      Console.WriteLine("Culture Name:      {0}", culture.Name)
      Console.WriteLine("User Overrides:    {0}", culture.UseUserOverride)
      Console.WriteLine("Long Time Pattern: {0}", culture.DateTimeFormat.LongTimePattern)
      Console.WriteLine()
            
      culture = New CultureInfo(CultureInfo.CurrentCulture.Name, False)
      Console.WriteLine("Culture Name:      {0}", culture.Name)
      Console.WriteLine("User Overrides:    {0}", culture.UseUserOverride)
      Console.WriteLine("Long Time Pattern: {0}", culture.DateTimeFormat.LongTimePattern)
   End Sub
End Module
' 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 veriDateTimeFormatInfo and dynamic data

DateTimeFormatInfo sınıfı tarafından sunulan Tarih ve saat değerlerini biçimlendirmek için kültüre özgü veriler, CultureInfo sınıfı tarafından sağlanmış kültürel verileri gibi dinamiktir.The culture-specific data for formatting date and time values provided by the DateTimeFormatInfo class is dynamic, just like cultural data provided by the CultureInfo class. Belirli CultureInfo nesneleriyle ilişkili DateTimeFormatInfo nesnelerinin değerlerinin kararlılığı hakkında herhangi bir varsayımın olmaması gerekir.You should not make any assumptions about the stability of values for DateTimeFormatInfo objects that are associated with particular CultureInfo objects. Yalnızca sabit kültür ve onunla ilişkili DateTimeFormatInfo nesnesi tarafından belirtilen veriler kararlı değildir.Only the data provided by the invariant culture and its associated DateTimeFormatInfo object is stable. Diğer veriler uygulama oturumları arasında ve hatta uygulamanız çalışırken değişebilir.Other data can change between application sessions or even while your application is running. Dört önemli değişiklik kaynağı vardır:There are four major sources of change:

  • Sistem güncelleştirmeleri.System updates. Tercih edilen Takvim veya normal tarih ve saat biçimleri gibi kültürel tercihleri, zaman içinde değişir.Cultural preferences such as the preferred calendar or customary date and time formats change over time. Bu durumda Windows Update, belirli bir kültür için DateTimeFormatInfo özellik değerindeki değişiklikleri içerir.When this happens, Windows Update includes changes to the DateTimeFormatInfo property value for a particular culture.

  • Değiştirme kültürleri.Replacement cultures. CultureAndRegionInfoBuilder sınıfı, var olan bir kültürün verilerini değiştirmek için kullanılabilir.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Özellik değerlerinde yapılan değişiklikler basamaklandırıyor.Cascading changes to property values. Kültür ile ilgili birçok özellik, çalışma zamanında değişebilir. Bu, sırasıyla DateTimeFormatInfo verilerinin değişmesine neden olur.A number of culture-related properties can change at run time, which, in turn, causes DateTimeFormatInfo data to change. Örneğin, geçerli kültür programlı bir şekilde veya Kullanıcı eylemi aracılığıyla değiştirilebilir.For example, the current culture can be changed either programmatically or through user action. Bu durumda, CurrentInfo özelliği tarafından döndürülen DateTimeFormatInfo nesnesi, geçerli kültürle ilişkili bir nesne olarak değişir.When this happens, the DateTimeFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture. Benzer şekilde, bir kültürün takvimi değişebilir, bu da çok sayıda DateTimeFormatInfo özellik değerlerinde değişikliklere yol açabilir.Similarly, a culture's calendar can change, which can result in changes to numerous DateTimeFormatInfo property values.

  • Kullanıcı tercihleri.User preferences. Uygulamanızın kullanıcıları, Denetim Masası 'ndaki bölge ve dil seçenekleri aracılığıyla geçerli sistem kültürüyle ilişkili değerlerin bazılarını geçersiz kılmayı tercih edebilir.Users of your application might choose to override some of the values associated with the current system culture through the regional and language options in Control Panel. Örneğin, kullanıcılar tarihi farklı bir biçimde görüntülemeyi seçebilir.For example, users might choose to display the date in a different format. CultureInfo.UseUserOverride özelliği trueolarak ayarlanırsa, DateTimeFormatInfo nesnesinin özellikleri kullanıcı ayarlarından de alınır.If the CultureInfo.UseUserOverride property is set to true, the properties of the DateTimeFormatInfo object is also retrieved from the user settings. Kullanıcı ayarları, CultureInfo nesnesiyle ilişkili kültür ile uyumsuzsa (örneğin, seçili takvim OptionalCalendars özelliği tarafından belirtilen takvimlerden biri değilse), yöntemlerin sonuçları ve özelliklerin değerleri tanımsız olur.If the user settings are incompatible with the culture associated with the CultureInfo object (for example, if the selected calendar is not one of the calendars indicated by the OptionalCalendars property), the results of the methods and the values of the properties are undefined.

Tutarsız veriler olasılığını en aza indirmek için, nesne oluşturulduğunda DateTimeFormatInfo nesnenin tüm Kullanıcı tarafından geçersiz kılınabilir özellikleri başlatılır.To minimize the possibility of inconsistent data, all user-overridable properties of a DateTimeFormatInfo object are initialized when the object is created. Hiçbir nesne oluşturma veya Kullanıcı geçersiz kılma işlemi atomik olmadığından ve ilgili değerler nesne oluşturma sırasında değişeceğinden, tutarsızlık olasılığı vardır.There is still a possibility of inconsistency, because neither object creation nor the user override process is atomic and the relevant values can change during object creation. Ancak, bu durum son derece nadir olmalıdır.However, this situation should be extremely rare.

Kullanıcı geçersiz kılmalarının, sistem kültürüyle aynı kültürü temsil eden DateTimeFormatInfo nesneleri içinde yansıtıldığını denetleyebilirsiniz.You can control whether user overrides are reflected in DateTimeFormatInfo objects that represent the same culture as the system culture. Aşağıdaki tabloda DateTimeFormatInfo nesnenin alınma yolları listelenmektedir ve sonuçta elde edilen nesnenin Kullanıcı geçersiz kılmalarını yansıtmadığını gösterir.The following table lists the ways in which a DateTimeFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

CultureInfo ve DateTimeFormatInfo nesnesinin kaynağıSource of CultureInfo and DateTimeFormatInfo object Kullanıcı geçersiz kılmalarını yansıtırReflects user overrides
CultureInfo.CurrentCulture.DateTimeFormat özelliğiCultureInfo.CurrentCulture.DateTimeFormat property EvetYes
DateTimeFormatInfo.CurrentInfo özelliğiDateTimeFormatInfo.CurrentInfo property EvetYes
CultureInfo.CreateSpecificCulture yöntemiCultureInfo.CreateSpecificCulture method EvetYes
CultureInfo.GetCultureInfo yöntemiCultureInfo.GetCultureInfo method HayırNo
CultureInfo.CultureInfo(String) OluşturucusuCultureInfo.CultureInfo(String) constructor EvetYes
CultureInfo.CultureInfo(String, Boolean) OluşturucusuCultureInfo.CultureInfo(String, Boolean) constructor useUserOverride parametresinin değerine bağlıdırDepends on value of useUserOverride parameter

Bunu yapmak için etkileyici bir neden olmadıkça, Kullanıcı girişini biçimlendirmek ve ayrıştırmak veya verileri göstermek için istemci uygulamalarında DateTimeFormatInfo nesnesini kullandığınızda Kullanıcı geçersiz kılmalara dikkat etmelisiniz.Unless there is a compelling reason to do otherwise, you should respect user overrides when you use the DateTimeFormatInfo object in client applications to format and parse user input or to display data. Sunucu uygulamaları veya katılımsız uygulamalar için, kullanmamalısınız.For server applications or unattended applications, you should not. Ancak, dize biçiminde tarih ve saat verilerini kalıcı hale getirmek için DateTimeFormatInfo nesnesini açıkça veya örtük olarak kullanıyorsanız, sabit kültürün biçimlendirme kurallarını yansıtan bir DateTimeFormatInfo nesnesi kullanmanız ya da kültürden bağımsız olarak kullandığınız özel bir tarih ve saat biçim dizesi belirtmeniz gerekir.However, if you are using the DateTimeFormatInfo object either explicitly or implicitly to persist date and time data in string form, you should either use a DateTimeFormatInfo object that reflects the formatting conventions of the invariant culture, or you should specify a custom date and time format string that you use regardless of culture.

Tarih ve saatleri biçimlendirmeFormatting dates and times

DateTimeFormatInfo nesne, tüm tarih ve saat biçimlendirme işlemlerinde örtük veya açık olarak kullanılır.A DateTimeFormatInfo object is used implicitly or explicitly in all date and time formatting operations. Bunlar aşağıdaki yöntemlere çağrılar içerir:These include calls to the following methods:

Tüm tarih ve saat biçimlendirme işlemleri IFormatProvider uygulamasını kullanır.All date and time formatting operations make use of an IFormatProvider implementation. IFormatProvider arabirimi tek bir yöntemi içerir, IFormatProvider.GetFormat(Type).The IFormatProvider interface includes a single method, IFormatProvider.GetFormat(Type). Bu geri çağırma yöntemi, biçimlendirme bilgilerini sağlamak için gereken türü temsil eden bir Type nesnesi geçirildi.This callback method is passed a Type object that represents the type needed to provide formatting information. Yöntemi bu türün bir örneğini veya null bir örneği sağlayamsunamaz.The method returns either an instance of that type or null if it cannot provide an instance of the type. .NET Framework, tarihleri ve saatleri biçimlendirmek için iki IFormatProvider uygulaması içerir:The .NET Framework includes two IFormatProvider implementations for formatting dates and times:

Bir IFormatProvider uygulama açıkça bir biçimlendirme yöntemine sağlanmazsa, geçerli iş parçacığı kültürünü temsil eden CultureInfo.CurrentCulture özelliği tarafından döndürülen CultureInfo nesnesi kullanılır.If an IFormatProvider implementation is not provided to a formatting method explicitly, the CultureInfo object returned by the CultureInfo.CurrentCulture property that represents the current thread culture is used.

Aşağıdaki örnekte, biçimlendirme işlemlerinde IFormatProvider arabirimi ve DateTimeFormatInfo sınıfı arasındaki ilişki gösterilmektedir.The following example illustrates the relationship between the IFormatProvider interface and the DateTimeFormatInfo class in formatting operations. GetFormat yöntemi biçimlendirme işlemi tarafından istenen nesnenin türünü gösteren özel bir IFormatProvider uygulamasını tanımlar.It defines a custom IFormatProvider implementation whose GetFormat method displays the type of the object requested by the formatting operation. DateTimeFormatInfo nesne istiyorsa, yöntemi geçerli iş parçacığı kültürü için DateTimeFormatInfo nesnesi sağlar.If it is requesting a DateTimeFormatInfo object, the method provides the DateTimeFormatInfo object for the current thread culture. Örneğin çıkışının gösterdiği gibi, Decimal.ToString(IFormatProvider) yöntemi biçimlendirme bilgilerini sağlamak için bir DateTimeFormatInfo nesnesi ister, ancak String.Format(IFormatProvider, String, Object[]) yöntemi NumberFormatInfo ve DateTimeFormatInfo nesnelerini ve ICustomFormatter uygulamasını ister.As the output from the example shows, the Decimal.ToString(IFormatProvider) method requests a DateTimeFormatInfo object to provide formatting information, whereas the String.Format(IFormatProvider, String, Object[]) method requests NumberFormatInfo and DateTimeFormatInfo objects as well as an ICustomFormatter implementation.

using System;
using System.Globalization;

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

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 5, 28, 12, 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
Imports System.Globalization

Public Class CurrentCultureFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      Console.WriteLine("Requesting an object of type {0}", 
                        formatType.Name)
      If formatType Is GetType(NumberFormatInfo) Then
         Return NumberFormatInfo.CurrentInfo
      Else If formatType Is GetType(DateTimeFormatInfo) Then
         Return DateTimeFormatInfo.CurrentInfo
      Else
         Return Nothing
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 05, 28, 13, 30, 0)
      Dim value As String = dateValue.ToString("F", New CurrentCultureFormatProvider())
      Console.WriteLine(value)
      Console.WriteLine()
      Dim composite As String = String.Format(New CurrentCultureFormatProvider, 
                                              "Date: {0:d}   Amount: {1:C}   Description: {2}",
                                              dateValue, 1264.03d, "Service Charge")
      Console.WriteLine(composite)
      Console.WriteLine()
   End Sub
End Module
' 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çimlendirmeFormat strings and DateTimeFormatInfo properties

DateTimeFormatInfo nesnesi, tarih ve saat değerleriyle biçimlendirme işlemlerinde kullanılan üç tür özellik içerir:The DateTimeFormatInfo object includes three kinds of properties that are used in formatting operations with date and time values:

"D", "D", "f" ve "F" gibi Standart Tarih ve saat biçim dizeleri, belirli DateTimeFormatInfo biçim deseninin özelliklerine karşılık gelen diğer adlardır.The standard date and time format strings, such as "d", "D", "f", and "F", are aliases that correspond to particular DateTimeFormatInfo format pattern properties. Özel tarih ve saat biçimi dizelerinin çoğu, bir biçimlendirme işleminin sonuç akışına eklediği dizeler veya alt dizeler ile ilgilidir.Most of the custom date and time format strings are related to strings or substrings that a formatting operation inserts into the result stream. Aşağıdaki tabloda standart ve özel tarih ve saat biçimi belirticileri ve ilişkili DateTimeFormatInfo özellikleri listelenmektedir.The following table lists the standard and custom date and time format specifiers and their associated DateTimeFormatInfo properties. Bu biçim Belirticilerinin nasıl kullanılacağına ilişkin ayrıntılar için bkz. Standart Tarih ve saat biçimi dizeleri ve özel tarih ve saat biçim dizeleri.For details about how to use these format specifiers, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Her standart biçim dizesinin değeri özel tarih ve saat biçim dizesi olan bir DateTimeFormatInfo özelliğine karşılık geldiğini unutmayın.Note that each standard format string corresponds to a DateTimeFormatInfo property whose value is a custom date and time format string. Bu özel biçim dizesindeki tek tek tanımlayıcılar, diğer DateTimeFormatInfo özelliklerine karşılık gelir.The individual specifiers in this custom format string in turn correspond to other DateTimeFormatInfo properties. Tablo, yalnızca standart biçim dizelerinin diğer adlar olduğu DateTimeFormatInfo özelliklerini listeler ve bu diğer ad özelliklerine atanmış özel biçim dizeleri tarafından erişilebilen özellikleri listelemez.The table lists only the DateTimeFormatInfo properties for which the standard format strings are aliases, and does not list properties that may be accessed by custom format strings assigned to those aliased properties. Ayrıca, tablo yalnızca DateTimeFormatInfo özelliklerine karşılık gelen özel biçim belirticilerini listeler.In addition, the table lists only custom format specifiers that correspond to DateTimeFormatInfo properties.

Biçim belirteciFormat specifier İlişkili özelliklerAssociated properties
"d" (kısa tarih; standart biçim dizesi)"d" (short date; standard format string) sonuç dizesinin Genel biçimini tanımlamak için ShortDatePattern.ShortDatePattern, to define the overall format of the result string.
"D" (uzun tarih; standart biçim dizesi)"D" (long date; standard format string) sonuç dizesinin Genel biçimini tanımlamak için LongDatePattern.LongDatePattern, to define the overall format of the result string.
"f" (tam tarih/kısa saat; standart biçim dizesi)"f" (full date / short time; standard format string) sonuç dizesinin tarih bileşeni biçimini tanımlamak için LongDatePattern.LongDatePattern, to define the format of the date component of the result string.

sonuç dizesinin zaman bileşeni biçimini tanımlamak için ShortTimePattern.ShortTimePattern, to define the format of the time component of the result string.
"F" (tam tarih/uzun saat; standart biçim dizesi)"F" (full date / long time; standard format string) sonuç dizesinin tarih bileşeni biçimini tanımlamak için LongDatePattern.LongDatePattern, to define the format of the date component of the result string.

sonuç dizesinin zaman bileşeni biçimini tanımlamak için LongTimePattern.LongTimePattern, to define the format of the time component of the result string.
"g" (Genel Tarih/kısa saat; standart biçim dizesi)"g" (general date / short time; standard format string) sonuç dizesinin tarih bileşeni biçimini tanımlamak için ShortDatePattern.ShortDatePattern, to define the format of the date component of the result string.

sonuç dizesinin zaman bileşeni biçimini tanımlamak için ShortTimePattern.ShortTimePattern, to define the format of the time component of the result string.
"G" (Genel Tarih/uzun saat; standart biçim dizesi)"G" (general date / long time; standard format string) sonuç dizesinin tarih bileşeni biçimini tanımlamak için ShortDatePattern.ShortDatePattern, to define the format of the date component of the result string.

sonuç dizesinin zaman bileşeni biçimini tanımlamak için LongTimePattern.LongTimePattern, to define the format of the time component of the result string.
"A", "a" (ay/gün; standart biçim dizesi)"M", "m" (month/day; standard format string) sonuç dizesinin Genel biçimini tanımlamak için MonthDayPattern.MonthDayPattern, to define the overall format of the result string.
"O", "o" (gidiş dönüş tarihi/saati; standart biçim dizesi)"O", "o" (round-trip date/time; standard format string) Yok.None.
"R", "r" (RFC1123; standart biçim dizesi)"R", "r" (RFC1123; standard format string) RFC 1123 standardına uyan bir sonuç dizesi tanımlamak için RFC1123Pattern.RFC1123Pattern, to define a result string that conforms to the RFC 1123 standard. Özellik salt okunurdur.The property is read-only.
"s" (sıralanabilir tarih/saat; standart biçim dizesi)"s" (sortable date/time; standard format string) ISO 8601 standardına uyan bir sonuç dizesi tanımlamak için SortableDateTimePattern.SortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard. Özellik salt okunurdur.The property is read-only.
"t" (kısa saat; standart biçim dizesi)"t" (short time; standard format string) sonuç dizesinin Genel biçimini tanımlamak için ShortTimePattern.ShortTimePattern, to define the overall format of the result string.
"T" (uzun saat; standart biçim dizesi)"T" (long time; standard format string) sonuç dizesinin Genel biçimini tanımlamak için LongTimePattern.LongTimePattern, to define the overall format of the result string.
"u" (Evrensel sıralanabilir tarih/saat; standart biçim dizesi)"u" (universal sortable date/time; standard format string) Eşgüdümlü Evrensel Saat için ISO 8601 standardına uyan bir sonuç dizesi tanımlamak için UniversalSortableDateTimePattern.UniversalSortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard for coordinated universal time. Özellik salt okunurdur.The property is read-only.
"U" (Evrensel tam tarih/saat; standart biçim dizesi)"U" (universal full date/time; standard format string) sonuç dizesinin Genel biçimini tanımlamak için FullDateTimePattern.FullDateTimePattern, to define the overall format of the result string.
"Y", "y" (yıl ay; standart biçim dizesi)"Y", "y" (year month; standard format string) sonuç dizesinin Genel biçimini tanımlamak için YearMonthPattern.YearMonthPattern, to define the overall format of the result string.
"ddd" (Özel Biçim Belirleyicisi)"ddd" (custom format specifier) Sonuç dizesinde Haftanın gününün kısaltılmış adını dahil etmek için AbbreviatedDayNames.AbbreviatedDayNames, to include the abbreviated name of the day of the week in the result string.
"g", "gg" (Özel Biçim Belirleyicisi)"g", "gg" (custom format specifier) Sonuç dizesinde dönem adını eklemek için GetEraName yöntemini çağırır.Calls the GetEraName method to insert the era name in the result string.
"Aaa" (Özel Biçim Belirleyicisi)"MMM" (custom format specifier) Sonuç dizesinde kısaltılmış ay adını eklemek için AbbreviatedMonthNames.AbbreviatedMonthNames, to include the abbreviated month name in the result string.
"Aaaa" (Özel Biçim Belirleyicisi)"MMMM" (custom format specifier) Sonuç dizesinde tam ay adını dahil etmek için MonthNames veya MonthGenitiveNames.MonthNames or MonthGenitiveNames, to include the full month name in the result string.
"t" (Özel Biçim Belirleyicisi)"t" (custom format specifier) Sonuç dizesinde, ı/PM göstergesinin ilk karakterini dahil etmek için AMDesignator veya PMDesignator.AMDesignator or PMDesignator, to include the first character of the AM/PM designator in the result string.
"tt" (Özel Biçim Belirleyicisi)"tt" (custom format specifier) Sonuç dizesinde tam har/PM göstergesini dahil etmek için AMDesignator veya PMDesignator.AMDesignator or PMDesignator, to include the full AM/PM designator in the result string.
":" (Özel Biçim Belirleyicisi)":" (custom format specifier) Sonuç dizesinde zaman ayırıcısını dahil etmek için TimeSeparator.TimeSeparator, to include the time separator in the result string.
"/" (Özel Biçim Belirleyicisi)"/" (custom format specifier) Sonuç dizesinde tarih ayırıcısını dahil etmek için DateSeparator.DateSeparator, to include the date separator in the result string.

DateTimeFormatInfo özelliklerini değiştirmeModifying DateTimeFormatInfo properties

Yazılabilir bir DateTimeFormatInfo nesnesinin ilişkili özelliklerini değiştirerek tarih ve saat biçim dizeleri tarafından üretilen sonuç dizesini değiştirebilirsiniz.You can change the result string produced by date and time format strings by modifying the associated properties of a writable DateTimeFormatInfo object. DateTimeFormatInfo nesnenin yazılabilir olup olmadığını anlamak için IsReadOnly özelliğini kullanın.To determine if a DateTimeFormatInfo object is writable, use the IsReadOnly property. DateTimeFormatInfo nesnesini bu şekilde özelleştirmek için:To customize a DateTimeFormatInfo object in this way:

  1. Biçimlendirme kurallarını değiştirmek istediğiniz DateTimeFormatInfo nesnenin okuma/yazma kopyasını oluşturun.Create a read/write copy of a DateTimeFormatInfo object whose formatting conventions you want to modify. ( Bir DateTimeFormatInfo nesnesi örneği oluşturma bölümüne bakın.)(See the Instantiating a DateTimeFormatInfo object section.)

  2. İstenen sonuç dizesini oluşturmak için kullanılan özelliği veya özellikleri değiştirin.Modify the property or properties that are used to produce the desired result string. (Biçimlendirme yöntemlerinin sonuç dizelerini tanımlamak için DateTimeFormatInfo özellikleri kullanma hakkında bilgi için, önceki bölüm, Biçim dizeleri ve DateTimeFormatInfo özellikleri' ne bakın.)(For information about how formatting methods use DateTimeFormatInfo properties to define result strings, see the previous section, Format strings and DateTimeFormatInfo properties.)

  3. Biçimlendirme yöntemlerine yapılan çağrılar içinde IFormatProvider bağımsız değişkeni olarak oluşturduğunuz özel DateTimeFormatInfo nesnesini kullanın.Use the custom DateTimeFormatInfo object you created as the IFormatProvider argument in calls to formatting methods.

Sonuç dizesinin biçimini değiştirmek için iki farklı yol vardır:There are two other ways to change the format of a result string:

  • Özel bir kültür (benzersiz bir ada sahip olan ve var olan kültürleri tamamlayan bir kültür) ya da değiştirme kültürü (belirli bir kültür yerine kullanılan bir kültür) tanımlamak için CultureAndRegionInfoBuilder sınıfını kullanabilirsiniz.You can use the CultureAndRegionInfoBuilder class to define either a custom culture (a culture that has a unique name and that supplements existing cultures) or a replacement culture (one that is used instead of a specific culture). Bu kültürü, .NET Framework tarafından desteklenen herhangi bir nesne CultureInfo program aracılığıyla kaydedebilir ve erişebilirsiniz.You can save and access this culture programmatically as you would any CultureInfo object supported by the .NET Framework.

  • Sonuç dizesi kültüre duyarlı değilse ve önceden tanımlı bir biçimi izlememezse, özel bir tarih ve saat biçim dizesi kullanabilirsiniz.If the result string is not culture-sensitive and doesn't follow a predefined format, you can use a custom date and time format string. Örneğin, tarih ve saat verilerini yyyyaaggssddss biçiminde serileştirıyorsanız, özel biçim dizesini DateTime.ToString(String) yöntemine geçirerek sonuç dizesini oluşturabilir ve DateTime.ParseExact yöntemini çağırarak sonuç dizesini bir DateTime değerine dönüştürebilirsiniz.For example, if you are serializing date and time data in the format YYYYMMDDHHmmss, you can generate the result string by passing the custom format string to the DateTime.ToString(String) method, and you can convert the result string back to a DateTime value by calling the DateTime.ParseExact method.

Kısa tarih düzenini değiştirmeChanging the short date pattern

Aşağıdaki örnek, "d" (kısa tarih) standart biçim dizesi tarafından üretilen sonuç dizesinin biçimini değiştirir.The following example changes the format of a result string produced by the "d" (short date) standard format string. En-US veya Ingilizce (Birleşik Devletler) kültürü için ilişkili ShortDatePattern özelliğini "M/d/yyyy" varsayılan değerinden "yyyy"-"AA"-"gg" olarak değiştirir ve ShortDatePattern özelliği değiştirildikten sonraki ve sonrasında tarihi göstermek için "d" standart biçim dizesini kullanır.It changes the associated ShortDatePattern property for the en-US or English (United States) culture from its default of "M/d/yyyy" to "yyyy'-"MM"-"dd" and uses the "d" standard format string to display the date both before and after the ShortDatePattern property is changed.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 8, 18); 
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
      
      Console.WriteLine("Before modifying DateTimeFormatInfo object: ");
      Console.WriteLine("{0}: {1}\n", dtfi.ShortDatePattern, 
                                    dateValue.ToString("d", enUS));

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

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 08, 18) 
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      
      Console.WriteLine("Before modifying DateTimeFormatInfo object: ")
      Console.WriteLine("{0}: {1}", dtfi.ShortDatePattern, 
                                    dateValue.ToString("d", enUS))
      Console.WriteLine()
      
      ' Modify the short date pattern.
      dtfi.ShortDatePattern = "yyyy-MM-dd"
      Console.WriteLine("After modifying DateTimeFormatInfo object: ")
      Console.WriteLine("{0}: {1}", dtfi.ShortDatePattern, 
                                    dateValue.ToString("d", enUS))
   End Sub
End Module
' 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ı karakteri değiştirmeChanging the date separator character

Aşağıdaki örnek, fr-FR kültürünün biçimlendirme kurallarını temsil eden bir DateTimeFormatInfo nesnesindeki tarih ayırıcı karakterini değiştirir.The following example changes the date separator character in a DateTimeFormatInfo object that represents the formatting conventions of the fr-FR culture. Örnek, tarihi DateSeparator özelliği değiştirildikten önce ve sonra görüntülenecek olan "g" standart biçim dizesini kullanır.The example uses the "g" standard format string to display the date both before and after the DateSeparator property is changed.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 08, 28); 
      CultureInfo frFR = CultureInfo.CreateSpecificCulture("fr-FR");
      DateTimeFormatInfo dtfi = frFR.DateTimeFormat;
      
      Console.WriteLine("Before modifying DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));
      
      // Modify the date separator.
      dtfi.DateSeparator = "-";
      Console.WriteLine("After modifying the DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));
   }
}
// The example displays the following output:
//       Before modifying DateSeparator property: 18/08/2013 00:00
//       After modifying the DateSeparator property: 18-08-2013 00:00
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 08, 28) 
      Dim frFR As CultureInfo = CultureInfo.CreateSpecificCulture("fr-FR")
      Dim dtfi As DateTimeFormatInfo = frFR.DateTimeFormat
      
      Console.WriteLine("Before modifying DateSeparator property: {0}",
                        dateValue.ToString("g", frFR))
      
      ' Modify the date separator.
      dtfi.DateSeparator = "-"
      Console.WriteLine("After modifying the DateSeparator property: {0}",
                        dateValue.ToString("g", frFR))
   End Sub
End Module
' 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 düzenini değiştirmeChanging day name abbreviations and the long date pattern

Bazı durumlarda, genellikle ayın günü ve yılı ile birlikte tam gün ve ay adını görüntüleyen uzun tarih deseninin sayısı çok uzun olabilir.In some cases, the long date pattern, which typically displays the full day and month name along with the number of the day of the month and the year, may be too long. Aşağıdaki örnek, en-US kültürünün uzun tarih deseninin önüne bir karakter veya iki karakterlik bir gün adı, ardından gün numarası, ay adı kısaltması ve yılı döndürür.The following example shortens the long date pattern for the en-US culture to return a one-character or two-character day name abbreviation followed by the day number, the month name abbreviation, and the year. Bu, AbbreviatedDayNames dizisine kısa gün adı kısaltmaları atayarak ve LongDatePattern özelliğine atanan özel biçim dizesini değiştirerek bunu yapar.It does this by assigning shorter day name abbreviations to the AbbreviatedDayNames array, and by modifying the custom format string assigned to the LongDatePattern property. Bu, "D" ve "f" standart biçim dizeleri tarafından döndürülen sonuç dizelerini etkiler.This affects the result strings returned by the "D" and "f" standard format strings.

using System;
using System.Globalization;

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

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

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

Module Example
   Public Sub Main()
      Dim value As New Date(2013, 7, 9)
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      Dim formats() As String = { "D", "F", "f" }

      ' Display date before modifying properties.
      For Each fmt In formats
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' We don't want to change the FullDateTimePattern, so we need to save it.
      Dim originalFullDateTimePattern As String = dtfi.FullDateTimePattern
      
      ' Modify day name abbreviations and long date pattern.
      dtfi.AbbreviatedDayNames = { "Su", "M", "Tu", "W", "Th", "F", "Sa" }
      dtfi.LongDatePattern = "ddd dd-MMM-yyyy"
      dtfi.FullDateTimePattern = originalFullDateTimePattern
      For Each fmt In formats
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi))
      Next
   End Sub
End Module
' The example displays the following output:
'       D: Tuesday, July 09, 2013
'       F: Tuesday, July 09, 2013 12:00:00 AM
'       f: Tuesday, July 09, 2013 12:00 AM
'       
'       D: Tu 09-Jul-2013
'       F: Tuesday, July 09, 2013 12:00:00 AM
'       f: Tu 09-Jul-2013 12:00 AM

Genellikle LongDatePattern özelliğindeki değişiklik, FullDateTimePattern özelliğini de etkiler ve bu da "F" standart biçim dizesi tarafından döndürülen sonuç dizesini tanımlar.Ordinarily, the change to the LongDatePattern property also affects the FullDateTimePattern property, which in turn defines the result string returned by the "F" standard format string. Özgün tam tarih ve saat modelini korumak için örnek, LongDatePattern özelliği değiştirildikten sonra FullDateTimePattern özelliğine atanan özgün özel biçim dizesini yeniden atar.To preserve the original full date and time pattern, the example reassigns the original custom format string assigned to the FullDateTimePattern property after the LongDatePattern property is modified.

12 saatlik biçimden 24 saatlik biçime geçmeChanging from a 12-hour clock to a 24-hour clock

.NET Framework birçok kültür için, saat, 12 saatlik bir saat ve bir har/PM göstergesi kullanılarak ifade edilir.For many cultures in the .NET Framework, the time is expressed by using a 12-hour clock and an AM/PM designator. Aşağıdaki örnek, 12 saatlik bir saat kullanan herhangi bir zaman biçimini, 24 saatlik bir saat kullanan bir biçimle değiştiren bir ReplaceWith24HourClock yöntemi tanımlar.The following example defines a ReplaceWith24HourClock method that replaces any time format that uses a 12-hour clock with a format that uses a 24-hour clock.

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

public class Example
{
   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
Imports System.Globalization
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = 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)
   End Sub
   
   Private Function ReplaceWith24HourClock(fmt As String) As String
      Dim pattern As String = "^(?<openAMPM>\s*t+\s*)? " +
                              "(?(openAMPM) h+(?<nonHours>[^ht]+)$ " +
                              "| \s*h+(?<nonHours>[^ht]+)\s*t+)"
      Return Regex.Replace(fmt, pattern, "HH${nonHours}", RegexOptions.IgnorePatternWhitespace)   
   End Function
End Module
' 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.The example uses a regular expression to modify the format string. Normal ifade deseninin @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) aşağıdaki gibi tanımlanır:The regular expression pattern @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) is defined as follows:

DesenPattern AçıklamaDescription
^ Dizenin başlangıcında eşleşmeyi başlatın.Begin the match at the beginning of the string.
(?<openAMPM>\s*t+\s*)? Sıfır veya daha fazla boşluk karakteri ile, sonra da sıfır veya daha fazla boşluk karakteri gelen sıfır veya daha fazla boşluk karakteri ile bir veya daha fazla boşluk karakteri eşleştirin.Match zero or one occurrence of zero or more white-space characters, followed by the letter "t" one or more times, followed by zero or more white-space characters. Bu yakalama grubu openAMPMolarak adlandırılmıştır.This capturing group is named openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ openAMPM grubunun bir eşleşmesi varsa, "h" harfini bir veya daha fazla kez, ardından "h" veya "t" olmayan bir veya daha fazla karakter ile eşleştirin.If the openAMPM group has a match, match the letter "h" one or more times, followed by one or more characters that are neither "h" nor "t". Eşleşme dizenin sonunda biter.The match ends at the end of the string. "H" den sonra yakalanan tüm karakterler, nonHoursadlı bir yakalama grubuna dahil edilir.All characters captured after "h" are included in a capturing group named nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) openAMPM grubunun bir eşleşmesi yoksa, "h" harfini bir veya daha fazla kez, ardından "h" veya "t" olmayan bir veya daha fazla karakter ve ardından sıfır veya daha fazla boşluk karakteri ile eşleştirin.If the openAMPM group does not have a match, match the letter "h" one or more times, followed by one or more characters that are neither "h" nor "t", followed by zero or more white-space characters. Son olarak, "t" harfinin bir veya daha fazla tekrarı ile eşleştirin.Finally, match one or more occurrences of the letter "t". "H" ve boşluk ve "t" karakterinden sonra yakalanan tüm karakterler, nonHoursadlı bir yakalama grubuna dahil edilir.All characters captured after "h" and before the white-spaces and "t" are included in a capturing group named nonHours.

nonHours yakalama grubu, bir özel tarih ve saat biçimlendirme dizesinin bir dakikasını ve büyük olasılıkla ikinci bileşenini içerir.The nonHours capturing group contains the minute and possibly the second component of a custom date and time format string, along with any time separator symbols. Değiştirme deseninin HH${nonHours}, bu öğelere "HH" alt dizesini alır.The replacement pattern HH${nonHours} prepends the substring "HH" to these elements.

Bir tarihte dönemi görüntüleme ve değiştirmeDisplaying and changing the era in a date

Aşağıdaki örnek, "g" özel biçim belirticisini, en-US kültürünün biçimlendirme kurallarını temsil eden bir nesnenin LongDatePattern özelliğine ekler.The following example adds the "g" custom format specifier to the LongDatePattern property of an object that represents the formatting conventions of the en-US culture. Bu ek, aşağıdaki üç standart biçim dizesini etkiler:This addition affects the following three standard format strings:

  • Doğrudan LongDatePattern özelliğine eşleyen "D" (uzun tarih) standart biçim dizesi.The "D" (long date) standard format string, which maps directly to the LongDatePattern property.

  • LongDatePattern ve ShortTimePattern özellikleri tarafından oluşturulan alt dizeleri birleştiren bir sonuç dizesi üreten "f" (tam tarih/kısa saat) standart biçim dizesi.The "f" (full date / short time) standard format string, which produces a result string that concatenates the substrings produced by the LongDatePattern and ShortTimePattern properties.

  • Doğrudan FullDateTimePattern özelliğine eşleyen "F" (tam tarih/uzun saat) standart biçim dizesi.The "F" (full date / long time) standard format string, which maps directly to the FullDateTimePattern property. Bu özellik değerini açıkça ayarlayamadığımızda, LongDatePattern ve LongTimePattern özellikleri bitiştirerek dinamik olarak oluşturulur.Because we have not explicitly set this property value, it is generated dynamically by concatenating the LongDatePattern and LongTimePattern properties.

Örnek ayrıca, takviminde tek bir dönem olan bir kültürün dönem adının nasıl değiştirileceğini gösterir.The example also shows how to change the era name for a culture whose calendar has a single era. Bu durumda, en-US kültürü bir GregorianCalendar nesnesi tarafından temsil edilen Gregoryen takvimini kullanır.In this case, the en-US culture uses the Gregorian calendar, which is represented by a GregorianCalendar object. GregorianCalendar sınıfı, M.S. adında tek bir dönemi desteklerThe GregorianCalendar class supports a single era, which it names A.D. (Anmini Dosız).(Anno Domini). Örnek, dönem adını C.E. olarak değiştirirThe example changes the era name to C.E. (Ortak dönem) FullDateTimePattern özelliğine atanan biçim dizesinde "g" özel biçim belirticisini değişmez dize ile değiştirerek.(Common Era) by replacing the "g" custom format specifier in the format string assigned to the FullDateTimePattern property with a literal string. Dönem adı, genellikle .NET Framework veya Windows işletim sistemi tarafından sağlanan kültür tablolarındaki özel verilerden GetEraName yöntemi tarafından döndürüldüğünden, değişmez değer dizesinin kullanılması gerekir.The use of a literal string is necessary, because the era name is typically returned by the GetEraName method from private data in the culture tables supplied by either the .NET Framework or the Windows operating system.

using System;
using System.Globalization;

public class Example
{
   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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 5, 18, 13, 30, 0)
      Dim formats() As String = { "D", "f", "F" }      
      
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      Dim originalLongDatePattern As String = dtfi.LongDatePattern

      ' Display the default form of three long date formats.
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' Modify the long date pattern.
      dtfi.LongDatePattern = originalLongDatePattern + " g"
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' Change A.D. to C.E. (for Common Era)
      dtfi.LongDatePattern = originalLongDatePattern + " 'C.E.'"
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
   End Sub
End Module
' 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ırmaParsing date and time strings

Ayrıştırma bir tarih ve saatin dize gösterimini DateTime veya DateTimeOffset değerine dönüştürmeyi içerir.Parsing involves converting the string representation of a date and time to a DateTime or DateTimeOffset value. Bu türlerin her ikisi de ayrıştırma işlemlerini desteklemek için Parse, TryParse, ParseExactve TryParseExact yöntemlerini içerir.Both of these types include the Parse, TryParse, ParseExact, and TryParseExact methods to support parsing operations. Parse ve TryParse yöntemleri, çeşitli biçimlere sahip olan bir dizeyi dönüştürür, ancak ParseExact ve TryParseExact dizenin tanımlanmış bir biçim veya biçimleri olmasını gerektirir.The Parse and TryParse methods convert a string that can have a variety of formats, whereas ParseExact and TryParseExact require that the string have a defined format or formats. Ayrıştırma işlemi başarısız olursa, Parse ve ParseExact bir özel durum oluşturur, ancak TryParse ve TryParseExact falsedöndürür.If the parsing operation fails, Parse and ParseExact throw an exception, whereas TryParse and TryParseExact return false.

Ayrıştırma yöntemleri, hangi stil öğelerinin (baştaki, sondaki veya iç beyaz boşluk gibi) Ayrıştırılacak dizede bulunabilecek ve ayrıştırılmış dizenin veya eksik öğelerin nasıl yorumlanacağı belirleyen bir DateTimeStyles numaralandırma değeri örtülü olarak veya açıkça kullanılır.The parsing methods implicitly or explicitly use a DateTimeStyles enumeration value to determine which style elements (such as leading, trailing, or inner white space) can be present in the string to be parsed, and how to interpret the parsed string or any missing elements. Parse veya TryParse yöntemini çağırdığınızda DateTimeStyles bir değer sağlamazsanız, DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhiteve DateTimeStyles.AllowInnerWhite bayraklarını içeren bir bileşik stil olan DateTimeStyles.AllowWhiteSpacesvarsayılandır.If you don't provide a DateTimeStyles value when you call the Parse or TryParse method, the default is DateTimeStyles.AllowWhiteSpaces, which is a composite style that includes the DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite, and DateTimeStyles.AllowInnerWhite flags. ParseExact ve TryParseExact yöntemleri için, varsayılan DateTimeStyles.None; giriş dizesi tam olarak belirli bir özel tarih ve saat biçimi dizesine karşılık gelmelidir.For the ParseExact and TryParseExact methods, the default is DateTimeStyles.None; the input string must correspond precisely to a particular custom date and time format string.

Ayrıştırma yöntemleri Ayrıca, ayrıştırılacak dizede gerçekleşebileceğini belirli sembolleri ve desenleri tanımlayan bir DateTimeFormatInfo nesnesini örtülü olarak veya açıkça kullanır.The parsing methods also implicitly or explicitly use a DateTimeFormatInfo object that defines the specific symbols and patterns that can occur in the string to be parsed. DateTimeFormatInfo nesne sağlamazsanız, varsayılan olarak geçerli iş parçacığı kültürü için DateTimeFormatInfo nesnesi kullanılır.If you don't provide a DateTimeFormatInfo object, the DateTimeFormatInfo object for the current thread culture is used by default. Tarih ve saat dizelerini ayrıştırma hakkında daha fazla bilgi için, DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExactve DateTimeOffset.TryParseExactgibi ayrı ayrıştırma yöntemlerine bakın.For more information about parsing date and time strings, see the individual parsing methods, such as DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExact, and DateTimeOffset.TryParseExact.

Aşağıdaki örnek, tarih ve saat dizelerinin ayrıştırılmasındaki kültürün duyarlı yapısını gösterir.The following example illustrates the culture-sensitive nature of parsing date and time strings. En-US, en-GB, fr-FR ve fi-FI kültürlerin kurallarını kullanarak iki tarih dizesini ayrıştırmaya çalışır.It tries to parse two date strings by using the conventions of the en-US, en-GB, fr-FR, and fi-FI cultures. En-US kültürünün 8/18/2014 olarak yorumlandığı Tarih, 18 ' in ay numarası olarak yorumlandığı için diğer üç kültürde FormatException bir özel durum oluşturur.The date that is interpreted as 8/18/2014 in the en-US culture throws a FormatException exception in the other three cultures because 18 is interpreted as the month number. 1/2/2015, en-US kültürünün ilk ayının ikinci günü, ancak kalan kültürlerin ikinci ayının ilk günü olarak ayrıştırılır.1/2/2015 is parsed as the second day of the first month in the en-US culture, but as the first day of the second month in the remaining cultures.

using System;
using System.Globalization;

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

Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "08/18/2014", "01/02/2015" }
      Dim cultureNames() As String = { "en-US", "en-GB", "fr-FR", "fi-FI" }
      
      For Each cultureName In cultureNames
         Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("Parsing strings using the {0} culture.", 
                           culture.Name)
         For Each dateStr In dateStrings
            Try
               Console.WriteLine(String.Format(culture, 
                                 "   '{0}' --> {1:D}", dateStr, 
                                 DateTime.Parse(dateStr, culture)))
            Catch e As FormatException
               Console.WriteLine("   Unable to parse '{0}'", dateStr)
            End Try
         Next
      Next
   End Sub
End Module
' 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 nedenden dolayı ayrıştırılır:Date and time strings are typically parsed for two reasons:

  • Kullanıcı girişini tarih ve saat değerine dönüştürmek için.To convert user input into a date and time value.

  • Bir tarih ve saat değerini geri döndürmek için; diğer bir deyişle, daha önce bir dize olarak serileştirilmiş bir tarih ve saat değerinin serisini kaldırmak için.To round-trip a date and time value; that is, to deserialize a date and time value that was previously serialized as a string.

Aşağıdaki bölümlerde bu iki işlem daha ayrıntılı bir şekilde ele alınmaktadır.The following sections discuss these two operations in greater detail.

Kullanıcı dizelerini ayrıştırmaParsing user strings

Kullanıcı tarafından girilen tarih ve saat dizelerini ayrıştırdığınızda, kullanıcının yapmış olabileceği özelleştirmeler dahil olmak üzere kullanıcının kültürel ayarlarını yansıtan bir DateTimeFormatInfo nesnesini her zaman örneklemelisiniz.When you parse date and time strings input by the user, you should always instantiate a DateTimeFormatInfo object that reflects the user's cultural settings, including any customizations the user may have made. Aksi takdirde, tarih ve saat nesnesi yanlış değerlere sahip olabilir.Otherwise, the date and time object may have incorrect values. Kullanıcı kültürel özelleştirmelerini yansıtan bir DateTimeFormatInfo nesnesinin örneği oluşturma hakkında daha fazla bilgi için, bkz. DateTimeFormatInfo ve Dynamic Data bölümü.For information about how to instantiate a DateTimeFormatInfo object that reflects user cultural customizations, see the DateTimeFormatInfo and dynamic data section.

Aşağıdaki örnek, Kullanıcı kültürel ayarlarını ve olmayan birini yansıtan bir ayrıştırma işlemi arasındaki farkı gösterir.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. Bu durumda, varsayılan sistem kültürü en-US şeklindedir ancak Kullanıcı, kısa tarih deseninin varsayılan değerini "M/d/yyyy" iken "yy/aa/gg" olarak değiştirmek için Denetim Masası, bölge ve dil kullandı.In this case, the default system culture is en-US, but the user has used Control Panel, Region and Language to change the short date pattern from its default of "M/d/yyyy" to "yy/MM/dd". Kullanıcı, Kullanıcı ayarlarını yansıtan bir dize girdiğinde ve dize aynı zamanda Kullanıcı ayarlarını (geçersiz kılmalar) 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.When the user enters a string that reflects user settings, and the string is parsed by a DateTimeFormatInfo object that also reflects user settings (overrides), the parsing operation returns a correct result. Ancak, dize standart en-US kültürel ayarlarını yansıtan bir DateTimeFormatInfo nesnesi tarafından ayrıştırıldığında ayrıştırma yöntemi, yılın son iki basamağını değil, ayın sayısı olarak 14 ' ü yorumlaması için bir FormatException özel durumu oluşturur.However, when the string is parsed by a DateTimeFormatInfo object that reflects standard en-US cultural settings, the parsing method throws a FormatException exception because it interprets 14 as the number of the month, not the last two digits of the year.

using System;
using System.Globalization;

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

Module Example
   Public Sub Main()
      Dim inputDate As String = "14/05/10"
      
      Dim cultures() As CultureInfo = { CultureInfo.GetCultureInfo("en-US"), 
                                        CultureInfo.CreateSpecificCulture("en-US") }
      
      For Each culture In cultures
         Try
            Console.WriteLine("{0} culture reflects user overrides: {1}", 
                              culture.Name, culture.UseUserOverride)
            Dim occasion As DateTime = DateTime.Parse(inputDate, culture)
            Console.WriteLine("'{0}' --> {1}", inputDate, 
                              occasion.ToString("D", CultureInfo.InvariantCulture))
         Catch e As FormatException
            Console.WriteLine("Unable to parse '{0}'", inputDate)                           
         End Try   
         Console.WriteLine()  
      Next
   End Sub
End Module
' 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 serileştirme ve seri durumundan çıkarmaSerializing and deserializing date and time data

Serileştirilmiş tarih ve saat verileri gidiş dönüş için beklenmektedir; diğer bir deyişle, tüm serileştirilmiş ve seri durumdan çıkarılan değerler aynı olmalıdır.Serialized date and time data are expected to round-trip; that is, all serialized and deserialized values should be identical. Tarih ve saat değeri zaman içinde tek bir kez temsil ediyorsa, seri durumdan çıkarılan değer, geri yüklendiği sistemin kültür veya saat diliminden bağımsız olarak, zaman içinde aynı anda temsil etmelidir.If a date and time value represents a single moment in time, the deserialized value should represent the same moment in time regardless of the culture or time zone of the system on which it was restored. Tarih ve saat verilerini başarıyla gidiş dönüş için, verileri oluşturmak ve ayrıştırmak için InvariantInfo özelliği tarafından döndürülen sabit kültürün kurallarını kullanmanız gerekir.To round-trip date and time data successfully, you must use the conventions of the invariant culture, which is returned by the InvariantInfo property, to generate and parse the data. Biçimlendirme ve ayrıştırma işlemleri, varsayılan kültürün kurallarını hiçbir şekilde yansıtmamalıdır.The formatting and parsing operations should never reflect the conventions of the default culture. Varsayılan kültürel ayarlarını kullanırsanız, verilerin taşınabilirliği kesinlikle sınırlı olur; yalnızca kültüreme özgü ayarları, serileştirildiği iş parçacığından özdeş olan iş parçacığında başarıyla seri hale getirilebilir.If you use default cultural settings, the portability of the data is strictly limited; it can be successfully deserialized only on a thread whose cultural-specific settings are identical to those of the thread on which it was serialized. Bazı durumlarda bu, verilerin aynı sistemde başarıyla serileştirilmeyeceği ve seri durumdan çıkarılmayacağı anlamına gelir.In some cases, this means that the data cannot even be successfully serialized and deserialized on the same system.

Tarih ve saat değerinin zaman bileşeni önemli ise, "o" veya "r" standart biçim dizesikullanılarak aynı zamanda UTC 'ye dönüştürülmelidir ve serileştirilmelidir.If the time component of a date and time value is significant, it should also be converted to UTC and serialized by using the "o" or "r" standard format string. Zaman verileri daha sonra bir ayrıştırma yöntemi çağırarak ve onu provider bağımsız değişkeni olarak sabit kültür ile birlikte uygun biçim dizesi geçirerek geri yüklenebilir.The time data can then be restored by calling a parsing method and passing it the appropriate format string along with the invariant culture as the provider argument.

Aşağıdaki örnek, bir tarih ve saat değerinin gidiş dönüşü sürecini gösterir.The following example illustrates the process of round-tripping a date and time value. Bir sistem üzerindeki bir tarih ve saati, ABD Pasifik saatine ve geçerli kültürün en-US olduğu bir sisteme serileştirir.It serializes a date and time on a system that observes U.S. Pacific time and whose current culture is en-US.

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

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

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\DateData.dat")
      ' Define a date and time to serialize.
      Dim originalDate As New Date(2014, 08, 18, 08, 16, 35)
      ' Display information on the date and time.
      Console.WriteLine("Date to serialize: {0:F}", originalDate)
      Console.WriteLine("Current Culture:   {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Time Zone:         {0}", 
                        TimeZoneInfo.Local.DisplayName)
      ' Convert the date value to UTC.
      Dim utcDate As Date = originalDate.ToUniversalTime()
      ' Serialize the UTC value.
      sw.Write(utcDate.ToString("o", DateTimeFormatInfo.InvariantInfo))
      sw.Close()
   End Sub
End Module
' 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)

Bir sistemdeki verileri, Brüksel, Kopenhag, Madrid ve Paris zaman diliminde ve geçerli kültürü fr-FR olan bir sistemde serileştirir.It deserializes the data on a system in the Brussels, Copenhagen, Madrid and Paris time zone and whose current culture is fr-FR. Geri yükleme tarihi, başlangıç tarihinden sonra sekiz saat daha sonra UTC 'den bir saat boyunca UTC 'nin saat dilimini ayarlamayı yansıtır.The restored date is nine hours later than the original date, which reflects the time zone adjustment from eight hours behind UTC to one hour ahead of UTC. Hem özgün tarih hem de geri yükleme tarihi aynı anda aynı anda temsil eder.Both the original date and the restored date represent the same moment in time.

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

public class Example
{
   public static void Main()
   {
      // Open the file and retrieve the date string.
      StreamReader sr = new StreamReader(@".\DateData.dat");             
      String dateValue = sr.ReadToEnd();
      
      // Parse the date.
      DateTime parsedDate = DateTime.ParseExact(dateValue, "o", 
                            DateTimeFormatInfo.InvariantInfo);
      // Convert it to local time.                             
      DateTime restoredDate = parsedDate.ToLocalTime();
      // Display information on the date and time.
      Console.WriteLine("Deserialized date: {0:F}", restoredDate);
      Console.WriteLine("Current Culture:   {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Time Zone:         {0}", 
                        TimeZoneInfo.Local.DisplayName);
   }
}
// The example displays the following output:
//    Deserialized date: lundi 18 août 2014 17:16:35
//    Current Culture:   fr-FR
//    Time Zone:         (UTC+01:00) Brussels, Copenhagen, Madrid, Paris
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      ' Open the file and retrieve the date string.
      Dim sr As New StreamReader(".\DateData.dat")             
      Dim dateValue As String = sr.ReadToEnd()
      
      ' Parse the date.
      Dim parsedDate As Date = Date.ParseExact(dateValue, "o", 
                               DateTimeFormatInfo.InvariantInfo)
      ' Convert it to local time.                             
      Dim restoredDate As Date = parsedDate.ToLocalTime()
      ' Display information on the date and time.
      Console.WriteLine("Deserialized date: {0:F}", restoredDate)
      Console.WriteLine("Current Culture:   {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Time Zone:         {0}", 
                        TimeZoneInfo.Local.DisplayName)
   End Sub
End Module
' 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

DateTimeFormatInfo()

Kültüre bağımsız (Sabit) olan DateTimeFormatInfo sınıfının yeni yazılabilir bir örneğini başlatır.Initializes a new writable instance of the DateTimeFormatInfo class that is culture-independent (invariant).

Özellikler

AbbreviatedDayNames

Haftanın günlerinin kültüre özgü kısaltılmış adlarını içeren String türünde tek boyutlu bir dizi alır veya ayarlar.Gets or sets a one-dimensional array of type String containing the culture-specific abbreviated names of the days of the week.

AbbreviatedMonthGenitiveNames

Geçerli DateTimeFormatInfo nesnesiyle ilişkili kısaltılmış ay adlarının dize dizisini alır veya ayarlar.Gets or sets a string array of abbreviated month names associated with the current DateTimeFormatInfo object.

AbbreviatedMonthNames

Ayların kültüre özgü kısaltılmış adlarını içeren tek boyutlu bir dize dizisi alır veya ayarlar.Gets or sets a one-dimensional string array that contains the culture-specific abbreviated names of the months.

AMDesignator

"Ante meridem" (Öğle önünde) olan saatlerin dize göstergesini alır veya ayarlar.Gets or sets the string designator for hours that are "ante meridiem" (before noon).

Calendar

Geçerli kültür için kullanılacak takvimi alır veya ayarlar.Gets or sets the calendar to use for the current culture.

CalendarWeekRule

Yılın ilk Takvim haftasını belirlemekte kullanılacak kuralı belirten bir değer alır veya ayarlar.Gets or sets a value that specifies which rule is used to determine the first calendar week of the year.

CurrentInfo

Değerleri geçerli kültür temelinde biçimlendiren salt okunurdur bir DateTimeFormatInfo nesnesi alır.Gets a read-only DateTimeFormatInfo object that formats values based on the current culture.

DateSeparator

Bir tarih, yani yıl, ay ve gün bileşenlerini ayıran dizeyi alır veya ayarlar.Gets or sets the string that separates the components of a date, that is, the year, month, and day.

DayNames

Haftanın günlerinin kültüre özgü tam adlarını içeren tek boyutlu bir dize dizisi alır veya ayarlar.Gets or sets a one-dimensional string array that contains the culture-specific full names of the days of the week.

FirstDayOfWeek

Haftanın ilk gününü alır veya ayarlar.Gets or sets the first day of the week.

FullDateTimePattern

Uzun tarih ve uzun saat değeri için özel biçim dizesini alır veya ayarlar.Gets or sets the custom format string for a long date and long time value.

InvariantInfo

Kültüre bağımsız (Sabit) olan varsayılan salt okunurdur DateTimeFormatInfo nesnesini alır.Gets the default read-only DateTimeFormatInfo object that is culture-independent (invariant).

IsReadOnly

DateTimeFormatInfo nesnesinin salt okunurdur olduğunu gösteren bir değer alır.Gets a value indicating whether the DateTimeFormatInfo object is read-only.

LongDatePattern

Uzun tarih değeri için özel biçim dizesini alır veya ayarlar.Gets or sets the custom format string for a long date value.

LongTimePattern

Uzun saat değeri için özel biçim dizesini alır veya ayarlar.Gets or sets the custom format string for a long time value.

MonthDayPattern

Ay ve gün değeri için özel biçim dizesini alır veya ayarlar.Gets or sets the custom format string for a month and day value.

MonthGenitiveNames

Geçerli DateTimeFormatInfo nesnesiyle ilişkili ay adlarının dize dizisini alır veya ayarlar.Gets or sets a string array of month names associated with the current DateTimeFormatInfo object.

MonthNames

Ayın kültüre özgü tam adlarını içeren String türünde tek boyutlu bir dizi alır veya ayarlar.Gets or sets a one-dimensional array of type String containing the culture-specific full names of the months.

NativeCalendarName

Geçerli DateTimeFormatInfo nesnesiyle ilişkili takvimin yerel adını alır.Gets the native name of the calendar associated with the current DateTimeFormatInfo object.

PMDesignator

"Meridem em" (öğleden sonra) olan saatlerin dize göstergesini alır veya ayarlar.Gets or sets the string designator for hours that are "post meridiem" (after noon).

RFC1123Pattern

Internet Mühendisliği görev gücü (IETF) Istek açıklaması Isteği (RFC) 1123 belirtimini temel alan bir zaman değeri için özel biçim dizesini alır.Gets the custom format string for a time value that is based on the Internet Engineering Task Force (IETF) Request for Comments (RFC) 1123 specification.

ShortDatePattern

Kısa tarih değeri için özel biçim dizesini alır veya ayarlar.Gets or sets the custom format string for a short date value.

ShortestDayNames

Geçerli DateTimeFormatInfo nesnesiyle ilişkili en kısa benzersiz kısaltılmış gün adlarının dize dizisini alır veya ayarlar.Gets or sets a string array of the shortest unique abbreviated day names associated with the current DateTimeFormatInfo object.

ShortTimePattern

Kısa saat değeri için özel biçim dizesini alır veya ayarlar.Gets or sets the custom format string for a short time value.

SortableDateTimePattern

Sıralanabilir tarih ve saat değeri için özel biçim dizesini alır.Gets the custom format string for a sortable date and time value.

TimeSeparator

Saat, saat, dakika ve saniye olan bileşenleri ayıran dizeyi alır veya ayarlar.Gets or sets the string that separates the components of time, that is, the hour, minutes, and seconds.

UniversalSortableDateTimePattern

ISO 8601 tarafından tanımlanan evrensel, sıralanabilir tarih ve saat dizesi için özel biçim dizesini alır.Gets the custom format string for a universal, sortable date and time string, as defined by ISO 8601.

YearMonthPattern

Yıl ve ay değeri için özel biçim dizesini alır veya ayarlar.Gets or sets the custom format string for a year and month value.

Yöntemler

Clone()

DateTimeFormatInfobasit bir kopyasını oluşturur.Creates a shallow copy of the DateTimeFormatInfo.

Equals(Object)

Belirtilen nesnenin geçerli nesneyle eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
GetAbbreviatedDayName(DayOfWeek)

Geçerli DateTimeFormatInfo nesnesiyle ilişkili kültürü temel alan, belirli bir haftanın belirtilen gününe ait kültüre özgü kısaltılmış adı döndürür.Returns the culture-specific abbreviated name of the specified day of the week based on the culture associated with the current DateTimeFormatInfo object.

GetAbbreviatedEraName(Int32)

Bir kısaltma varsa, belirtilen dönem kısaltılmış adını içeren dizeyi döndürür.Returns the string containing the abbreviated name of the specified era, if an abbreviation exists.

GetAbbreviatedMonthName(Int32)

Geçerli DateTimeFormatInfo nesnesiyle ilişkili kültürü temel alarak belirtilen ayın kültüre özgü kısaltılmış adını döndürür.Returns the culture-specific abbreviated name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetAllDateTimePatterns()

Tarih ve saat değerlerinin biçimlendirileceği tüm standart desenleri döndürür.Returns all the standard patterns in which date and time values can be formatted.

GetAllDateTimePatterns(Char)

Tarih ve saat değerlerinin, belirtilen standart biçim dizesi kullanılarak biçimlendirileceği tüm desenleri döndürür.Returns all the patterns in which date and time values can be formatted using the specified standard format string.

GetDayName(DayOfWeek)

Geçerli DateTimeFormatInfo nesnesiyle ilişkili kültürü temel alarak haftanın belirtilen gününe ait kültüre özgü tam adı döndürür.Returns the culture-specific full name of the specified day of the week based on the culture associated with the current DateTimeFormatInfo object.

GetEra(String)

Belirtilen dönemi temsil eden tamsayıyı döndürür.Returns the integer representing the specified era.

GetEraName(Int32)

Belirtilen dönem adını içeren dizeyi döndürür.Returns the string containing the name of the specified era.

GetFormat(Type)

Tarih ve saat biçimlendirme hizmeti sağlayan, belirtilen türde bir nesne döndürür.Returns an object of the specified type that provides a date and time formatting service.

GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetInstance(IFormatProvider)

Belirtilen IFormatProviderilişkili DateTimeFormatInfo nesnesini döndürür.Returns the DateTimeFormatInfo object associated with the specified IFormatProvider.

GetMonthName(Int32)

Geçerli DateTimeFormatInfo nesnesiyle ilişkili kültürü temel alarak belirtilen ayın kültüre özgü tam adını döndürür.Returns the culture-specific full name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetShortestDayName(DayOfWeek)

Geçerli DateTimeFormatInfo nesnesiyle ilişkili haftanın belirtilen günü için en kısa kısaltılmış gün adını alır.Obtains the shortest abbreviated day name for a specified day of the week associated with the current DateTimeFormatInfo object.

GetType()

Geçerli örneğin Type alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
MemberwiseClone()

Geçerli Objectbasit bir kopyasını oluşturur.Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
ReadOnly(DateTimeFormatInfo)

Salt okunurdur DateTimeFormatInfo sarmalayıcı döndürür.Returns a read-only DateTimeFormatInfo wrapper.

SetAllDateTimePatterns(String[], Char)

Belirtilen bir standart biçim dizesine karşılık gelen özel tarih ve saat biçimi dizelerini ayarlar.Sets the custom date and time format strings that correspond to a specified standard format string.

ToString()

Geçerli nesneyi temsil eden bir dize döndürür.Returns a string that represents the current object.

(Devralındığı yer: Object)

Belirtik Arabirim Kullanımları

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Şunlara uygulanır

Ayrıca bkz.