DateTimeFormatInfo Třída

Definice

public ref class DateTimeFormatInfo sealed : IFormatProvider

public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider

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

public sealed class DateTimeFormatInfo : IFormatProvider

public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider

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

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

type DateTimeFormatInfo = class
    interface IFormatProvider

type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider

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

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

Public NotInheritable Class DateTimeFormatInfo
Implements IFormatProvider

Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider

Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider, ISerializable

Dědičnost

Object

DateTimeFormatInfo

Atributy

SerializableAttribute ComVisibleAttribute

Implementuje

IFormatProvider ICloneable ISerializable

Příklady

Následující příklad používá reflexi k získání vlastností DateTimeFormatInfo objektu pro jazykovou verzi angličtiny (USA). Zobrazí hodnotu těchto vlastností, které obsahují řetězce vlastního formátu, a používá tyto řetězce k zobrazení formátovaných kalendářních dat.

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

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

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

Imports System.Globalization
Imports System.Reflection

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

Poznámky

Vlastnosti DateTimeFormatInfo třídy obsahují informace specifické pro jazykovou verzi pro formátování nebo analýzu hodnot data a času, například následující:

• Vzory používané k formátování hodnot kalendářních dat.
• Vzory používané k formátování časových hodnot.
• Názvy dnů v týdnu.
• Názvy měsíců v roce.
• Označení A.M. a P.M. použité v časových hodnotách.
• Kalendář, ve kterém jsou kalendářní data vyjádřena.

Vytvoření instance objektu DateTimeFormatInfo

Objekt DateTimeFormatInfo může představovat konvence formátování invariantní kultury, konkrétní kultury, neutrální kultury nebo aktuální kultury. Tato část popisuje, jak vytvořit instanci každého typu objektu DateTimeFormatInfo .

Vytvoření instance objektu DateTimeFormatInfo pro invariantní jazykovou verzi

Invariantní kultura představuje kulturu, která není závislá na kulturních rozdílech. Je založená na anglickém jazyce, ale ne na konkrétní zemi nebo oblasti pro angličtinu. I když data konkrétních jazykových verzí můžou být dynamická a můžou se měnit tak, aby odrážela nové kulturní konvence nebo uživatelské předvolby, data invariantní jazykové verze se nemění. Objekt DateTimeFormatInfo, který představuje konvence formátování invariantní jazykové verze, můžete vytvořit následujícími způsoby:

• Načtením hodnoty vlastnosti InvariantInfo. Vrácený DateTimeFormatInfo objekt je jen pro čtení.
• Voláním bezparametrického konstruktoru DateTimeFormatInfo. Vrácený DateTimeFormatInfo objekt je pro čtení a zápis.
• Načtením hodnoty DateTimeFormat vlastnosti z objektu CultureInfo , který je vrácen vlastností CultureInfo.InvariantCulture . Vrácený DateTimeFormatInfo objekt je jen pro čtení.

Následující příklad používá každou z těchto metod k vytvoření instance objektu DateTimeFormatInfo, který představuje invariantní jazykovou verzi. Potom určuje, jestli je objekt jen pro čtení.

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

Vytvoření instance objektu DateTimeFormatInfo pro konkrétní jazykovou verzi

Konkrétní kulturní prostředí představuje jazyk, kterým se mluví v určité zemi nebo regionu. En-US je například specifická jazyková verze, která představuje anglický jazyk mluvený v USA a en-CA je specifická jazyková verze, která představuje anglický jazyk mluvený v Kanadě. Můžete vytvořit instanci objektu, který představuje konvence formátování konkrétní kultury, následujícími způsoby:

• Voláním metody CultureInfo.GetCultureInfo(String) a načtením hodnoty vlastnosti CultureInfo vráceného objektu CultureInfo.DateTimeFormat. Vrácený DateTimeFormatInfo objekt je jen pro čtení.

• Předáním objektu reprezentujícího kulturní nastavení do statické metody GetInstance, jejíž CultureInfo objekt chcete získat. Vrácený DateTimeFormatInfo objekt je pro čtení a zápis.

• Voláním statické CultureInfo.CreateSpecificCulture metody a načtením hodnoty vrácené CultureInfo vlastnosti objektu CultureInfo.DateTimeFormat . Vrácený DateTimeFormatInfo objekt je pro čtení a zápis.

• Voláním konstruktoru třídy CultureInfo.CultureInfo a načtením hodnoty vlastnosti CultureInfo vráceného objektu CultureInfo.DateTimeFormat. Vrácený DateTimeFormatInfo objekt je pro čtení a zápis.

Následující příklad ukazuje každý z těchto způsobů vytvoření instance objektu DateTimeFormatInfo a označuje, zda je výsledný objekt jen pro čtení.

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

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

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

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

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

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

Vytvoření instance objektu DateTimeFormatInfo pro neutrální jazykovou verzi

Neutrální kultura představuje kulturu nebo jazyk, který je nezávislý na zemi/oblasti; obvykle je rodičem jedné nebo více konkrétních kultur. Fr je například neutrální jazyková verze pro francouzštinu a nadřazená jazyková verze fr-FR. Vytvořit instanci objektu DateTimeFormatInfo , který představuje konvence formátování neutrální jazykové verze stejným způsobem, jak vytvoříte DateTimeFormatInfo objekt, který představuje konvence formátování konkrétní jazykové verze. Kromě toho můžete načíst objekt neutrální jazykové verze DateTimeFormatInfo načtením neutrální jazykové verze z vlastnosti konkrétní jazykové CultureInfo.Parent verze a načtením objektu DateTimeFormatInfo vráceného jeho CultureInfo.DateTimeFormat vlastností. Pokud nadřazená kulturní verze nepředstavuje invariantní kulturní verzi, je vrácený DateTimeFormatInfo objekt čitelný a zapisovatelný. Následující příklad ukazuje tyto způsoby vytvoření instance objektu DateTimeFormatInfo, který představuje neutrální kulturní prostředí.

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

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

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

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

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

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

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

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

Neutrální kultura však nemá informace o formátování specifické pro kulturu, protože je nezávislá na konkrétní zemi nebo oblasti. Místo naplnění DateTimeFormatInfo objektu obecnými hodnotami vrátí DateTimeFormatInfo .NET objekt, který odráží konvence formátování konkrétní jazykové verze, která je podřízeným objektem neutrální jazykové verze. Například DateTimeFormatInfo objekt pro neutrální jazykovou verzi en-culture odráží konvence formátování jazykové verze en-US a DateTimeFormatInfo objekt pro jazykovou verzi fr-FR odráží konvence formátování jazykové verze fr-FR.

K určení, jakými konvencemi formátování se řídí konkrétní kultura představovaná neutrální kulturou, lze použít kód podobný následujícímu. Příklad používá reflexi k porovnání DateTimeFormatInfo vlastností neutrální kultury s vlastnostmi konkrétní podřízené kultury. Považuje dva kalendáře za ekvivalentní, pokud jsou stejného typu kalendáře a u gregoriánských kalendářů mají vlastnosti GregorianCalendar.CalendarType stejné hodnoty.

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

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

            ListSimilarChildCultures(name);
        }
    }

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

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

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

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

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

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

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

        Console.WriteLine();
    }
}

Vytvoření instance objektu DateTimeFormatInfo pro aktuální jazykovou verzi

Můžete vytvořit instanci objektu DateTimeFormatInfo, který představuje konvence formátování aktuální kultury následujícími způsoby:

• Načtením hodnoty vlastnosti CurrentInfo. Vrácený DateTimeFormatInfo objekt je jen pro čtení.

• Načtením hodnoty DateTimeFormat vlastnosti z objektu CultureInfo , který je vrácen vlastností CultureInfo.CurrentCulture . Vrácený DateTimeFormatInfo objekt je jen pro čtení.

• Voláním metody GetInstance s objektem CultureInfo, který představuje aktuální kulturu. Vrácený DateTimeFormatInfo objekt je jen pro čtení.

Následující příklad používá každou z těchto metod k instanciaci objektu DateTimeFormatInfo, který reprezentuje konvence formátování aktuální kultury. Potom určuje, jestli je objekt jen pro čtení.

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

Můžete vytvořit zapisovatelný DateTimeFormatInfo objekt, který představuje konvence aktuální jazykové verze jedním z těchto způsobů:

• Načtením objektu DateTimeFormatInfo některým ze tří předchozích způsobů a voláním Clone metody na vrácený DateTimeFormatInfo objekt. Tím se vytvoří kopie původního DateTimeFormatInfo objektu s tím rozdílem, že jeho IsReadOnly vlastnost je false.

• Voláním metody CultureInfo.CreateSpecificCulture za účelem vytvoření CultureInfo objektu, který představuje aktuální locale, a poté pomocí jeho CultureInfo.DateTimeFormat vlastnosti získat DateTimeFormatInfo objekt.

Následující příklad znázorňuje každý způsob vytvoření instance objektu pro čtení/zápis DateTimeFormatInfo a zobrazí hodnotu jeho IsReadOnly vlastnosti.

using System;
using System.Globalization;

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

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

Ve Windows může uživatel prostřednictvím aplikace DateTimeFormatInfo v Ovládacích panelech přepsat některé hodnoty vlastností použité při operacích formátování a parsování. Uživatel, jehož jazyková verze je angličtina (USA), může například zvolit zobrazení dlouhých časových hodnot pomocí 24hodinových hodin (ve formátu HH:mm:ss) místo výchozích 12hodinových hodin (ve formátu h:mm:ss tt). Objekty DateTimeFormatInfo načtené způsoby, které byly diskutovány dříve, odrážejí uživatelská přepsání. Pokud je to nežádoucí, můžete vytvořit objekt NumberFormatInfo, který neodráží přepsání uživatele (a umožňuje čtení i zápis, na rozdíl od pouze pro čtení) voláním konstruktoru CultureInfo.CultureInfo(String, Boolean) a zadáním hodnoty false pro argument useUserOverride. Následující příklad ukazuje tento příklad pro systém, jehož aktuální jazyková verze je angličtina (USA) a jehož dlouhý časový vzor byl změněn z výchozí hodnoty h:mm:ss tt na HH:mm:ss.

using System;
using System.Globalization;

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

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

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

DateTimeFormatInfo a dynamická data

Kulturně specifická data pro formátování hodnot data a času poskytovaná třídou DateTimeFormatInfo jsou dynamická, stejně jako kulturně specifická data poskytovaná třídou CultureInfo. Neměli byste provádět žádné předpoklady o stabilitě hodnot pro DateTimeFormatInfo objekty, které jsou přidruženy k určitým CultureInfo objektům. Stabilní jsou pouze data poskytovaná invariantní kulturou a přidruženým DateTimeFormatInfo objektem. Jiná data se mohou měnit mezi relacemi aplikací nebo i v době, kdy je vaše aplikace spuštěná. Existují čtyři hlavní zdroje změn:

• Aktualizace systému. Kulturní předvolby, jako je upřednostňovaný kalendář nebo vlastní formáty data a času, se mění v průběhu času. Když k tomu dojde, služba služba Windows Update zahrnuje změny hodnoty vlastnosti DateTimeFormatInfo pro konkrétní jazykovou verzi.

• Náhradní kultury. Třídu CultureAndRegionInfoBuilder lze použít k nahrazení dat stávající kultury.

• Kaskádové změny hodnot vlastností Během běhu programu se může změnit řada vlastností souvisejících s jazykovou verzí, což následně způsobí DateTimeFormatInfo změnu dat. Aktuální kulturní nastavení můžete například změnit programově nebo uživatelskou akcí. V takovém případě se DateTimeFormatInfo objekt vrácený CurrentInfo vlastností změní na objekt přidružený k aktuální kultuře. Kalendář určité kultury se může změnit, což může vést ke změnám mnoha DateTimeFormatInfo hodnot vlastností.

• Uživatelské předvolby. Uživatelé vaší aplikace se můžou rozhodnout přepsat některé hodnoty spojené s aktuálním nastavením systémové kultury prostřednictvím místní a jazykové možnosti v Ovládacím panelu. Uživatelé se například můžou rozhodnout zobrazit datum v jiném formátu. Pokud je vlastnost nastavena CultureInfo.UseUserOverride na true, vlastnosti objektu DateTimeFormatInfo jsou také načteny z uživatelských nastavení. Pokud uživatelská nastavení nejsou kompatibilní s jazykovou verzí přidruženou k objektu CultureInfo (například pokud vybraný kalendář není jedním z kalendářů označených OptionalCalendars vlastností), výsledky metod a hodnoty vlastností nejsou definovány.

Aby se minimalizovala možnost nekonzistentních dat, inicializují se při vytváření objektu všechny vlastnosti DateTimeFormatInfo přepsatelné uživatelem. Stále existuje možnost nekonzistence, protože vytvoření objektu ani proces přepsání uživatelem není atomický a příslušné hodnoty se mohou během vytváření objektu změnit. Tato situace by však měla být velmi vzácná.

Můžete určit, jestli se přepsání uživatelů projeví v DateTimeFormatInfo objektech, které představují stejnou kulturu jako systémová kultura. Následující tabulka uvádí způsoby, jak lze DateTimeFormatInfo objekt načíst, a označuje, zda výsledný objekt odráží uživatelské přepsání.

Zdroj objektu CultureInfo a DateTimeFormatInfo	Odráží přednostní nastavení uživatelů.
vlastnost CultureInfo.CurrentCulture.DateTimeFormat	Ano
vlastnost DateTimeFormatInfo.CurrentInfo	Ano
metoda CultureInfo.CreateSpecificCulture	Ano
metoda CultureInfo.GetCultureInfo	No
CultureInfo.CultureInfo(String) konstruktor	Ano
CultureInfo.CultureInfo(String, Boolean) konstruktor	Závisí na hodnotě parametru useUserOverride .

Pokud neexistuje přesvědčivý důvod jednat jinak, měli byste respektovat úpravy uživatelů při použití objektu DateTimeFormatInfo v klientských aplikacích pro formátování a zpracování uživatelského vstupu nebo pro zobrazení dat. U serverových aplikací nebo bezobslužných aplikací byste neměli. Pokud však objekt používáte DateTimeFormatInfo explicitně nebo implicitně k zachování dat data a času v řetězcové podobě, měli byste použít DateTimeFormatInfo objekt, který odráží konvence formátování invariantní jazykové verze, nebo byste měli zadat vlastní řetězec formátu data a času, který používáte bez ohledu na jazykovou verzi.

Formátování dat a časů

Objekt DateTimeFormatInfo se používá implicitně nebo explicitně ve všech operacích formátování data a času. Patří mezi ně volání následujících metod:

• Všechny metody formátování data a času, například DateTime.ToString() a DateTimeOffset.ToString(String).
• Hlavní metoda složeného formátování, což je String.Format.
• Jiné složené metody formátování, například Console.WriteLine(String, Object[]) a StringBuilder.AppendFormat(String, Object[]).

Všechny operace formátování data a času využívají implementaci IFormatProvider . Rozhraní IFormatProvider obsahuje jednu metodu, IFormatProvider.GetFormat(Type). Tato metoda zpětného volání je předána objekt Type, který představuje typ potřebný k poskytnutí formátovacích informací. Metoda vrátí buď instanci tohoto typu, nebo null pokud nemůže poskytnout instanci typu. .NET obsahuje dvě IFormatProvider implementace pro formátování kalendářních dat a časů:

• Třída CultureInfo, která představuje konkrétní kulturu (nebo konkrétní jazyk v konkrétní zemi/oblasti). V operaci formátování data a času metoda CultureInfo.GetFormat vrátí objekt DateTimeFormatInfo, který je přidružený ke své vlastnosti CultureInfo.DateTimeFormat.
• Třída DateTimeFormatInfo, která poskytuje informace o konvencích formátování přidružené kultury. Metoda DateTimeFormatInfo.GetFormat vrátí instanci sama sebe.

Pokud implementace IFormatProvider není explicitně poskytnuta pro metodu formátování, je použit objekt vrácený vlastností CultureInfo, která představuje aktuální jazykovou verzi CultureInfo.CurrentCulture.

Následující příklad znázorňuje vztah mezi rozhraním IFormatProvider a DateTimeFormatInfo třídou v operacích formátování. Definuje vlastní IFormatProvider implementaci, jejíž GetFormat metoda zobrazuje typ objektu požadovaného operací formátování. Pokud žádá o DateTimeFormatInfo objekt, metoda poskytuje DateTimeFormatInfo objekt pro aktuální kulturu. Jak ukazuje výstup z příkladu, metoda Decimal.ToString(IFormatProvider) požaduje objekt DateTimeFormatInfo k poskytnutí informací o formátování, zatímco metoda String.Format(IFormatProvider, String, Object[]) požaduje objekty NumberFormatInfo a DateTimeFormatInfo i implementaci ICustomFormatter.

using System;
using System.Globalization;

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

public class FormatProviderEx1
{
    public static void Main()
    {
        DateTime dateValue = new(2013, 5, 28, 13, 30, 0);
        string value = dateValue.ToString("F", new CurrentCultureFormatProvider());
        Console.WriteLine(value);
        Console.WriteLine();
        string composite = string.Format(new CurrentCultureFormatProvider(),
                                         "Date: {0:d}   Amount: {1:C}   Description: {2}",
                                         dateValue, 1264.03m, "Service Charge");
        Console.WriteLine(composite);
        Console.WriteLine();
    }
}

// The example displays output like the following:
//       Requesting an object of type DateTimeFormatInfo
//       Tuesday, May 28, 2013 1:30:00 PM
//
//       Requesting an object of type ICustomFormatter
//       Requesting an object of type DateTimeFormatInfo
//       Requesting an object of type NumberFormatInfo
//       Date: 5/28/2013   Amount: $1,264.03   Description: Service Charge

Řetězce formátu a vlastnosti DateTimeFormatInfo

Objekt DateTimeFormatInfo obsahuje tři druhy vlastností, které se používají při operacích formátování s hodnotami data a času:

• Vlastnosti související s kalendářem Vlastnosti jako AbbreviatedDayNames, AbbreviatedMonthNames, DayNames a MonthNames jsou přidruženy ke kalendáři používanému kulturou, který je definován vlastností Calendar. Tyto vlastnosti se používají pro dlouhé formáty data a času.

• Vlastnosti, které vytvářejí výsledek definovaný standardy. Vlastnosti RFC1123Pattern, SortableDateTimePattern a UniversalSortableDateTimePattern obsahují vlastní formátovací řetězce, které vytvářejí výsledné řetězce podle mezinárodních standardů. Tyto vlastnosti jsou jen pro čtení a nelze je změnit.

• Vlastnosti definující řetězce výsledků citlivé na kulturní kontext. Některé vlastnosti, například FullDateTimePattern a , obsahují ShortDatePattern řetězce, které určují formát výsledného řetězce. Jiné, například AMDesignator, DateSeparator, PMDesignator a TimeSeparator, definují symboly nebo podřetězce citlivé na kulturu, které mohou být zahrnuty do výsledného řetězce.

Standardní řetězce formátu data a času, například "d", "D", "f" a "F", jsou aliasy, které odpovídají konkrétním DateTimeFormatInfo vlastnostem vzoru formátu. Většina vlastních řetězců formátu data a času souvisí s řetězci nebo podřetězci, které operace formátování vloží do výsledného datového proudu. Následující tabulka uvádí standardní a vlastní specifikátory formátu data a času a jejich přidružené DateTimeFormatInfo vlastnosti. Podrobnosti o použití těchto specifikátorů formátu naleznete v tématu Standardní řetězce formátu data a času a vlastní řetězce formátu data a času. Všimněte si, že každý standardní formátovací řetězec odpovídá DateTimeFormatInfo vlastnosti, jejíž hodnota je vlastní řetězec formátu data a času. Jednotlivé specifikátory v tomto řetězci vlastního formátu zase odpovídají dalším DateTimeFormatInfo vlastnostem. V tabulce jsou uvedeny pouze DateTimeFormatInfo vlastnosti, pro které jsou standardní řetězce formátu aliasy, a nejsou uvedeny vlastnosti, ke kterým mohou přistupovat řetězce vlastního formátu přiřazené těmto aliasovaným vlastnostem. Kromě toho tabulka uvádí pouze specifikátory vlastního formátu, které odpovídají vlastnostem DateTimeFormatInfo .

Specifikátor formátu	Přidružené vlastnosti
"d" (krátké datum; řetězec standardního formátu)	ShortDatePattern, definovat celkový formát výsledného řetězce.
"D" (dlouhé datum; řetězec standardního formátu)	LongDatePattern, definovat celkový formát výsledného řetězce.
"f" (úplné datum / krátký čas; řetězec standardního formátu)	LongDatePattern, definovat formát součásti data výsledného řetězce. ShortTimePattern, definovat formát časové komponenty výsledného řetězce.
"F" (úplné datum / dlouhý čas; standardní formátovací řetězec)	LongDatePattern, definovat formát součásti data výsledného řetězce. LongTimePattern, definovat formát časové komponenty výsledného řetězce.
"g" (obecné datum / krátký čas; standardní formátovací řetězec)	ShortDatePattern, definovat formát součásti data výsledného řetězce. ShortTimePattern, definovat formát časové komponenty výsledného řetězce.
"G" (obecné datum / dlouhý čas; standardní formátovací řetězec)	ShortDatePattern, definovat formát součásti data výsledného řetězce. LongTimePattern, definovat formát časové komponenty výsledného řetězce.
"M", "m" (měsíc/den; řetězec standardního formátu)	MonthDayPattern, definovat celkový formát výsledného řetězce.
"O", "o" (datum a čas tam a zpět; standardní řetězec formátu)	Žádné.
"R", "r" (RFC1123; standardní formátovací řetězec)	RFC1123Pattern, definovat výsledný řetězec, který odpovídá standardu RFC 1123. Vlastnost je určena jen pro čtení.
"s" (seřazené datum a čas; standardní formátovací řetězec)	SortableDateTimePattern, k definování výsledného řetězce, který odpovídá normě ISO 8601. Vlastnost je určena jen pro čtení.
"t" (krátký čas; řetězec standardního formátu)	ShortTimePattern, definovat celkový formát výsledného řetězce.
"T" (dlouhý čas; řetězec standardního formátu)	LongTimePattern, definovat celkový formát výsledného řetězce.
"u" (univerzální tříděné datum/čas; standardní formátovací řetězec)	UniversalSortableDateTimePattern, pro definování výsledného řetězce, který odpovídá standardu ISO 8601 pro koordinovaný univerzální čas. Vlastnost je určena jen pro čtení.
"U" (univerzální úplné datum a čas; standardní formátovací řetězec)	FullDateTimePattern, definovat celkový formát výsledného řetězce.
"Y", "y" (měsíc roku; řetězec standardního formátu)	YearMonthPattern, definovat celkový formát výsledného řetězce.
"ddd" (specifikátor vlastního formátu)	AbbreviatedDayNames, aby se do výsledného řetězce zahrnul zkrácený název dne v týdnu.
"g", "gg" (specifikátor vlastního formátu)	Volá metodu GetEraName , která vloží název éry do výsledného řetězce.
"MMM" (specifikátor vlastního formátu)	AbbreviatedMonthNames nebo AbbreviatedMonthGenitiveNames, pokud chcete do výsledného řetězce zahrnout zkrácený název měsíce.
"MMMM" (specifikátor vlastního formátu)	MonthNames nebo MonthGenitiveNames, pokud chcete do výsledného řetězce zahrnout celý název měsíce.
"t" (specifikátor vlastního formátu)	AMDesignator nebo PMDesignator, aby se do výsledného řetězce zahrnul první znak označení AM/PM.
"tt" (specifikátor vlastního formátu)	AMDesignator nebo PMDesignator, aby se do výsledného řetězce zahrnulo kompletní označení AM/PM.
":" (specifikátor vlastního formátu)	TimeSeparator– chcete-li do výsledného řetězce zahrnout oddělovač času.
"/" (specifikátor vlastního formátu)	DateSeparator, aby se do výsledného řetězce zahrnul oddělovač kalendářních dat.

Úprava vlastností DateTimeFormatInfo

Výsledný řetězec vytvořený řetězcem formátu data a času můžete změnit úpravou přidružených vlastností zapisovatelného DateTimeFormatInfo objektu. Chcete-li zjistit, zda DateTimeFormatInfo je objekt zapisovatelný, použijte IsReadOnly vlastnost. Přizpůsobení objektu DateTimeFormatInfo tímto způsobem:

1. Vytvořte kopii objektu DateTimeFormatInfo pro čtení a zápis, jehož konvence formátování chcete upravit.

2. Upravte vlastnost nebo vlastnosti, které slouží k vytvoření požadovaného výsledného řetězce. (Informace o tom, jak metody formátování používají DateTimeFormatInfo vlastnosti k definování výsledných řetězců, naleznete v předchozí části Formátovací řetězce a DateTimeFormatInfo vlastnosti.)

3. Použijte vlastní DateTimeFormatInfo objekt, který jste vytvořili jako IFormatProvider argument ve volání metod formátování.

Formát výsledného řetězce můžete změnit dvěma způsoby:

• Třídu můžete použít CultureAndRegionInfoBuilder k definování vlastní jazykové verze (jazykové verze, která má jedinečný název a který doplňuje existující jazykové verze) nebo náhradní jazykovou verzi (která se používá místo konkrétní jazykové verze). Můžete tuto kulturní informaci ukládat a programaticky k ní přistupovat stejně jako k jakémukoli objektu CultureInfo podporovanému rozhraním .NET.

• Pokud výsledný řetězec není citlivý na jazykovou verzi a nedodržuje předdefinovaný formát, můžete použít vlastní řetězec formátu data a času. Pokud například serializujete data a času ve formátu YYYYMMDDHHmmss, můžete vygenerovat výsledný řetězec předáním vlastního formátu řetězce metodě DateTime.ToString(String), a můžete převést výsledný řetězec zpět na hodnotu DateTime pomocí metody DateTime.ParseExact.

Změnit vzor krátkého data

Následující příklad změní formát výsledného řetězce vytvořeného řetězcem standardního formátu "d" (krátké datum). Změní přidruženou vlastnost ShortDatePattern pro jazykovou verzi en-US nebo English (USA) z výchozí hodnoty "M/d/yyyy" na "yyyy-MM-dd" a použije řetězec standardního formátu "d" k zobrazení data jak před změnou, tak i po změně vlastnosti ShortDatePattern.

using System;
using System.Globalization;

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

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

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

Změna znaku oddělovače kalendářních dat

Následující příklad změní znak oddělovače data v objektu DateTimeFormatInfo, který představuje konvence formátování kultury fr-FR. Příklad používá standardní formátovací řetězec "g" k zobrazení data před i po DateSeparator změně vlastnosti.

using System;
using System.Globalization;

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

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

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

Změna zkratek názvů dnů a dlouhého vzoru kalendářního data

V některých případech může být formát dlouhého data, který obvykle zobrazuje celý den a název měsíce spolu s číslem dne v měsíci a rokem, příliš dlouhý. Následující příklad zkracuje dlouhý vzor formátu data pro jazykovou verzi en-US tak, aby vrátil jednodušší zkratku názvu dne s jedním nebo dvěma znaky následovanou číslem dne, zkratkou názvu měsíce a rokem. Toto provádí přiřazením kratších zkratek jmen dnů k AbbreviatedDayNames poli a úpravou řetězce vlastního formátu přiřazeného vlastnosti LongDatePattern. Toto má vliv na výsledné řetězce vrácené pomocí standardních formátovacích řetězců "D" a "f".

using System;
using System.Globalization;

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

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

        Console.WriteLine();

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

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

Obvykle změna vlastnosti LongDatePattern také ovlivňuje vlastnost FullDateTimePattern, která pak definuje výsledný řetězec vrácený standardním formátovacím řetězcem "F". Chcete-li zachovat původní vzor úplného data a času, příklad znovu přiřadí původní řetězec vlastního formátu přiřazený vlastnosti FullDateTimePattern poté, co je změněna vlastnost LongDatePattern.

Změna z 12hodinového systému na 24hodinový systém

V případě mnoha kulturních prostředí v .NET se čas vyjadřuje pomocí 12hodinového formátu a označení AM/PM. Následující příklad definuje metodu ReplaceWith24HourClock , která nahrazuje libovolný formát času, který používá 12hodinový formát s formátem, který používá 24hodinový formát.

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

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

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

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

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

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

V příkladu se k úpravě řetězce formátu používá regulární výraz. Vzor regulárního výrazu @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) je definován takto:

Pattern	Description
^	Začněte se shodou na začátku řetězce.
(?<openAMPM>\s*t+\s*)?	Porovná žádný nebo jeden výskyt nuly nebo více prázdných znaků následovaných písmenem "t" jednou nebo vícekrát, za kterými následuje nula nebo více prázdných znaků. Tato zachytácí skupina má název openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$	openAMPM Pokud má skupina shodu, shodujte písmeno "h" jednou nebo vícekrát a za ním jeden nebo více znaků, které nejsou "h" ani "t". Shoda končí na konci řetězce. Všechny znaky zachycené za "h" jsou zahrnuty do zachytávání skupiny s názvem nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+)	openAMPM Pokud skupina nemá shodu, shodujte písmeno "h" jednou nebo vícekrát a za ním jeden nebo více znaků, které nejsou "h" ani "t", následované nulou nebo více prázdnými znaky. Nakonec porovná jeden nebo více výskytů písmena "t". Všechny znaky zachycené za "h" a před prázdnými znaky a "t" jsou zahrnuty do zachycené skupiny s názvem nonHours.

Zachytávací skupina nonHours obsahuje minutu a případně i vteřinu z vlastního formátovacího řetězce data a času, spolu se symboly, které oddělují čas. Vzorek nahrazení HH${nonHours} přidá podřetězec "HH" na začátek těchto prvků.

Zobrazení a změna éry v datu

Následující příklad přidává specifikátor formátu "g" do vlastnosti LongDatePattern objektu, který představuje konvence formátování pro kulturu en-US. Tento doplněk má vliv na následující tři standardní řetězce formátu:

• Standardní formátovací řetězec „D“ (dlouhé datum), který přímo odpovídá vlastnosti LongDatePattern.
• Řetězec standardního formátu "f" (úplné datum/ krátký čas), který vytvoří výsledný řetězec, který zřetězí podřetězce vytvořené vlastnostmi LongDatePattern a ShortTimePattern vlastnostmi.
• Standardní formátovací řetězec "F" (plné datum / dlouhý čas), který se mapuje přímo na vlastnost FullDateTimePattern. Protože jsme tuto hodnotu vlastnosti explicitně nenastavili, generuje se dynamicky zřetězením LongDatePattern vlastností a LongTimePattern vlastností.

Příklad také ukazuje, jak změnit název éry pro kulturu, jejíž kalendář má jednu éru. V tomto případě používá jazyková verze en-US gregoriánský kalendář, který je reprezentován objektem GregorianCalendar . Třída GregorianCalendar podporuje jedinou éru, která se jmenuje A.D. (Anno Domini). Příklad změní název éry na C.E. (Common Era) nahrazením specifikátoru vlastního formátu "g" v řetězci formátu přiřazeného vlastnosti FullDateTimePattern literálovým řetězcem. Použití literálového řetězce je nezbytné, protože název éry je obvykle vrácen metodou GetEraName z privátních dat v tabulkách jazykové verze poskytované .NET nebo operačním systémem.

using System;
using System.Globalization;

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

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

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

        Console.WriteLine();

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

        Console.WriteLine();

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

Parsování řetězců s hodnotami data a času

Analýza zahrnuje převod řetězcové reprezentace data a času na DateTime hodnotu nebo DateTimeOffset hodnotu. Oba tyto typy zahrnují Parse, TryParse, ParseExacta TryParseExact metody pro podporu parsování operací. Tyto Parse metody TryParse převádějí řetězec, který může mít různé formáty, zatímco ParseExact a TryParseExact vyžadují, aby řetězec měl definovaný formát nebo formáty. Pokud operace analýzy selže, Parse a ParseExact vyvolají výjimku, zatímco TryParse a TryParseExact vrátí false.

Metody analýzy implicitně nebo explicitně používají DateTimeStyles hodnotu výčtu k určení, které prvky stylu (například úvodní, koncové nebo vnitřní prázdné znaky) mohou být přítomny v řetězci, které se mají analyzovat, a jak interpretovat parsovaný řetězec nebo jakékoli chybějící prvky. Pokud nepředáte hodnotu DateTimeStyles při volání metod Parse nebo TryParse, použije se výchozí hodnota DateTimeStyles.AllowWhiteSpaces, což je složený styl zahrnující příznaky DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite a DateTimeStyles.AllowInnerWhite. Pro metody ParseExact a TryParseExact je výchozí hodnota DateTimeStyles.None, vstupní řetězec musí přesně odpovídat určitému vlastnímu řetězci formátu data a času.

Metody analýzy také implicitně nebo explicitně používají DateTimeFormatInfo objekt, který definuje konkrétní symboly a vzory, které mohou nastat v řetězci, které se mají analyzovat. Pokud nezadáte objekt DateTimeFormatInfo, ve výchozím nastavení se použije objekt DateTimeFormatInfo pro aktuální jazykovou verzi. Další informace o analýze řetězců data a času naleznete v jednotlivých metodách analýzy, například DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExacta DateTimeOffset.TryParseExact.

Následující příklad znázorňuje povahu analýzy řetězců data a času citlivé na jazykovou verzi. Snaží se parsovat dva řetězce kalendářních dat pomocí konvencí en-US, en-GB, fr-FR a fi-FI jazykových verzí. Datum, které je interpretováno jako 8/18/2014 v jazykové verzi en-US vyvolá FormatException výjimku v ostatních třech jazykových verzích, protože 18 je interpretováno jako číslo měsíce. 1/2/2015 se parsuje jako druhý den prvního měsíce v jazykové verzi en-US, ale jako první den druhého měsíce ve zbývajících kulturách.

using System;
using System.Globalization;

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

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

Řetězce data a času se obvykle analyzují ze dvou důvodů:

• Převod vstupu uživatele na hodnotu data a času
• Pro obnovení hodnoty data a času zpět; to znamená deserializaci hodnoty data a času, která byla dříve serializována jako řetězec.

Tyto dvě operace jsou podrobněji popsány v následujících částech.

Analýza uživatelských řetězců

Když analyzujete řetězce data a času zadané uživatelem, měli byste vždy vytvořit instanci DateTimeFormatInfo objektu, který odráží kulturní nastavení uživatele, včetně všech přizpůsobení, které uživatel mohl provést. V opačném případě může mít objekt data a času nesprávné hodnoty. Informace o tom, jak vytvořit instanci objektu DateTimeFormatInfo, který odráží kulturní přizpůsobení uživatele, naleznete v oddílu DateTimeFormatInfo a dynamická data.

Následující příklad znázorňuje rozdíl mezi operací analýzy, která odráží kulturní nastavení uživatele, a operací, která nikoli. V tomto případě je výchozí systémová jazyková verze en-US, ale uživatel použil Ovládací panely, oblast a jazyk ke změně krátkého vzorce kalendářního data z výchozí hodnoty M/d/y na yyy/MM/dd. Když uživatel zadá řetězec, který odráží uživatelská nastavení, a tento řetězec se analyzuje objektem DateTimeFormatInfo, který také odráží (případně přepisuje) uživatelská nastavení, vrátí operace analýzy správný výsledek. Pokud je však řetězec analyzován objektem DateTimeFormatInfo, který odráží standardní kulturní nastavení pro en-US, analytická metoda vyvolá FormatException výjimku, protože číslo 14 bere jako číslo měsíce, nikoli jako poslední dvě číslice roku.

using System;
using System.Globalization;

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

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

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

Serializace a deserializace údajů data a času

Očekává se, že serializovaná data a času budou zachována; to znamená, že všechny serializované a deserializované hodnoty by měly být identické. Pokud hodnota data a času představuje jeden okamžik v čase, deserializovaná hodnota by měla představovat stejný okamžik v čase bez ohledu na jazykovou verzi nebo časové pásmo systému, na kterém byla obnovena. Pro úspěšnou konverzi datumu a času tam a zpět je nutné použít konvence invariantní jazykové verze, kterou zajišťuje vlastnost InvariantInfo, při generování a parsování těchto dat. Operace formátování a analýzy by nikdy neměly odrážet konvence výchozí jazykové verze. Pokud používáte výchozí kulturní nastavení, přenositelnost dat je přísně omezená; lze úspěšně deserializovat pouze na vlákně, jehož kulturní-specifické nastavení jsou identické s vláknem, na kterém byl serializován. V některých případech to znamená, že data nemohou být dokonce úspěšně serializována a deserializována ve stejném systému.

Pokud je časová komponenta hodnoty data a času významná, měla by být také převedena na UTC a serializována pomocí standardního formátovací řetězce "o" nebo "r". Časová data je pak možné obnovit voláním metody pro analýzu a předáním příslušného řetězce formátu spolu s invariantní jazykovou verzí jako argumentem provider.

Následující příklad znázorňuje proces obousměrného převodu hodnoty data a času. Serializuje datum a čas v systému, který používá americký tichomořský čas a jehož aktuální kulturní nastavení je en-US.

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

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

Deserializuje data o systému v bruselské, kodaňské, madridské a pařížské časové zóně a jejíž současná kultura je fr-FR. Datum obnovení je o devět hodin později než původní datum, které odráží úpravy časového pásma od osmi hodin za UTC do jedné hodiny před UTC. Původní i obnovené datum představují stejný okamžik v čase.

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

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

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

Viz také

• DateTime
• Calendar
• CultureInfo