DateTimeFormatInfo Osztály

Definíció

Névtér:: System.Globalization

Szerelvények:: mscorlib.dll, System.Globalization.dll

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Globalization.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Forrás:: DateTimeFormatInfo.cs

Forrás:: DateTimeFormatInfo.cs

Forrás:: DateTimeFormatInfo.cs

Forrás:: DateTimeFormatInfo.cs

Forrás:: DateTimeFormatInfo.cs

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Kultúraspecifikus információkat nyújt a dátum- és időértékek formátumáról.

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

Öröklődés: Object
DateTimeFormatInfo

Attribútumok: SerializableAttribute ComVisibleAttribute

Megvalósítás: IFormatProvider ICloneable ISerializable

Példák

Az alábbi példa tükröződés használatával lekéri az angol (Egyesült Államok) kultúra DateTimeFormatInfo objektumának tulajdonságait. Megjeleníti az egyéni formázási sztringeket tartalmazó tulajdonságok értékét, és ezeket a sztringeket használja a formázott dátumok megjelenítéséhez.

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

Megjegyzések

Az osztály tulajdonságai kultúraspecifikus DateTimeFormatInfo információkat tartalmaznak a dátum- és időértékek formázásához vagy elemzéséhez, például a következőkhöz:

A dátumértékek formázásához használt minták.
Az időértékek formázásához használt minták.
A hét napjainak neve.
Az év hónapjainak nevei.
Az időértékekben használt A.M. és P.M. jelölők.
A naptár, amelyben a dátumok kifejezésre kerülnek.

DateTimeFormatInfo objektum példányosítása

Az DateTimeFormatInfo objektumok az invariáns kultúra, egy adott kultúra, egy semleges vagy az aktuális kultúra formázási konvencióit jelölhetik. Ez a szakasz ismerteti, hogyan lehet példányosítani minden típusú DateTimeFormatInfo objektumot.

Az invariant kultúrához hozzon létre egy DateTimeFormatInfo objektumot

Az invariáns kultúra olyan kultúrát képvisel, amelyre nem hatnak a kulturális különbségek. Ez az angol nyelven alapul, de nem egy adott angol nyelvű országon/régión. Bár az egyes kultúrák adatai dinamikusak lehetnek, és az új kulturális konvencióknak vagy felhasználói beállításoknak megfelelően változhatnak, az invariáns kultúra adatai nem változnak. Az invariáns kultúra formázási konvencióit képviselő objektumok példányosítása DateTimeFormatInfo a következő módokon lehetséges:

A InvariantInfo tulajdonság értékének beolvasásával. A visszaadott DateTimeFormatInfo objektum írásvédett.
A paraméter nélküli DateTimeFormatInfo konstruktor meghívásával. A visszaadott DateTimeFormatInfo objektum olvasási és írási hozzáférésű.
A DateTimeFormat tulajdonság értékének lekérése a CultureInfo tulajdonság által visszaadott CultureInfo.InvariantCulture objektumból. A visszaadott DateTimeFormatInfo objektum írásvédett.

Az alábbi példa ezen metódusok mindegyikével létrehoz egy DateTimeFormatInfo objektumot, amely az invariáns kultúrát képviseli. Ezután jelzi, hogy az objektum írásvédett-e.

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

DateTimeFormatInfo objektum példányosítása egy adott kultúrához

Az adott kultúra egy adott országban/régióban beszélt nyelvet jelöl. Az en-US például egy adott kultúra, amely a Egyesült Államok beszélt angol nyelvet jelöli, az en-CA pedig egy olyan sajátos kultúra, amely a Kanadában beszélt angol nyelvet képviseli. Egy adott kultúra formázási DateTimeFormatInfo konvencióit képviselő objektumot az alábbi módokon hozhat létre:

A CultureInfo.GetCultureInfo(String) metódus meghívásával és a visszaadott CultureInfo objektum CultureInfo.DateTimeFormat tulajdonságának értékének beolvasásával. A visszaadott DateTimeFormatInfo objektum írásvédett.
A statikus GetInstance metódus használatával adjon meg egy CultureInfo objektumot, amely azt a kultúrát jelöli, amelynek DateTimeFormatInfo objektumát le szeretné kérni. A visszaadott DateTimeFormatInfo objektum olvasási és írási hozzáférésű.
A statikus CultureInfo.CreateSpecificCulture metódus meghívásával, majd a visszaadott CultureInfo objektum CultureInfo.DateTimeFormat tulajdonságának értékének lekérdezésével. A visszaadott DateTimeFormatInfo objektum olvasási és írási hozzáférésű.
A CultureInfo.CultureInfo osztálykonstruktor meghívásával és a visszaadott CultureInfo objektum CultureInfo.DateTimeFormat tulajdonságának értékének beolvasásával. A visszaadott DateTimeFormatInfo objektum olvasási és írási hozzáférésű.

Az alábbi példa bemutatja a DateTimeFormatInfo objektum példányosításának minden egyes módját, és jelzi, hogy az eredményül kapott objektum írásvédett-e.

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

A DateTimeFormatInfo objektum példányosítása egy semleges kultúrához

A semleges kultúra egy országtól/régiótól független kultúrát vagy nyelvet jelöl; általában egy vagy több meghatározott kultúra szülője. Például az Fr semleges kultúra a francia nyelv számára, és az fr-FR kultúra szülője. A semleges kultúra formázási konvencióit képviselő DateTimeFormatInfo objektumot ugyanazon módszerekkel példányosíthatja, mint egy DateTimeFormatInfo adott kultúra formázási konvencióit képviselő objektumot. Emellett lekérheti a semleges kultúra objektumát DateTimeFormatInfo úgy is, hogy lekér egy semleges kultúrát egy adott kultúra CultureInfo.Parent tulajdonságából, és lekéri a DateTimeFormatInfo tulajdonsága által CultureInfo.DateTimeFormat visszaadott objektumot. Ha az alapértelmezett kultúra nem képviseli az invariáns kultúrát, a visszaadott DateTimeFormatInfo objektum írható/olvasható lesz. Az alábbi példa bemutatja azokat a módokat, amelyekkel egy DateTimeFormatInfo objektum, amely semleges kultúrát jelképez, példányosítható.

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

A semleges kultúra azonban nem rendelkezik kultúraspecifikus formázási információkkal, mivel független egy adott országtól/régiótól. Az objektum általános értékekkel való feltöltése helyett a DateTimeFormatInfo .NET egy DateTimeFormatInfo olyan objektumot ad vissza, amely a semleges kultúra gyermekének számító adott kultúra formázási konvencióit tükrözi. A semleges en kultúra objektuma például DateTimeFormatInfo az en-US kultúra formázási konvencióit tükrözi, az DateTimeFormatInfo fr kultúra objektuma pedig az fr-FR kultúra formázási konvencióit tükrözi.

Az alábbihoz hasonló kóddal meghatározhatja, hogy a semleges kultúra milyen konkrét kultúra formázási konvencióit képviseli. A példa tükröződéssel hasonlítja össze a DateTimeFormatInfo semleges kultúra tulajdonságait egy adott gyermekkultúra tulajdonságaival. A két naptárt egyenértékűnek tekinti, ha azonos naptártípushoz tartoznak, és a Gergely-naptárak esetében, ha a GregorianCalendar.CalendarType tulajdonságaik azonos értéket mutatnak.

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();
    }
}

DateTimeFormatInfo objektum példányosítása a jelenlegi kultúra szerint

A jelenlegi kultúra formázási konvencióit képviselő objektumok példányosítása DateTimeFormatInfo a következő módokon lehetséges:

A CurrentInfo tulajdonság értékének beolvasásával. A visszaadott DateTimeFormatInfo objektum írásvédett.
A DateTimeFormat tulajdonság értékének lekérése a CultureInfo tulajdonság által visszaadott CultureInfo.CurrentCulture objektumból. A visszaadott DateTimeFormatInfo objektum írásvédett.
Az GetInstance metódus hívása egy CultureInfo objektummal, amely az aktuális kultúrát jelképezi. A visszaadott DateTimeFormatInfo objektum írásvédett.

Az alábbi példa ezen metódusok mindegyikével létrehoz egy DateTimeFormatInfo objektumot, amely az aktuális kultúra formázási konvencióit képviseli. Ezután jelzi, hogy az objektum írásvédett-e.

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

Létrehozhat egy írható DateTimeFormatInfo objektumot, amely az aktuális kultúra konvencióit képviseli az alábbi módokon:

Ha bármelyik korábban említett három módon beolvassa a DateTimeFormatInfo objektumot, és meghívja a Clone metódust a visszaadott DateTimeFormatInfo objektumon. Ezzel másolatot készít az eredeti DateTimeFormatInfo objektumról, azzal a kivételével, hogy a IsReadOnly tulajdonsága false.
A metódus meghívásával CultureInfo.CreateSpecificCulture hozzon létre egy CultureInfo objektumot, amely az aktuális kultúrát képviseli, majd a tulajdonságával CultureInfo.DateTimeFormat kérje le az DateTimeFormatInfo objektumot.

Az alábbi példa bemutatja az olvasási/írási DateTimeFormatInfo objektumok példányosításának minden módját, és megjeleníti annak tulajdonságának IsReadOnly értékét.

using System;
using System.Globalization;

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

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

Windows rendszerben a felhasználó felülbírálhatja a DateTimeFormatInfo formázási és elemzési műveletekben használt néhány tulajdonságértéket a Vezérlőpult Régió és nyelv alkalmazásán keresztül. Például egy olyan felhasználó, akinek a kultúrája angol (Egyesült Államok), dönthet úgy, hogy az alapértelmezett 12 órás óra helyett (h:mm:ss tt formátumban) 24 órás (HH:mm:ss formátumban) hosszú idejű értékeket jelenít meg. A DateTimeFormatInfo korábban tárgyalt módokon lekért objektumok mindegyike ezeket a felhasználói felülbírálásokat tükrözi. Ha ez nem kívánatos, létrehozhat egy NumberFormatInfo objektumot, amely nem tükrözi a felhasználói felülbírálásokat (és írás/olvasás helyett olvasható/írható) a CultureInfo.CultureInfo(String, Boolean) konstruktor meghívásával és az false argumentum értéke számára useUserOverride megadásával. Az alábbi példa egy olyan rendszer esetében szemlélteti ezt, amelynek jelenlegi kultúrája angol (Egyesült Államok), és amelynek hosszú ideje a h:mm:ss tt alapértelmezett értékéről HH:mm:ss értékre módosult.

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 és dinamikus adatok

Az osztály által DateTimeFormatInfo biztosított dátum- és időértékek formázására szolgáló kultúraspecifikus adatok dinamikusak, hasonlóan az CultureInfo osztály által biztosított kulturális adatokhoz. Az egyes DateTimeFormatInfo objektumokhoz társított objektumok értékeinek CultureInfo stabilitásáról nem szabad feltételezéseket tenni. Csak az invariáns kultúra és a hozzá tartozó DateTimeFormatInfo objektum által biztosított adatok stabilak. Más adatok is változhatnak az alkalmazás munkamenetei között, vagy akár az alkalmazás futása közben is. A változásnak négy fő forrása van:

Rendszerfrissítések. A kulturális beállítások, például az előnyben részesített naptár vagy a szokásos dátum- és időformátumok idővel változnak. Ha ez történik, a Windows Update egy adott kultúra tulajdonságértékének DateTimeFormatInfo módosítását tartalmazza.
Cserekultúrák. Az CultureAndRegionInfoBuilder osztály egy meglévő kultúra adatainak cseréjére használható.
A tulajdonságértékek kaszkádolt változásai. A kultúrával kapcsolatos tulajdonságok száma futásidőben változhat, ami viszont az adatok változását okozza DateTimeFormatInfo . Az aktuális kultúra például programozott módon vagy felhasználói műveleten keresztül módosítható. Ha ez történik, a DateTimeFormatInfo tulajdonság által CurrentInfo visszaadott objektum az aktuális kultúrához társított objektumra változik. Hasonlóképpen, a kultúra naptára is megváltozhat, ami számos DateTimeFormatInfo tulajdonságérték módosítását eredményezheti.
Felhasználói beállítások. Az alkalmazás felhasználói dönthetnek úgy, hogy felülbírálják az aktuális rendszerkultúra egyes értékeit a Vezérlőpult területi és nyelvi beállításaival. A felhasználók például dönthetnek úgy, hogy a dátumot más formátumban jelenítik meg. Ha a CultureInfo.UseUserOverride tulajdonság értéke be van állítva true, a rendszer az DateTimeFormatInfo objektum tulajdonságait is lekéri a felhasználói beállításokból. Ha a felhasználói beállítások nem kompatibilisek az objektumhoz társított kultúrával CultureInfo (például ha a kijelölt naptár nem a tulajdonság által OptionalCalendars jelzett naptárak egyike), a metódusok eredményei és a tulajdonságok értékei nem lesznek meghatározva.

Az inkonzisztens adatok lehetőségének minimalizálása érdekében az DateTimeFormatInfo objektum minden felhasználó által felülírható tulajdonsága inicializálva lesz az objektum létrehozásakor. Továbbra is fennáll az inkonzisztencia lehetősége, mert sem az objektumlétrehozás, sem a felhasználói felülbírálási folyamat nem atomi, és a vonatkozó értékek az objektum létrehozása során változhatnak. Ennek a helyzetnek azonban rendkívül ritkanak kell lennie.

Szabályozhatja, hogy a felhasználói felülbírálások megjelennek-e a rendszerkultúrával azonos kultúrát képviselő objektumokban DateTimeFormatInfo . Az alábbi táblázat felsorolja az objektumok lekérésének módjait DateTimeFormatInfo , és jelzi, hogy az eredményül kapott objektum tükrözi-e a felhasználói felülbírálásokat.

A CultureInfo és a DateTimeFormatInfo objektum forrása	Felhasználói felülírásokat tükröz
`CultureInfo.CurrentCulture.DateTimeFormat` ingatlan	Yes
DateTimeFormatInfo.CurrentInfo ingatlan	Yes
CultureInfo.CreateSpecificCulture módszer	Yes
CultureInfo.GetCultureInfo módszer	No
CultureInfo.CultureInfo(String) Konstruktor	Yes
CultureInfo.CultureInfo(String, Boolean) Konstruktor	A paraméter értékétől `useUserOverride` függ

Hacsak nincs kényszerítő ok az ellenkezőjére, tiszteletben kell tartania a felhasználói felülbírálásokat, amikor az ügyfélalkalmazásokban a DateTimeFormatInfo objektumot felhasználja a felhasználói bemenetek formázására és elemzésére, illetve az adatok megjelenítésére. Kiszolgálóalkalmazások vagy felügyelet nélküli alkalmazások esetén nem szabad. Ha azonban az DateTimeFormatInfo objektumot explicit módon vagy implicit módon használja a dátum- és időadatok sztring formában való megőrzéséhez, akkor vagy olyan DateTimeFormatInfo objektumot kell használnia, amely tükrözi az invariáns kultúra formázási konvencióit, vagy meg kell adnia egy egyéni dátum- és időformátum-sztringet, amelyet a kultúrától függetlenül használ.

Dátumok és időpontok formázása

Az DateTimeFormatInfo objektumot implicit módon vagy explicit módon használják minden dátum- és időformázási műveletben. Ezek közé tartoznak a következő metódusokra irányuló hívások:

Minden dátum- és időformázási módszer, például DateTime.ToString() és DateTimeOffset.ToString(String).
A fő összetett formázási módszer, amely a String.Format.
Egyéb összetett formázási módszerek, például Console.WriteLine(String, Object[]) és StringBuilder.AppendFormat(String, Object[]).

Minden dátum- és időformázási művelet implementációt IFormatProvider használ. Az IFormatProvider interfész egyetlen metódust tartalmaz. IFormatProvider.GetFormat(Type) Ez a visszahívási módszer egy Type olyan objektumot ad át, amely a formázási információk megadásához szükséges típust jelöli. A metódus egy ilyen típusú példányt ad vissza, vagy null ha nem tud ilyen típusú példányt biztosítani. A .NET két IFormatProvider implementációt tartalmaz a dátumok és időpontok formázásához:

Az CultureInfo osztály, amely egy adott kultúrát (vagy egy adott ország/régió egy adott nyelvét) jelöl. Egy dátum- és időformázási műveletben a CultureInfo.GetFormat metódus visszaadja azt az DateTimeFormatInfo objektumot, amely a CultureInfo.DateTimeFormat tulajdonságához társul.
Az DateTimeFormatInfo osztály, amely információkat nyújt a társított kultúra formázási konvencióiról. A DateTimeFormatInfo.GetFormat metódus egy saját példányt ad vissza.

Ha egy IFormatProvider implementációt nem biztosítunk explicit módon egy formázási módszer számára, akkor a CultureInfo objektumot használják, amelyet a CultureInfo.CurrentCulture tulajdonság ad vissza, és amely az aktuális kultúrát képviseli.

Az alábbi példa a felület és az IFormatProvider DateTimeFormatInfo osztály közötti kapcsolatot mutatja be a formázási műveletekben. Meghatároz egy egyéni IFormatProvider implementációt, amelynek GetFormat metódusa megjeleníti a formázási művelet által kért objektum típusát. Ha objektumot DateTimeFormatInfo kér, a metódus biztosítja az DateTimeFormatInfo objektumot az aktuális kultúrához. Ahogy a példa kimenete is mutatja, a Decimal.ToString(IFormatProvider) metódus egy DateTimeFormatInfo objektumot kér a formázási információk megadására, míg a String.Format(IFormatProvider, String, Object[]) metódus NumberFormatInfo és DateTimeFormatInfo objektumokat, valamint egy ICustomFormatter implementációt kér.

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

Sztringek és DateTimeFormatInfo tulajdonságok formázása

Az DateTimeFormatInfo objektum háromféle tulajdonságot tartalmaz, amelyeket dátum- és időértékekkel rendelkező formázási műveletekben használnak:

Naptárral kapcsolatos tulajdonságok. Az olyan tulajdonságok, mint AbbreviatedDayNamesa , AbbreviatedMonthNames, DayNamesés MonthNames, a kultúra által használt naptárhoz vannak társítva, amelyet a Calendar tulajdonság határoz meg. Ezek a tulajdonságok hosszú dátum- és időformátumokhoz használhatók.
Szabványok által definiált eredménysztringet előállító tulajdonságok. A RFC1123Pattern, SortableDateTimePatternés UniversalSortableDateTimePattern tulajdonságok olyan egyéni formázási sztringeket tartalmaznak, amelyek nemzetközi szabványok által meghatározott eredménysztringeket hoznak létre. Ezek a tulajdonságok írásvédettek, és nem módosíthatók.
Kultúraérzékeny eredménysztringeket definiáló tulajdonságok. Egyes tulajdonságok( például FullDateTimePattern és ShortDatePattern) egyéni formázási sztringeket tartalmaznak, amelyek megadják az eredménysztring formátumát. Mások, például AMDesignator, DateSeparator, PMDesignator, és TimeSeparator, olyan kultúraérzékeny szimbólumokat vagy alsztringeket definiálnak, amelyek egy eredménysztringben szerepelhetnek.

A szabványos dátum- és időformátum-sztringek, például a "d", a "D", az "f" és az "F" olyan aliasok, amelyek megfelelnek a formátumminta adott DateTimeFormatInfo tulajdonságainak. Az egyéni dátum- és időformátum-sztringek többsége olyan sztringekhez vagy alsztringekhez kapcsolódik, amelyeket egy formázási művelet beszúr az eredményfolyamba. Az alábbi táblázat a szabványos és egyéni dátum- és időformátum-meghatározókat és azok társított DateTimeFormatInfo tulajdonságait sorolja fel. A formátumkijelölők használatáról további információt a Standard dátum- és időformátum sztringjei, valamint az egyéni dátum- és időformátum-sztringek című témakörben talál. Vegye figyelembe, hogy minden szabványos formátumsztring egy DateTimeFormatInfo olyan tulajdonságnak felel meg, amelynek értéke testreszabott dátum- és időformátum-sztring. Az egyéni formázási sztring egyes meghatározói viszont más DateTimeFormatInfo tulajdonságoknak felelnek meg. A táblázat csak azokat a DateTimeFormatInfo tulajdonságokat sorolja fel, amelyekhez a standard formátumú sztringek aliasok; nem sorolja fel azokat a tulajdonságokat, amelyekhez az aliasolt tulajdonságokhoz hozzárendelt egyéni formátumú sztringek férhetnek hozzá. A táblázat emellett csak a tulajdonságoknak DateTimeFormatInfo megfelelő egyéni formátumkijelölőket sorolja fel.

Formátumkijelölő	Társított tulajdonságok
"d" (rövid dátum; standard formátumú karakterlánc)	ShortDatePatternaz eredménysztring általános formátumának meghatározásához.
"D" (hosszú dátum; szabványos formátumkarakterlánc)	LongDatePatternaz eredménysztring általános formátumának meghatározásához.
"f" (teljes dátum / rövid idő; standard formátum sztring)	LongDatePattern, az eredménysztring dátumösszetevőjének formátumának meghatározásához. ShortTimePatternaz eredménysztring időösszetevőjének formátumának meghatározásához.
"F" (teljes dátum/hosszú idő; standard formátumú karakterlánc)	LongDatePattern, az eredménysztring dátumösszetevőjének formátumának meghatározásához. LongTimePatternaz eredménysztring időösszetevőjének formátumának meghatározásához.
"g" (általános dátum és rövid idő; standard formátumú karaktersorozat)	ShortDatePattern, az eredménysztring dátumösszetevőjének formátumának meghatározásához. ShortTimePatternaz eredménysztring időösszetevőjének formátumának meghatározásához.
"G" (általános dátum/idő; szabvány formátumkarakterlánc)	ShortDatePattern, az eredménysztring dátumösszetevőjének formátumának meghatározásához. LongTimePatternaz eredménysztring időösszetevőjének formátumának meghatározásához.
"M", "m" (hónap/nap; standard formátumú string)	MonthDayPatternaz eredménysztring általános formátumának meghatározásához.
"O", "o" (oda-vissza utazás dátuma/ideje; standard formátumú sztring)	None.
"R", "r" (RFC1123; standard formátumú karakterlánc)	RFC1123Pattern érdekében, hogy egy RFC 1123 szabványnak megfelelő eredménysztringet definiáljunk. A tulajdonság csak olvasható.
"s" (rendezhető dátum/idő; standard formátumú karakterlánc)	SortableDateTimePattern az ISO 8601 szabványnak megfelelő eredményszöveg definiálásához. A tulajdonság csak olvasható.
"t" (rövid idő; standard formátum)	ShortTimePatternaz eredménysztring általános formátumának meghatározásához.
"T" (hosszú formátum; standard formátumú karakterlánc)	LongTimePatternaz eredménysztring általános formátumának meghatározásához.
"u" (univerzális rendezhető dátum/idő; standard formátumú karakterlánc)	UniversalSortableDateTimePattern, hogy egy eredménykaraktersorozatot definiáljunk, amely megfelel az összehangolt világidő ISO 8601 szabványának. A tulajdonság csak olvasható.
"U" (univerzális teljes dátum/idő; standard formátumú karakterlánc)	FullDateTimePatternaz eredménysztring általános formátumának meghatározásához.
"Y", "y" (év hónap; standard formátumú karakterlánc)	YearMonthPatternaz eredménysztring általános formátumának meghatározásához.
"ddd" (egyéni formátumkijelölő)	AbbreviatedDayNames, ha a hét napjának rövidített nevét szeretné szerepeltetni az eredménysztringben.
"g", "gg" (egyéni formátumjelölő)	Meghívja a GetEraName metódust, hogy beszúrja a kor nevét az eredménysztringbe.
"MMM" (egyéni formátumkijelölő)	AbbreviatedMonthNames vagy AbbreviatedMonthGenitiveNamesa rövidített hónap nevének belefoglalásához az eredménysztringbe.
"MMMM" (egyéni formátumkijelölő)	MonthNames vagy MonthGenitiveNamesa teljes hónap nevének belefoglalásához az eredménysztringbe.
"t" (egyéni formátumkijelölő)	AMDesignator vagy PMDesignator, az AM/PM megjelölő első karakterének belefoglalásához az eredménysztringbe.
"tt" (egyéni formátumkijelölő)	AMDesignator vagy PMDesignator a teljes AM/PM-jelölő belefoglalásához az eredményláncba.
":" (egyéni formátumkijelölő)	TimeSeparator, hogy az időelválasztót az eredménysztringbe beillesszük.
"/" (egyéni formátumkijelölő)	DateSeparator, azért, hogy a dátumelválasztót belefoglalja az eredményláncba.

DateTimeFormatInfo tulajdonságainak módosítása

A dátum- és időformátum-sztringek alapján létrehozott eredménysztring módosítható egy írható DateTimeFormatInfo objektum társított tulajdonságainak módosításával. Annak megállapításához, hogy egy DateTimeFormatInfo objektum írható-e, használja a tulajdonságot IsReadOnly . Így szabja testre az DateTimeFormatInfo objektumot:

Hozzon létre egy olvasási/írási másolatot egy DateTimeFormatInfo olyan objektumról, amelynek formázási konvencióit módosítani szeretné.
Módosítsa a kívánt eredménysztring létrehozásához használt tulajdonságot vagy tulajdonságokat. (További információ arról, hogy a formázási módszerek hogyan használnak DateTimeFormatInfo tulajdonságokat az eredménysztringek definiálásához, lásd az előző szakaszt, a Sztringek formázása és a DateTimeFormatInfo tulajdonságokat.)
A formázási metódusok meghívásakor használja az általad létrehozott egyéni DateTimeFormatInfo objektumot IFormatProvider argumentumként.

Az eredménysztring formátumát kétféleképpen módosíthatja:

Az CultureAndRegionInfoBuilder osztály használatával egyéni kultúrát (egyedi nevet tartalmazó és meglévő kultúrákat kiegészítő kultúrát) vagy helyettesítő kultúrát (egy adott kultúra helyett) definiálhat. A kulturális adatok programozottan menthetők és érhetők el, ahogy a .NET által támogatott CultureInfo objektumok.
Ha az eredménysztring nem kulturális szempontból érzékeny, és nem követi az előre definiált formátumot, egyéni dátum- és időformátum-sztringet is használhat. Ha például dátum- és időadatokat szerializál YYYYMMDHHmmss formátumban, az eredménysztringet úgy hozhatja létre, hogy átadja az egyéni formátumsztringet a DateTime.ToString(String) metódusnak, és a metódus meghívásával DateTime visszaalakíthatja az eredménysztringet egy DateTime.ParseExact értékre.

Módosítsa a rövid dátummintát

Az alábbi példa a "d" (rövid dátum) standard formátumsztring által előállított eredménysztring formátumát módosítja. Az en-US vagy az angol (Egyesült Államok) kultúra társított ShortDatePattern tulajdonságát az alapértelmezett "M/d/yy" értékről "yyyy'-"MM"-"dd" értékre módosítja, és a "d" standard formátumú sztringet használja a ShortDatePattern tulajdonság módosítása előtti és utáni dátum megjelenítéséhez.

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

A dátumelválasztó karakter módosítása

Az alábbi példa egy olyan objektum dátumelválasztó karakterét DateTimeFormatInfo módosítja, amely az fr-FR-kultúra formázási konvencióinak felel meg. A példa a "g" standard formátumú sztringet használja a tulajdonság módosítása előtti és utáni DateSeparator dátum megjelenítéséhez.

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

A napnevek rövidítéseinek és a hosszú dátummintának módosítása.

Bizonyos esetekben a hosszú dátumminta, amely általában az egész nap és a hónap nevét, valamint a hónap és az év napjának számát jeleníti meg, túl hosszú lehet. Az alábbi példa lerövidíti az usa-beli kultúra hosszú dátummintáját, és egy vagy két karakterből álló napnév rövidítést ad vissza, amelyet a napszám, a hónapnév rövidítése és az év követ. Ezt úgy teszi, hogy rövidebb napnév-rövidítéseket rendel a AbbreviatedDayNames tömbhöz, és módosítja a tulajdonsághoz LongDatePattern rendelt egyéni formátumsztringet. Ez hatással van a "D" és az "f" standard formátumú karakterláncok által visszaadott eredményláncokra.

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

A LongDatePattern tulajdonság módosítása általában a FullDateTimePattern tulajdonságra is hatással van, ami meghatározza az "F" standard formátumú sztring által visszaadott eredménysztringet. Az eredeti teljes dátum- és időminta megőrzése érdekében a példa az eredeti egyéni formátumsztringet rendeli újra a FullDateTimePattern tulajdonsághoz, miután a LongDatePattern tulajdonság módosításra került.

Váltás 12 órásról 24 órásra

A .NET-ben sok kultúra esetében az idő 12 órás óra és egy AM/PM tervező használatával van kifejezve. Az alábbi példa egy olyan metódust ReplaceWith24HourClock határoz meg, amely minden olyan időformátumot lecserél, amely egy 12 órás órát használ egy 24 órás órát használó formátumra.

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

A példa egy reguláris kifejezést használ a formátumsztring módosításához. A reguláris kifejezésminta @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) a következőképpen van definiálva:

Pattern	Description
`^`	Kezdje el az egyezést a karakterlánc elején.
`(?<openAMPM>\st+\s)?`	Egyezik nulla vagy egy előfordulással nulla vagy több szóköz karakterből, amelyet a "t" betű követ egy vagy több alkalommal, majd nulla vagy több szóköz karakter követ. Ennek a rögzítési csoportnak a neve `openAMPM`.
`(?(openAMPM) h+(?<nonHours>[^ht]+)$`	Ha a `openAMPM` csoport egyezést tartalmaz, egy vagy több alkalommal egyezzen a "h" betűvel, majd egy vagy több karakterrel, amelyek nem "h" vagy "t". Az egyezés a sztring végén ér véget. A "h" után rögzített összes karakter szerepel egy `nonHours` nevű rögzítési csoportban.
`\| \sh+(?<nonHours>[^ht]+)\st+)`	Ha a `openAMPM` csoportnak nincs egyezése, egy vagy több alkalommal egyezzen a "h" betűvel, majd egy vagy több olyan karakterrel, amely nem "h" vagy "t", majd nulla vagy több szóköz karakterrel. Végül egyezzen a "t" betű egy vagy több előfordulásával. Az "h" után, a szóközök és a "t" előtt rögzített összes karakter szerepel egy `nonHours` nevű rögzítő csoportban.

A nonHours rögzítési csoport tartalmazza az egyéni dátum- és időformátum-sztring perc- és esetleg második összetevőjét, valamint az időelválasztó szimbólumokat. A csereminta HH${nonHours} a "HH" részszöveget hozzáadja ezekhez az elemekhez.

A korszak megjelenítése és módosítása egy dátumban

Az alábbi példa hozzáadja a "g" egyéni formátumjelölőt egy objektum tulajdonságához LongDatePattern , amely az en-US kultúra formázási konvencióinak felel meg. Ez a kiegészítés a következő három szabványos formátumsztringet érinti:

A "D" (hosszú dátum) szabványos formátumú karakterlánc, amely közvetlenül a LongDatePattern tulajdonsághoz van leképezve.
Az "f" (teljes dátum/rövid idő) szabvány formátum sztring egy olyan eredménysztringet hoz létre, amely a LongDatePattern és ShortTimePattern tulajdonságok által előállított részsztringeket fűzi össze.
Az "F" (teljes dátum / hosszú idő) standard formázású karakterlánc, amely közvetlenül a FullDateTimePattern tulajdonsághoz van leképezve. Mivel nem állítottuk be explicit módon ezt a tulajdonságértéket, ezért dinamikusan jön létre a LongDatePattern és a LongTimePattern tulajdonságok összefűzésével.

A példa azt is bemutatja, hogyan módosíthatja egy olyan kultúra korszaknevét, amelynek naptára egyetlen korszakot alkot. Ebben az esetben az USA-beli kultúra a Gergely-naptárt használja, amelyet egy GregorianCalendar objektum jelöl. Az GregorianCalendar osztály egyetlen korszakot támogat, amelyet A.D. (Anno Domini) néven nevez el. A példa úgy módosítja a kor nevét a C.E. (Common Era) értékre, hogy a tulajdonsághoz rendelt FullDateTimePattern formátumsztringben a "g" egyéni formátumjelölőt egy literális sztringre cseréli. A szó szerinti karakterlánc használatára azért van szükség, mert a GetEraName metódus általában a .NET vagy az operációs rendszer által biztosított kulturális táblákban található magán adatokból adja vissza a kornevet.

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

Dátum- és idősztringek elemzése

Az elemzés magában foglalja egy dátum és idő sztringképének konvertálását egy DateTime vagy DateTimeOffset értékké. Mindkét típus tartalmazza az Parseelemzési műveleteket támogató , TryParse, ParseExactés TryParseExact metódusokat. A Parse és TryParse metódusok különböző formátumokkal rendelkező karakterláncokat konvertálnak, míg a ParseExact és TryParseExact metódusok esetében a karakterláncnak definiált formátummal vagy formátumokkal kell rendelkeznie. Ha az elemzési művelet meghiúsul, Parse és ParseExact kivételt dob, míg TryParse és TryParseExact visszaadja a false értéket.

Az elemzési metódusok implicit módon vagy explicit módon enumerálási értéket használnak DateTimeStyles annak meghatározásához, hogy mely stíluselemek (például a bevezető, záró vagy belső szóköz) lehetnek jelen az elemezni kívánt sztringben, és hogyan értelmezhetők az elemzett sztring vagy a hiányzó elemek. Ha nem ad meg egy DateTimeStyles értéket, amikor meghívja a Parse vagy TryParse metódust, akkor az alapértelmezett a DateTimeStyles.AllowWhiteSpaces, amely egy összetett stílus, és magában foglalja a DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite és DateTimeStyles.AllowInnerWhite jelölőket. A ParseExact és TryParseExact metódusok esetében az alapértelmezett érték: DateTimeStyles.None; a bemeneti sztringnek pontosan meg kell felelnie egy egyedi dátum- és időformátum-sztringnek.

Az elemzési módszerek implicit módon vagy explicit módon is használnak egy DateTimeFormatInfo objektumot, amely meghatározza az elemezni kívánt sztringben előforduló szimbólumokat és mintákat. Ha nem ad meg objektumot DateTimeFormatInfo , a rendszer alapértelmezés szerint az DateTimeFormatInfo aktuális kultúra objektumát használja. A dátum- és idősztringek elemzésével kapcsolatos további információkért lásd az egyes elemzési módszereket, például DateTime.Parse: , DateTime.TryParse DateTimeOffset.ParseExact, és DateTimeOffset.TryParseExact.

Az alábbi példa a dátum- és idősztringek elemzésének kultúraérzékeny jellegét mutatja be. Két dátumformátumot próbál feldolgozni az en-US, en-GB, fr-FR és fi-FI kultúrák konvencióinak alkalmazásával. A 2014.08.18-i dátum az usa-beli kultúrában kivételt FormatException jelent a másik három kultúrában, mert a 18 hónapszámként van értelmezve. 2015.01.02. az usa-beli kultúrában az első hónap második napjaként, a többi kultúrában azonban a második hónap első napjaként értelmezik.

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

A dátum- és idősztringek általában két okból vannak elemezve:

A felhasználói bemenet dátum- és időértékké alakítása.
Dátum- és időértéket oda-vissza átalakítani, azaz egy korábban sztringként szerializált dátum- és időértéket deszerializálni.

A következő szakaszok részletesebben ismertetik ezt a két műveletet.

Felhasználói sztringek elemzése

Amikor elemzi a felhasználó által bevitt dátum- és idősztringeket, mindig olyan objektumot kell létrehoznia DateTimeFormatInfo , amely tükrözi a felhasználó kulturális beállításait, beleértve a felhasználó által esetleg végrehajtott testreszabásokat is. Ellenkező esetben előfordulhat, hogy a dátum- és időobjektum értéke helytelen. A felhasználói kulturális testreszabásokat tükröző objektumok példányosításával DateTimeFormatInfo kapcsolatos információkért tekintse meg a DateTimeFormatInfo és a dinamikus adatok szakaszt.

Az alábbi példa a felhasználói kulturális beállításokat tükröző elemzési művelet és a nem megfelelő elemzési művelet közötti különbséget mutatja be. Ebben az esetben az alapértelmezett rendszerkultúra az EN-US, de a felhasználó Vezérlőpult, régió és nyelv használatával módosította a rövid dátummintát az alapértelmezett "M/d/yyyy" értékről "éééé/HH/dd"-ra. Ha a felhasználó olyan sztringet ad meg, amely tükrözi a felhasználói beállításokat, és a sztringet egy DateTimeFormatInfo olyan objektum elemzi, amely a felhasználói beállításokat (felülbírálásokat) is tükrözi, az elemzési művelet helyes eredményt ad vissza. Ha azonban a sztringet egy DateTimeFormatInfo olyan objektum elemzi, amely a szabványos en-US kulturális beállításokat tükrözi, az elemzési módszer kivételt FormatException vet fel, mivel a 14-et a hónap számaként értelmezi, nem pedig az év utolsó két számjegyét.

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

Dátum- és időadatok szerializálása és deszerializálása

A szerializált dátum- és időadatok várhatóan oda-vissza fordulnak; vagyis minden szerializált és deszerializált értéknek azonosnak kell lennie. Ha egy dátum- és időérték egyetlen időpontot jelöl az időben, a deszerializált értéknek ugyanazt a pillanatot kell jelölnie az időben, függetlenül attól, hogy a rendszer milyen kultúrát vagy időzónát adott vissza. A dátum- és időadatok sikeres lekerekítéséhez a tulajdonság által InvariantInfo visszaadott invariáns kultúra konvencióit kell használnia az adatok létrehozásához és elemzéséhez. A formázási és elemzési műveleteknek soha nem szabad az alapértelmezett kultúra konvencióit tükrözniük. Ha alapértelmezett kulturális beállításokat használ, az adatok hordozhatósága szigorúan korlátozott; csak olyan szálon lehet sikeresen deszerializálni, amelynek kulturális adottságai megegyeznek azon száléval, amelyen szerializálták. Bizonyos esetekben ez azt jelenti, hogy az adatok nem is szerializálhatók és deszerializálhatók ugyanazon a rendszeren.

Ha egy dátum- és időérték időösszetevője jelentős, akkor azt UTC-re is át kell alakítani, és szerializálni kell az "o" vagy az "r" standard formátumú sztring használatával. Az időadatok ezután visszaállíthatók egy elemzési módszer meghívásával, majd a megfelelő formátumsztringet és az invariáns kultúrát argumentumként átadva.

Az alábbi példa egy dátum- és időérték kerekítésének folyamatát mutatja be. Szerializál egy dátumot és időt egy olyan rendszeren, amely megfigyeli az Egyesült Államok csendes-óceáni idejét, és amelynek jelenlegi kultúrája az 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)

Deszerializálja a brüsszeli, koppenhágai, madridi és párizsi időzónában található rendszer adatait, amelynek jelenlegi kultúrája fr-FR. A visszaállított dátum kilenc órával későbbi, mint az eredeti dátum, ami az időzóna kiigazítását tükrözi, amikor UTC mögötti nyolc óráról UTC előtti egy órára váltottak. Az eredeti dátum és a visszaállított dátum is ugyanazt az időpontot jelöli.

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

Konstruktorok

Name	Description
DateTimeFormatInfo()	Inicializálja a DateTimeFormatInfo kultúrafüggetlen (invariant) osztály új írható példányát.

Tulajdonságok

Name	Description
AbbreviatedDayNames	Lekéri vagy beállítja a hét napjainak kultúraspecifikus rövidített neveit tartalmazó egydimenziós tömböt String .
AbbreviatedMonthGenitiveNames	Lekéri vagy beállítja az aktuális DateTimeFormatInfo objektumhoz társított rövidített hónapnevekből álló sztringtömböt.
AbbreviatedMonthNames	Lekéri vagy beállít egy egydimenziós sztringtömböt, amely tartalmazza a hónapok kultúraspecifikus rövidített neveit.
AMDesignator	Lekéri vagy beállítja a sztringtervezőt órákra, amelyek "ante meridiem" (dél előtt).
Calendar	Lekéri vagy beállítja a naptárt az aktuális kultúrához.
CalendarWeekRule	Lekéri vagy beállít egy értéket, amely meghatározza, hogy melyik szabályt használja az év első naptári hetének meghatározásához.
CurrentInfo	Egy írásvédett DateTimeFormatInfo objektumot kap, amely az aktuális kultúra alapján formáz értékeket.
DateSeparator	Lekéri vagy beállítja a dátum, vagyis az év, a hónap és a nap összetevőit elválasztó sztringet.
DayNames	Lekéri vagy beállít egy egydimenziós sztringtömböt, amely tartalmazza a hét napjainak kultúraspecifikus teljes nevét.
FirstDayOfWeek	Lekéri vagy beállítja a hét első napját.
FullDateTimePattern	Lekéri vagy beállítja az egyéni formázási sztringet egy hosszú dátumhoz és hosszú időhöz.
InvariantInfo	Lekéri az alapértelmezett írásvédett DateTimeFormatInfo objektumot, amely kultúrafüggetlen (invariant).
IsReadOnly	Beolvas egy értéket, amely jelzi, hogy az DateTimeFormatInfo objektum írásvédett-e.
LongDatePattern	Lekéri vagy beállítja az egyéni formázási sztringet egy hosszú dátumértékhez.
LongTimePattern	Hosszú ideig lekéri vagy beállítja az egyéni formázási sztringet.
MonthDayPattern	Lekéri vagy beállítja az egyéni formátumsztringet egy hónapra és napra vonatkozóan.
MonthGenitiveNames	Lekéri vagy beállítja az aktuális DateTimeFormatInfo objektumhoz társított hónapnevekből álló sztringtömböt.
MonthNames	Lekéri vagy beállítja a hónapok kultúraspecifikus teljes nevét tartalmazó egydimenziós tömböt String .
NativeCalendarName	Lekéri az aktuális DateTimeFormatInfo objektumhoz társított naptár natív nevét.
PMDesignator	Lekéri vagy beállítja a sztringtervezőt órákra, amelyek "post meridiem" (dél után).
RFC1123Pattern	Az Internet Engineering Task Force (IETF) Request for Comments (RFC) 1123 specifikáción alapuló időérték egyéni formátumsztringjének lekérése.
ShortDatePattern	Lekéri vagy beállítja az egyéni formázási sztringet egy rövid dátumértékhez.
ShortestDayNames	Lekéri vagy beállítja az aktuális DateTimeFormatInfo objektumhoz társított legrövidebb rövidített napnevekből álló sztringtömböt.
ShortTimePattern	Rövid időre lekéri vagy beállítja az egyéni formátumsztringet.
SortableDateTimePattern	Lekéri az egyéni formátumsztringet egy rendezhető dátum- és időértékhez.
TimeSeparator	Lekéri vagy beállítja azt a sztringet, amely elválasztja az idő összetevőit, vagyis az órát, a percet és a másodpercet.
UniversalSortableDateTimePattern	Lekéri az ISO 8601 által meghatározott univerzális, rendezhető dátum- és idősztring egyéni formátumsztringét.
YearMonthPattern	Lekéri vagy beállítja az egyéni formátumsztringet egy évre és hónapra vonatkozóan.

Metódusok

Name	Description
Clone()	Létrehoz egy sekély másolatot a DateTimeFormatInfo.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetAbbreviatedDayName(DayOfWeek)	A hét megadott napjának kultúraspecifikus rövidített nevét adja vissza az aktuális DateTimeFormatInfo objektumhoz társított kultúra alapján.
GetAbbreviatedEraName(Int32)	A megadott korszak rövidített nevét tartalmazó sztringet adja vissza, ha létezik rövidítés.
GetAbbreviatedMonthName(Int32)	A megadott hónap kultúraspecifikus rövidített nevét adja vissza az aktuális DateTimeFormatInfo objektumhoz társított kultúra alapján.
GetAllDateTimePatterns()	Azokat a szabványos mintákat adja vissza, amelyekben a dátum- és időértékek formázhatók.
GetAllDateTimePatterns(Char)	Azokat a mintákat adja vissza, amelyekben a dátum- és időértékek a megadott szabványos formátumsztring használatával formázhatók.
GetDayName(DayOfWeek)	A hét megadott napjának kultúraspecifikus teljes nevét adja vissza az aktuális DateTimeFormatInfo objektumhoz társított kultúra alapján.
GetEra(String)	A megadott korszakot képviselő egész számot adja vissza.
GetEraName(Int32)	A megadott korszak nevét tartalmazó sztringet adja vissza.
GetFormat(Type)	Egy megadott típusú objektumot ad vissza, amely dátum- és időformázási szolgáltatást biztosít.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetInstance(IFormatProvider)	DateTimeFormatInfo A megadott IFormatProviderobjektumhoz társított objektumot adja vissza.
GetMonthName(Int32)	A megadott hónap kultúraspecifikus teljes nevét adja vissza az aktuális DateTimeFormatInfo objektumhoz társított kultúra alapján.
GetShortestDayName(DayOfWeek)	Lekérte az aktuális DateTimeFormatInfo objektumhoz társított hét egy adott napjának legrövidebb rövidített napnevét.
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
ReadOnly(DateTimeFormatInfo)	Írásvédett DateTimeFormatInfo burkolót ad vissza.
SetAllDateTimePatterns(String[], Char)	Beállítja a megadott szabványos formátumsztringnek megfelelő egyéni dátum- és időformátum-sztringeket.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)

Explicit interfész-implementációk

Name	Description
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Feltölt egy szerializálásiinfo-t a célobjektum szerializálásához szükséges adatokkal.

A következőre érvényes:

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?