DateTimeFormatInfo 클래스

정의

날짜 및 시간 값 형식에 대한 문화권별 정보를 제공합니다.Provides culture-specific information about the format of date and time values.

public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider
상속
DateTimeFormatInfo
특성
구현

예제

다음 예제에서는 리플렉션을 사용 하 여 속성을 가져옵니다는 DateTimeFormatInfo 영어 (미국) 문화권에 대 한 개체입니다.The following example uses reflection to get the properties of the DateTimeFormatInfo object for the English (United States) culture. 사용자 지정 서식 문자열을 포함 하는 해당 속성의 값을 표시 하 고 서식 지정 된 날짜로 표시 하려면 해당 문자열을 사용 합니다.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

설명

속성을 DateTimeFormatInfo 서식 지정 또는 구문 분석 같은 날짜 및 시간 값에 대 한 문화권별 형식 정보를 포함 하는 클래스:The properties of the DateTimeFormatInfo class contain culture-specific information for formatting or parsing date and time values such as the following:

  • 날짜 값의 서식을 지정 하는 데 패턴입니다.The patterns used to format date values.

  • 시간 값의 서식을 지정 하는 데 패턴입니다.The patterns used to format time values.

  • 주의 요일 이름입니다.The names of the days of the week.

  • 해당 연도의 달의 이름입니다.The names of the months of the year.

  • A.M.The A.M. 오후and P.M. 시간 값에 사용 되는 지정자입니다.designators used in time values.

  • 날짜 표시 되는 달력입니다.The calendar in which dates are expressed.

섹션 내용In this section:

DateTimeFormatInfo 개체 인스턴스화Instantiating a DateTimeFormatInfo object

DateTimeFormatInfo 개체 고정 문화권, 특정 문화권, 중립 문화권에 또는 현재 문화권의 서식 규칙을 나타낼 수 있습니다.A DateTimeFormatInfo object can represent the formatting conventions of the invariant culture, a specific culture, a neutral culture, or the current culture. 이 섹션에서는 각 유형의 인스턴스화하는 방법을 설명 DateTimeFormatInfo 개체입니다.This section discusses how to instantiate each type of DateTimeFormatInfo object.

고정 문화권에 대 한 DateTimeFormatInfo 개체 인스턴스화Instantiating a DateTimeFormatInfo object for the invariant culture

고정 문화권을 문화권을 구분 하는 문화권을 나타냅니다.The invariant culture represents a culture that is culture-insensitive. 특정 영어권 국가/지역에는 없지만 영어 언어에 기반 합니다.It is based on the English language, but not on any specific English-speaking country/region. 특정 문화권의 데이터는 동적일 수 있습니다 하 고 새 문화권 규칙 또는 사용자 기본 설정에 맞게 변경 될 수 있지만 고정 문화권의 데이터는 변경 되지 않습니다.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. 인스턴스화할 수 있습니다는 DateTimeFormatInfo 다음과 같은 방법으로 고정 문화권의 서식 규칙을 나타내는 개체입니다.You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

다음 예제에서는 이러한 각 메서드를 사용 하 여 인스턴스화하는 DateTimeFormatInfo 고정 문화권을 나타내는 개체입니다.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the invariant culture. 그런 다음 개체가 읽기 전용인 지 여부를 나타냅니다.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      

특정 문화권의 DateTimeFormatInfo 개체 인스턴스화Instantiating a DateTimeFormatInfo object for a specific culture

특정 문화권에는 특정 국가/지역에서 사용 되는 언어를 나타냅니다.A specific culture represents a language that is spoken in a particular country/region. 예를 들어, EN-US, 미국에서 사용 되는 영어를 나타내는 특정 문화권 이며 EN-CA 음성 캐나다의 영어 언어를 나타내는 특정 문화권입니다.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. 인스턴스화할 수 있습니다는 DateTimeFormatInfo 다음과 같은 방법으로 특정 문화권의 서식 규칙을 나타내는 개체입니다.You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

다음 예제에서는 각각을 인스턴스화하는 이러한 방법의 한 DateTimeFormatInfo 개체 및 결과 개체가 읽기 전용인 지 여부를 나타냅니다.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

중립 문화권에 대 한 DateTimeFormatInfo 개체 인스턴스화Instantiating a DateTimeFormatInfo object for a neutral culture

문화권 또는 국가/지역;와 독립적인 언어 중립 문화권을 나타냅니다. 일반적으로 하나 이상의 특정 문화권의 부모가 됩니다.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. 예를 들어, Fr 프랑스어 및 FR-FR 문화권의 부모에 대 한 중립 문화권입니다.For example, Fr is a neutral culture for the French language and the parent of the fr-FR culture. 인스턴스화할 수 있습니다는 DateTimeFormatInfo 사용자가 만든 동일한 방식으로 중립 문화권의 서식 규칙을 나타내는 개체를 DateTimeFormatInfo 특정 문화권의 서식 규칙을 나타내는 개체입니다.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. 또한가 중립 문화권을 검색할 수 있습니다 DateTimeFormatInfo 개체는 특정 문화권의에서 중립 문화권을 검색 하 여 CultureInfo.Parent 속성 및 검색 합니다 DateTimeFormatInfo 반환한 개체가 해당 CultureInfo.DateTimeFormat 속성.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. 부모 문화권 나타내는 고정 문화권을 반환된 하지 않는 한 DateTimeFormatInfo 개체 읽기/쓰기입니다.Unless the parent culture represents the invariant culture, the returned DateTimeFormatInfo object is read/write. 다음 예제에서는 이러한 방법으로 인스턴스화하는 DateTimeFormatInfo 중립 문화권을 나타내는 개체입니다.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       

참고

통해.NET Framework 버전 1.0 .NET Framework 3.5.NET Framework 3.5검색 하는 동안는 DateTimeFormatInfo 중립 문화권의 서식 규칙을 반영 하는 개체를 throw를 NotSupportedException 예외입니다.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.

그러나 중립 문화권에 특정 국가/지역 독립적 이기 때문에 culture 별 서식 지정 정보를 없습니다.However, a neutral culture lacks culture-specific formatting information, because it is independent of a specific country/region. 채우기 대신 합니다 DateTimeFormatInfo 반환 하는.NET Framework 제네릭 값 개체를 DateTimeFormatInfo 개체는 특정 형식 지정 규칙 문화권을 반영 하는 중립 문화권의 자식입니다.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. 예를 들어 합니다 DateTimeFormatInfo EN-US 문화권의 서식 규칙을 반영 하는 en 중립 문화권에 대 한 개체 및 DateTimeFormatInfo FR-FR 문화권의 서식 규칙을 반영 하는 fr 문화권 개체입니다.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.

중립 문화권을 나타내는 특정 문화권의 서식 규칙을 확인 하려면 다음과 같은 코드를 사용할 수 있습니다.You can use code like the following to determine which specific culture's formatting conventions a neutral culture represents. 이 예제에서는 리플렉션을 사용 하 여 비교를 DateTimeFormatInfo 특정 자식 문화권의 속성을 사용 하 여 중립 문화권의 속성입니다.The example uses reflection to compare the DateTimeFormatInfo properties of a neutral culture with the properties of a specific child culture. 두 달력 달력 형식이 같은 경우에 동등한 것으로 간주 하 고, 일반 달력에 대 한 달력 이면 해당 GregorianCalendar.CalendarType 동일한 값을 갖는 속성입니다.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

현재 문화권의 DateTimeFormatInfo 개체 인스턴스화Instantiating a DateTimeFormatInfo object for the current culture

인스턴스화할 수 있습니다는 DateTimeFormatInfo 다음과 같은 방법으로 현재 문화권의 서식 규칙을 나타내는 개체입니다.You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture in the following ways:

다음 예제에서는 이러한 각 메서드를 사용 하 여 인스턴스화하는 DateTimeFormatInfo 현재 문화권의 서식 규칙을 나타내는 개체입니다.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture. 그런 다음 개체가 읽기 전용인 지 여부를 나타냅니다.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

쓰기 가능한 만들면 DateTimeFormatInfo 다음이 방법 중 하나에 현재 스레드 문화권의 규칙을 나타내는 개체입니다.You can create a writable DateTimeFormatInfo object that represents the conventions of the current thread culture in one of these ways:

다음 예제에서는 각 방법 마다 인스턴스화하는 읽기/쓰기 DateTimeFormatInfo 개체의 값을 표시 및 해당 IsReadOnly 속성입니다.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에서 사용자를 재정의할 수 중 일부는 DateTimeFormatInfo 서식 지정 및 구문 분석을 통해 작업에 사용 된 속성 값을 국가 및 언어 제어판 애플리케이션입니다.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. 예를 들어, 문화권이 영어 (미국) 인 사용자는 (형식 h:mm: ss tt)에서 기본 12 시간제 시계 대신 긴 시간 값 (mm: ss 형식)에 24 시간제를 사용 하 여 표시 하도록 선택할 수 있습니다.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). DateTimeFormatInfo 설명 하는 방법에서 검색 한 개체가 이전에 모두 이러한 사용자 재정의 반영 합니다.The DateTimeFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. 이 필요 없는 경우 만들 수 있습니다는 NumberFormatInfo 재정의 (및 읽기 전용 대신 읽기/쓰기 이기도) 사용자는 반영 되지 않는 개체를 호출 하 여는 CultureInfo.CultureInfo(String, Boolean) 생성자 및 값을 제공 false 에 대 한는 useUserOverride 인수입니다.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. 다음 예제에이 시스템에 대 한 현재 문화권이 영어 (미국) 인 및 긴 시간 패턴 인 hh: mm:로 h:mm: ss tt 기본값에서 변경 되었습니다.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 및 dynamic dataDateTimeFormatInfo and dynamic data

제공 하는 날짜 및 시간 값의 서식을 지정 하는 것에 대 한 culture 별 데이터를 DateTimeFormatInfo 클래스는에서 제공 하는 문화권 데이터와 마찬가지로 동적는 CultureInfo 클래스입니다.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. 에 대 한 값의 안정성에 대 한 어떠한가 정도 만들면 안 DateTimeFormatInfo 연결 된 개체를 특정 CultureInfo 개체입니다.You should not make any assumptions about the stability of values for DateTimeFormatInfo objects that are associated with particular CultureInfo objects. 고정 문화권 및 연결 된 제공한 데이터만 DateTimeFormatInfo 개체 안정적입니다.Only the data provided by the invariant culture and its associated DateTimeFormatInfo object is stable. 다른 데이터는 애플리케이션 세션 간에 또는 애플리케이션을 실행 하는 동안에 변경할 수 있습니다.Other data can change between application sessions or even while your application is running. 변경의 네 가지 주요 원본 가지가 있습니다.There are four major sources of change:

  • 시스템 업데이트 합니다.System updates. 시간이 지남에 따라 기본 달력 또는 일반적인 날짜 및 시간 형식과 같이 문화권 기본 설정을 변경 합니다.Cultural preferences such as the preferred calendar or customary date and time formats change over time. Windows 업데이트 변경 되어이 경우는 DateTimeFormatInfo 특정 문화권에 대 한 속성 값입니다.When this happens, Windows Update includes changes to the DateTimeFormatInfo property value for a particular culture.

  • 대체 문화권입니다.Replacement cultures. CultureAndRegionInfoBuilder 클래스는 기존 문화권의 데이터를 바꾸는 데 사용할 수 있습니다.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • 속성 값이 변경 연계 합니다.Cascading changes to property values. 다양 한 문화권 관련 속성 인해는 런타임 시 변경할 수 있습니다 DateTimeFormatInfo 데이터를 변경 합니다.A number of culture-related properties can change at run time, which, in turn, causes DateTimeFormatInfo data to change. 예를 들어, 사용자 동작을 통해 또는 프로그래밍 방식으로 현재 문화권을 변경할 수 있습니다.For example, the current culture can be changed either programmatically or through user action. 이 경우는 DateTimeFormatInfo 에서 반환 된 개체는 CurrentInfo 현재 문화권과 연결 된 개체 속성 변경 합니다.When this happens, the DateTimeFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture. 마찬가지로, 문화권의 달력에 변경할 수는 변경 될 수 있습니다 여러 DateTimeFormatInfo 속성 값입니다.Similarly, a culture's calendar can change, which can result in changes to numerous DateTimeFormatInfo property values.

  • 사용자 기본 설정입니다.User preferences. 애플리케이션 사용자는 제어판에서 국가 및 언어 옵션을 통해 현재 시스템 문화권과 연관 된 값의 일부를 재정의할 수도 있습니다.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. 예를 들어 사용자가 다른 형식으로 날짜를 표시할 수도 있습니다.For example, users might choose to display the date in a different format. 경우는 CultureInfo.UseUserOverride 속성이 true의 속성은 DateTimeFormatInfo 개체는 또한 사용자 설정에서 검색 됩니다.If the CultureInfo.UseUserOverride property is set to true, the properties of the DateTimeFormatInfo object is also retrieved from the user settings. 사용자 설정을 사용 하 여 연결 된 문화권을 사용 하 여 호환 되지 않습니다는 CultureInfo 개체 (예를 들어 선택한 일정 하나가 아닌 경우에 나타난 달력을 OptionalCalendars 속성), 메서드 및 속성의 값의 결과 정의 되지 않습니다.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.

일관 되지 않은 데이터의 모든 사용자를 재정의할 수 있는 속성의 가능성을 최소화 하는 DateTimeFormatInfo 개체는 개체를 만들 때 초기화 됩니다.To minimize the possibility of inconsistent data, all user-overridable properties of a DateTimeFormatInfo object are initialized when the object is created. 가능성이 있는 여전히 불일치, 개체 생성도 아니고 사용자 재정의 프로세스는 원자성 이므로 개체를 만드는 동안 관련 값을 변경할 수 있습니다.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. 그러나이 경우 매우 드문 있어야 합니다.However, this situation should be extremely rare.

사용자 재정의에 반영 되 고 있는지 여부를 제어할 수 있습니다. DateTimeFormatInfo 시스템 문화권과 동일한 문화권을 나타내는 개체입니다.You can control whether user overrides are reflected in DateTimeFormatInfo objects that represent the same culture as the system culture. 다음 표에 나와 있는 방법을 DateTimeFormatInfo 개체를 검색할 수 있습니다 및 결과 개체 사용자 재정의 반영 하는지 여부를 나타냅니다.The following table lists the ways in which a DateTimeFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

CultureInfo 및 DateTimeFormatInfo 개체의 원본Source of CultureInfo and DateTimeFormatInfo object 사용자 재정의 반영합니다.Reflects user overrides
CultureInfo.CurrentCulture.DateTimeFormat 속성CultureInfo.CurrentCulture.DateTimeFormat property Yes
DateTimeFormatInfo.CurrentInfo 속성DateTimeFormatInfo.CurrentInfo property Yes
CultureInfo.CreateSpecificCulture 메서드CultureInfo.CreateSpecificCulture method Yes
CultureInfo.GetCultureInfo 메서드CultureInfo.GetCultureInfo method 아니요No
CultureInfo.CultureInfo(String) 생성자CultureInfo.CultureInfo(String) constructor Yes
CultureInfo.CultureInfo(String, Boolean) 생성자CultureInfo.CultureInfo(String, Boolean) constructor 값에 따라 useUserOverride 매개 변수Depends on value of useUserOverride parameter

사용 하는 경우 사용자 재정의가 없는 중요 한 이유가 없는 고려해 야 합니다 DateTimeFormatInfo 서식을 지정 하 고 사용자 입력을 구문 분석 하거나 데이터를 표시 하도록 클라이언트 애플리케이션에서 개체입니다.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. 서버 애플리케이션 또는 무인된 애플리케이션에 대 한 없습니다 다음을 수행 해야합니다.For server applications or unattended applications, you should not. 그러나 사용 중인 경우는 DateTimeFormatInfo 개체를 명시적으로 하나 또는 암시적으로 사용 해야 문자열 형식으로 날짜 및 시간 데이터를 유지 하려면를 DateTimeFormatInfo 고정 문화권의 서식 규칙을 반영 하는 개체를 지정 해야는 사용자 지정 날짜 및 시간 서식 문화권에 관계 없이 사용 하는 문자열입니다.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.

날짜 및 시간 서식 지정Formatting dates and times

DateTimeFormatInfo 개체는 암시적 또는 명시적으로 모든 날짜 및 시간 서식 지정 작업입니다.A DateTimeFormatInfo object is used implicitly or explicitly in all date and time formatting operations. 다음 메서드를 호출 하는 다음과 같습니다.These include calls to the following methods:

모든 날짜 및 시간 서식 지정 작업 사용을 IFormatProvider 구현 합니다.All date and time formatting operations make use of an IFormatProvider implementation. 합니다 IFormatProvider 단일 메서드를 포함 하는 인터페이스 IFormatProvider.GetFormat(Type)합니다.The IFormatProvider interface includes a single method, IFormatProvider.GetFormat(Type). 이 콜백 메서드에 전달 되는 Type 서식 지정 정보를 제공 하는 데 필요한 형식을 나타내는 개체입니다.This callback method is passed a Type object that represents the type needed to provide formatting information. 해당 형식의 인스턴스를 반환 하는 메서드 또는 null 형식의 인스턴스를 제공할 수 없는 경우.The method returns either an instance of that type or null if it cannot provide an instance of the type. .NET Framework에 두 개의 IFormatProvider 날짜 및 시간 서식 지정에 대 한 구현을:The .NET Framework includes two IFormatProvider implementations for formatting dates and times:

경우는 IFormatProvider 구현이 형식 지정 메서드를 명시적으로 제공 하지는 CultureInfo 반환한 개체는 CultureInfo.CurrentCulture 현재 스레드 문화권을 나타내는 속성을 사용 합니다.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.

다음 예제에서는 관계를 보여 줍니다.는 IFormatProvider 인터페이스 및 DateTimeFormatInfo 서식 지정 작업에는 클래스입니다.The following example illustrates the relationship between the IFormatProvider interface and the DateTimeFormatInfo class in formatting operations. 사용자 지정 정의 IFormatProvider 구현입니다 GetFormat 메서드 서식 지정 작업을 요청한 개체의 유형을 표시 합니다.It defines a custom IFormatProvider implementation whose GetFormat method displays the type of the object requested by the formatting operation. 요청 하는 경우는 DateTimeFormatInfo 개체를 제공 하는 메서드는 DateTimeFormatInfo 현재 스레드 문화권에 대 한 개체입니다.If it is requesting a DateTimeFormatInfo object, the method provides the DateTimeFormatInfo object for the current thread culture. 예제에서 출력으로는 Decimal.ToString(IFormatProvider) 메서드 요청을 DateTimeFormatInfo 반면 서식 지정 정보를 제공 하는 개체를 String.Format(IFormatProvider, String, Object[]) 메서드 요청 NumberFormatInfo 하 고 DateTimeFormatInfo 개체 뿐만 ICustomFormatter 구현입니다.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

형식 문자열 및 DateTimeFormatInfo 속성Format strings and DateTimeFormatInfo properties

DateTimeFormatInfo 개체 서식 지정 날짜 및 시간 값을 사용 하 여 작업에 사용 되는 속성의 세 가지를 포함 합니다.The DateTimeFormatInfo object includes three kinds of properties that are used in formatting operations with date and time values:

합니다 표준 날짜 및 시간 형식 문자열와 같은 "d", "D", "f"와 "F"는 특정에 해당 하는 별칭 DateTimeFormatInfo 패턴 속성 형식을 지정 합니다.The standard date and time format strings, such as "d", "D", "f", and "F", are aliases that correspond to particular DateTimeFormatInfo format pattern properties. 대부분의 사용자 지정 날짜 및 시간 형식 문자열 서식 지정 작업 결과 스트림에 삽입 하는 문자열 또는 부분 문자열을 관련이 있습니다.Most of the custom date and time format strings are related to strings or substrings that a formatting operation inserts into the result stream. 다음 표에서 표준 및 사용자 지정 날짜 및 시간 서식 지정자 및 이와 관련 된 DateTimeFormatInfo 속성입니다.The following table lists the standard and custom date and time format specifiers and their associated DateTimeFormatInfo properties. 형식 지정자를 사용 하는 방법에 대 한 세부 정보를 참조 하세요 표준 날짜 및 시간 서식 문자열 하 고 사용자 지정 날짜 및 시간 형식 문자열합니다.For details about how to use these format specifiers, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. 각 표준 형식 문자열에 해당 하는 참고를 DateTimeFormatInfo 사용자 지정 날짜 및 시간 서식 문자열 값을 갖는 속성입니다.Note that each standard format string corresponds to a DateTimeFormatInfo property whose value is a custom date and time format string. 이 사용자 지정 형식 문자열에서 개별 지정자는 다른 일치 DateTimeFormatInfo 속성입니다.The individual specifiers in this custom format string in turn correspond to other DateTimeFormatInfo properties. 만 표에 DateTimeFormatInfo 속성은 표준 형식 문자열의 별칭을 및 해당 별칭이 지정 된 속성에 할당 된 사용자 지정 형식 문자열에서 액세스할 수 있는 목록 속성 하지 않습니다.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. 테이블에 해당 하는 사용자 지정 형식 지정자만을 나열 하는 또한 DateTimeFormatInfo 속성입니다.In addition, the table lists only custom format specifiers that correspond to DateTimeFormatInfo properties.

형식 지정자Format specifier 연결된 속성Associated properties
"d" (간단한 날짜, 표준 형식 문자열)"d" (short date; standard format string) ShortDatePattern를 결과 문자열의 전체 서식을 정의 합니다.ShortDatePattern, to define the overall format of the result string.
"D" (자세한 날짜, 표준 형식 문자열)"D" (long date; standard format string) LongDatePattern를 결과 문자열의 전체 서식을 정의 합니다.LongDatePattern, to define the overall format of the result string.
"f" (전체 날짜 / 시간, 표준 짧은 형식 문자열)"f" (full date / short time; standard format string) LongDatePattern에 형식의 결과 문자열의 날짜 구성 요소를 정의 합니다.LongDatePattern, to define the format of the date component of the result string.

ShortTimePattern에 형식의 결과 문자열의 시간 구성 요소를 정의 합니다.ShortTimePattern, to define the format of the time component of the result string.
"F" (전체 날짜 / 시간 시간, 표준 형식 문자열)"F" (full date / long time; standard format string) LongDatePattern에 형식의 결과 문자열의 날짜 구성 요소를 정의 합니다.LongDatePattern, to define the format of the date component of the result string.

LongTimePattern에 형식의 결과 문자열의 시간 구성 요소를 정의 합니다.LongTimePattern, to define the format of the time component of the result string.
"g" (일반 날짜 / 짧은 시간, 표준 형식 문자열)"g" (general date / short time; standard format string) ShortDatePattern에 형식의 결과 문자열의 날짜 구성 요소를 정의 합니다.ShortDatePattern, to define the format of the date component of the result string.

ShortTimePattern에 형식의 결과 문자열의 시간 구성 요소를 정의 합니다.ShortTimePattern, to define the format of the time component of the result string.
"G" (일반 날짜 / 시간 시간, 표준 형식 문자열)"G" (general date / long time; standard format string) ShortDatePattern에 형식의 결과 문자열의 날짜 구성 요소를 정의 합니다.ShortDatePattern, to define the format of the date component of the result string.

LongTimePattern에 형식의 결과 문자열의 시간 구성 요소를 정의 합니다.LongTimePattern, to define the format of the time component of the result string.
"M", "m" (월/일, 표준 형식 문자열)"M", "m" (month/day; standard format string) MonthDayPattern를 결과 문자열의 전체 서식을 정의 합니다.MonthDayPattern, to define the overall format of the result string.
"O", "o" (라운드트립 날짜/시간, 표준 형식 문자열)"O", "o" (round-trip date/time; standard format string) 없음None.
"R", "r" (RFC1123; 표준 형식 문자열)"R", "r" (RFC1123; standard format string) RFC1123Pattern을 RFC 1123 표준에 따르는 결과 문자열을 정의 합니다.RFC1123Pattern, to define a result string that conforms to the RFC 1123 standard. 속성이 읽기 전용입니다.The property is read-only.
"s" (정렬 가능한 날짜/시간, 표준 형식 문자열)"s" (sortable date/time; standard format string) SortableDateTimePatternISO 8601 표준을 따르는 결과 문자열을 정의할 수 있습니다.SortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard. 속성이 읽기 전용입니다.The property is read-only.
"t" (짧은 시간, 표준 형식 문자열)"t" (short time; standard format string) ShortTimePattern를 결과 문자열의 전체 서식을 정의 합니다.ShortTimePattern, to define the overall format of the result string.
"T" (긴 시간, 표준 형식 문자열)"T" (long time; standard format string) LongTimePattern를 결과 문자열의 전체 서식을 정의 합니다.LongTimePattern, to define the overall format of the result string.
"u" (정렬 가능한 유니버설 날짜/시간, 표준 형식 문자열)"u" (universal sortable date/time; standard format string) UniversalSortableDateTimePatterncoordinated universal time ISO 8601 표준을 따르는 결과 문자열을 정의할 수 있습니다.UniversalSortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard for coordinated universal time. 속성이 읽기 전용입니다.The property is read-only.
"U" (유니버설 전체 날짜/시간, 표준 형식 문자열)"U" (universal full date/time; standard format string) FullDateTimePattern를 결과 문자열의 전체 서식을 정의 합니다.FullDateTimePattern, to define the overall format of the result string.
"Y", "y" (연도 월; 표준 형식 문자열)"Y", "y" (year month; standard format string) YearMonthPattern를 결과 문자열의 전체 서식을 정의 합니다.YearMonthPattern, to define the overall format of the result string.
"ddd" (사용자 지정 형식 지정자)"ddd" (custom format specifier) AbbreviatedDayNames를 결과 문자열에 요일을 기준의 약식된 이름이 포함 되도록 합니다.AbbreviatedDayNames, to include the abbreviated name of the day of the week in the result string.
"g", "gg" (사용자 지정 형식 지정자)"g", "gg" (custom format specifier) 호출 된 GetEraName 연대 이름을 결과 문자열에 삽입 하는 방법입니다.Calls the GetEraName method to insert the era name in the result string.
"MMM" (사용자 지정 형식 지정자)"MMM" (custom format specifier) AbbreviatedMonthNames약식된 월 이름을 결과 문자열에 포함 합니다.AbbreviatedMonthNames, to include the abbreviated month name in the result string.
"MMMM" (사용자 지정 형식 지정자)"MMMM" (custom format specifier) MonthNames 또는 MonthGenitiveNames전체 월 이름을 결과 문자열에 포함 합니다.MonthNames or MonthGenitiveNames, to include the full month name in the result string.
"t" (사용자 지정 형식 지정자)"t" (custom format specifier) AMDesignator 또는 PMDesignator결과 문자열에 AM/PM 지정자의 첫 번째 문자를 포함 합니다.AMDesignator or PMDesignator, to include the first character of the AM/PM designator in the result string.
"tt" (사용자 지정 형식 지정자)"tt" (custom format specifier) AMDesignator 또는 PMDesignator결과 문자열에 전체 AM/PM 지정자를 포함 합니다.AMDesignator or PMDesignator, to include the full AM/PM designator in the result string.
":" (사용자 지정 형식 지정자)":" (custom format specifier) TimeSeparator를 결과 문자열에는 시간 구분 기호를 포함 합니다.TimeSeparator, to include the time separator in the result string.
"/" (사용자 지정 형식 지정자)"/" (custom format specifier) DateSeparator를 결과 문자열에는 날짜 구분 기호를 포함 합니다.DateSeparator, to include the date separator in the result string.

DateTimeFormatInfo 속성 수정Modifying DateTimeFormatInfo properties

쓰기 가능한의 연결된 속성을 수정 하 여 날짜 및 시간 형식 문자열에서 생성 된 결과 문자열을 변경할 수 있습니다 DateTimeFormatInfo 개체입니다.You can change the result string produced by date and time format strings by modifying the associated properties of a writable DateTimeFormatInfo object. 여부를 확인 하는 DateTimeFormatInfo 개체가 쓰기를 사용 하 여는 IsReadOnly 속성입니다.To determine if a DateTimeFormatInfo object is writable, use the IsReadOnly property. 사용자 지정 하는 DateTimeFormatInfo 이런에서 개체:To customize a DateTimeFormatInfo object in this way:

  1. 읽기/쓰기 복사본 만들기를 DateTimeFormatInfo 개체를 수정 하려면 해당 형식 지정 규칙입니다.Create a read/write copy of a DateTimeFormatInfo object whose formatting conventions you want to modify. (참조를 DateTimeFormatInfo 개체 인스턴스화 섹션입니다.)(See the Instantiating a DateTimeFormatInfo object section.)

  2. 속성 또는 원하는 결과 문자열을 생성 하는 데 사용 되는 속성을 수정 합니다.Modify the property or properties that are used to produce the desired result string. (서식 지정 방법을 메서드 사용에 대 한 자세한 DateTimeFormatInfo 결과 문자열을 정의 하는 속성의 이전 섹션에서 참조 서식 문자열 및 DateTimeFormatInfo 속성.)(For information about how formatting methods use DateTimeFormatInfo properties to define result strings, see the previous section, Format strings and DateTimeFormatInfo properties.)

  3. 사용자 지정을 사용 하 여 DateTimeFormatInfo 로 만든 개체는 IFormatProvider 서식 지정 메서드에 대 한 호출에 인수입니다.Use the custom DateTimeFormatInfo object you created as the IFormatProvider argument in calls to formatting methods.

두 가지 다른 결과 문자열의 형식을 변경 하려면:There are two other ways to change the format of a result string:

  • 사용할 수는 CultureAndRegionInfoBuilder (고유 이름을 가진 및 기존를 보완 하는 문화권 문화권) 사용자 지정 문화권 또는 대체 문화권 (하나는 특정 문화권 대신 사용 되는)를 정의 하는 클래스입니다.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). 저장 하 고와 마찬가지로이 문화권을 프로그래밍 방식으로 액세스할 수 있습니다 CultureInfo .NET Framework에서 지 원하는 개체입니다.You can save and access this culture programmatically as you would any CultureInfo object supported by the .NET Framework.

  • 결과 문자열 문화권 구분 되 고 미리 정의 된 서식을 따르지 않습니다, 경우에 사용자 지정 날짜 및 시간 서식 문자열을 사용할 수 있습니다.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. 예를 들어, YYYYMMDDHHmmss 형식의 날짜 및 시간 데이터를 직렬화 하는 경우 생성할 수 있습니다 결과 문자열에 사용자 지정 형식 문자열을 전달 하 여 합니다 DateTime.ToString(String) 메서드를 결과 문자열을 변환할 수 있습니다 다시는 DateTime 호출 하 여 값을 DateTime.ParseExact 메서드.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.

간단한 날짜 패턴 변경Changing the short date pattern

다음 예제에서는 "d" (간단한 날짜) 표준 서식 문자열에 의해 생성 되는 결과 문자열의 형식을 변경 합니다.The following example changes the format of a result string produced by the "d" (short date) standard format string. 연결 된 변경 ShortDatePattern 속성을 "M/d/yyyy"의 기본값에서 영어 (미국) 문화권을 EN-US에 대 한 "yyyy' 앞과 뒤에 날짜를 표시 하려면"d"표준 서식 문자열 사용 하 여 dd"-"MM"-"는 ShortDatePattern 속성은 변경 합니다.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

날짜 구분 기호를 변경합니다.Changing the date separator character

다음 예제에서는 변경의 날짜 구분 기호 문자는 DateTimeFormatInfo FR-FR 문화권의 서식 규칙을 나타내는 개체입니다.The following example changes the date separator character in a DateTimeFormatInfo object that represents the formatting conventions of the fr-FR culture. 예제에서는 "g" 표준 서식 문자열을 사용 하 여 이전과 이후에 날짜를 표시 하는 DateSeparator 속성이 변경 됩니다.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

요일 이름 약어 및 자세한 날짜 패턴 변경Changing day name abbreviations and the long date pattern

경우에 따라 긴 날짜 패턴이 며, 일반적으로 전체 요일과 월 이름을 월과 연도 중 일 수와 함께 표시를 너무 길어질 수 있습니다.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. 다음 예에서는 일 뒤에 1 자리 또는 두 자리 요일 이름 약어, 월 이름 약어 및 연도 반환 하는 EN-US 문화권의 긴 날짜 패턴을 단축 합니다.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. 짧은 요일 이름 약어를 할당 하 여 이렇게 합니다 AbbreviatedDayNames 배열에서 할당할 사용자 지정 서식 문자열을 수정 하는 LongDatePattern 속성.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. "D"에서 반환 된 결과 문자열 및 "f" 표준 서식 문자열에 영향을 줍니다.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

일반적으로 변경 합니다 LongDatePattern 속성이 영향을 주는지도 FullDateTimePattern 속성에서 "F" 표준 서식 문자열에 의해 반환 된 결과 문자열을 정의 하는 합니다.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. 예제를 유지 하기 위해 원래 전체 날짜 및 시간 패턴에 할당 된 원래 사용자 지정 형식 문자열을 다시 할당 합니다 FullDateTimePattern 후 속성을 LongDatePattern 속성을 수정 합니다.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 시간제 시계에서 24 시간제로 변경Changing from a 12-hour clock to a 24-hour clock

.NET Framework의 많은 문화권에 대 한 시간을 12 시간제 시계 및 AM/PM 지정자를 사용 하 여 표현 됩니다.For many cultures in the .NET Framework, the time is expressed by using a 12-hour clock and an AM/PM designator. 다음 예제에서는 정의 ReplaceWith24HourClock 24 시간제를 사용 하는 형식에는 12 시간제 시계를 사용 하는 모든 시간 형식으로 대체 하는 메서드.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

형식 문자열을 수정 하려면 정규식을 사용 하는 예제입니다.The example uses a regular expression to modify the format string. 정규식 패턴 @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) 다음과 같이 정의 됩니다.The regular expression pattern @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) is defined as follows:

무늬Pattern 설명Description
^ 문자열의 시작 부분에서 검색을 시작합니다.Begin the match at the beginning of the string.
(?<openAMPM>\s*t+\s*)? 일치 항목 0 개 또는 1 발생 0 개 이상의 공백 문자, 하나는 "t" 문자 뒤에 또는 뒤에 0 개 이상의 공백 문자가 번 이상.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. 이 캡처링 그룹의 이름은 openAMPM합니다.This capturing group is named openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ 경우는 openAMPM 그룹에 일치 하는, "h" 및 "t" 아닌 하나 이상의 문자 뒤에 한 번 이상, "h" 문자를 일치 합니다.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". 일치 하는 문자열의 끝에서 끝납니다.The match ends at the end of the string. 모든 문자 "h" 명명 된 캡처링 그룹에 포함 된 후에 캡처된 nonHours합니다.All characters captured after "h" are included in a capturing group named nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) 경우는 openAMPM 그룹에 일치 하는 항목이 없는, "h" 뒤에 0 개 이상의 공백 문자가 한 번 이상, "h" 및 "t" 아닌 하나 이상의 문자 뒤에 문자와 일치 합니다.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. 문자 "t"의 하나 이상의 항목을 마지막으로 일치 합니다.Finally, match one or more occurrences of the letter "t". 모든 문자 "h" 및 "t" 고 공백을 명명 된 캡처링 그룹에 포함 된 전에 캡처된 nonHours합니다.All characters captured after "h" and before the white-spaces and "t" are included in a capturing group named nonHours.

nonHours 캡처링 그룹이 포함 되어 있습니다 분 및 초 구성 요소 사용자 지정 날짜 및 시간 서식 문자열을 함께 모든 시간 구분 기호입니다.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. 바꾸기 패턴 HH${nonHours} 이러한 요소에 "HH" 부분 문자열 앞에 추가 합니다.The replacement pattern HH${nonHours} prepends the substring "HH" to these elements.

표시 하 고 날짜의 연대를 변경 합니다.Displaying and changing the era in a date

다음 예제에서는 "g" 사용자 지정 형식 지정자를 추가 합니다 LongDatePattern EN-US 문화권의 서식 규칙을 나타내는 개체의 속성입니다.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. 이 추가 다음 세 가지 표준 형식 문자열을 영향을 줍니다.This addition affects the following three standard format strings:

  • "D" (긴 날짜) 표준 형식 문자열에 직접 매핑되는 LongDatePattern 속성입니다.The "D" (long date) standard format string, which maps directly to the LongDatePattern property.

  • "F" (전체 날짜 / 시간을 요약)에서 생성 된 부분 문자열을 연결 하는 결과 문자열을 생성 하는 표준 형식 문자열을 LongDatePatternShortTimePattern 속성입니다.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.

  • "F" (전체 날짜 자세한 시간 /) 표준 서식 문자열에 직접 매핑되는 FullDateTimePattern 속성입니다.The "F" (full date / long time) standard format string, which maps directly to the FullDateTimePattern property. 에서는 명시적으로이 속성 값을 설정 하지 때문에 생성 된 동적으로 연결 하 여 합니다 LongDatePatternLongTimePattern 속성입니다.Because we have not explicitly set this property value, it is generated dynamically by concatenating the LongDatePattern and LongTimePattern properties.

또한 해당 일정에 단일 연대를 문화권에 대 한 연대 이름을 변경 하는 방법을 보여 줍니다.The example also shows how to change the era name for a culture whose calendar has a single era. EN-US 문화권으로 표현 되는 양력을 사용 하는 경우에 GregorianCalendar 개체입니다.In this case, the en-US culture uses the Gregorian calendar, which is represented by a GregorianCalendar object. GregorianCalendar 클래스 기 이름을 하에서는 단일 연대를 지원 합니다.The GregorianCalendar class supports a single era, which it names A.D. (Anno Domini)입니다.(Anno Domini). 이 예제에서는 기 연대 이름 변경The example changes the era name to C.E. (Common Era)에 할당 된 형식 문자열에서 "g" 사용자 지정 형식 지정자를 대체 하 여는 FullDateTimePattern 리터럴 문자열을 사용 하 여 속성입니다.(Common Era) by replacing the "g" custom format specifier in the format string assigned to the FullDateTimePattern property with a literal string. 리터럴 문자열의 사용은 연대 이름에서 일반적으로 반환 되기 때문에 필요 합니다 GetEraName 개인 데이터는.NET Framework 또는 Windows 운영 체제에서 제공 되는 문화권 테이블에서 메서드.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

날짜 및 시간 문자열 구문 분석Parsing date and time strings

날짜 및 시간의 문자열 표현으로 변환에서는 구문 분석을 DateTime 또는 DateTimeOffset 값입니다.Parsing involves converting the string representation of a date and time to a DateTime or DateTimeOffset value. 이러한 두 유형을 모두 포함 된 Parse, TryParse, ParseExact, 및 TryParseExact 구문 분석 작업을 지 원하는 방법.Both of these types include the Parse, TryParse, ParseExact, and TryParseExact methods to support parsing operations. Parse 하 고 TryParse 반면 메서드는 다양 한 형식으로 나타낼 수 있는 문자열을 변환 ParseExactTryParseExact 정의 된 형식 또는 형식 문자열에 포함 합니다.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. 구문 분석 작업이 실패 하는 경우 Parse 하 고 ParseExact 반면 예외가 throw TryParse 하 고 TryParseExact 반환 false합니다.If the parsing operation fails, Parse and ParseExact throw an exception, whereas TryParse and TryParseExact return false.

구문 분석 메서드를 암시적 또는 명시적으로 사용 된 DateTimeStyles (예: 앞, 뒤, 또는 내부 공백) 스타일 요소를 확인 하는 열거형 값을 구문 분석할 문자열 및 구문 분석된 된 문자열 또는 누락 된 해석 하는 방법에 있을 수 있습니다 요소입니다.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. 제공 하지 않으면를 DateTimeStyles 를 호출할 때 값을 Parse 또는 TryParse 메서드, 기본값은 DateTimeStyles.AllowWhiteSpaces, 포함 된 복합 스타일 인를 DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite, 및 DateTimeStyles.AllowInnerWhite 플래그입니다.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 하 고 TryParseExact 메서드, 기본값은 DateTimeStyles.None; 입력된 문자열은 특정 사용자 지정 날짜 및 시간 서식 문자열을 정확 하 게 일치 해야 합니다.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.

구문 분석 메서드를 암시적으로 또는 명시적으로 사용 된 DateTimeFormatInfo 특정 기호 정의 패턴으로 개체를 구문 분석 될 문자열에서 발생할 수 있습니다.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 개체는 DateTimeFormatInfo 개체가 현재 스레드 문화권에 기본적으로 사용 됩니다.If you don't provide a DateTimeFormatInfo object, the DateTimeFormatInfo object for the current thread culture is used by default. 날짜 및 시간 문자열 구문 분석 하는 방법에 대 한 자세한 내용은 참조는 개별 구문 분석 메서드 같은 DateTime.Parse, DateTime.TryParseDateTimeOffset.ParseExact, 및 DateTimeOffset.TryParseExact합니다.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.

다음 예제에서는 구문 분석 된 날짜 및 시간 문자열의 문화권 구분 특성을 보여 줍니다.The following example illustrates the culture-sensitive nature of parsing date and time strings. EN-US, EN-GB, FR-FR 및 FI-FI 문화권의 규칙을 사용 하 여 두 날짜 문자열을 구문 분석 하려고 합니다.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의 2014 년 8 월 18/로 해석 되는 날짜 문화권 throw를 FormatException 18 개월 수로 해석 되기 때문에 다른 3 개 예외 문화권입니다.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. 2015 년 2 월 1 일에는 EN-US 문화권의 첫 번째 월 2 일 하지만 나머지 문화에 두 번째 달의 첫째 요일로 구문 분석 됩니다.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

날짜 및 시간 문자열은 일반적으로 두 가지 이유로 구문 분석 됩니다.Date and time strings are typically parsed for two reasons:

  • 날짜 및 시간 값으로 사용자 입력을 변환 합니다.To convert user input into a date and time value.

  • 날짜 및 시간 값 라운드트립 하려면 즉, 이전에 문자열로 serialize 된 날짜 및 시간 값을 deserialize 하는 데 있습니다.To round-trip a date and time value; that is, to deserialize a date and time value that was previously serialized as a string.

다음 섹션에서는 이러한 두 작업에 자세히 설명합니다.The following sections discuss these two operations in greater detail.

사용자 문자열을 구문 분석Parsing user strings

항상 인스턴스화해야 사용자가 입력 하는 날짜 및 시간 문자열을 구문 분석할 때를 DateTimeFormatInfo 사용자 수행한 모든 사용자 지정을 포함 하 여 사용자의 문화권 설정을 반영 하는 개체입니다.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. 그렇지 않은 경우 날짜 및 시간 개체는 잘못 된 값 있을 수 있습니다.Otherwise, the date and time object may have incorrect values. 인스턴스화하는 방법에 대 한 자세한를 DateTimeFormatInfo 사용자 지정 문화권을 반영 하는 개체 참조를 DateTimeFormatInfo 및 dynamic data 섹션입니다.For information about how to instantiate a DateTimeFormatInfo object that reflects user cultural customizations, see the DateTimeFormatInfo and dynamic data section.

다음 예제에서는 사용자 문화권 설정을 반영 하는 구문 분석 작업을 하지 않는 사이의 차이점을 보여 줍니다.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. 이 경우 기본 시스템 문화권은 EN-US, 하지만 사용자가 제어판을 사용 하는 것 국가 및 언어 "M/d/yyyy" 기본 "yy/MM/dd"에서 간단한 날짜 패턴을 변경 하려면.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". 때 사용자 사용자 설정을 반영 하는 문자열을 입력 하 고 문자열에서 구문 분석 되는 DateTimeFormatInfo 도 사용자 설정 (재정의)를 반영 하는 개체 구문 분석 작업이 올바른 결과 반환 합니다.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. 그러나 경우는 문자열은 구문 분석 하 여는 DateTimeFormatInfo 표준 EN-US 문화권 설정을 구문 분석 메서드가 throw를 반영 하는 개체를 FormatException 예외 해석 하므로 14 숫자로 월의 마지막 두 자리 연도의 없습니다.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

직렬화 및 역직렬화 날짜 및 시간 데이터Serializing and deserializing date and time data

직렬화 된 날짜 및 시간 데이터 왕복; 필요 합니다. 즉, 모든 직렬화 및 역직렬화 된 값이 동일 해야 합니다.Serialized date and time data are expected to round-trip; that is, all serialized and deserialized values should be identical. 날짜 및 시간 값을 단일 시점을 나타내는 경우 역직렬화 된 값으로 복원 된 시스템의 표준 시간대를 문화권에 관계 없이 동일한 순간을 나타내야 합니다.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. 라운드트립 날짜 및 시간 데이터를 성공적으로 사용 해야가 반환한 고정 문화권의 규칙을 InvariantInfo 속성을 생성 하 고 데이터를 구문 분석 합니다.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. 서식 지정 및 구문 분석 작업을 해야 기본 문화권의 규칙을 반영 되지 않습니다.The formatting and parsing operations should never reflect the conventions of the default culture. 기본 문화권 설정을 사용 하는 경우 데이터의 이식성 엄격 하 게 제한 합니다. 문화권 관련 설정 되어 있는 serialize 된 스레드와 동일한 스레드에서 정상적으로 deserialize 할 수 있습니다.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. 경우에 따라이 의미는 데이터가 없습니다도 성공적으로 직렬화 및 역직렬화 될 동일한 시스템에서 합니다.In some cases, this means that the data cannot even be successfully serialized and deserialized on the same system.

날짜 및 시간 값의 시간 구성 요소에 중요 한 경우 또한 될 UTC로 변환 하 고 "o" 또는 "r"을 사용 하 여 직렬화 표준 형식 문자열합니다.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. 데이터를 구문 분석 방법 및 고정 문화권을 사용 하 여 적절 한 형식 문자열의 전달 호출 하 여 복원할 수 있습니다는 provider 인수입니다.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.

다음 예제에서는 라운드트립 날짜 및 시간 값의 프로세스를 보여 줍니다.The following example illustrates the process of round-tripping a date and time value. 날짜 및 시간을 미국 관찰 하는 시스템을 serialize 태평양 표준시 기준 및 현재 문화권이 EN-US 인 합니다.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)

브뤼셀, 코펜하겐, 마드리드 및 파리 표준 시간대 시스템에서 데이터를 deserialize 할 및 현재 문화권이 인 fr.It deserializes the data on a system in the Brussels, Copenhagen, Madrid and Paris time zone and whose current culture is fr-FR. 복원 된 날짜는 9 시간 UTC 보다 한 시간을 UTC 보다 8 시간에서 표준 시간대 조정에 반영 하는 원래 날짜 보다 나중입니다.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. 원래 날짜와 복원 된 날짜 시간의 동일한 순간을 나타냅니다.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

생성자

DateTimeFormatInfo()

문화권 독립(고정)적인 DateTimeFormatInfo 클래스의 쓰기 가능한 새 인스턴스를 초기화합니다.Initializes a new writable instance of the DateTimeFormatInfo class that is culture-independent (invariant).

속성

AbbreviatedDayNames

문화권별 약식 요일 이름이 들어 있는 String 형식의 1차원 배열을 가져오거나 설정합니다.Gets or sets a one-dimensional array of type String containing the culture-specific abbreviated names of the days of the week.

AbbreviatedMonthGenitiveNames

현재 DateTimeFormatInfo 개체와 연결된 약식 월 이름의 문자열 배열을 가져오거나 설정합니다.Gets or sets a string array of abbreviated month names associated with the current DateTimeFormatInfo object.

AbbreviatedMonthNames

문화권별 약식 월 이름이 들어 있는 1차원 문자열 배열을 가져오거나 설정합니다.Gets or sets a one-dimensional string array that contains the culture-specific abbreviated names of the months.

AMDesignator

"AM(ante meridiem)"(오전) 시간에 대한 문자열 지정자를 가져오거나 설정합니다.Gets or sets the string designator for hours that are "ante meridiem" (before noon).

Calendar

현재 문화권에 사용할 달력을 가져오거나 설정합니다.Gets or sets the calendar to use for the current culture.

CalendarWeekRule

연도의 첫째 주를 결정하는 데 사용되는 규칙을 지정하는 값을 가져오거나 설정합니다.Gets or sets a value that specifies which rule is used to determine the first calendar week of the year.

CurrentInfo

현재 문화권에 따라 값의 형식을 지정하는 읽기 전용 DateTimeFormatInfo 개체를 가져옵니다.Gets a read-only DateTimeFormatInfo object that formats values based on the current culture.

DateSeparator

날짜의 구성 요소 즉, 연도, 월, 일을 구분하는 문자열을 가져오거나 설정합니다.Gets or sets the string that separates the components of a date, that is, the year, month, and day.

DayNames

문화권별 전체 요일 이름이 들어 있는 1차원 문자열 배열을 가져오거나 설정합니다.Gets or sets a one-dimensional string array that contains the culture-specific full names of the days of the week.

FirstDayOfWeek

주의 첫째 요일을 가져오거나 설정합니다.Gets or sets the first day of the week.

FullDateTimePattern

긴 날짜 및 긴 시간 값에 대한 사용자 지정 서식 문자열을 가져오거나 설정합니다.Gets or sets the custom format string for a long date and long time value.

InvariantInfo

문화권 독립(고정)적인 기본 읽기 전용 DateTimeFormatInfo 개체를 가져옵니다.Gets the default read-only DateTimeFormatInfo object that is culture-independent (invariant).

IsReadOnly

DateTimeFormatInfo 개체가 읽기 전용인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the DateTimeFormatInfo object is read-only.

LongDatePattern

긴 날짜 값의 사용자 지정 형식 문자열을 가져오거나 설정합니다.Gets or sets the custom format string for a long date value.

LongTimePattern

긴 시간 값의 사용자 지정 형식 문자열을 가져오거나 설정합니다.Gets or sets the custom format string for a long time value.

MonthDayPattern

월 및 일 값에 대한 사용자 지정 서식 문자열을 가져오거나 설정합니다.Gets or sets the custom format string for a month and day value.

MonthGenitiveNames

현재 DateTimeFormatInfo 개체와 연결된 월 이름의 문자열 배열을 가져오거나 설정합니다.Gets or sets a string array of month names associated with the current DateTimeFormatInfo object.

MonthNames

문화권별 전체 월 이름이 들어 있는 String 형식의 1차원 배열을 가져오거나 설정합니다.Gets or sets a one-dimensional array of type String containing the culture-specific full names of the months.

NativeCalendarName

현재 DateTimeFormatInfo 개체와 연결된 달력의 네이티브 이름을 가져옵니다.Gets the native name of the calendar associated with the current DateTimeFormatInfo object.

PMDesignator

"PM(post meridiem)"(오후) 시간에 대한 문자열 지정자를 가져오거나 설정합니다.Gets or sets the string designator for hours that are "post meridiem" (after noon).

RFC1123Pattern

IETF(Internet Engineering Task Force) RFC(Request for Comments) 1123 사양을 기반으로 하는 시간 값에 대한 사용자 지정 서식 문자열을 가져옵니다.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

짧은 날짜 값의 사용자 지정 형식 문자열을 가져오거나 설정합니다.Gets or sets the custom format string for a short date value.

ShortestDayNames

현재 DateTimeFormatInfo 개체와 연결된 가장 짧은 고유 약식 요일 이름의 문자열 배열을 가져오거나 설정합니다.Gets or sets a string array of the shortest unique abbreviated day names associated with the current DateTimeFormatInfo object.

ShortTimePattern

짧은 시간 값의 사용자 지정 형식 문자열을 가져오거나 설정합니다.Gets or sets the custom format string for a short time value.

SortableDateTimePattern

정렬 가능한 날짜 및 시간 값에 대한 사용자 지정 서식 문자열을 가져옵니다.Gets the custom format string for a sortable date and time value.

TimeSeparator

시간의 구성 요소 즉, 시, 분, 초를 구분하는 문자열을 가져오거나 설정합니다.Gets or sets the string that separates the components of time, that is, the hour, minutes, and seconds.

UniversalSortableDateTimePattern

ISO 8601에서 정의된 정렬 가능한 유니버설 날짜 및 시간 문자열에 대한 사용자 지정 서식 문자열을 가져옵니다.Gets the custom format string for a universal, sortable date and time string, as defined by ISO 8601.

YearMonthPattern

연도 및 월 값에 대한 사용자 지정 서식 문자열을 가져오거나 설정합니다.Gets or sets the custom format string for a year and month value.

메서드

Clone()

DateTimeFormatInfo의 부분 복사본을 만듭니다.Creates a shallow copy of the DateTimeFormatInfo.

Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
GetAbbreviatedDayName(DayOfWeek)

현재 DateTimeFormatInfo 개체와 연결된 문화권에 기반하여 지정된 요일의 문화권별 약식 이름을 반환합니다.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)

약식 형태가 있는 경우 지정된 연대의 약식 이름이 들어 있는 문자열을 반환합니다.Returns the string containing the abbreviated name of the specified era, if an abbreviation exists.

GetAbbreviatedMonthName(Int32)

현재 DateTimeFormatInfo 개체와 연결된 문화권에 기반하여 지정된 월의 문화권별 약식 이름을 반환합니다.Returns the culture-specific abbreviated name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetAllDateTimePatterns()

날짜 및 시간 값의 형식을 지정할 수 있는 모든 표준 패턴을 반환합니다.Returns all the standard patterns in which date and time values can be formatted.

GetAllDateTimePatterns(Char)

지정된 표준 형식 문자열을 사용하여 날짜 및 시간 값의 형식을 지정할 수 있는 모든 패턴을 반환합니다.Returns all the patterns in which date and time values can be formatted using the specified standard format string.

GetDayName(DayOfWeek)

현재 DateTimeFormatInfo 개체와 연결된 문화권에 기반하여 지정된 요일의 문화권별 전체 이름을 반환합니다.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)

지정된 서기를 나타내는 정수를 반환합니다.Returns the integer representing the specified era.

GetEraName(Int32)

지정된 연대 이름이 들어 있는 문자열을 반환합니다.Returns the string containing the name of the specified era.

GetFormat(Type)

날짜 및 시간 형식 지정 서비스를 제공하는 지정된 형식의 개체를 반환합니다.Returns an object of the specified type that provides a date and time formatting service.

GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetInstance(IFormatProvider)

지정된 DateTimeFormatInfo 개체와 연결된 IFormatProvider 개체를 반환합니다.Returns the DateTimeFormatInfo object associated with the specified IFormatProvider.

GetMonthName(Int32)

현재 DateTimeFormatInfo 개체와 연결된 문화권에 기반하여 지정된 월의 문화권별 전체 이름을 반환합니다.Returns the culture-specific full name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetShortestDayName(DayOfWeek)

현재 DateTimeFormatInfo 개체와 연결된 지정된 요일의 가장 짧은 약식 요일 이름을 가져옵니다.Obtains the shortest abbreviated day name for a specified day of the week associated with the current DateTimeFormatInfo object.

GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
ReadOnly(DateTimeFormatInfo)

읽기 전용 DateTimeFormatInfo 래퍼를 반환합니다.Returns a read-only DateTimeFormatInfo wrapper.

SetAllDateTimePatterns(String[], Char)

지정된 표준 형식 문자열에 해당하는 사용자 지정 날짜 및 시간 형식 문자열을 설정합니다.Sets the custom date and time format strings that correspond to a specified standard format string.

ToString()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(다음에서 상속됨 Object)

명시적 인터페이스 구현

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

적용 대상

추가 정보