Dela via

DateTimeFormatInfo klass

Anmärkning

Den här artikeln innehåller ytterligare kommentarer till referensdokumentationen för det här API:et.

Egenskaperna för DateTimeFormatInfo klassen innehåller kulturspecifik information för formatering eller parsning av datum- och tidsvärden, till exempel följande:

  • De mönster som används för att formatera datumvärden.
  • De mönster som används för att formatera tidsvärden.
  • Namnen på veckodagarna.
  • Namnen på årets månader.
  • A.M. och P.M. beteckningar som används för tidsangivelser.
  • Kalendern där datum uttrycks.

Instansiera ett DateTimeFormatInfo-objekt

Ett DateTimeFormatInfo objekt kan representera formateringskonventionerna för den invarianta kulturen, en specifik kultur, en neutral kultur eller den aktuella kulturen. I det här avsnittet beskrivs hur du instansierar varje typ av DateTimeFormatInfo objekt.

Instansiera ett DateTimeFormatInfo-objekt för den invarianta kulturen

Den invarianta kulturen representerar en kultur som är kulturneutral. Det är baserat på det engelska språket, men inte på något specifikt engelsktalande land/region. Även om data för specifika kulturer kan vara dynamiska och kan ändras för att återspegla nya kulturella konventioner eller användarinställningar, ändras inte data i den invarianta kulturen. Du kan instansiera ett DateTimeFormatInfo objekt som representerar formateringskonventionerna för den invarianta kulturen på följande sätt:

I följande exempel används var och en av dessa metoder för att instansiera ett DateTimeFormatInfo objekt som representerar den invarianta kulturen. Sedan anger det om objektet är skrivskyddat.

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

Instansiera ett DateTimeFormatInfo-objekt för en specifik kultur

En specifik kultur representerar ett språk som talas i ett visst land/en viss region. En-US är till exempel en specifik kultur som representerar det engelska språket som talas i USA, och en-CA är en specifik kultur som representerar det engelska språket som talas i Kanada. Du kan instansiera ett DateTimeFormatInfo objekt som representerar formateringskonventionerna för en viss kultur på följande sätt:

I följande exempel visas vart och ett av dessa sätt att instansiera ett DateTimeFormatInfo objekt och anger om det resulterande objektet är skrivskyddat.

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

Instansiera ett DateTimeFormatInfo-objekt för en neutral kultur

En neutral kultur representerar en kultur eller ett språk som är oberoende av ett land/en region. Det är vanligtvis överordnat till en eller flera specifika kulturer. Till exempel är Fr en neutral kultur för det franska språket och föräldern till fr-FR-kulturen. Du kan instansiera ett DateTimeFormatInfo objekt som representerar formateringskonventionerna för en neutral kultur på samma sätt som du skapar ett DateTimeFormatInfo objekt som representerar formateringskonventionerna för en viss kultur. Dessutom kan du hämta ett neutralt kulturobjekt DateTimeFormatInfo genom att hämta en neutral kultur från en specifik kulturs CultureInfo.Parent egenskap och hämta DateTimeFormatInfo objektet som returneras av dess CultureInfo.DateTimeFormat egenskap. Om inte den överordnade kulturen representerar den invarianta kulturen, läses/skrivs det returnerade DateTimeFormatInfo objektet. I följande exempel visas dessa sätt att instansiera ett DateTimeFormatInfo objekt som representerar en neutral kultur.

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

En neutral kultur saknar dock kulturspecifik formateringsinformation, eftersom den är oberoende av ett visst land/en viss region. I stället för att fylla objektet DateTimeFormatInfo med generiska värden returnerar .NET ett DateTimeFormatInfo objekt som återspeglar formateringskonventionerna för en specifik kultur som är underordnad den neutrala kulturen. Till exempel DateTimeFormatInfo återspeglar objektet för den neutrala kulturen formateringskonventionerna för en-US-kulturen, och DateTimeFormatInfo objektet för fr-kulturen återspeglar formateringskonventionerna för fr-FR-kulturen.

Du kan använda kod som följande för att avgöra vilka specifika kulturformateringskonventioner som en neutral kultur representerar. Exemplet använder reflection för att jämföra egenskaperna för DateTimeFormatInfo en neutral kultur med egenskaperna för en specifik barnkultur. Den anser att två kalendrar är likvärdiga om de är av samma kalendertyp och, för gregorianska kalendrar, om deras GregorianCalendar.CalendarType egenskaper har identiska värden.

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

Instansiera ett DateTimeFormatInfo-objekt för den aktuella kulturen

Du kan instansiera ett DateTimeFormatInfo objekt som representerar formateringskonventionerna för den aktuella kulturen på följande sätt:

I följande exempel används var och en av dessa metoder för att instansiera ett DateTimeFormatInfo objekt som representerar formateringskonventionerna i den aktuella kulturen. Sedan anger det om objektet är skrivskyddat.

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

Du kan skapa ett skrivbart DateTimeFormatInfo objekt som representerar den aktuella kulturens konventioner på något av följande sätt:

I följande exempel visas varje sätt att instansiera ett läs-/skrivobjekt DateTimeFormatInfo och visa värdet för dess IsReadOnly egenskap.

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

I Windows kan användaren åsidosätta några av de DateTimeFormatInfo egenskapsvärden som används för formatering och parsning av åtgärder via programmet Region och Språk i Kontrollpanelen. En användare vars kultur är engelska (USA) kan till exempel välja att visa långa tidsvärden med en 24-timmarsklocka (i formatet HH:mm:ss) i stället för standardklockan på 12 timmar (i formatet h:mm:ss tt). De DateTimeFormatInfo objekt som hämtades på det sätt som tidigare beskrivits reflekterar dessa användaråtsidosättningar. Om detta inte är önskvärt kan du skapa ett NumberFormatInfo objekt som inte återspeglar användaråsidosättningar (och som också är läs/skriv istället för skrivskyddat) genom att anropa CultureInfo.CultureInfo(String, Boolean) konstruktorn och ange värdet false för useUserOverride argumentet. I följande exempel visas detta för ett system vars nuvarande kultur är engelska (USA) och vars långa tidsmönster har ändrats från standardvärdet h:mm:ss tt till HH:mm:ss.

using System;
using System.Globalization;

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

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

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

DateTimeFormatInfo och dynamiska data

Kulturspecifika data för formatering av datum- och tidsvärden som tillhandahålls av DateTimeFormatInfo klassen är dynamiska, precis som kulturella data som tillhandahålls av CultureInfo klassen. Du bör inte göra några antaganden om stabiliteten för värden för DateTimeFormatInfo objekt som är associerade med vissa CultureInfo objekt. Endast data som tillhandahålls av den invarianta kulturen och dess associerade DateTimeFormatInfo objekt är stabila. Andra data kan ändras mellan programsessioner eller även när programmet körs. Det finns fyra huvudsakliga ändringskällor:

  • Systemuppdateringar. Kulturella inställningar som önskad kalender eller vanliga datum- och tidsformat ändras över tid. När detta händer innehåller Windows Update ändringar i egenskapsvärdet DateTimeFormatInfo för en viss kultur.

  • Ersättningskulturer. Klassen CultureAndRegionInfoBuilder kan användas för att ersätta data i en befintlig kultur.

  • Sammanhängande ändringar av egenskapsvärden. Ett antal kulturrelaterade egenskaper kan ändras vid körning, vilket i sin tur medför att DateTimeFormatInfo data ändras. Den aktuella kulturen kan till exempel ändras antingen programmatiskt eller genom användaråtgärder. När detta inträffar ändras objektet DateTimeFormatInfo som returneras av CurrentInfo egenskapen till ett objekt som är associerat med den aktuella kulturen. På samma sätt kan en kulturs kalender ändras, vilket kan leda till ändringar i många DateTimeFormatInfo egenskapsvärden.

  • Användarinställningar. Användare av ditt program kan välja att åsidosätta några av de värden som är associerade med den aktuella systemkulturen via de regionala alternativen och språkalternativen i Kontrollpanelen. Användare kan till exempel välja att visa datumet i ett annat format. Om egenskapen CultureInfo.UseUserOverride är inställd truepå hämtas även objektets DateTimeFormatInfo egenskaper från användarinställningarna. Om användarinställningarna inte är kompatibla med den kultur som är associerad med CultureInfo objektet (till exempel om den valda kalendern inte är en av de kalendrar som anges av OptionalCalendars egenskapen) är resultatet av metoderna och värdena för egenskaperna odefinierat.

För att minimera risken för inkonsekventa data initieras alla användaröversidosättningsbara egenskaper för ett DateTimeFormatInfo objekt när objektet skapas. Det finns fortfarande en risk för inkonsekvens eftersom varken skapande av objekt eller användarens åsidosättningsprocess är atomisk och relevanta värden kan ändras när objektet skapas. Denna situation bör dock vara extremt sällsynt.

Du kan kontrollera om åsidosättningar för användare återspeglas i DateTimeFormatInfo-objekt som representerar samma kultur som systemkulturen. I följande tabell visas hur ett DateTimeFormatInfo-objekt kan hämtas och anger om det resulterande objektet återspeglar användaråsidosättningar.

Källa för CultureInfo- och DateTimeFormatInfo-objekt Återspeglar användarinställningar
CultureInfo.CurrentCulture.DateTimeFormat egenskap Ja
DateTimeFormatInfo.CurrentInfo egenskap Ja
CultureInfo.CreateSpecificCulture metod Ja
CultureInfo.GetCultureInfo metod Nej
CultureInfo.CultureInfo(String) konstruktor Ja
CultureInfo.CultureInfo(String, Boolean) konstruktor Beror på värdet för useUserOverride parametern

Om det inte finns en övertygande anledning att göra något annat bör du respektera användarens åsidosättningar när du använder DateTimeFormatInfo objektet i klientprogram för att formatera och parsa användarindata eller för att visa data. För serverprogram eller obevakade program bör du inte göra det. Men om du använder DateTimeFormatInfo objektet explicit eller implicit för att bevara datum- och tidsdata i strängform bör du antingen använda ett DateTimeFormatInfo objekt som återspeglar formateringskonventionerna för den invarianta kulturen, eller ange en anpassad datum- och tidsformatsträng som du använder oavsett kultur.

Formatera datum och tider

Ett DateTimeFormatInfo objekt används implicit eller explicit i alla datum- och tidsformateringsåtgärder. Dessa inkluderar anrop till följande metoder:

Alla datum- och tidsformateringsåtgärder använder en IFormatProvider implementering. Gränssnittet IFormatProvider innehåller en enda metod, IFormatProvider.GetFormat(Type). Den här motringningsmetoden får ett Type objekt som representerar den typ som behövs för att tillhandahålla formateringsinformation. Metoden returnerar antingen en instans av den typen eller null om den inte kan ange en instans av typen. .NET innehåller två IFormatProvider implementeringar för formatering av datum och tider:

Om en IFormatProvider implementering inte uttryckligen tillhandahålls till en formateringsmetod används objektet CultureInfo som returneras av egenskapen CultureInfo.CurrentCulture som representerar den aktuella kulturen.

I följande exempel visas relationen mellan IFormatProvider gränssnittet och DateTimeFormatInfo klassen i formateringsåtgärder. Den definierar en anpassad IFormatProvider implementering vars GetFormat metod visar vilken typ av objekt som begärs av formateringsåtgärden. Om den begär ett DateTimeFormatInfo objekt tillhandahåller metoden objektet DateTimeFormatInfo för den aktuella kulturen. Som utdata från exemplet visar Decimal.ToString(IFormatProvider) begär metoden ett DateTimeFormatInfo objekt för att tillhandahålla formateringsinformation, medan String.Format(IFormatProvider, String, Object[]) metoden begär NumberFormatInfo och DateTimeFormatInfo objekt samt en ICustomFormatter implementering.

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

Formatera strängar och Egenskaper för DateTimeFormatInfo

Objektet DateTimeFormatInfo innehåller tre typer av egenskaper som används i formateringsåtgärder med datum- och tidsvärden:

Standardformatsträngarna för datum och tid, till exempel "d", "D", "f" och "F", är alias som motsvarar specifika DateTimeFormatInfo formatmönsteregenskaper. De flesta av de anpassade datum- och tidsformatsträngarna är relaterade till strängar eller delsträngar som en formateringsåtgärd infogar i resultatströmmen. I följande tabell visas standard- och anpassade datum- och tidsformat och deras associerade DateTimeFormatInfo egenskaper. Mer information om hur du använder dessa formatspecificerare finns i Standardformatsträngar för datum och tid samt anpassade datum- och tidsformatsträngar. Observera att varje standardformatsträng motsvarar en DateTimeFormatInfo egenskap vars värde är en anpassad datum- och tidsformatsträng. De enskilda specificerarna i den här anpassade formatsträngen motsvarar i sin tur andra DateTimeFormatInfo egenskaper. Tabellen visar endast de DateTimeFormatInfo egenskaper som standardformatsträngarna är alias för och visar inte egenskaper som kan kommas åt av anpassade formatsträngar som tilldelats dessa aliasegenskaper. Dessutom listar tabellen endast anpassade formatspecificerare som motsvarar DateTimeFormatInfo egenskaper.

Formatsspecifikator Associerade egenskaper
"d" (kort datum; standardformatsträng) ShortDatePattern, för att definiera det övergripande formatet för resultatsträngen.
"D" (långt datum, standardformatsträng) LongDatePattern, för att definiera det övergripande formatet för resultatsträngen.
"f" (fullständigt datum/kort tid; standardformatsträng) LongDatePattern, för att definiera formatet för datumkomponenten i resultatsträngen.

ShortTimePattern, för att definiera formatet för tidskomponenten i resultatsträngen.
"F" (fullständigt datum/lång tid; standardformatsträng) LongDatePattern, för att definiera formatet för datumkomponenten i resultatsträngen.

LongTimePattern, för att definiera formatet för tidskomponenten i resultatsträngen.
"g" (allmänt datum/kort tid; standardformatsträng) ShortDatePattern, för att definiera formatet för datumkomponenten i resultatsträngen.

ShortTimePattern, för att definiera formatet för tidskomponenten i resultatsträngen.
"G" (allmänt datum/lång tid; standardformatsträng) ShortDatePattern, för att definiera formatet för datumkomponenten i resultatsträngen.

LongTimePattern, för att definiera formatet för tidskomponenten i resultatsträngen.
"M", "m" (månad/dag; standardformatsträng) MonthDayPattern, för att definiera det övergripande formatet för resultatsträngen.
"O", "o" (datum/tid för avresa, standardformatsträng) Inga.
"R", "r" (RFC1123; standardformatsträng) RFC1123Pattern, för att definiera en resultatsträng som överensstämmer med RFC 1123-standarden. Egenskapen är skrivskyddad.
"s" (sorterbar datum/tid, standardformatsträng) SortableDateTimePattern, för att definiera en resultatsträng som överensstämmer med ISO 8601-standarden. Egenskapen är skrivskyddad.
"t" (kort tid; standardformatsträng) ShortTimePattern, för att definiera det övergripande formatet för resultatsträngen.
"T" (lång tid; standardformatsträng) LongTimePattern, för att definiera det övergripande formatet för resultatsträngen.
"u" (universell sorterbar datum/tid, standardformatsträng) UniversalSortableDateTimePattern, för att definiera en resultatsträng som överensstämmer med ISO 8601-standarden för samordnad universell tid. Egenskapen är skrivskyddad.
"U" (universellt fullständigt datum/tid; standardformatsträng) FullDateTimePattern, för att definiera det övergripande formatet för resultatsträngen.
"Y", "y" (årsmånad; standardformatsträng) YearMonthPattern, för att definiera det övergripande formatet för resultatsträngen.
"ddd" (anpassad formatspecificerare) AbbreviatedDayNames, för att inkludera det förkortade namnet på veckodagen i resultatsträngen.
"g", "gg" (anpassad format specificerare) Anropar GetEraName-metoden för att infoga era-namnet i resultatsträngen.
"MMM" (anpassad formatspecificerare) AbbreviatedMonthNames eller AbbreviatedMonthGenitiveNames, för att inkludera det förkortade månadsnamnet i resultatsträngen.
"MMMM" (anpassad formatspecificerare) MonthNames eller MonthGenitiveNames, för att inkludera det fullständiga månadsnamnet i resultatsträngen.
"t" (anpassad formatspecifikator) AMDesignator eller PMDesignator, för att inkludera det första tecknet för AM/PM-designatorn i resultatsträngen.
"tt" (anpassad formatspecificerare) AMDesignator eller PMDesignator, för att inkludera den fullständiga AM/PM-designatorn i resultatsträngen.
":" (anpassad formatspecificerare) TimeSeparator, för att inkludera tidsavgränsaren i resultatsträngen.
"/" (anpassad formatspecificerare) DateSeparator, för att inkludera datumavgränsaren i resultatsträngen.

Ändra egenskaper för DateTimeFormatInfo

Du kan ändra resultatsträngen som skapas av datum- och tidsformatsträngar genom att ändra de associerade egenskaperna för ett skrivbart DateTimeFormatInfo objekt. Använd DateTimeFormatInfo för att avgöra om ett IsReadOnly-objekt är skrivbart. Så här anpassar du ett DateTimeFormatInfo objekt:

  1. Skapa en läs-/skrivkopia av ett DateTimeFormatInfo objekt vars formateringskonventioner du vill ändra.

  2. Ändra den egenskap eller de egenskaper som används för att skapa önskad resultatsträng. (Information om hur formateringsmetoder använder DateTimeFormatInfo egenskaper för att definiera resultatsträngar finns i föregående avsnitt, Formatsträngar och DateTimeFormatInfo-egenskaper.)

  3. Använd det anpassade DateTimeFormatInfo objekt som du skapade som IFormatProvider argument i anrop till formateringsmetoder.

Det finns två andra sätt att ändra formatet på en resultatsträng:

  • Du kan använda CultureAndRegionInfoBuilder klassen för att definiera antingen en anpassad kultur (en kultur som har ett unikt namn och som kompletterar befintliga kulturer) eller en ersättningskultur (en kultur som används i stället för en specifik kultur). Du kan spara och komma åt den här kulturen programmatiskt på samma sätt som alla CultureInfo objekt som stöds av .NET.

  • Om resultatsträngen inte är kulturkänslig och inte följer ett fördefinierat format kan du använda en anpassad datum- och tidsformatsträng. Om du till exempel serialiserar datum- och tidsdata i formatet YYYYMMDDHHmmss kan du generera resultatsträngen genom att skicka den anpassade formatsträngen DateTime.ToString(String) till metoden, och du kan konvertera resultatsträngen tillbaka till ett DateTime värde genom att anropa DateTime.ParseExact metoden.

Ändra mönster för kort datum

I följande exempel ändras formatet för en resultatsträng som skapas av standardformatsträngen "d" (kort datum). Den ändrar den associerade ShortDatePattern egenskapen för kulturen en-US eller engelska (USA) från standardvärdet "M/d/åååå" till "åå"-"MM"-"dd" och använder standardformatsträngen "d" för att visa datumet både före och efter ShortDatePattern att egenskapen har ändrats.

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

Ändra datumavgränsningstecknet

I följande exempel ändras datumavgränsningstecknet i ett DateTimeFormatInfo objekt som representerar formateringskonventionerna för fr-FR-kulturen. I exemplet används standardformatsträngen "g" för att visa datumet både före och efter att DateSeparator egenskapen har ändrats.

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

Ändra dagnamnsförkortningar och långt datummönster

I vissa fall kan det långa datummönstret, som vanligtvis visar hela dag- och månadsnamnet tillsammans med antalet dagar i månaden och året, vara för långt. I följande exempel förkortas det långa datummönstret för en-US-kulturen för att returnera en enteckens- eller tvåteckens dagnamnsförkortning följt av dagnumret, månadsnamnets förkortning och året. Det gör den genom att tilldela kortare förkortningar för dagnamnen till matrisen AbbreviatedDayNames och genom att ändra den anpassade formatsträngen som tilldelats egenskapen LongDatePattern. Detta påverkar de resultatsträngar som returneras av standardformatsträngarna "D" och "f".

using System;
using System.Globalization;

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

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

        Console.WriteLine();

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

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

Vanligtvis påverkar ändringen av LongDatePattern-egenskapen även FullDateTimePattern-egenskapen, som i sin tur definierar den resultatsträng som returneras av standardformatsträngen "F". För att bevara det ursprungliga fullständiga datum- och tidsmönstret tilldelas den ursprungliga anpassade formatsträngen igen till FullDateTimePattern-egenskapen efter att LongDatePattern-egenskapen har ändrats.

Ändra från en 12-timmarsklocka till en 24-timmarsklocka

För många kulturer i .NET uttrycks tiden med en 12-timmarsklocka och en AM/PM-designator. I följande exempel definieras en ReplaceWith24HourClock metod som ersätter alla tidsformat som använder en 12-timmarsklocka med ett format som använder en 24-timmarsklocka.

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

I exemplet används ett reguljärt uttryck för att ändra formatsträngen. Det reguljära uttrycket @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) definieras på följande sätt:

Mönster beskrivning
^ Börja matchningen i början av strängen.
(?<openAMPM>\s*t+\s*)? Matcha noll eller en förekomst av noll eller fler blankstegstecken följt av bokstaven "t" en eller flera gånger följt av noll eller fler blankstegstecken. Den här fångstgruppen heter openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Om gruppen openAMPM har en matchning matchar du bokstaven "h" en eller flera gånger, följt av ett eller flera tecken som varken är "h" eller "t". Matchen avslutas vid slutet av strängen. Alla tecken som fångas efter "h" ingår i en samlande grupp med namnet nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) Om gruppen openAMPM inte har någon matchning matchar du bokstaven "h" en eller flera gånger, följt av ett eller flera tecken som varken är "h" eller "t", följt av noll eller fler blankstegstecken. Matcha slutligen en eller flera förekomster av bokstaven "t". Alla tecken som hämtats efter "h" och före blankstegen och "t" ingår i en samlande grupp med namnet nonHours.

Fångstgruppen nonHours innehåller minut- och eventuellt sekundkomponenten i en anpassad datum- och tidsformatsträng, tillsammans med eventuella tidsavgränsarsymboler. Ersättningsmönstret HH${nonHours} lägger till delsträngen "HH" framför dessa element.

Visa och ändra eran i ett datum

I följande exempel läggs den anpassade formatspecificeraren "g" till LongDatePattern egenskapen för ett objekt som representerar formateringskonventionerna för en-US-kulturen. Det här tillägget påverkar följande tre standardformatsträngar:

  • Standardformatsträngen "D" (långt datum) som mappar direkt till LongDatePattern egenskapen.

  • Standardformatsträngen "f" (fullständigt datum/kort tid) ger en resultatsträng som sammanfogar de delsträngar som skapas av LongDatePattern egenskaperna och ShortTimePattern .

  • Standardformatsträngen "F" (fullständigt datum/lång tid) som mappar direkt till FullDateTimePattern egenskapen. Eftersom vi inte uttryckligen har angett det här egenskapsvärdet genereras det dynamiskt genom att LongDatePattern egenskaperna och LongTimePattern sammanfogas.

Exemplet visar också hur du ändrar eranamnet för en kultur vars kalender har en enda era. I det här fallet använder en-US-kulturen den gregorianska kalendern, som representeras av ett GregorianCalendar objekt. Klassen GregorianCalendar stöder en enda era som heter A.D. (Anno Domini). Exemplet ändrar era-namnet till C.E. (Common Era) genom att ersätta den anpassade formatspecificeraren "g" i formatsträngen FullDateTimePattern som tilldelats egenskapen med en literalsträng. Det är nödvändigt att använda en literalsträng eftersom era-namnet vanligtvis returneras av GetEraName metoden från privata data i kulturtabellerna som tillhandahålls av antingen .NET eller operativsystemet.

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

Parsa datum- och tidssträngar

Parsning innebär att konvertera strängrepresentationen av ett datum och en tid till ett DateTime- eller DateTimeOffset-värde. Båda dessa typer omfattar Parsemetoderna , TryParse, ParseExactoch TryParseExact som stöder parsningsåtgärder. Metoderna Parse och TryParse konverterar en sträng som kan ha olika format, medan ParseExact och TryParseExact kräver att strängen har ett definierat format eller format. Om parsningsåtgärden misslyckas Parse och ParseExact utlöser ett undantag, medan TryParse och TryParseExact returnerar false.

Parsningsmetoderna använder implicit eller explicit ett DateTimeStyles uppräkningsvärde för att avgöra vilka formatelement (till exempel inledande, avslutande eller inre blanksteg) som kan finnas i strängen som ska parsas och hur du tolkar den tolkade strängen eller eventuella saknade element. Om du inte anger något DateTimeStyles värde när du anropar Parse metoden eller TryParse är DateTimeStyles.AllowWhiteSpacesstandardvärdet , vilket är ett sammansatt format som innehåller flaggorna DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhiteoch DateTimeStyles.AllowInnerWhite . ParseExact För metoderna och TryParseExact är DateTimeStyles.Nonestandardvärdet . Indatasträngen måste exakt motsvara en viss anpassad datum- och tidsformatsträng.

Parsningsmetoderna använder också implicit eller explicit ett DateTimeFormatInfo objekt som definierar de specifika symboler och mönster som kan förekomma i strängen som ska parsas. Om du inte anger något DateTimeFormatInfo objekt DateTimeFormatInfo används objektet för den aktuella kulturen som standard. Mer information om att parsa datum- och tidssträngar finns i de enskilda parsningsmetoderna, till exempel DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExactoch DateTimeOffset.TryParseExact.

I följande exempel visas den kulturkänsliga karaktären hos parsning av datum- och tidssträngar. Den försöker parsa två datumsträngar med hjälp av konventionerna i kulturerna en-US, en-GB, fr-FR och fi-FI. Datumet som tolkas som 2014-08-18 i en-US-kulturen genererar ett FormatException undantag i de andra tre kulturerna eftersom 18 tolkas som månadsnumret. 1/2/2015 parsas som den andra dagen i den första månaden i en-US-kulturen, men som den första dagen i den andra månaden i de återstående kulturerna.

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

Datum- och tidssträngar parsas vanligtvis av två orsaker:

  • Så här konverterar du användarindata till ett datum- och tidsvärde.
  • För att återskapa ett datum- och tidsvärde, det vill säga att deserialisera ett datum- och tidsvärde som tidigare serialiserats som en sträng.

I följande avsnitt beskrivs dessa två åtgärder i detalj.

Parsa användarsträngar

När du parsar indata för datum- och tidssträngar av användaren bör du alltid instansiera ett DateTimeFormatInfo objekt som återspeglar användarens kulturella inställningar, inklusive eventuella anpassningar som användaren kan ha gjort. Annars kan datum- och tidsobjektet ha felaktiga värden. Information om hur du instansierar ett DateTimeFormatInfo objekt som återspeglar användarens kulturella anpassningar finns i avsnittet DateTimeFormatInfo och dynamiska data .

I följande exempel visas skillnaden mellan en parsningsåtgärd som återspeglar användarens kulturella inställningar och en som inte gör det. I det här fallet är standardsystemkulturen en-US, men användaren har använt Kontrollpanelen, Region och Språk för att ändra det korta datummönstret från standardvärdet "M/d/åååå" till "ååå/MM/dd". När användaren anger en sträng som återspeglar användarinställningarna, och strängen parsas av ett DateTimeFormatInfo objekt som också återspeglar användarinställningar (åsidosättningar), returnerar parsningsåtgärden ett korrekt resultat. Men när strängen parsas av ett DateTimeFormatInfo objekt som återspeglar standardinställningar för en-US-kultur, utlöser parsningsmetoden ett FormatException undantag eftersom den tolkar 14 som månadens antal, inte årets två sista siffror.

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

Serialisera och deserialisera datum- och tidsdata

Serialiserade datum- och tidsdata förväntas tur och retur. Alla serialiserade och deserialiserade värden ska alltså vara identiska. Om ett datum- och tidsvärde representerar ett enda ögonblick i tiden ska det deserialiserade värdet representera samma ögonblick i tiden oavsett kulturen eller tidszonen i det system där det återställdes. För att datum- och tidsdata ska kunna förenas utan informationsförlust måste du använda konventionerna från den invarianta kulturen, som erhålls via InvariantInfo-egenskapen, för att generera och tolka data. Formaterings- och parsningsåtgärderna bör aldrig återspegla standardkulturens konventioner. Om du använder standardinställningar för kultur är portabiliteten för data strikt begränsad. Det kan endast deserialiseras på en tråd vars kulturspecifika inställningar är identiska med de för tråden där den serialiserades. I vissa fall innebär det att data inte ens kan serialiseras och deserialiseras på samma system.

Om tidskomponenten för ett datum- och tidsvärde är betydande bör den också konverteras till UTC och serialiseras med standardformatsträngen "o" eller "r". Tidsdata kan sedan återställas genom att anropa en parsningsmetod och skicka lämplig formatsträng tillsammans med den invarianta kulturen som provider argument.

I följande exempel visas processen med att avrunda ett datum- och tidsvärde. Den serialiserar ett datum och en tid i ett system som observerar amerikansk Stillahavstid och vars nuvarande kultur är 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)

Den deserialiserar uppgifterna om ett system i tidszonen Bryssel, Köpenhamn, Madrid och Paris och vars nuvarande kultur är fr-FR. Det återställde datumet är nio timmar senare än det ursprungliga datumet, vilket återspeglar tidszonsjusteringen från åtta timmar efter UTC till en timme före UTC. Både det ursprungliga datumet och det återställda datumet representerar samma tidpunkt.

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
  • Last updated on