CultureInfo Klass

Definition

public ref class CultureInfo : IFormatProvider

public ref class CultureInfo : ICloneable, IFormatProvider

public class CultureInfo : IFormatProvider

public class CultureInfo : ICloneable, IFormatProvider

[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider

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

type CultureInfo = class
    interface IFormatProvider

type CultureInfo = class
    interface ICloneable
    interface IFormatProvider

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

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

Public Class CultureInfo
Implements IFormatProvider

Public Class CultureInfo
Implements ICloneable, IFormatProvider

Arv

Object

CultureInfo

Attribut

SerializableAttribute ComVisibleAttribute

Implementeringar

IFormatProvider ICloneable

Kommentarer

Klassen CultureInfo innehåller information som är associerad med en specifik kultur, till exempel språk, underspråk, land/region, kalender och konventioner. Den här klassen ger också åtkomst till kulturspecifika instanser av objekten DateTimeFormatInfo, NumberFormatInfo, CompareInfooch TextInfo . Dessa objekt innehåller den information som krävs för kulturspecifika åtgärder, till exempel hölje, formateringsdatum och tal och jämförelse av strängar. Klassen CultureInfo används antingen direkt eller indirekt av klasser som formaterar, parsar eller manipulerar kulturspecifika data, till exempel String, DateTime, DateTimeOffsetoch de numeriska typerna.

Kulturnamn och identifierare

Klassen CultureInfo anger ett unikt namn för varje kultur, baserat på RFC 4646. Namnet är en kombination av en ISO 639-kod med två bokstäver eller tre bokstäver som är associerad med ett språk och en ISO 3166-kod med två bokstäver med versaler som är associerad med ett land eller en region. För appar som körs under Windows 10 eller senare stöds dessutom kulturnamn som motsvarar giltiga BCP-47-språktaggar.

Formatet för kulturnamnet baserat på RFC 4646 är languagecode2-country/regioncode2, där languagecode2 är språkkoden med två bokstäver och country/regioncode2 är subkulturkoden med två bokstäver. Exempel är ja-JP japanska (Japan) och en-US engelska (USA). I de fall där en språkkod med två bokstäver inte är tillgänglig används en kod med tre bokstäver enligt definitionen i ISO 639-3.

Vissa kulturnamn anger också ett ISO 15924-skript. Cyrl anger till exempel det kyrilliska skriptet och Latn anger det latinska skriptet. Ett kulturnamn som innehåller ett skript använder mönstret languagecode2-scripttag-country/regioncode2. Ett exempel på den här typen av kulturnamn är uz-Cyrl-UZ för uzbekiska (kyrilliska, Uzbekistan). I Windows-operativsystem före Windows Vista använder ett kulturnamn som innehåller ett skript mönstret languagecode2-country/regioncode2-scripttag, till exempel uz-UZ-Cyrl för uzbekiska (kyrilliska, Uzbekistan).

En neutral kultur anges genom endast den tvåbokstaviga, gement skrivna språkkoden. Till exempel fr anger den neutrala kulturen för franska och de anger den neutrala kulturen för tyska.

En kulturidentifierare är en internationell standardförkortning och har de komponenter som krävs för att unikt identifiera en av de installerade kulturerna. Ditt program kan använda fördefinierade kulturidentifierare eller definiera anpassade identifierare.

Vissa fördefinierade kulturnamn och identifierare används av den här och andra klasser i System.Globalization namnområdet. Detaljerad kulturinformation för Windows-system finns i kolumnen Språktagg i listan över språk-/regionnamn som stöds av Windows. Kulturnamn följer standarden som definieras av BCP 47.

Kulturnamnen och identifierarna representerar endast en delmängd av kulturer som finns på en viss dator. Windows-versioner eller servicepaket kan ändra tillgängliga kulturer. Program kan lägga till anpassade kulturer med hjälp av CultureAndRegionInfoBuilder klassen. Användare kan lägga till egna anpassade kulturer med hjälp av verktyget Microsoft Locale Builder . Microsoft Locale Builder skrivs i hanterad kod med hjälp av CultureAndRegionInfoBuilder klassen .

Flera distinkta namn är nära associerade med en kultur, särskilt namnen som är associerade med följande klassmedlemmar:

• CultureInfo.ToString
• CultureInfo.Name
• CompareInfo.Name

Invarianta, neutrala och specifika kulturer

Kulturerna är vanligtvis grupperade i tre uppsättningar: invarianta kulturer, neutrala kulturer och specifika kulturer.

En kultur som är invariant är okänslig för kulturella influenser. Ditt program anger den invarianta kulturen efter namn med hjälp av en tom sträng ("") eller dess identifierare. InvariantCulture definierar en instans av den invarianta kulturen. Det är associerat med det engelska språket men inte med något land/region. Det används i nästan alla metoder i Globalization namnområdet som kräver en kultur.

En neutral kultur är en kultur som är associerad med ett språk men inte med ett land/en region. En specifik kultur är en kultur som är associerad med ett språk och ett land/en region. Till exempel fr är det neutrala namnet för den franska kulturen och fr-FR är namnet på den specifika franska kulturen (Frankrike). Observera att kinesiska (förenklad) och kinesiska (traditionell) också betraktas som neutrala kulturer.

Att skapa en instans av en CompareInfo klass för en neutral kultur rekommenderas inte eftersom de data som den innehåller är godtyckliga. Om du vill visa och sortera data anger du både språk och region. Dessutom Name returnerar egenskapen för ett CompareInfo objekt som skapats för en neutral kultur endast landet och inkluderar inte regionen.

De definierade kulturerna har en hierarki där föräldern till en viss kultur är en neutral kultur och föräldern till en neutral kultur är den invarianta kulturen. Egenskapen Parent innehåller den neutrala kultur som är associerad med en specifik kultur. Anpassade kulturer bör definiera egenskapen Parent i enlighet med det här mönstret.

Om resurserna för en specifik kultur inte är tillgängliga i operativsystemet används resurserna för den associerade neutrala kulturen. Om resurserna för den neutrala kulturen inte är tillgängliga används de resurser som är inbäddade i huvudsammansättningen. Mer information om reservprocessen för resurser finns i Paketera och distribuera resurser.

Listan över nationella inställningar i Windows API skiljer sig något från listan över kulturer som stöds av .NET. Om samverkan med Windows till exempel krävs via p/invoke-mekanismen bör programmet använda en specifik kultur som har definierats för operativsystemet. Användningen av den specifika kulturen säkerställer konsekvens med motsvarande Windows-språk, som identifieras med en språkidentifierare som är samma som LCID.

En DateTimeFormatInfo eller en NumberFormatInfo kan endast skapas för den invarianta kulturen eller för specifika kulturer, inte för neutrala kulturer.

Om DateTimeFormatInfo.Calendar är TaiwanCalendar men Thread.CurrentCulture är inte inställt på zh-TW, sedan DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraNameoch DateTimeFormatInfo.GetAbbreviatedEraName returnerar en tom sträng ("").

Anpassade kulturer

I Windows kan du skapa anpassade nationella inställningar. Mer information finns i Anpassade nationella inställningar.

CultureInfo och kulturella data

.NET härleder sina kulturella data från två olika källor, beroende på operativsystemet:

• På Unix-plattformar eller Windows 10 och senare versioner tillhandahålls kulturella data av International Components for Unicode (ICU) Library. Den specifika versionen av ICU-biblioteket beror på det enskilda operativsystemet.
• På Windows 8.1 och tidigare versioner tillhandahålls kulturella data av Windows operativsystem.

På grund av detta kanske en kultur som är tillgänglig på en viss .NET-implementering, plattform eller version inte är tillgänglig på en annan .NET-implementering, plattform eller version.

Vissa CultureInfo objekt skiljer sig åt beroende på den underliggande plattformen. I synnerhet zh-CN, eller kinesiska (förenklad, Kina) och zh-TW, eller kinesiska (traditionell, Taiwan), är tillgängliga kulturer på Windows-system, men de är aliaskulturer på Unix-system. "zh-CN" är ett alias för kulturen "zh-Hans-CN" och "zh-TW" är ett alias för kulturen "zh-Hant-TW". Aliaskulturer returneras inte av anrop till GetCultures metoden och kan ha olika egenskapsvärden, inklusive olika Parent kulturer, än deras Windows-motsvarigheter. För kulturerna zh-CN och zh-TW omfattar dessa skillnader följande:

• På Windows-system är den överordnade kulturen för "zh-CN" "zh-Hans", och den överordnade kulturen för "zh-TW" är "zh-Hant". Den överordnade kulturen i båda dessa kulturer är "zh". I Unix-system är föräldrarna till båda kulturer "zh". Det innebär att om du inte tillhandahåller kulturspecifika resurser för kulturkulturerna "zh-CN" eller "zh-TW", men tillhandahåller resurser för den neutrala "zh-Hans" eller "zh-Hant"-kulturen, kommer ditt program att läsa in resurserna för den neutrala kulturen i Windows men inte på Unix. På Unix-system måste du uttryckligen ange trådens CurrentUICulture till antingen "zh-Hans" eller "zh-Hant".

• På Windows-system, när man anropar CultureInfo.Equals på en instans som representerar "zh-CN"-kulturen och passerar en "zh-Hans-CN"-instans, returnerar den true. I Unix-system returnerar falsemetodanropet . Det här beteendet gäller även för att anropa Equals en "zh-TW" CultureInfo -instans och skicka den en "zh-Hant-Tw"-instans.

Dynamiska kulturdata

Förutom den invarianta kulturen är kulturdata dynamiska. Detta gäller även för de fördefinierade kulturerna. Länder eller regioner använder till exempel nya valutor, ändrar stavningen av ord eller ändrar önskad kalender och kulturdefinitioner ändras för att spåra detta. Anpassade kulturer kan ändras utan föregående meddelande, och en viss kultur kan åsidosättas av en anpassad ersättningskultur. Som beskrivs nedan kan en enskild användare åsidosätta kulturella inställningar. Applikationer ska alltid hämta kulturdata vid körning.

Den aktuella kulturen och den aktuella användargränssnittskulturen

Varje tråd i ett .NET-program har en aktuell kultur och en aktuell användargränssnittskultur. Den aktuella kulturen bestämmer formateringskonventionerna för datum, tider, tal och valutavärden, sorteringsordningen för text, höljekonventioner och hur strängar jämförs. Den aktuella användargränssnittskulturen används för att vid körningstid hämta kulturspecifika resurser.

Mer detaljerad information om den aktuella kulturen finns i egenskapen CultureInfo.CurrentCulture . Mer detaljerad information om den aktuella användargränssnittskulturen finns i egenskapsavsnittet CultureInfo.CurrentUICulture .

Hämta aktuella och aktuella användargränssnittskulturer

Du kan hämta ett CultureInfo objekt som representerar den aktuella kulturen på något av två sätt:

• Genom att hämta värdet för egenskapen CultureInfo.CurrentCulture.
• Genom att hämta värdet för egenskapen Thread.CurrentThread.CurrentCulture .

I följande exempel hämtas båda egenskapsvärdena, jämför dem för att visa att de är lika och visar namnet på den aktuella kulturen.

using System;
using System.Globalization;
using System.Threading;

public class CurrentCultureEx
{
    public static void Main()
    {
        CultureInfo culture1 = CultureInfo.CurrentCulture;
        CultureInfo culture2 = Thread.CurrentThread.CurrentCulture;
        Console.WriteLine($"The current culture is {culture1.Name}");
        Console.WriteLine($"The two CultureInfo objects are equal: {culture1 == culture2}");
    }
}
// The example displays output like the following:
//     The current culture is en-US
//     The two CultureInfo objects are equal: True

Du kan hämta ett CultureInfo objekt som representerar den aktuella användargränssnittskulturen på något av två sätt:

• Genom att hämta värdet för egenskapen CultureInfo.CurrentUICulture.

• Genom att hämta värdet för egenskapen Thread.CurrentThread.CurrentUICulture .

I följande exempel hämtas båda egenskapsvärdena, jämför dem för att visa att de är lika och visar namnet på den aktuella användargränssnittskulturen.

using System;
using System.Globalization;
using System.Threading;

public class CurrentUIEx
{
    public static void Main()
    {
        CultureInfo uiCulture1 = CultureInfo.CurrentUICulture;
        CultureInfo uiCulture2 = Thread.CurrentThread.CurrentUICulture;
        Console.WriteLine($"The current UI culture is {uiCulture1.Name}");
        Console.WriteLine($"The two CultureInfo objects are equal: {uiCulture1 == uiCulture2}");
    }
}
// The example displays output like the following:
//     The current UI culture is en-US
//     The two CultureInfo objects are equal: True

Ange aktuella och aktuella användargränssnittskulturer

Om du vill ändra kulturen och användargränssnittskulturen i en tråd gör du följande:

1. Instansiera ett CultureInfo objekt som representerar den kulturen genom att anropa en CultureInfo klasskonstruktor och skicka namnet på kulturen. Konstruktorn CultureInfo(String) instansierar ett CultureInfo objekt som återspeglar användarens åsidosättningar om den nya kulturen är densamma som den aktuella Windows-kulturen. Med CultureInfo(String, Boolean) konstruktorn kan du ange om det nyligen instansierade CultureInfo objektet återspeglar användarens åsidosättningar om den nya kulturen är densamma som den aktuella Windows-kulturen.

2. CultureInfo Tilldela objektet till CultureInfo.CurrentCulture egenskapen ellerCultureInfo.CurrentUICulture.

I följande exempel hämtas den aktuella kulturen. Om det är något annat än den franska kulturen (Frankrike) ändrar det den nuvarande kulturen till franska (Frankrike). Annars ändras den nuvarande kulturen till franska (Luxemburg).

using System;
using System.Globalization;

public class ChangeEx1
{
    public static void Main()
    {
        CultureInfo current = CultureInfo.CurrentCulture;
        Console.WriteLine("The current culture is {0}", current.Name);
        CultureInfo newCulture;
        if (current.Name.Equals("fr-FR"))
            newCulture = new CultureInfo("fr-LU");
        else
            newCulture = new CultureInfo("fr-FR");

        CultureInfo.CurrentCulture = newCulture;
        Console.WriteLine("The current culture is now {0}",
                          CultureInfo.CurrentCulture.Name);
    }
}
// The example displays output like the following:
//     The current culture is en-US
//     The current culture is now fr-FR

I följande exempel hämtas den aktuella kulturen. Om det är något annat den slovenska kulturen (Slovenien) ändrar den nuvarande kulturen till slovenska (Slovenien). Annars ändras den nuvarande kulturen till kroatiska (Kroatien).

using System;
using System.Globalization;

public class ChangeUICultureEx
{
    public static void Main()
    {
        CultureInfo current = CultureInfo.CurrentUICulture;
        Console.WriteLine($"The current UI culture is {current.Name}");
        CultureInfo newUICulture;
        if (current.Name.Equals("sl-SI"))
            newUICulture = new CultureInfo("hr-HR");
        else
            newUICulture = new CultureInfo("sl-SI");

        CultureInfo.CurrentUICulture = newUICulture;
        Console.WriteLine($"The current UI culture is now {CultureInfo.CurrentUICulture.Name}");
    }
}
// The example displays output like the following:
//     The current UI culture is en-US
//     The current UI culture is now sl-SI

Hämta alla kulturer

Du kan hämta en matris med specifika kategorier av kulturer eller alla kulturer som är tillgängliga på den lokala datorn genom att anropa GetCultures metoden. Du kan till exempel hämta anpassade kulturer, specifika kulturer eller neutrala kulturer antingen ensamma eller i kombination.

I följande exempel anropas GetCultures metoden två gånger, först med System.Globalization.CultureTypes uppräkningsmedlemmen för att hämta alla anpassade kulturer och sedan med System.Globalization.CultureTypes uppräkningsmedlemmen för att hämta alla ersättningskulturer.

using System;
using System.Globalization;

public class GetCulturesEx
{
    public static void Main()
    {
        // Get all custom cultures.
        CultureInfo[] custom = CultureInfo.GetCultures(CultureTypes.UserCustomCulture);
        if (custom.Length == 0)
        {
            Console.WriteLine("There are no user-defined custom cultures.");
        }
        else
        {
            Console.WriteLine("Custom cultures:");
            foreach (var culture in custom)
                Console.WriteLine($"   {culture.Name} -- {culture.DisplayName}");
        }
        Console.WriteLine();

        // Get all replacement cultures.
        CultureInfo[] replacements = CultureInfo.GetCultures(CultureTypes.ReplacementCultures);
        if (replacements.Length == 0)
        {
            Console.WriteLine("There are no replacement cultures.");
        }
        else
        {
            Console.WriteLine("Replacement cultures:");
            foreach (var culture in replacements)
                Console.WriteLine($"   {culture.Name} -- {culture.DisplayName}");
        }
        Console.WriteLine();
    }
}
// The example displays output like the following:
//     Custom cultures:
//        x-en-US-sample -- English (United States)
//        fj-FJ -- Boumaa Fijian (Viti)
//
//     There are no replacement cultures.

Kultur och trådar

När en ny programtråd startas definieras dess aktuella kultur och aktuella användargränssnittskultur av den aktuella systemkulturen och inte av den aktuella trådkulturen. I följande exempel visas skillnaden. Den ställer in den nuvarande kulturen och den nuvarande UI-kulturen för en applikationstråd till den franska (Frankrike) kulturen (fr-FR). Om den aktuella kulturen redan är fr-FR, ändrar exemplet den till engelska kulturen (USA) (en-US). Den visar tre slumpmässiga tal som valutavärden och skapar sedan en ny tråd, som i sin tur visar ytterligare tre slumpmässiga tal som valutavärden. Men som utdata från exemplet visar återspeglar valutavärdena som visas av den nya tråden inte formateringskonventionerna för den franska kulturen (Frankrike), till skillnad från utdata från huvudprogramtråden.

using System;
using System.Globalization;
using System.Threading;

public class DefaultThreadEx
{
    static Random rnd = new Random();

    public static void Main()
    {
        if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR")
        {
            // If current culture is not fr-FR, set culture to fr-FR.
            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
            Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
        }
        else
        {
            // Set culture to en-US.
            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
            Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
        }
        ThreadProc();

        Thread worker = new Thread(ThreadProc);
        worker.Name = "WorkerThread";
        worker.Start();
    }

    private static void DisplayThreadInfo()
    {
        Console.WriteLine($"\nCurrent Thread Name: '{Thread.CurrentThread.Name}'");
        Console.WriteLine($"Current Thread Culture/UI Culture: {Thread.CurrentThread.CurrentCulture.Name}/{Thread.CurrentThread.CurrentUICulture.Name}");
    }

    private static void DisplayValues()
    {
        // Create new thread and display three random numbers.
        Console.WriteLine("Some currency values:");
        for (int ctr = 0; ctr <= 3; ctr++)
            Console.WriteLine($"   {rnd.NextDouble() * 10:C2}");
    }

    private static void ThreadProc()
    {
        DisplayThreadInfo();
        DisplayValues();
    }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          8,11 €
//          1,48 €
//          8,99 €
//          9,04 €
//
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: en-US/en-US
//       Some currency values:
//          $6.72
//          $6.35
//          $2.90
//          $7.72

Du kan ange kulturen och UI-kulturen för alla trådar i en programdomän genom att tilldela ett CultureInfo objekt som representerar den DefaultThreadCurrentCulture kulturen till egenskaperna och DefaultThreadCurrentUICulture . I följande exempel används dessa egenskaper för att säkerställa att alla trådar i standardprogramdomänen delar samma kultur.

using System;
using System.Globalization;
using System.Threading;

public class SetThreadsEx
{
    static Random rnd = new Random();

    public static void Main()
    {
        if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR")
        {
            // If current culture is not fr-FR, set culture to fr-FR.
            CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
            CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
        }
        else
        {
            // Set culture to en-US.
            CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
            CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
        }
        ThreadProc();

        Thread worker = new Thread(SetThreadsEx.ThreadProc);
        worker.Name = "WorkerThread";
        worker.Start();
    }

    private static void DisplayThreadInfo()
    {
        Console.WriteLine($"\nCurrent Thread Name: '{Thread.CurrentThread.Name}'");
        Console.WriteLine($"Current Thread Culture/UI Culture: {Thread.CurrentThread.CurrentCulture.Name}/{Thread.CurrentThread.CurrentUICulture.Name}");
    }

    private static void DisplayValues()
    {
        // Create new thread and display three random numbers.
        Console.WriteLine("Some currency values:");
        for (int ctr = 0; ctr <= 3; ctr++)
            Console.WriteLine($"   {rnd.NextDouble() * 10:C2}");
    }

    private static void ThreadProc()
    {
        DisplayThreadInfo();
        DisplayValues();
    }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          6,83 €
//          3,47 €
//          6,07 €
//          1,70 €
//
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          9,54 €
//          9,50 €
//          0,58 €
//          6,91 €

När du tilldelar värden till DefaultThreadCurrentCulture egenskaperna och DefaultThreadCurrentUICulture ändras även kulturen och användargränssnittskulturen för trådarna i programdomänen om de inte uttryckligen har tilldelats en kultur. De här trådarna återspeglar dock bara de nya kulturinställningarna när de körs i den aktuella programdomänen. Om dessa trådar körs i en annan programdomän blir deras kultur den standardkultur som definierats för programdomänen. Därför rekommenderar vi att du alltid ställer in kulturen i huvudprogramtråden och inte förlitar dig på DefaultThreadCurrentCulture egenskaperna och DefaultThreadCurrentUICulture för att ändra den.

Kultur- och aktivitetsbaserade asynkrona åtgärder

Det aktivitetsbaserade asynkrona programmeringsmönstret använder Task och Task<TResult> objekt för att asynkront köra delegater på trådar i trådpoolen. Den specifika tråd som en viss aktivitet körs på är inte känd i förväg, men bestäms endast vid körning.

Kultur är en del av en asynkron åtgärds kontext. Med andra ord ärver asynkrona åtgärder som standard värdena av egenskaperna CurrentCulture och CurrentUICulture från den tråd som de startas från. Om den aktuella kulturen eller den aktuella användargränssnittskulturen skiljer sig från systemkulturen korsar den aktuella kulturen trådgränserna och blir den aktuella kulturen i trådpoolstråden som kör en asynkron åtgärd.

I följande exempel visas en enkel bild. I exemplet definieras ett Func<TResult> ombud, formatDelegate, som returnerar vissa tal som är formaterade som valutavärden. Exemplet ändrar den nuvarande systemkulturen till antingen Franska (Frankrike), eller om franska (Frankrike) redan är den nuvarande kulturen, till Engelska (USA). Då:

• Anropar ombudet direkt så att det körs synkront på huvudtråden i appen.
• Skapar en uppgift som kör delegaten asynkront i en tråd i trådpoolen.
• Skapar en uppgift som kör delegaten synkront på huvudapptråden genom att anropa metoden Task.RunSynchronously.

Som utdata från exemplet visar, när den aktuella kulturen ändras till franska (Frankrike), blir den aktuella kulturen i tråden från vilken uppgifter anropas asynkront den aktuella kulturen för den asynkrona åtgärden.

using System;
using System.Globalization;
using System.Threading;
using System.Threading.Tasks;

public class AsyncCultureEx1
{
    public static void Main()
    {
        decimal[] values = { 163025412.32m, 18905365.59m };
        string formatString = "C2";

        string FormatDelegate()
        {
            string output = $"Formatting using the {CultureInfo.CurrentCulture.Name} " +
                $"culture on thread {Thread.CurrentThread.ManagedThreadId}.\n";
            foreach (decimal value in values)
                output += $"{value.ToString(formatString)}   ";

            output += Environment.NewLine;
            return output;
        }

        Console.WriteLine($"The example is running on thread {Thread.CurrentThread.ManagedThreadId}");
        // Make the current culture different from the system culture.
        Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}");
        if (CultureInfo.CurrentCulture.Name == "fr-FR")
            Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
        else
            Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

        Console.WriteLine($"Changed the current culture to {CultureInfo.CurrentCulture.Name}.\n");

        // Execute the delegate synchronously.
        Console.WriteLine("Executing the delegate synchronously:");
        Console.WriteLine(FormatDelegate());

        // Call an async delegate to format the values using one format string.
        Console.WriteLine("Executing a task asynchronously:");
        var t1 = Task.Run(FormatDelegate);
        Console.WriteLine(t1.Result);

        Console.WriteLine("Executing a task synchronously:");
        var t2 = new Task<string>(FormatDelegate);
        t2.RunSynchronously();
        Console.WriteLine(t2.Result);
    }
}
// The example displays the following output:
//         The example is running on thread 1
//         The current culture is en-US
//         Changed the current culture to fr-FR.
//
//         Executing the delegate synchronously:
//         Formatting using the fr-FR culture on thread 1.
//         163 025 412,32 €   18 905 365,59 €
//
//         Executing a task asynchronously:
//         Formatting using the fr-FR culture on thread 3.
//         163 025 412,32 €   18 905 365,59 €
//
//         Executing a task synchronously:
//         Formatting using the fr-FR culture on thread 1.
//         163 025 412,32 €   18 905 365,59 €

CultureInfo-objektserialisering

När ett CultureInfo-objekt serialiseras lagras faktiskt bara Name och UseUserOverride. Det deserialiseras endast i en miljö där Name har samma betydelse. Följande tre exempel visar varför detta inte alltid är fallet:

• Om egenskapsvärdet CultureTypes är CultureTypes.InstalledWin32Cultures, och om den kulturen först introducerades i en viss version av Windows-operativsystemet, går det inte att deserialisera den på en tidigare version av Windows. Om en kultur till exempel introducerades i Windows 10 kan den inte deserialiseras i Windows 8.

• CultureTypes Om värdet är CultureTypes.UserCustomCulture, och den dator där det deserialiseras inte har den här användaranpassade kulturen installerad, går det inte att deserialisera det.

• CultureTypes Om värdet är CultureTypes.ReplacementCultures, och den dator där det deserialiseras inte har den här ersättningskulturen, deserialiseras det till samma namn, men inte med alla samma egenskaper. Om till exempel en-US är en ersättningskultur på dator A, men inte på dator B, och om ett CultureInfo objekt som refererar till den här kulturen serialiseras på dator A och deserialiseras på dator B, överförs ingen av kulturens anpassade egenskaper. Kulturen deserialiserar framgångsrikt, men med en förändrad betydelse.

Kontrollpanelen åsidosättningar

Användaren kan välja att åsidosätta några av de värden som är associerade med den aktuella kulturen i Windows via den regionala delen och språkalternativen i Kontrollpanelen. Användaren kan till exempel välja att visa datumet i ett annat format eller använda en annan valuta än standardvärdet för kulturen. I allmänhet bör dina applikationer respektera dessa användarinställningar.

Om UseUserOverride är true och den angivna kulturen matchar den aktuella kulturen i Windows, CultureInfo använder dessa åsidosättningar, inklusive användarinställningar för egenskaperna för den DateTimeFormatInfo instans som returneras av DateTimeFormat egenskapen och egenskaperna för den NumberFormatInfo instans som returneras av NumberFormat egenskapen. Om användarinställningarna inte är kompatibla med kulturen som är associerad med CultureInfo, till exempel om den valda kalendern inte är en av OptionalCalendarsmetoderna , är resultatet av metoderna och värdena för egenskaperna odefinierat.

Alternativa sorteringsordningar

Vissa kulturer stöder mer än en sorteringsordning. Ett exempel:

• Den spanska kulturen (Spanien) har två sorteringsordningar: standardordningen för internationell sortering och den traditionella sorteringsordningen. När du instansierar ett CultureInfo objekt med es-ES kulturnamnet används den internationella sorteringsordningen. När du instansierar ett CultureInfo objekt med es-ES-tradnl kulturnamnet används den traditionella sorteringsordningen.
• Kulturen zh-CN (förenklad kinesiska, Kina) stöder två sorteringsordningar: efter uttal (standard) och efter antal streck. När du instansierar ett CultureInfo objekt med zh-CN kulturnamnet används standardsorteringsordningen. När du instansierar ett CultureInfo objekt med en lokal identifierare för 0x00020804 sorteras strängar efter antal linjer.

I följande tabell visas de kulturer som stöder alternativa sorteringsordningar och identifierarna för standardordningarna och alternativa sorteringsordningar.

Kulturnamn	Kultur	Standardsorteringsnamn och identifierare	Alternativt sorteringsnamn och identifierare
es-ES	Spanska (Spanien)	Internationell: 0x00000C0A	Traditionell: 0x0000040A
zh-TW	Kinesiska (Taiwan)	Antal linjer: 0x00000404	Bopomofo: 0x00030404
zh-CN	Kinesiska (Folkrepubliken Kina)	Uttal: 0x00000804	Antal slag: 0x00020804
zh-HK	Kinesiska (Hong Kongs särskilda administrativa region)	Antal streck: 0x00000c04	Antal slag: 0x00020c04
zh-SG	Kinesiska (Singapore)	Uttal: 0x00001004	Antal streck: 0x00021004
zh-MO	Kina (Macao SAR)	Uttal: 0x00001404	Antal slag: 0x00021404
ja-JP	Japanska (Japan)	Standard: 0x00000411	Unicode: 0x00010411
ko-KR	koreanska (Korea)	Standardvärde: 0x00000412	Koreanska Xwansung – Unicode: 0x00010412
de-DE	Tyska (Tyskland)	Ordlista: 0x00000407	Sortera telefonbok DIN: 0x00010407
hu-HU	Ungerska (Ungern)	Standard: 0x0000040e	Teknisk sortering: 0x0001040e
ka-GE	Georgiska (Georgien)	Traditionell: 0x00000437	Modern sortering: 0x00010437

Example

I följande exempel visas hur du skapar ett CultureInfo objekt för spanska (Spanien) med den internationella sorteringen och ett annat CultureInfo objekt med den traditionella sorteringen.

using System;
using System.Globalization;

public class SamplesCultureInfo
{
    public static void Main()
    {
        // Creates and initializes the CultureInfo which uses the international sort.
        CultureInfo myCIintl = new CultureInfo("es-ES", false);

        // Creates and initializes the CultureInfo which uses the traditional sort.
        CultureInfo myCItrad = new CultureInfo(0x040A, false);

        // Displays the properties of each culture.
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "PROPERTY", "INTERNATIONAL", "TRADITIONAL");
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "CompareInfo", myCIintl.CompareInfo, myCItrad.CompareInfo);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "DisplayName", myCIintl.DisplayName, myCItrad.DisplayName);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "EnglishName", myCIintl.EnglishName, myCItrad.EnglishName);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsNeutralCulture", myCIintl.IsNeutralCulture, myCItrad.IsNeutralCulture);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsReadOnly", myCIintl.IsReadOnly, myCItrad.IsReadOnly);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "LCID", myCIintl.LCID, myCItrad.LCID);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Name", myCIintl.Name, myCItrad.Name);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "NativeName", myCIintl.NativeName, myCItrad.NativeName);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Parent", myCIintl.Parent, myCItrad.Parent);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TextInfo", myCIintl.TextInfo, myCItrad.TextInfo);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterISOLanguageName", myCIintl.ThreeLetterISOLanguageName, myCItrad.ThreeLetterISOLanguageName);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterWindowsLanguageName", myCIintl.ThreeLetterWindowsLanguageName, myCItrad.ThreeLetterWindowsLanguageName);
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TwoLetterISOLanguageName", myCIintl.TwoLetterISOLanguageName, myCItrad.TwoLetterISOLanguageName);
        Console.WriteLine();

        // Compare two strings using myCIintl.
        Console.WriteLine("Comparing \"llegar\" and \"lugar\"");
        Console.WriteLine("   With myCIintl.CompareInfo.Compare: {0}", myCIintl.CompareInfo.Compare("llegar", "lugar"));
        Console.WriteLine("   With myCItrad.CompareInfo.Compare: {0}", myCItrad.CompareInfo.Compare("llegar", "lugar"));
    }
}

/*
This code produces the following output.

PROPERTY                       INTERNATIONAL                                  TRADITIONAL
CompareInfo                    CompareInfo - es-ES                            CompareInfo - es-ES_tradnl
DisplayName                    Spanish (Spain)                                Spanish (Spain)
EnglishName                    Spanish (Spain, International Sort)            Spanish (Spain, Traditional Sort)
IsNeutralCulture               False                                          False
IsReadOnly                     False                                          False
LCID                           3082                                           1034
Name                           es-ES                                          es-ES
NativeName                     Español (España, alfabetización internacional) Español (España, alfabetización tradicional)
Parent                         es                                             es
TextInfo                       TextInfo - es-ES                               TextInfo - es-ES_tradnl
ThreeLetterISOLanguageName     spa                                            spa
ThreeLetterWindowsLanguageName ESN                                            ESP
TwoLetterISOLanguageName       es                                             es

Comparing "llegar" and "lugar"
   With myCIintl.CompareInfo.Compare: -1
   With myCItrad.CompareInfo.Compare: 1

*/

Imports System.Collections
Imports System.Globalization

Module Module1

    Public Sub Main()

        ' Creates and initializes the CultureInfo which uses the international sort.
        Dim myCIintl As New CultureInfo("es-ES", False)

        ' Creates and initializes the CultureInfo which uses the traditional sort.
        Dim myCItrad As New CultureInfo(&H40A, False)

        ' Displays the properties of each culture.
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "PROPERTY", "INTERNATIONAL", "TRADITIONAL")
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "CompareInfo", myCIintl.CompareInfo, myCItrad.CompareInfo)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "DisplayName", myCIintl.DisplayName, myCItrad.DisplayName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "EnglishName", myCIintl.EnglishName, myCItrad.EnglishName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsNeutralCulture", myCIintl.IsNeutralCulture, myCItrad.IsNeutralCulture)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsReadOnly", myCIintl.IsReadOnly, myCItrad.IsReadOnly)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "LCID", myCIintl.LCID, myCItrad.LCID)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Name", myCIintl.Name, myCItrad.Name)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "NativeName", myCIintl.NativeName, myCItrad.NativeName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Parent", myCIintl.Parent, myCItrad.Parent)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TextInfo", myCIintl.TextInfo, myCItrad.TextInfo)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterISOLanguageName", myCIintl.ThreeLetterISOLanguageName, myCItrad.ThreeLetterISOLanguageName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterWindowsLanguageName", myCIintl.ThreeLetterWindowsLanguageName, myCItrad.ThreeLetterWindowsLanguageName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TwoLetterISOLanguageName", myCIintl.TwoLetterISOLanguageName, myCItrad.TwoLetterISOLanguageName)
        Console.WriteLine()

        ' Compare two strings using myCIintl.
        Console.WriteLine("Comparing ""llegar"" and ""lugar""")
        Console.WriteLine("   With myCIintl.CompareInfo.Compare: {0}", myCIintl.CompareInfo.Compare("llegar", "lugar"))
        Console.WriteLine("   With myCItrad.CompareInfo.Compare: {0}", myCItrad.CompareInfo.Compare("llegar", "lugar"))

    End Sub



'This code produces the following output.
'
'PROPERTY                       INTERNATIONAL                                  TRADITIONAL              
'CompareInfo                    CompareInfo - es-ES                            CompareInfo - es-ES_tradnl
'DisplayName                    Spanish (Spain)                                Spanish (Spain)          
'EnglishName                    Spanish (Spain, International Sort)            Spanish (Spain, Traditional Sort)
'IsNeutralCulture               False                                          False                    
'IsReadOnly                     False                                          False                    
'LCID                           3082                                           1034                     
'Name                           es-ES                                          es-ES                    
'NativeName                     Español (España, alfabetización internacional) Español (España, alfabetización tradicional)
'Parent                         es                                             es                       
'TextInfo                       TextInfo - es-ES                               TextInfo - es-ES_tradnl  
'ThreeLetterISOLanguageName     spa                                            spa                      
'ThreeLetterWindowsLanguageName ESN                                            ESP                      
'TwoLetterISOLanguageName       es                                             es                       
'
'Comparing "llegar" and "lugar"
'   With myCIintl.CompareInfo.Compare: -1
'   With myCItrad.CompareInfo.Compare: 1

End Module

Se även

• CultureAndRegionInfoBuilder
• RegionInfo