Třída DateTimeFormatInfo

  • Článek

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

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.
  • Designátory 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í neutrální jazykové verze, konkrétní jazykovou verzi, neutrální jazykovou verzi nebo aktuální jazykovou verzi. Tato část popisuje, jak vytvořit instanci každého typu objektu DateTimeFormatInfo .

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

Invariantní jazyková verze představuje jazykovou verzi, která není závislá na jazykové verzi. 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í. Vytvořit instanci objektu DateTimeFormatInfo , který představuje konvence formátování invariantní jazykové verze následujícími způsoby:

Následující příklad používá každou z těchto metod k vytvoření instance DateTimeFormatInfo objektu, 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í jazyková verze představuje jazyk, který se mluví v konkrétní zemi nebo oblasti. 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 DateTimeFormatInfo , který představuje konvence formátování konkrétní jazykové verze následujícími způsoby:

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("{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

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 nadřazenou jednou nebo více konkrétní jazykovou verzí. 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á jazyková verze nepředstavuje neutrální jazykovou verzi, vrácený DateTimeFormatInfo objekt je přečten/zapisovat. Následující příklad ukazuje tyto způsoby vytvoření instance objektu DateTimeFormatInfo , který představuje neutrální jazykovou verzi.

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

Neutrální jazyková verze však nemá informace o formátování specifické pro jazykovou verzi, 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ód podobný následujícímu kódu můžete použít k určení konvencí formátování konkrétní jazykové verze, které představuje neutrální jazyková verze. Příklad používá reflexi k porovnání DateTimeFormatInfo vlastností neutrální jazykové verze s vlastnostmi konkrétní podřízené jazykové verze. 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 {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();
    }
}

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í jazykové verze následujícími způsoby:

Následující příklad používá každou z těchto metod k vytvoření instance DateTimeFormatInfo objektu, který představuje konvence formátování aktuální jazykové verze. 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ů:

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 přepsat některé hodnoty DateTimeFormatInfo vlastností použité při operacích formátování a analýzy prostřednictvím aplikace Oblast a jazyk v Ovládací panely. 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é jsme probírali dříve, odrážejí přepsání těchto uživatelů. Pokud je to nežádoucí, můžete vytvořit NumberFormatInfo objekt, který neodráží přepsání uživatele (a je také pro čtení a zápis namísto jen pro čtení) voláním konstruktoru CultureInfo.CultureInfo(String, Boolean) a zadáním hodnoty argumentu falseuseUserOverride . 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:      {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

DateTimeFormatInfo a dynamická data

Data specifická pro jazykovou verzi pro formátování hodnot data a času poskytovaných DateTimeFormatInfo třídou jsou dynamická, stejně jako kulturní data poskytovaná CultureInfo třídou. 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í jazykovou verzí a přidruženým DateTimeFormatInfo objektem. Jiná data se můžou mezi relacemi aplikací měnit nebo dokonce 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. Pokud k tomu dojde, služba Windows Update zahrnuje změny DateTimeFormatInfo hodnoty vlastnosti pro určitou jazykovou verzi.

  • Náhradní jazykové verze. Třídu CultureAndRegionInfoBuilder lze použít k nahrazení dat existující jazykové verze.

  • Kaskádové změny hodnot vlastností V době běhu se může změnit řada vlastností souvisejících s jazykovou verzí, což zase způsobí DateTimeFormatInfo změnu dat. Aktuální jazykovou verzi můžete například změnit prostřednictvím kódu programu nebo prostřednictvím akce uživatele. V takovém případě se DateTimeFormatInfo objekt vrácený CurrentInfo vlastností změní na objekt přidružený k aktuální jazykové verzi. Kalendář jazykové verze 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í jazykovou verzí systému prostřednictvím místních a jazykových možností v Ovládací panely. 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 jazykovou verzi jako systémová jazyková verze. Následující tabulka uvádí způsoby, kterými DateTimeFormatInfo lze objekt načíst, a označuje, zda výsledný objekt odráží přepsání uživatele.

Zdroj objektu CultureInfo a DateTimeFormatInfo Reflexe s user overrides
CultureInfo.CurrentCulture.DateTimeFormat Vlastnost Ano
DateTimeFormatInfo.CurrentInfo Vlastnost Ano
CultureInfo.CreateSpecificCulture Metoda Ano
CultureInfo.GetCultureInfo Metoda 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 k tomu, abyste jinak, měli byste respektovat přepsání uživatelů při použití objektu DateTimeFormatInfo v klientských aplikacích k formátování a analýze uživatelského vstupu nebo k 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 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án Type objekt, který představuje typ potřebný k poskytnutí informací o formátování. 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ů:

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

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 požaduje DateTimeFormatInfo objekt, metoda poskytuje DateTimeFormatInfo objekt pro aktuální jazykovou verzi. Jak ukazuje výstup z příkladu, Decimal.ToString(IFormatProvider) metoda požaduje DateTimeFormatInfo objekt k poskytnutí informací o formátování, zatímco String.Format(IFormatProvider, String, Object[]) požadavky NumberFormatInfo metody a DateTimeFormatInfo objekty i ICustomFormatter implementace.

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 FormatProviderEx1
{
    public static void Main()
    {
        DateTime dateValue = new DateTime(2013, 5, 28, 13, 30, 0);
        string value = dateValue.ToString("F", new CurrentCultureFormatProvider());
        Console.WriteLine(value);
        Console.WriteLine();
        string composite = String.Format(new CurrentCultureFormatProvider(),
                                         "Date: {0:d}   Amount: {1:C}   Description: {2}",
                                         dateValue, 1264.03m, "Service Charge");
        Console.WriteLine(composite);
        Console.WriteLine();
    }
}
// The example displays output like the following:
//       Requesting an object of type DateTimeFormatInfo
//       Tuesday, May 28, 2013 1:30:00 PM
//
//       Requesting an object of type ICustomFormatter
//       Requesting an object of type DateTimeFormatInfo
//       Requesting an object of type NumberFormatInfo
//       Date: 5/28/2013   Amount: $1,264.03   Description: Service Charge

Formátování řetězců a vlastností DateTimeFormatInfo

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

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 neobsahuje vlastnosti seznamu, ke kterým mohou přistupovat řetězce vlastního formátu přiřazené těmto vlastnostem aliasu. 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 odezvy; řetězec standardního formátu) Nezaokrouhlovat.
"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" (universal sortable date/time; standard format string) 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, aby se do výsledného řetězce zahrnul 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 návrhu AM/PM.
"tt" (specifikátor vlastního formátu) AMDesignator nebo PMDesignator, aby se do výsledného řetězce zahrnul celý návrh 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). Tuto jazykovou verzi můžete ukládat a přistupovat k této jazykové verzi programově stejně jako jakýkoli CultureInfo objekt podporovaný 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 data a času ve formátu YYYYMMDDHHmmss, můžete vygenerovat výsledný řetězec předáním řetězce vlastního DateTime.ToString(String) formátu metodě a můžete převést výsledný řetězec zpět na DateTime hodnotu voláním DateTime.ParseExact metody.

Změna vzoru 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 ShortDatePattern vlastnost jazykové verze en-US nebo english (USA) z výchozí hodnoty "M/d/yy" na "y'-"MM"-"dd" a použije řetězec standardního formátu "d" k zobrazení data před i po ShortDatePattern změně vlastnosti.

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("{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

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

Následující příklad změní znak oddělovače kalendářních dat v objektu DateTimeFormatInfo , který představuje konvence formátování jazykové verze 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: {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: 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ýchpřípadechchm dat může být v některých případech dlouhý vzor dlouhého data, který obvykle zobrazuje celý den a název měsíce. Následující příklad zkracuje dlouhý vzor kalendářního data pro jazykovou verzi en-US tak, aby vrátil zkratku názvu jednoho nebo dvouznakového dne následovanou číslem dne, zkratkou názvu měsíce a rokem. To provede přiřazením kratších zkratek názvů dnů k AbbreviatedDayNames poli a úpravou řetězce vlastního formátu přiřazeného LongDatePattern k vlastnosti. To má vliv na výsledné řetězce vrácené řetězci standardního formátu "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("{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 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

Změna vlastnosti má obvykle LongDatePattern vliv FullDateTimePattern také na vlastnost, která zase 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 FullDateTimePattern formátu přiřazený vlastnosti po LongDatePattern změně vlastnosti.

Změna z 12hodinových hodin na 24hodinový formát

V případě mnoha jazykových verzí v .NET se čas vyjadřuje pomocí 12hodinového formátu a návrhu 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("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

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

Vzor Popis
^ Zahajte shodu 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.

Skupina nonHours zachycení obsahuje minutu a případně druhou komponentu vlastního řetězce formátu data a času spolu se symboly oddělovače času. Vzor nahrazení HH${nonHours} předloží podřetězce "HH" na tyto prvky.

Zobrazení a změna éry v datu

Následující příklad přidá specifikátor vlastního formátu "g" do LongDatePattern vlastnosti objektu, který představuje konvence formátování jazykové verze 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ý se mapuje přímo na LongDatePattern vlastnost.

  • Ř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 FullDateTimePattern vlastnost. 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 jazykovou verzi, 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 vyvolá výjimku, zatímco TryParse a TryParseExact vrátit 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 při volání Parse nebo metody nezadáte DateTimeStyles hodnotu, je výchozí hodnota , což je DateTimeStyles.AllowWhiteSpacessložený styl, který obsahuje DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhitea DateTimeStyles.AllowInnerWhiteTryParse příznaky. ParseExact U metod a TryParseExact metod je DateTimeStyles.Nonevýchozí hodnota ; 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 objekt nezadáte DateTimeFormatInfo , DateTimeFormatInfo použije se objekt pro aktuální jazykovou verzi ve výchozím nastavení. 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 {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

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

  • Převod vstupu uživatele na hodnotu data a času
  • Pro odezvu hodnoty data a času; to znamená, že chcete deserializovat hodnotu 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 části DateTimeFormatInfo a dynamická data oddíl.

Následující příklad znázorňuje rozdíl mezi operací analýzy, která odráží kulturní nastavení uživatele a která neodpovídá. 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áží nastavení uživatele a řetězec se analyzuje objektem DateTimeFormatInfo , který také odráží uživatelská nastavení (přepsání), vrátí operace analýzy správný výsledek. Pokud je však řetězec analyzován objektem DateTimeFormatInfo , který odráží standardní kulturní nastavení en-US, analýza metoda vyvolá FormatException výjimku, protože interpretuje 14 jako číslo měsíce, nikoli 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("{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

Serializace a deserializace dat data a času

Očekává se, že serializovaná data data a času budou zaokrouhlena; 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. Chcete-li data a času odezvy úspěšně dokončit, je nutné použít konvence invariantní jazykové verze, která je vrácena InvariantInfo vlastností, k vygenerování a parsování 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 analýzy a předáním příslušného řetězce formátu spolu s invariantní jazykovou verzí jako argument.provider

Následující příklad znázorňuje proces odezvy hodnoty data a času. Serializuje datum a čas v systému, který sleduje americký tichomořský čas a jehož aktuální jazyková verze 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: {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)

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: {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