Delen via

CultureInfo klas

In dit artikel vindt u aanvullende opmerkingen in de referentiedocumentatie voor deze API.

De CultureInfo klasse biedt cultuurspecifieke informatie, zoals de taal, subtaal, land/regio, agenda en conventies die aan een bepaalde cultuur zijn gekoppeld. Deze klasse biedt ook toegang tot cultuurspecifieke exemplaren van de DateTimeFormatInfo, NumberFormatInfoen CompareInfoTextInfo objecten. Deze objecten bevatten de informatie die nodig is voor cultuurspecifieke bewerkingen, zoals het wijzigen van hoofd- en kleine letters, het opmaken van datums en getallen, en het vergelijken van tekenreeksen. De CultureInfo klasse wordt direct of indirect gebruikt door klassen die cultuurspecifieke gegevens opmaken, parseren of manipuleren, zoals String, DateTime, DateTimeOffseten de numerieke typen.

Cultuurnamen en identificaties.

De CultureInfo klasse geeft een unieke naam op voor elke cultuur, op basis van RFC 4646. De naam is een combinatie van een ISO 639-cultuurcode met twee letters of drie letters die is gekoppeld aan een taal en een ISO 3166-subcultuurcode met twee letters die is gekoppeld aan een land of regio. Daarnaast worden cultuurnamen die overeenkomen met geldige BCP-47-taaltags ondersteund voor apps die worden uitgevoerd onder Windows 10 of hoger.

Notitie

Wanneer een cultuurnaam wordt doorgegeven aan een klasseconstructor of een methode zoals CreateSpecificCulture of CultureInfo, is de case niet significant.

De notatie voor de cultuurnaam op basis van RFC 4646 is languagecode2-country/regioncode2, waar languagecode2 de tweeletterige taalcode is en country/regioncode2 de subcultuurcode van twee letters is. Voorbeelden zijn onder andere ja-JP voor Japans (Japan) en en-US voor Engels (Verenigde Staten). In gevallen waarin er geen tweeletterige taalcode beschikbaar is, wordt een code van drie letters gebruikt, zoals gedefinieerd in ISO 639-3.

Sommige cultuurnamen geven ook een ISO 15924-script op. Cyrl geeft bijvoorbeeld het Cyrillische script op en Latn specificeert het Latijnse script. Een cultuurnaam die een script bevat, maakt gebruik van het patroonlanguagecode2-scripttag-country/regioncode2. Een voorbeeld van dit type cultuurnaam is uz-Cyrl-UZ voor Oezbeeks (Cyrillisch, Oezbekistan). Op Windows-besturingssystemen vóór Windows Vista wordt, bij een cultuurnaam die een script bevat, het patroon languagecode2-country/regioncode2-scripttag gebruikt, bijvoorbeeld uz-UZ-Cyrl voor Oezbeeks (Cyrillisch, Oezbekistan).

Een neutrale cultuur wordt alleen opgegeven door de tweeletterige, kleine taalcode. Hiermee geeft u bijvoorbeeld fr de neutrale cultuur voor Frans op en de geeft u de neutrale cultuur voor Duits aan.

Notitie

Er zijn twee cultuurnamen die deze regel tegenspreken. De culturen Chinees (vereenvoudigd), benoemd zh-Hansen Chinees (traditioneel), zijn zh-Hantneutrale culturen. De cultuurnamen vertegenwoordigen de huidige standaard en moeten worden gebruikt, tenzij u een reden hebt voor het gebruik van de oudere namen zh-CHS en zh-CHT.

Een cultuur-id is een standaard internationale numerieke afkorting en heeft de onderdelen die nodig zijn om een van de geïnstalleerde culturen uniek te identificeren. Uw toepassing kan vooraf gedefinieerde cultuur-id's gebruiken of aangepaste id's definiëren.

Bepaalde vooraf gedefinieerde cultuurnamen en -id's worden door deze en andere klassen in de System.Globalization naamruimte gebruikt. Zie de kolom Taaltag in de lijst met taal-/regionamen die door Windows worden ondersteund voor gedetailleerde cultuurinformatie voor Windows-systemen. Cultuurnamen volgen de standaard die is gedefinieerd door BCP 47.

De cultuurnamen en -id's vertegenwoordigen slechts een subset van culturen die op een bepaalde computer te vinden zijn. Windows-versies of servicepacks kunnen de beschikbare culturen wijzigen. Toepassingen kunnen aangepaste culturen toevoegen met behulp van de CultureAndRegionInfoBuilder klasse. Gebruikers kunnen hun eigen aangepaste culturen toevoegen met het hulpprogramma Microsoft Locale Builder . Microsoft Locale Builder wordt geschreven in beheerde code met behulp van de CultureAndRegionInfoBuilder klasse.

Verschillende afzonderlijke namen zijn nauw gekoppeld aan een cultuur, met name de namen die aan de volgende klasseleden zijn gekoppeld:

Invariant, neutraal en specifieke culturen

De culturen worden over het algemeen gegroepeerd in drie sets: invariante culturen, neutrale culturen en specifieke culturen.

Een invariante cultuur is cultuurongevoelig. Uw toepassing specificeert de invariante cultuur op naam met behulp van een lege tekenreeks ("") of met de bijbehorende id. InvariantCulture definieert een exemplaar van de invariante cultuur. Het is gekoppeld aan de Engelse taal, maar niet met een land/regio. Het wordt gebruikt in vrijwel elke methode in de Globalization naamruimte waarvoor een cultuur is vereist.

Een neutrale cultuur is een cultuur die is gekoppeld aan een taal, maar niet aan een land/regio. Een specifieke cultuur is een cultuur die is gekoppeld aan een taal en een land/regio. Is bijvoorbeeld fr de neutrale naam voor de Franse cultuur en fr-FR is de naam van de specifieke Franse cultuur (Frankrijk). Houd er rekening mee dat Chinees (vereenvoudigd) en Chinees (traditioneel) ook als neutrale culturen worden beschouwd.

Het maken van een instantie van een CompareInfo klasse voor een neutrale cultuur wordt niet aanbevolen omdat de gegevens die deze bevat willekeurig zijn. Als u gegevens wilt weergeven en sorteren, geeft u zowel de taal als de regio op. Bovendien retourneert de Name eigenschap van een CompareInfo object dat is gemaakt voor een neutrale cultuur alleen het land en bevat deze niet de regio.

De gedefinieerde culturen hebben een hiërarchie waarin de ouder van een specifieke cultuur een neutrale cultuur is en de ouder van een neutrale cultuur de invariante cultuur is. De Parent eigenschap bevat de neutrale cultuur die is gekoppeld aan een specifieke cultuur. Aangepaste culturen moeten de Parent eigenschap definiëren in overeenstemming met dit patroon.

Als de resources voor een specifieke cultuur niet beschikbaar zijn in het besturingssysteem, worden de resources voor de bijbehorende neutrale cultuur gebruikt. Als de resources voor de neutrale cultuur niet beschikbaar zijn, worden de resources die zijn ingesloten in de hoofdsamenstelling gebruikt. Raadpleeg Resources verpakken en implementeren voor meer informatie over het terugvalproces van resources.

De lijst met landinstellingen in de Windows-API wijkt enigszins af van de lijst met culturen die worden ondersteund door .NET. Als interoperabiliteit met Windows vereist is, bijvoorbeeld via het mechanisme p/invoke, moet de toepassing een specifieke cultuur gebruiken die is gedefinieerd voor het besturingssysteem. Het gebruik van de specifieke cultuur zorgt voor consistentie met de equivalente Landinstelling van Windows, die wordt geïdentificeerd met een landinstellingen-id die hetzelfde is als LCID.

A DateTimeFormatInfo of a NumberFormatInfo kan alleen worden gecreëerd voor de invariante cultuur of voor specifieke culturen, niet voor neutrale culturen.

Als DateTimeFormatInfo.Calendar de TaiwanCalendar is maar Thread.CurrentCulture niet is ingesteld op zh-TW, dan retourneren DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraName, en DateTimeFormatInfo.GetAbbreviatedEraName een lege tekenreeks ("").

Aangepaste culturen

In Windows kunt u aangepaste landinstellingen maken. Zie Aangepaste landinstellingen voor meer informatie.

CultureInfo en culturele gegevens

.NET leidt de culturele gegevens af van een van een van de verschillende bronnen, afhankelijk van de implementatie, het platform en de versie:

  • In alle versies van .NET (Core) die worden uitgevoerd op Unix-platforms of Windows 10- en latere versies, worden culturele gegevens geleverd door de International Components for Unicode (ICU)-bibliotheek. De specifieke versie van de ICU-bibliotheek is afhankelijk van het afzonderlijke besturingssysteem.
  • In alle versies van .NET (Core) die worden uitgevoerd in Windows 9 en eerdere versies, worden culturele gegevens geleverd door het Windows-besturingssysteem.
  • In .NET Framework 4 en latere versies worden culturele gegevens geleverd door het Windows-besturingssysteem.

Daarom is een cultuur die beschikbaar is op een bepaalde .NET-implementatie, -platform of -versie mogelijk niet beschikbaar op een andere .NET-implementatie, -platform of -versie.

Sommige CultureInfo objecten verschillen, afhankelijk van het onderliggende platform. In het bijzonder zijn zh-CN, of Chinees (vereenvoudigd, China) en zh-TW, of Chinees (traditioneel, Taiwan), beschikbare culturen op Windows-systemen, maar ze zijn alias culturen op Unix-systemen. "zh-CN" is een alias voor de cultuur "zh-Hans-CN" en "zh-TW" is een alias voor de "zh-Hant-TW"-cultuur. Aliassen van culturen worden niet geretourneerd door aanroepen naar de GetCultures methode en kunnen verschillende eigenschapswaarden hebben, inclusief verschillende Parent culturen, dan hun Windows-tegenhangers. Voor de zh-CN en zh-TW culturen zijn de volgende verschillen:

  • Op Windows-systemen is de bovenliggende cultuur van de "zh-CN" cultuur "zh-Hans", en de bovenliggende cultuur van de "zh-TW" cultuur is "zh-Hant". De oorspronkelijke cultuur van beide culturen is "zh". Op Unix-systemen zijn de ouders van beide culturen 'zh'. Dit betekent dat als u geen cultuurspecifieke resources levert voor de culturen 'zh-CN' of 'zh-TW', maar wel een resource biedt voor de neutrale 'zh-Hans' of 'zh-Hant'-cultuur, laadt uw toepassing de resources voor de neutrale cultuur in Windows, maar niet op Unix. Op Unix-systemen moet u de thread CurrentUICulture expliciet instellen op 'zh-Hans' of 'zh-Hant'.

  • Op Windows-systemen, wanneer CultureInfo.Equals wordt aangeroepen op een instantie die de 'zh-CN' cultuur vertegenwoordigt en deze een 'zh-Hans-CN'-instantie krijgt, retourneert het true. Op Unix-systemen retourneert false de methode-aanroep. Dit gedrag geldt ook voor het aanroepen van een "zh-TW" Equals-exemplaar en het doorgeven van een "zh-Hant-Tw"-exemplaar.

Dynamische cultuurgegevens

Met uitzondering van de invariante cultuur zijn cultuurgegevens dynamisch. Dit geldt zelfs voor de vooraf gedefinieerde culturen. Landen of regio's gebruiken bijvoorbeeld nieuwe valuta's, wijzigen hun spelling van woorden of wijzigen hun voorkeurskalender en cultuurdefinities veranderen om dit bij te houden. Aangepaste culturen kunnen zonder kennisgeving worden gewijzigd en elke specifieke cultuur kan worden overschreven door een aangepaste vervangingscultuur. Zoals hieronder besproken, kan een individuele gebruiker culturele voorkeuren overschrijven. Toepassingen moeten altijd cultuurgegevens verkrijgen tijdens runtime.

Let op

Wanneer u gegevens opslaat, moet uw toepassing de invariante cultuur, een binaire indeling of een specifieke cultuuronafhankelijke indeling gebruiken. Gegevens die zijn opgeslagen op basis van de huidige waarden die zijn gekoppeld aan een bepaalde cultuur, behalve de invariante cultuur, kunnen onleesbaar worden of kunnen veranderen als die cultuur verandert.

De huidige cultuur en huidige UI-cultuur

Elke thread in een .NET-toepassing heeft een huidige cultuur en een huidige UI-cultuur. De huidige cultuur bepaalt de opmaakconventies voor datums, tijden, getallen en valutawaarden, de sorteervolgorde van tekst, hoofdletterconventies en de manieren waarop tekenreeksen worden vergeleken. De huidige UI-cultuur wordt gebruikt voor het ophalen van cultuurspecifieke resources tijdens runtime.

Notitie

Zie de sectie Cultuur en threads voor informatie over hoe de huidige en huidige UI-cultuur per thread wordt bepaald. Zie de sectie Cultuur en toepassingsdomeinen voor informatie over hoe de huidige en huidige UI-cultuur wordt bepaald op threads die worden uitgevoerd in een nieuw toepassingsdomein en op threads die grenzen aan toepassingsdomeinen overschrijden. Zie de sectie Cultuur en op taken gebaseerde asynchrone bewerkingen voor informatie over hoe de huidige en huidige UI-cultuur wordt bepaald op threads die asynchrone bewerkingen uitvoeren op basis van taken.

Zie de CultureInfo.CurrentCulture accommodatie voor meer gedetailleerde informatie over de huidige cultuur. Zie het CultureInfo.CurrentUICulture onderwerp over eigenschappen voor meer informatie over de huidige UI-cultuur.

De huidige en huidige UI-culturen ophalen

U kunt een CultureInfo object ophalen dat de huidige cultuur op twee manieren vertegenwoordigt:

In het volgende voorbeeld worden beide eigenschapswaarden opgehaald, worden ze vergeleken om aan te geven dat ze gelijk zijn en worden de naam van de huidige cultuur weergegeven.

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

U kunt op twee manieren een CultureInfo object ophalen dat de huidige UI-cultuur vertegenwoordigt:

In het volgende voorbeeld worden beide eigenschapswaarden opgehaald, worden ze vergeleken om aan te geven dat ze gelijk zijn en worden de naam van de huidige UI-cultuur weergegeven.

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

De huidige en huidige UI-culturen instellen

Ga als volgt te werk om de cultuur en ui-cultuur van een thread te wijzigen:

  1. Instantieer een CultureInfo object dat de betreffende cultuur vertegenwoordigt door een CultureInfo klasseconstructeur aan te roepen en de naam van de cultuur door te geven aan. De CultureInfo(String) constructor instantieert een CultureInfo object dat gebruikersoverschrijvingen weerspiegelt als de nieuwe cultuur dezelfde is als de huidige Windows-cultuur. Met de CultureInfo(String, Boolean)-constructor kunt u aangeven of het nieuw aangemaakte CultureInfo-object de gebruikersinstellingen weerspiegelt, als de nieuwe cultuur dezelfde is als de huidige Windows-cultuur.

  2. Wijs het CultureInfo object toe aan de CultureInfo.CurrentCulture of CultureInfo.CurrentUICulture eigenschap op .NET Core en .NET Framework 4.6 en latere versies.

In het volgende voorbeeld wordt de huidige cultuur opgehaald. Als het iets anders is dan de Franse cultuur (Frankrijk), wordt de huidige cultuur veranderd naar Frans (Frankrijk). Anders verandert de huidige cultuur in Frans (Luxemburg).

using System;
using System.Globalization;

public class ChangeEx1
{
    public static void Main()
    {
        CultureInfo current = CultureInfo.CurrentCulture;
        Console.WriteLine($"The current culture is {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 {CultureInfo.CurrentCulture.Name}");
    }
}
// The example displays output like the following:
//     The current culture is en-US
//     The current culture is now fr-FR

In het volgende voorbeeld wordt de huidige cultuur opgehaald. Als het iets anders is dan de Sloveense cultuur, verandert het de huidige cultuur naar Sloveens (Slovenië). Anders verandert de huidige taalinstelling naar Kroatisch (Kroatië).

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

Alle culturen ophalen

U kunt een matrix ophalen van specifieke categorieën culturen of van alle culturen die beschikbaar zijn op de lokale computer door de methode aan te GetCultures roepen. U kunt bijvoorbeeld aangepaste culturen, specifieke culturen of neutrale culturen alleen of in combinatie ophalen.

In het volgende voorbeeld wordt de GetCultures methode tweemaal aangeroepen, eerst met het System.Globalization.CultureTypes opsommingslid om alle aangepaste culturen op te halen en vervolgens met het System.Globalization.CultureTypes opsommingslid om alle vervangingsculturen op te halen.

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.

Cultuur en draadjes

Wanneer een nieuwe toepassingsthread wordt gestart, worden de huidige cultuur en huidige UI-cultuur gedefinieerd door de huidige systeemcultuur en niet door de huidige threadcultuur. In het volgende voorbeeld ziet u het verschil. Hiermee stelt u de huidige cultuur en de huidige UI-cultuur van een toepassingsthread in op de Franse (Frankrijk) cultuur (fr-FR). Als de huidige cultuur al fr-FR is, wordt deze in het voorbeeld ingesteld op de Engelse cultuur (Verenigde Staten) (en-US). Er worden drie willekeurige getallen weergegeven als valutawaarden en er wordt vervolgens een nieuwe thread gemaakt, die op zijn beurt drie willekeurige getallen weergeeft als valutawaarden. Maar zoals de uitvoer uit het voorbeeld laat zien, weerspiegelen de valutawaarden die door de nieuwe thread worden weergegeven niet de opmaakconventies van de Franse cultuur (Frankrijk), in tegenstelling tot de uitvoer van de hoofdtoepassingsthread.

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

U kunt de cultuur en ui-cultuur van alle threads in een toepassingsdomein instellen door een CultureInfo object toe te wijzen dat die cultuur aan de DefaultThreadCurrentCulture en DefaultThreadCurrentUICulture eigenschappen vertegenwoordigt. In het volgende voorbeeld worden deze eigenschappen gebruikt om ervoor te zorgen dat alle threads in het standaardtoepassingsdomein dezelfde cultuur delen.

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 €

Waarschuwing

Hoewel de DefaultThreadCurrentCulture eigenschappen DefaultThreadCurrentUICulture statische leden zijn, definiëren ze alleen de standaardcultuur en de standaard-UI-cultuur voor het toepassingsdomein dat actueel is op het moment dat deze eigenschapswaarden zijn ingesteld. Zie de volgende sectie, Cultuur- en toepassingsdomeinen voor meer informatie.

Wanneer u waarden toewijst aan de DefaultThreadCurrentCulture en DefaultThreadCurrentUICulture eigenschappen, worden de cultuur en ui-cultuur van de threads in het toepassingsdomein ook gewijzigd als ze niet expliciet een cultuur hebben toegewezen. Deze threads weerspiegelen echter alleen de nieuwe cultuurinstellingen terwijl ze worden uitgevoerd in het huidige toepassingsdomein. Als deze threads worden uitgevoerd in een ander toepassingsdomein, wordt hun cultuur de standaardcultuur die is gedefinieerd voor dat toepassingsdomein. Als gevolg hiervan raden we u aan altijd de cultuur van de hoofdtoepassingsthread in te stellen en niet te vertrouwen op de DefaultThreadCurrentCulture en DefaultThreadCurrentUICulture eigenschappen om deze te wijzigen.

Cultuur- en toepassingsdomeinen

DefaultThreadCurrentCulture en DefaultThreadCurrentUICulture statische eigenschappen zijn die expliciet een standaardcultuur definiëren voor het toepassingsdomein dat actueel is wanneer de eigenschapswaarde wordt ingesteld of opgehaald. In het volgende voorbeeld wordt de standaardcultuur en de standaard-UI-cultuur in het standaardtoepassingsdomein ingesteld op Frans (Frankrijk) en wordt vervolgens de AppDomainSetup klasse en de AppDomainInitializer gemachtigde gebruikt om de standaardcultuur en ui-cultuur in te stellen in een nieuw toepassingsdomein op Russisch (Rusland). Eén thread voert vervolgens twee methoden uit in elk toepassingsdomein. Houd er rekening mee dat de cultuur en ui-cultuur van de thread niet expliciet zijn ingesteld; ze zijn afgeleid van de standaardcultuur en ui-cultuur van het toepassingsdomein waarin de thread wordt uitgevoerd. Houd er ook rekening mee dat de DefaultThreadCurrentCulture en DefaultThreadCurrentUICulture eigenschappen de standaardwaarden CultureInfo retourneren van het toepassingsdomein dat actueel is wanneer de methode-aanroep wordt gedaan.

using System;
using System.Globalization;

public class Example
{
    public static void Main()
    {
        // Set the default culture and display the current date in the current application domain.
        Info info1 = new Info();
        SetAppDomainCultures("fr-FR");

        // Create a second application domain.
        AppDomainSetup setup = new AppDomainSetup();
        setup.AppDomainInitializer = SetAppDomainCultures;
        setup.AppDomainInitializerArguments = new string[] { "ru-RU" };
        AppDomain domain = AppDomain.CreateDomain("Domain2", null, setup);
        // Create an Info object in the new application domain.
        Info info2 = (Info)domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName,
                                                           "Info");

        // Execute methods in the two application domains.
        info2.DisplayDate();
        info2.DisplayCultures();

        info1.DisplayDate();
        info1.DisplayCultures();
    }

    public static void SetAppDomainCultures(string[] names)
    {
        SetAppDomainCultures(names[0]);
    }

    public static void SetAppDomainCultures(string name)
    {
        try
        {
            CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture(name);
            CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture(name);
        }
        // If an exception occurs, we'll just fall back to the system default.
        catch (CultureNotFoundException)
        {
            return;
        }
        catch (ArgumentException)
        {
            return;
        }
    }
}

public class Info : MarshalByRefObject
{
    public void DisplayDate()
    {
        Console.WriteLine($"Today is {DateTime.Now:D}");
    }

    public void DisplayCultures()
    {
        Console.WriteLine($"Application domain is {AppDomain.CurrentDomain.Id}");
        Console.WriteLine($"Default Culture: {CultureInfo.DefaultThreadCurrentCulture}");
        Console.WriteLine($"Default UI Culture: {CultureInfo.DefaultThreadCurrentUICulture}");
    }
}
// The example displays the following output:
//       Today is 14 октября 2011 г.
//       Application domain is 2
//       Default Culture: ru-RU
//       Default UI Culture: ru-RU
//       Today is vendredi 14 octobre 2011
//       Application domain is 1
//       Default Culture: fr-FR
//       Default UI Culture: fr-FR

Zie de sectie 'Toepassingsdomeinen en threads' in het onderwerp Toepassingsdomeinen voor meer informatie over culturen en toepassingsdomeinen.

Asynchrone bewerkingen gebaseerd op cultuur en taken

Het taakgebaseerd asynchroon programmeerpatroon gebruikt Task en Task<TResult> objecten om gedelegeerden asynchroon uit te voeren op draadpool-threads. De specifieke thread waarop een bepaalde taak wordt uitgevoerd, is vooraf niet bekend, maar wordt alleen tijdens runtime bepaald.

Voor apps die zich richten op .NET Framework 4.6 of een latere versie, maakt cultuur deel uit van de context van een asynchrone bewerking. Met andere woorden, asynchrone bewerkingen nemen standaard de waarden van de CurrentCulture en CurrentUICulture eigenschappen van de thread over van waaruit ze worden gestart. Als de huidige cultuur of huidige UI-cultuur afwijkt van de systeemcultuur, overschrijdt de huidige cultuur threadgrenzen en wordt de huidige cultuur van de threadgroep die een asynchrone bewerking uitvoert.

In het volgende voorbeeld ziet u een eenvoudige afbeelding. In het voorbeeld wordt een Func<TResult> gemachtigde gedefinieerd, formatDelegatewaarmee sommige getallen worden geretourneerd die zijn opgemaakt als valutawaarden. In het voorbeeld wordt de huidige systeemcultuur gewijzigd in Frans (Frankrijk) of, als Frans (Frankrijk) al de huidige cultuur is, Engels (Verenigde Staten). Vervolgens wordt het volgende uitgevoerd:

  • Roept de gemachtigde rechtstreeks aan, zodat deze synchroon wordt uitgevoerd op de hoofd-app-thread.
  • Hiermee maakt u een taak waarmee de gemachtigde asynchroon wordt uitgevoerd op een thread van een threadgroep.
  • Hiermee maakt u een taak waarmee de gemachtigde synchroon wordt uitgevoerd op de hoofd-app-thread door de methode aan te Task.RunSynchronously roepen.

Zoals de uitvoer van het voorbeeld laat zien, wanneer de huidige cultuur wordt gewijzigd in Frans (Frankrijk), wordt de huidige cultuur van de thread van waaruit taken asynchroon worden aangeroepen, de huidige cultuur voor die asynchrone bewerking.

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 €

DefaultThreadCurrentCulture en DefaultThreadCurrentUICulture zijn domeineigenschappen per app. Dat wil gezegd: ze zorgen voor een standaardcultuur voor alle threads die niet expliciet een cultuur in een specifiek toepassingsdomein hebben toegewezen. Voor apps die zich richten op .NET Framework 4.6 of hoger, blijft de cultuur van de aanroepende thread echter onderdeel van de context van een asynchrone taak, zelfs als de taak app-domeingrenzen overschrijdt.

Serialisatie van CultureInfo-objecten

Wanneer een CultureInfo object wordt geserialiseerd, worden alleen Name en UseUserOverride daadwerkelijk opgeslagen. Het wordt alleen succesvol gedeserialiseerd in een omgeving waarin Name dezelfde betekenis heeft. In de volgende drie voorbeelden ziet u waarom dit niet altijd het geval is:

  • Als de waarde van de eigenschap CultureTypes is en als die cultuur voor de eerste keer is geïntroduceerd in een bepaalde versie van het Windows-besturingssysteem, is het niet mogelijk om deze te deserialiseren op een eerdere versie van Windows. Als een cultuur bijvoorbeeld is geïntroduceerd in Windows 10, kan deze niet worden gedeserialiseerd in Windows 8.

  • Als de CultureTypes-waarde CultureTypes.UserCustomCulture is en de aangepaste cultuur van de gebruiker niet is geïnstalleerd op de computer waarop deze wordt gedeserialiseerd, is het niet mogelijk om deze te deserialiseren.

  • Als de waarde van CultureTypesCultureTypes.ReplacementCultures is, en de computer waarop het wordt gedeserialiseerd niet over deze vervangingscultuur beschikt, wordt het met dezelfde naam gedeserialiseerd, maar niet met alle oorspronkelijke kenmerken. Als en-US bijvoorbeeld een vervangingscultuur is op computer A, maar niet op computer B, en als een CultureInfo object dat naar deze cultuur verwijst, wordt geserialiseerd op computer A en gedeserialiseerd op computer B, worden geen van de aangepaste kenmerken van de cultuur verzonden. De cultuur ontserialiseerd met succes, maar met een andere betekenis.

Configuratiescherm onderdrukkingen

De gebruiker kan ervoor kiezen om bepaalde waarden te overschrijven die zijn gekoppeld aan de huidige cultuur van Windows via het gedeelte landinstellingen en taalopties van Configuratiescherm. De gebruiker kan er bijvoorbeeld voor kiezen om de datum in een andere notatie weer te geven of een andere valuta te gebruiken dan de standaardwaarde voor de cultuur. Over het algemeen moeten uw applicaties deze gebruikersaanpassingen respecteren.

Als UseUserOverridetrue is en de opgegeven cultuur overeenkomt met de huidige cultuur van Windows, gebruikt CultureInfo die overschrijvingen, inclusief gebruikersinstellingen voor de eigenschappen van het DateTimeFormatInfo-exemplaar dat door de DateTimeFormat-eigenschap wordt geretourneerd en de eigenschappen van het NumberFormatInfo-exemplaar dat door de NumberFormat-eigenschap wordt geretourneerd. Als de gebruikersinstellingen niet compatibel zijn met de cultuur die is geassocieerd met de CultureInfo, bijvoorbeeld als de geselecteerde kalender niet een van de OptionalCalendars is, dan zijn de resultaten van de methoden en de waarden van de eigenschappen niet gedefinieerd.

Alternatieve sorteervolgordes

Sommige culturen ondersteunen meer dan één sorteervolgorde. Voorbeeld:

  • De Spaanse cultuur (Spanje) heeft twee sorteervolgordes: de standaard internationale sorteervolgorde en de traditionele sorteervolgorde. Wanneer u een CultureInfo object instantiëren met de es-ES cultuurnaam, wordt de internationale sorteervolgorde gebruikt. Wanneer u een CultureInfo object instantiëren met de es-ES-tradnl cultuurnaam, wordt de traditionele sorteervolgorde gebruikt.

  • De zh-CN-cultuur (Vereenvoudigd Chinees, Volksrepubliek China) ondersteunt twee sorteervolgordes: op basis van uitspraak (standaard) en op basis van het aantal streepjes. Wanneer u een CultureInfo object instantiëren met de zh-CN cultuurnaam, wordt de standaardsorteervolgorde gebruikt. Wanneer u een CultureInfo object instantieert met een lokale identificatie van 0x00020804, worden strings gesorteerd op aantal streken.

De volgende tabel bevat de culturen die alternatieve sorteervolgordes ondersteunen en de id's voor de standaard- en alternatieve sorteervolgordes.

Cultuurnaam Cultuur Standaardsorteringsnaam en -id Alternatieve sorteernaam en id
es-ES Spaans (Spanje) Internationaal: 0x00000C0A Traditioneel: 0x0000040A
zh-TW Chinees (Taiwan) Aantal potloodstreken: 0x00000404 Bopomofo: 0x00030404
zh-CN Chinees (Volksrepubliek China) Uitspraak: 0x00000804 Aantal streken: 0x00020804
zh-HK Chinees (Hongkong SAR) Aantal pennenstreken: 0x00000c04 Aantal pennenstreken: 0x00020c04
zh-SG Chinees (Singapore) Uitspraak: 0x00001004 Aantal strepen: 0x00021004
zh-MO Chinees (Macau SAR) Uitspraak: 0x00001404 Strepenaantal: 0x00021404
ja-JP Japans (Japan) Standaard: 0x00000411 Unicode: 0x00010411
ko-KR Koreaans (Korea) Standaard: 0x00000412 Koreaanse Xwansung - Unicode: 0x00010412
de-DE Duits (Duitsland) Woordenboek: 0x00000407 Telefoonboek sorteren DIN: 0x00010407
hu-HU Hongaars (Hongarije) Standaard: 0x0000040e Technische sortering: 0x0001040e
ka-GE Georgisch (Georgië) Traditioneel: 0x00000437 Modern sorteren: 0x00010437

De huidige cultuur en UWP-apps

In Universal Windows Platform (UWP)-apps zijn de CurrentCulture en CurrentUICulture eigenschappen lees- en schrijfbaar, net zoals in .NET Framework- en .NET Core-apps. UWP-apps herkennen echter één cultuur. De CurrentCulture en CurrentUICulture eigenschappen worden toegewezen aan de eerste waarde in de verzameling Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages .

In .NET-apps is de huidige cultuur een instelling per thread en de CurrentCulture en CurrentUICulture eigenschappen weerspiegelen alleen de cultuur en ui-cultuur van de huidige thread. In UWP-apps wordt de huidige cultuur toegewezen aan de verzameling Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages . Dit is een globale instelling. Als u de eigenschap CurrentCulture of CurrentUICulture wijzigt, verandert de cultuur voor de hele app; de cultuur kan niet per thread worden ingesteld.