CultureInfo Classe

Definizione

Fornisce informazioni su impostazioni cultura specifiche, ovvero impostazioni locali per lo sviluppo di codice non gestito. Le informazioni includono i nomi delle impostazioni cultura, il sistema di scrittura, il calendario usato, l'ordinamento delle stringhe e la formattazione di date e numeri.

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
Ereditarietà
CultureInfo
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene illustrato come creare un oggetto per lo spagnolo (Spagna) con l'ordinamento internazionale e un altro CultureInfo CultureInfo oggetto con l'ordinamento tradizionale.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
int main()
{
   
   // Creates and initializes the CultureInfo which uses the international sort.
   CultureInfo^ myCIintl = gcnew CultureInfo( "es-ES",false );
   
   // Creates and initializes the CultureInfo which uses the traditional sort.
   CultureInfo^ myCItrad = gcnew 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

*/
using System;
using System.Collections;
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

Commenti

La classe fornisce informazioni specifiche delle impostazioni cultura, ad esempio lingua, sottolinguaggio, CultureInfo paese/area geografica, calendario e convenzioni associate a determinate impostazioni cultura. Questa classe fornisce anche l'accesso alle istanze specifiche delle impostazioni cultura degli oggetti DateTimeFormatInfo NumberFormatInfo , , e CompareInfo TextInfo . Questi oggetti contengono le informazioni necessarie per le operazioni specifiche delle impostazioni cultura, ad esempio l'utilizzo di maiuscole e minuscole, la formattazione di date e numeri e il confronto di stringhe. La classe viene utilizzata direttamente o indirettamente dalle classi che formattano, analizzano o modificano dati specifici delle impostazioni cultura, ad esempio CultureInfo , , e i tipi String DateTime DateTimeOffset numerici.

Contenuto della sezione:

Nomi e identificatori delle impostazioni cultura
Impostazioni cultura invarianti, neutre e specifiche
Impostazioni cultura personalizzate
Dati delle impostazioni cultura dinamiche
CultureInfo e dati culturali
Impostazioni cultura correnti e impostazioni cultura dell'interfaccia utente correnti
Ottenere tutte le impostazioni cultura
Impostazioni cultura e thread
Impostazioni cultura e domini applicazione
Impostazioni cultura e operazioni asincrone basate su attività
Serializzazione di oggetti CultureInfo
Pannello di controllo override
Ordinamento alternativo
Impostazioni cultura e Windows app\

Nomi e identificatori delle impostazioni cultura

La CultureInfo classe specifica un nome univoco per ogni impostazione cultura, in base a RFC 4646. Il nome è una combinazione di un codice delle impostazioni cultura minuscole ISO 639 di due lettere associato a una lingua e di un codice di impostazioni cultura secondarie di due lettere maiuscole ISO 3166 associato a un paese o a un'area geografica. Inoltre, per le app che hanno come destinazione .NET Framework 4 o versione successiva e vengono eseguite in Windows 10 o versioni successive, sono supportati i nomi delle impostazioni cultura che corrispondono ai tag di lingua BCP-47 validi.

Nota

Quando un nome di impostazioni cultura viene passato a un costruttore di classe o a un metodo come o , la distinzione tra maiuscole CreateSpecificCulture CultureInfo e minuscole non è significativa.

Il formato per il nome delle impostazioni cultura basato su RFC 4646 è , dove è il codice lingua di due lettere e è il codice delle impostazioni cultura languagecode2 - country/regioncode2 languagecode2 country/regioncode2 secondarie di due lettere. Ad ja-JP esempio, per il giapponese (Giappone) en-US e per l'inglese (Stati Uniti). Nei casi in cui non è disponibile un codice lingua a due lettere, viene usato un codice a tre lettere derivato da ISO 639-2.

Alcuni nomi di impostazioni cultura specificano anche uno script ISO 15924. Ad esempio, Cyrl specifica lo script cirillico e Latn specifica lo script latino. Un nome di impostazioni cultura che include uno script usa il modello languagecode2 - scripttag - country/regioncode2 . Un esempio di questo tipo di nome di impostazioni cultura è per uz-Cyrl-UZ Uzbeco (alfabeto cirillico, Uzbekistan). Nei Windows precedenti a Windows Vista, un nome di impostazioni cultura che include uno script usa il modello , ad esempio languagecode2 - country/regioncode2 - scripttag per uz-UZ-Cyrl Uzbeco (cirillico, Uzbekistan).

Le impostazioni cultura non indipendenti vengono specificate solo dal codice lingua di due lettere minuscole. Ad esempio, fr specifica le impostazioni cultura neutre per il francese e specifica le impostazioni cultura de neutre per il tedesco.

Nota

Esistono due nomi di impostazioni cultura che contraddicono questa regola. Le impostazioni cultura cinese (semplificato), denominate zh-Hans e cinese (tradizionale), denominate zh-Hant , sono impostazioni cultura non indipendenti. I nomi delle impostazioni cultura rappresentano lo standard corrente e devono essere usati a meno che non si abbia un motivo per usare i nomi meno recenti zh-CHS e zh-CHT .

Un identificatore delle impostazioni cultura è un'abbreviazione numerica internazionale standard e include i componenti necessari per identificare in modo univoco una delle impostazioni cultura installate. L'applicazione può usare identificatori di impostazioni cultura predefiniti o definire identificatori personalizzati.

Alcuni identificatori e nomi di impostazioni cultura predefiniti vengono usati da questa e da altre classi nello spazio dei System.Globalization nomi . Per informazioni dettagliate sulle impostazioni cultura Windows, vedere la colonna Tag di lingua nell'elenco dei nomi di lingua/areageografica supportati da Windows . I nomi delle impostazioni cultura seguono lo standard definito da BCP 47.

I nomi e gli identificatori delle impostazioni cultura rappresentano solo un subset di impostazioni cultura disponibili in un computer specifico. Windows versioni o Service Pack possono modificare le impostazioni cultura disponibili. Le applicazioni possono aggiungere impostazioni cultura personalizzate usando la CultureAndRegionInfoBuilder classe . Gli utenti possono aggiungere impostazioni cultura personalizzate usando lo strumento Microsoft Locale Builder. Microsoft Locale Builder è scritto in codice gestito usando la CultureAndRegionInfoBuilder classe .

Diversi nomi distinti sono strettamente associati a impostazioni cultura, in particolare i nomi associati ai membri di classe seguenti:

Impostazioni cultura invarianti, neutre e specifiche

Le impostazioni cultura sono in genere raggruppate in tre set: impostazioni cultura invarianti, impostazioni cultura non specifiche e impostazioni cultura specifiche.

Le impostazioni cultura invarianti non sono indipendenti dalle impostazioni cultura. L'applicazione specifica le impostazioni cultura invarianti in base al nome usando una stringa vuota ("") o tramite il relativo identificatore. InvariantCulture definisce un'istanza delle impostazioni cultura invarianti. È associata alla lingua inglese, ma non ad alcun paese/area geografica. Viene usato in quasi tutti i metodi dello spazio Globalization dei nomi che richiedono impostazioni cultura.

Le impostazioni cultura non associate ad alcun paese sono associate a una lingua, ma non a un paese. Impostazioni cultura specifiche sono impostazioni cultura associate a una lingua e a un paese/area geografica. Ad esempio, è il nome neutro per le impostazioni cultura francese e è il nome delle impostazioni cultura fr fr-FR francese (Francia) specifiche. Si noti che anche il cinese (semplificato) e il cinese (tradizionale) sono considerati impostazioni cultura neutre.

La creazione di un'istanza di una classe per impostazioni cultura non indipendenti non CompareInfo è consigliata perché i dati in essa contenuti sono arbitrari. Per visualizzare e ordinare i dati, specificare sia la lingua che l'area. Inoltre, la proprietà di un oggetto creato per impostazioni cultura non specifiche Name restituisce solo il paese e non include CompareInfo l'area.

Le impostazioni cultura definite hanno una gerarchia in cui l'elemento padre di impostazioni cultura specifiche è una lingua neutra e l'elemento padre di impostazioni cultura non indipendenti è la lingua invariante. La Parent proprietà contiene le impostazioni cultura non associate ad alcun paese associate a impostazioni cultura specifiche. Le impostazioni cultura personalizzate devono definire Parent la proprietà in conformità con questo modello.

Se le risorse per impostazioni cultura specifiche non sono disponibili nel sistema operativo, vengono usate le risorse per le impostazioni cultura non associate. Se le risorse per le impostazioni cultura non sono disponibili, vengono usate le risorse incorporate nell'assembly principale. Per altre informazioni sul processo di fallback delle risorse, vedere Creazione di pacchetti e distribuzione di risorse.

L'elenco delle impostazioni locali nell'API Windows è leggermente diverso dall'elenco delle impostazioni cultura supportate da .NET. Se è necessaria l'interoperabilità con Windows, ad esempio tramite il meccanismo p/invoke, l'applicazione deve usare impostazioni cultura specifiche definite per il sistema operativo. L'uso delle impostazioni cultura specifiche garantisce la coerenza con le impostazioni locali Windows equivalenti, identificate con un identificatore delle impostazioni locali uguale a LCID .

Un oggetto o può essere creato solo per le impostazioni cultura invarianti o per impostazioni DateTimeFormatInfo NumberFormatInfo cultura specifiche, non per impostazioni cultura non indipendenti.

Se DateTimeFormatInfo.Calendar è ma non è impostato su , , e TaiwanCalendar Thread.CurrentCulture zh-TW DateTimeFormatInfo.NativeCalendarName DateTimeFormatInfo.GetEraName DateTimeFormatInfo.GetAbbreviatedEraName restituiscono una stringa vuota ("").

Impostazioni cultura personalizzate

In Windows è possibile creare impostazioni locali personalizzate. Per altre informazioni, vedere Impostazioni locali personalizzate.

CultureInfo e dati culturali

.NET deriva i dati culturali da un'ampia gamma di origini, a seconda dell'implementazione, della piattaforma e della versione:

  • In .NET Framework 3.5 e versioni precedenti, i dati relativi alle impostazioni cultura vengono forniti dal sistema operativo Windows e dalle .NET Framework.

  • In .NET Framework 4 e versioni successive, i dati relativi alle impostazioni cultura vengono forniti dal Windows operativo.

  • In tutte le versioni di .NET Core in esecuzione Windows, i dati relativi alle impostazioni cultura vengono forniti dal Windows operativo.

  • In tutte le versioni di .NET Core in esecuzione su piattaforme Unix, i dati culturali vengono forniti dalla libreria ICU (International Components for Unicode). La versione specifica della libreria ICU dipende dal singolo sistema operativo.

Per questo problema, le impostazioni cultura disponibili in una determinata implementazione, piattaforma o versione di .NET potrebbero non essere disponibili in un'implementazione, una piattaforma o una versione di .NET diversa.

Alcuni CultureInfo oggetti variano a seconda della piattaforma sottostante. In particolare, , o zh-CN cinese (semplificato, Cina) e o cinese (tradizionale, Taiwan), sono impostazioni cultura disponibili nei sistemi Windows, ma sono impostazioni cultura con alias nei sistemi zh-TW Unix. "zh-CN" è un alias per le impostazioni cultura "zh-Hans-CN" e "zh-TW" è un alias per le impostazioni cultura "zh-Hant-TW". Le impostazioni cultura con alias non vengono restituite dalle chiamate al metodo e possono avere valori di proprietà diversi, incluse impostazioni cultura diverse, rispetto alle relative GetCultures Parent Windows corrispondenti. Per le zh-CN impostazioni cultura e , queste differenze includono quanto zh-TW segue:

  • Nei sistemi Windows, le impostazioni cultura padre delle impostazioni cultura "zh-CN" sono "zh-Hans" e le impostazioni cultura padre delle impostazioni cultura "zh-TW" sono "zh-Hant". Le impostazioni cultura padre di entrambe queste impostazioni cultura sono "zh". Nei sistemi Unix gli elementi padre di entrambe le impostazioni cultura sono "zh". Ciò significa che, se non si forniscono risorse specifiche delle impostazioni cultura per le impostazioni cultura "zh-CN" o "zh-TW", ma si specificano risorse per le impostazioni cultura neutre "zh-Hans" o "zh-Hant", l'applicazione carica le risorse per le impostazioni cultura neutre in Windows ma non in Unix. Nei sistemi Unix è necessario impostare in modo esplicito l'oggetto del thread su CurrentUICulture "zh-Hans" o "zh-Hant".

  • Nei Windows, la chiamata a su un'istanza che rappresenta le impostazioni cultura "zh-CN" e il passaggio di un'istanza CultureInfo.Equals di "zh-Hans-CN" restituisce true . Nei sistemi Unix la chiamata al metodo restituisce false . Questo comportamento si applica anche alla chiamata a in un'istanza "zh-TW" e al passaggio di un'istanza Equals CultureInfo "zh-Hant-Tw".

Dati delle impostazioni cultura dinamiche

Ad eccezione delle impostazioni cultura invarianti, i dati delle impostazioni cultura sono dinamici. Questo vale anche per le impostazioni cultura predefinite. Ad esempio, paesi o aree geografiche adottano nuove valute, modificano l'ortografia delle parole o modificano il calendario preferito e le definizioni delle impostazioni cultura cambiano per tenerne traccia. Le impostazioni cultura personalizzate sono soggette a modifiche senza preavviso e le impostazioni cultura specifiche potrebbero essere sostituite da impostazioni cultura di sostituzione personalizzate. Inoltre, come illustrato di seguito, un singolo utente può eseguire l'override delle preferenze culturali. Le applicazioni devono sempre ottenere dati sulle impostazioni cultura in fase di esecuzione.

Attenzione

Quando si salvano i dati, l'applicazione deve usare le impostazioni cultura invarianti, un formato binario o un formato specifico indipendente dalle impostazioni cultura. I dati salvati in base ai valori correnti associati a determinate impostazioni cultura, diverse dalle impostazioni cultura invarianti, potrebbero diventare illeggibili o potrebbero cambiare significato se le impostazioni cultura cambiano.

Impostazioni cultura correnti e impostazioni cultura correnti dell'interfaccia utente

Ogni thread in un'applicazione .NET ha impostazioni cultura correnti e impostazioni cultura dell'interfaccia utente correnti. Le impostazioni cultura correnti determinano le convenzioni di formattazione per date, ore, numeri e valori di valuta, l'ordinamento del testo, le convenzioni di distinzione tra maiuscole e minuscole e le modalità di confronto delle stringhe. Le impostazioni cultura correnti dell'interfaccia utente vengono usate per recuperare risorse specifiche delle impostazioni cultura in fase di esecuzione.

Nota

Per informazioni su come vengono determinate le impostazioni cultura correnti e correnti dell'interfaccia utente per ogni thread, vedere la sezione Impostazioni cultura e thread. Per informazioni su come vengono determinate le impostazioni cultura correnti e correnti dell'interfaccia utente sui thread in esecuzione in un nuovo dominio applicazione e sui thread che superano i limiti del dominio applicazione, vedere la sezione Impostazioni cultura e domini applicazione. Per informazioni su come viene determinato il corrente e il corrente sui thread che eseguono operazioni asincrone basate su attività, vedere la sezione Impostazioni cultura e operazioni asincrone basate su attività.

Per informazioni più dettagliate sulle impostazioni cultura correnti, vedere CultureInfo.CurrentCulture l'argomento della proprietà . Per informazioni più dettagliate sulle impostazioni cultura correnti dell'interfaccia utente, vedere CultureInfo.CurrentUICulture l'argomento della proprietà .

Recupero delle impostazioni cultura correnti e correnti dell'interfaccia utente

È possibile ottenere un CultureInfo oggetto che rappresenta le impostazioni cultura correnti in uno dei due modi seguenti:

Nell'esempio seguente vengono recuperati entrambi i valori delle proprietà, confrontati per mostrare che sono uguali e viene visualizzato il nome delle impostazioni cultura correnti.

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

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

Module Example
   Public Sub Main()
      Dim culture1 As CultureInfo = CultureInfo.CurrentCulture
      Dim culture2 As CultureInfo = Thread.CurrentThread.CurrentCulture
      Console.WriteLine("The current culture is {0}", culture1.Name)
      Console.WriteLine("The two CultureInfo objects are equal: {0}",
                        culture1.Equals(culture2))
   End Sub
End Module
' The example displays output like the following:
'     The current culture is en-US
'     The two CultureInfo objects are equal: True

È possibile ottenere un oggetto che rappresenta le impostazioni cultura correnti CultureInfo dell'interfaccia utente in uno dei due modi seguenti:

L'esempio seguente recupera entrambi i valori delle proprietà, li confronta per mostrare che sono uguali e visualizza il nome delle impostazioni cultura correnti dell'interfaccia utente.

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

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

Module Example
   Public Sub Main()
      Dim uiCulture1 As CultureInfo = CultureInfo.CurrentUICulture
      Dim uiCulture2 As CultureInfo = Thread.CurrentThread.CurrentUICulture
      Console.WriteLine("The current UI culture is {0}", uiCulture1.Name)
      Console.WriteLine("The two CultureInfo objects are equal: {0}",
                        uiCulture1.Equals(uiCulture2))
   End Sub
End Module
' The example displays output like the following:
'     The current UI culture is en-US
'     The two CultureInfo objects are equal: True

Impostare le impostazioni cultura correnti e correnti dell'interfaccia utente

Per modificare le impostazioni cultura e le impostazioni cultura dell'interfaccia utente di un thread, eseguire le operazioni seguenti:

  1. Creare un'istanza di un oggetto che rappresenta le impostazioni cultura chiamando un costruttore di classe CultureInfo e passando il nome delle impostazioni CultureInfo cultura. Il costruttore crea un'istanza di un oggetto che riflette gli override dell'utente se le nuove impostazioni cultura sono le stesse Windows CultureInfo(String) CultureInfo impostazioni cultura correnti. Il costruttore consente di specificare se l'oggetto di cui è stata creata un'istanza riflette gli override dell'utente se le nuove impostazioni cultura sono le stesse delle impostazioni cultura CultureInfo(String, Boolean) CultureInfo Windows correnti.

  2. Assegnare CultureInfo l'oggetto CultureInfo.CurrentCulture alla proprietà o in CultureInfo.CurrentUICulture .NET Core e .NET Framework 4.6 e versioni successive. In .NET Framework 4.5.2 e versioni precedenti è possibile assegnare l'oggetto CultureInfo alla Thread.CurrentCulture proprietà o Thread.CurrentUICulture .

Nell'esempio seguente vengono recuperate le impostazioni cultura correnti. Se è diverso dalle impostazioni cultura francese (Francia), le impostazioni cultura correnti vengono cambiate in francese (Francia). In caso contrario, le impostazioni cultura correnti vengono cambiate in francese (belgio).

using System;
using System.Globalization;

public class Example
{
   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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current As CultureInfo = CultureInfo.CurrentCulture
      Console.WriteLine("The current culture is {0}", current.Name)
      Dim newCulture As CultureInfo
      If current.Name.Equals("fr-FR") Then
         newCulture = New CultureInfo("fr-LU")
      Else   
         newCulture = new CultureInfo("fr-FR")
      End If
      
      CultureInfo.CurrentCulture = newCulture
      Console.WriteLine("The current culture is now {0}", 
                        CultureInfo.CurrentCulture.Name)   
   End Sub
End Module
' The example displays output like the following:
'     The current culture is en-US
'     The current culture is now fr-FR

Nell'esempio seguente vengono recuperate le impostazioni cultura correnti. Se si tratta di altre impostazioni cultura slovena (Slovenia), le impostazioni cultura correnti vengono cambiate in sloveno (Slovenia). In caso contrario, le impostazioni cultura correnti vengono cambiate in serbo (Bosnia).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo current = CultureInfo.CurrentUICulture;
      Console.WriteLine("The current UI culture is {0}", 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 {0}",
                        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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current As CultureInfo = CultureInfo.CurrentUICulture
      Console.WriteLine("The current UI culture is {0}", current.Name)
      Dim newUICulture As CultureInfo
      If current.Name.Equals("sl-SI") Then
         newUICulture = New CultureInfo("hr-HR")
      Else   
         newUICulture = new CultureInfo("sl-SI")
      End If
      
      CultureInfo.CurrentUICulture = newUICulture
      Console.WriteLine("The current UI culture is now {0}", 
                        CultureInfo.CurrentUICulture.Name)   
   End Sub
End Module
' The example displays output like the following:
'     The current UI culture is en-US
'     The current UI culture is now sl-SI

Ottenere tutte le impostazioni cultura

È possibile recuperare una matrice di categorie specifiche di impostazioni cultura o di tutte le impostazioni cultura disponibili nel computer locale chiamando il GetCultures metodo . Ad esempio, è possibile recuperare impostazioni cultura personalizzate, impostazioni cultura specifiche o impostazioni cultura neutre da sole o in combinazione.

Nell'esempio seguente viene chiamato il metodo due volte, prima con il membro di enumerazione per recuperare tutte le impostazioni cultura personalizzate e quindi con il membro di enumerazione per recuperare tutte le impostazioni GetCultures System.Globalization.CultureTypes cultura di System.Globalization.CultureTypes sostituzione.

using System;
using System.Globalization;

public class Example
{
   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("   {0} -- {1}", 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("   {0} -- {1}", 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.
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Get all custom cultures.
      Dim custom() As CultureInfo = CultureInfo.GetCultures(CultureTypes.UserCustomCulture)
      If custom.Length = 0 Then 
         Console.WriteLine("There are no user-defined custom cultures.")
      Else
         Console.WriteLine("Custom cultures:")
         For Each culture In custom 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName)
         Next       
      End If
      Console.WriteLine()
      
      ' Get all replacement cultures.
      Dim replacements() As CultureInfo = CultureInfo.GetCultures(CultureTypes.ReplacementCultures)
      If replacements.Length = 0 Then 
         Console.WriteLine("There are no replacement cultures.")
      Else 
         Console.WriteLine("Replacement cultures:")
         For Each culture in replacements 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName)    
         Next
      End If
      Console.WriteLine()
   End Sub
End Module
' 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.

Impostazioni cultura e thread

Quando viene avviato un nuovo thread dell'applicazione, le impostazioni cultura correnti e le impostazioni cultura correnti dell'interfaccia utente vengono definite dalle impostazioni cultura correnti del sistema e non dalle impostazioni cultura del thread corrente. Nell'esempio che segue viene illustrata la differenza. Imposta le impostazioni cultura correnti e le impostazioni cultura correnti dell'interfaccia utente di un thread dell'applicazione sulle impostazioni cultura francese (Francia) (fr-FR). Se le impostazioni cultura correnti sono già fr-FR, nell'esempio vengono impostate le impostazioni cultura inglese (Stati Uniti) (en-US). Visualizza tre numeri casuali come valori di valuta e quindi crea un nuovo thread che, a sua volta, visualizza altri tre numeri casuali come valori di valuta. Come illustrato nell'output dell'esempio, tuttavia, i valori di valuta visualizzati dal nuovo thread non riflettono le convenzioni di formattazione delle impostazioni cultura francese (Francia), a differenza dell'output del thread principale dell'applicazione.

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

public class Example
{
   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: '{0}'",
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
                        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("   {0:C2}", rnd.NextDouble() * 10);
   }

   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
Imports System.Globalization
Imports System.Threading

Module Example
   Dim rnd As New Random()
   
   Public Sub Main()
      If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
         ' 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")
      End If
      ThreadProc()
          
       Dim worker As New Thread(AddressOf ThreadProc)
       worker.Name = "WorkerThread"
       worker.Start()
   End Sub
   
   Private Sub DisplayThreadInfo()
      Console.WriteLine()
      Console.WriteLine("Current Thread Name: '{0}'", 
                        Thread.CurrentThread.Name)
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name)                        
   End Sub
   
   Private Sub DisplayValues()
      ' Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:")
      For ctr As Integer = 0 To 3
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10)                        
      Next
   End Sub
   
   Private Sub ThreadProc()
      DisplayThreadInfo()
      DisplayValues()
   End Sub
End Module
' 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

Nelle versioni di .NET Framework precedenti a .NET Framework 4.5, il modo più comune per garantire che il thread dell'applicazione principale condivoni le stesse impostazioni cultura con tutti gli altri thread di lavoro è passare a un delegato il nome delle impostazioni cultura a livello di applicazione o un oggetto che rappresenta le impostazioni cultura a livello di CultureInfo System.Threading.ParameterizedThreadStart applicazione. L'esempio seguente usa questo approccio per garantire che i valori di valuta visualizzati da due thread riflettano le convenzioni di formattazione delle stesse impostazioni cultura.

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

public class Example
{
   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");
      }
      DisplayThreadInfo();
      DisplayValues();

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

   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'",
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
                        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("   {0:C2}", rnd.NextDouble() * 10);
   }

   private static void ThreadProc(Object obj)
   {
      Thread.CurrentThread.CurrentCulture = (CultureInfo) obj;
      Thread.CurrentThread.CurrentUICulture = (CultureInfo) obj;
      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 €
Imports System.Globalization
Imports System.Threading

Module Example
   Dim rnd As New Random()
   
   Public Sub Main()
      If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
         ' 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")
      End If
      DisplayThreadInfo()
      DisplayValues()
          
       Dim worker As New Thread(AddressOf ThreadProc)
       worker.Name = "WorkerThread"
       worker.Start(Thread.CurrentThread.CurrentCulture)
   End Sub
   
   Private Sub DisplayThreadInfo()
      Console.WriteLine()
      Console.WriteLine("Current Thread Name: '{0}'", 
                        Thread.CurrentThread.Name)
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name)                        
   End Sub
   
   Private Sub DisplayValues()
      ' Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:")
      For ctr As Integer = 0 To 3
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10)                        
      Next
   End Sub
   
   Private Sub ThreadProc(obj As Object)
      Thread.CurrentThread.CurrentCulture = CType(obj, CultureInfo)
      Thread.CurrentThread.CurrentUICulture = CType(obj, CultureInfo)
      DisplayThreadInfo()
      DisplayValues()
   End Sub
End Module
' 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 €

È possibile impostare le impostazioni cultura e le impostazioni cultura dell'interfaccia utente dei thread del pool di thread in modo simile chiamando il ThreadPool.QueueUserWorkItem(WaitCallback, Object) metodo .

A partire da .NET Framework 4.5, è possibile impostare le impostazioni cultura e le impostazioni cultura dell'interfaccia utente di tutti i thread in un dominio applicazione in modo più diretto assegnando un oggetto che rappresenta le impostazioni cultura alle proprietà CultureInfo DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture . Nell'esempio seguente vengono utilizzate queste proprietà per garantire che tutti i thread nel dominio applicazione predefinito convivino le stesse impostazioni cultura.

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

public class Example
{
   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(Example.ThreadProc);
      worker.Name = "WorkerThread";
      worker.Start();
   }

   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'",
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
                        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("   {0:C2}", rnd.NextDouble() * 10);
   }

   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 €
Imports System.Globalization
Imports System.Threading

Module Example
   Dim rnd As New Random()
   
   Public Sub Main()
      If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
         ' 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")
      End If
      ThreadProc()

       Dim worker As New Thread(AddressOf ThreadProc)
       worker.Name = "WorkerThread"
       worker.Start()
   End Sub
   
   Private Sub DisplayThreadInfo()
      Console.WriteLine()
      Console.WriteLine("Current Thread Name: '{0}'", 
                        Thread.CurrentThread.Name)
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name)                        
   End Sub
   
   Private Sub DisplayValues()
      ' Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:")
      For ctr As Integer = 0 To 3
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10)                        
      Next
   End Sub
   
   Private Sub ThreadProc()
      DisplayThreadInfo()
      DisplayValues()
   End Sub
End Module
' 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 €

Avviso

Anche se le proprietà e sono membri statici, definiscono le impostazioni cultura predefinite e le impostazioni cultura predefinite dell'interfaccia utente solo per il dominio applicazione corrente al momento dell'impostazione DefaultThreadCurrentCulture di questi valori di DefaultThreadCurrentUICulture proprietà. Per altre informazioni, vedere la sezione successiva, Impostazioni cultura e domini applicazione.

Quando si assegnano valori alle proprietà e , le impostazioni cultura e le impostazioni cultura dell'interfaccia utente dei thread nel dominio applicazione cambiano anche se non sono state assegnate in modo esplicito DefaultThreadCurrentCulture DefaultThreadCurrentUICulture impostazioni cultura. Tuttavia, questi thread riflettono le nuove impostazioni cultura solo mentre vengono eseguiti nel dominio applicazione corrente. Se questi thread vengono eseguiti in un altro dominio applicazione, le impostazioni cultura diventano le impostazioni cultura predefinite definite per tale dominio applicazione. Di conseguenza, è consigliabile impostare sempre le impostazioni cultura del thread dell'applicazione principale e non basarsi sulle proprietà DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture per modificarlo.

Impostazioni cultura e domini applicazione

DefaultThreadCurrentCulture e sono proprietà statiche che definiscono in modo esplicito le impostazioni cultura predefinite solo per il dominio applicazione corrente DefaultThreadCurrentUICulture quando il valore della proprietà viene impostato o recuperato. L'esempio seguente imposta le impostazioni cultura predefinite e le impostazioni cultura predefinite dell'interfaccia utente nel dominio applicazione predefinito su Francese (Francia) e quindi usa la classe e il delegato per impostare le impostazioni cultura predefinite e le impostazioni cultura dell'interfaccia utente in un nuovo dominio applicazione su Russo AppDomainSetup AppDomainInitializer (Russia). Un singolo thread esegue quindi due metodi in ogni dominio applicazione. Si noti che le impostazioni cultura e le impostazioni cultura dell'interfaccia utente del thread non sono impostate in modo esplicito. derivano dalle impostazioni cultura predefinite e dalle impostazioni cultura dell'interfaccia utente del dominio applicazione in cui è in esecuzione il thread. Si noti anche che le proprietà e restituiscono i valori predefiniti del dominio applicazione DefaultThreadCurrentCulture corrente quando viene effettuata la chiamata al metodo DefaultThreadCurrentUICulture CultureInfo .

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

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 {0:D}", DateTime.Now);
   }

   public void DisplayCultures()
   {
      Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id);
      Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture);
      Console.WriteLine("Default UI Culture: {0}", 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
Imports System.Globalization
Imports System.Reflection
Imports System.Threading

Module Example
   Public Sub Main()
      ' Set the default culture and display the current date in the current application domain.
      Dim info1 As New Info()
      SetAppDomainCultures("fr-FR")
      
      ' Create a second application domain.
      Dim setup As New AppDomainSetup()
      setup.AppDomainInitializer = AddressOf SetAppDomainCultures
      setup.AppDomainInitializerArguments = { "ru-RU" }
      Dim domain As AppDomain = AppDomain.CreateDomain("Domain2", Nothing, setup)
      ' Create an Info object in the new application domain.
      Dim info2 As Info = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName, 
                                                               "Info"), Info) 

      ' Execute methods in the two application domains.
      info2.DisplayDate()
      info2.DisplayCultures()
      
      info1.DisplayDate()
      info1.DisplayCultures()            
   End Sub
   
   Public Sub SetAppDomainCultures(names() As String)
      SetAppDomainCultures(names(0))
   End Sub
   
   Public Sub SetAppDomainCultures(name As String)
       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 e As CultureNotFoundException
         Return
      Catch e As ArgumentException
         Return
      End Try      
   End Sub
End Module

Public Class Info : Inherits MarshalByRefObject
   Public Sub DisplayDate()
      Console.WriteLine("Today is {0:D}", Date.Now)
   End Sub
   
   Public Sub DisplayCultures()
      Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id)
      Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture)
      Console.WriteLine("Default UI Culture: {0}", CultureInfo.DefaultThreadCurrentUICulture)
   End Sub
End Class
' 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

Per altre informazioni sulle impostazioni cultura e sui domini applicazione, vedere la sezione "Domini applicazione e thread" nell'argomento Domini applicazione.

Impostazioni cultura e operazioni asincrone basate su attività

Il modello di programmazione asincrona basato su attività usa oggetti e per eseguire in modo Task Task<TResult> asincrono delegati nei thread del pool di thread. Il thread specifico in cui viene eseguita una determinata attività non è noto in anticipo, ma viene determinato solo in fase di esecuzione.

Per le app che .NET Framework 4.6 o versione successiva, le impostazioni cultura fanno parte del contesto di un'operazione asincrona. In altre parole, a partire dalle app che hanno come destinazione .NET Framework 4.6, le operazioni asincrone per impostazione predefinita ereditano i valori delle proprietà e del thread da cui CurrentCulture CurrentUICulture vengono avviate. Se le impostazioni cultura correnti o le impostazioni cultura correnti dell'interfaccia utente sono diverse dalle impostazioni cultura di sistema, le impostazioni cultura correnti superano i limiti dei thread e diventano le impostazioni cultura correnti del thread del pool di thread che esegue un'operazione asincrona.

Nell'esempio seguente viene illustrato questo concetto. Usa TargetFrameworkAttribute l'attributo per la destinazione .NET Framework 4.6. Nell'esempio viene definito Func<TResult> un delegato , , che restituisce alcuni numeri formatDelegate formattati come valori di valuta. Nell'esempio le impostazioni cultura di sistema correnti vengono cambiate in francese (Francia) o, se il francese (Francia) sono già le impostazioni cultura correnti, inglese (Stati Uniti). Quindi:

  • Richiama direttamente il delegato in modo che venga eseguito in modo sincrono nel thread dell'app principale.

  • Crea un'attività che esegue il delegato in modo asincrono in un thread del pool di thread.

  • Crea un'attività che esegue il delegato in modo sincrono nel thread dell'app principale chiamando il Task.RunSynchronously metodo .

Come illustrato nell'output dell'esempio, quando le impostazioni cultura correnti vengono modificate in francese (Francia), le impostazioni cultura correnti del thread da cui le attività vengono richiamate in modo asincrono diventano le impostazioni cultura correnti per l'operazione asincrona.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

[assembly:TargetFramework(".NETFramework,Version=v4.6")]

public class Example
{

   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));

                                             output += Environment.NewLine;
                                             return output;
                                           };

       Console.WriteLine("The example is running on thread {0}",
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}",
                         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 {0}.\n",
                         CultureInfo.CurrentCulture.Name);

       // 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 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

<Assembly:TargetFramework(".NETFramework,Version=v4.6")>

Module Example
   Public Sub Main()
       Dim values() As Decimal = { 163025412.32d, 18905365.59d }
       Dim formatString As String = "C2"
       Dim formatDelegate As Func(Of String) = Function()
                                                  Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
                                                                                       CultureInfo.CurrentCulture.Name,
                                                                                       Thread.CurrentThread.ManagedThreadId)
                                                  output += Environment.NewLine
                                                  For Each value In values
                                                     output += String.Format("{0}   ", value.ToString(formatString))
                                                  Next 
                                                  output += Environment.NewLine
                                                  Return output
                                               End Function
       
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId)
       ' Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name)
       If CultureInfo.CurrentCulture.Name = "fr-FR" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If
       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       Console.WriteLine()                  
       
       ' 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:") 
       Dim t1 = Task.Run(formatDelegate)
       Console.WriteLine(t1.Result)
       
       Console.WriteLine("Executing a task synchronously:")
       Dim t2 = New Task(Of String)(formatDelegate) 
       t2.RunSynchronously()
       Console.WriteLine(t2.Result)
   End Sub
End Module
' 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 Imports the fr-FR culture on thread 1.
'          163 025 412,32 €   18 905 365,59 €
'
'          Executing a task asynchronously:
'          Formatting Imports the fr-FR culture on thread 3.
'          163 025 412,32 €   18 905 365,59 €
'
'          Executing a task synchronously:
'          Formatting Imports the fr-FR culture on thread 1.
'          163 025 412,32 €   18 905 365,59 €

Per le app che hanno come destinazione versioni di .NET Framework precedenti .NET Framework 4.6 o per le app che non hanno come destinazione una versione specifica di .NET Framework, le impostazioni cultura del thread chiamante non fanno parte del contesto di un'attività. A meno che non venga definito in modo esplicito, per impostazione predefinita le impostazioni cultura dei nuovi thread sono le impostazioni cultura di sistema. L'esempio seguente, identico all'esempio precedente, ad eccezione del fatto che non dispone TargetFrameworkAttribute dell'attributo , illustra questa operazione. Poiché le impostazioni cultura di sistema del sistema in cui è stato eseguito l'esempio erano inglese (Stati Uniti), le impostazioni cultura dell'attività che viene eseguita in modo asincrono in un thread del pool di thread sono en-US invece di fr-FR .

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));

                                             output += Environment.NewLine;
                                             return output;
                                           };

       Console.WriteLine("The example is running on thread {0}",
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}",
                         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 {0}.\n",
                         CultureInfo.CurrentCulture.Name);

       // 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 en-US 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 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
       Dim values() As Decimal = { 163025412.32d, 18905365.59d }
       Dim formatString As String = "C2"
       Dim formatDelegate As Func(Of String) = Function()
                                                  Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
                                                                                       CultureInfo.CurrentCulture.Name,
                                                                                       Thread.CurrentThread.ManagedThreadId)
                                                  output += Environment.NewLine
                                                  For Each value In values
                                                     output += String.Format("{0}   ", value.ToString(formatString))
                                                  Next 
                                                  output += Environment.NewLine
                                                  Return output
                                               End Function
       
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId)
       ' Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name)
       If CultureInfo.CurrentCulture.Name = "fr-FR" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If
       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       Console.WriteLine()                  
       
       ' 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:") 
       Dim t1 = Task.Run(formatDelegate)
       Console.WriteLine(t1.Result)
       
       Console.WriteLine("Executing a task synchronously:")
       Dim t2 = New Task(Of String)(formatDelegate) 
       t2.RunSynchronously()
       Console.WriteLine(t2.Result)
   End Sub
End Module
' 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 en-US 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 €

Per le app che hanno come destinazione versioni di .NET Framework da .NET Framework 4.5 e versioni successive ma precedenti .NET Framework 4.6, è possibile usare le proprietà e per assicurarsi che le impostazioni cultura del thread chiamante siano usate nelle attività asincrone che vengono eseguite sui thread del DefaultThreadCurrentCulture DefaultThreadCurrentUICulture pool di thread. L'esempio seguente è identico all'esempio precedente, ad eccezione del fatto che usa la proprietà per garantire che i thread del pool di thread hanno le stesse impostazioni cultura DefaultThreadCurrentCulture del thread dell'app principale.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));

                                             output += Environment.NewLine;
                                             return output;
                                           };

       Console.WriteLine("The example is running on thread {0}",
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}",
                         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 {0}.\n",
                         CultureInfo.CurrentCulture.Name);
       CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CurrentCulture;

       // 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 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
       Dim values() As Decimal = { 163025412.32d, 18905365.59d }
       Dim formatString As String = "C2"
       Dim formatDelegate As Func(Of String) = Function()
                                                  Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
                                                                                       CultureInfo.CurrentCulture.Name,
                                                                                       Thread.CurrentThread.ManagedThreadId)
                                                  output += Environment.NewLine
                                                  For Each value In values
                                                     output += String.Format("{0}   ", value.ToString(formatString))
                                                  Next 
                                                  output += Environment.NewLine
                                                  Return output
                                               End Function
       
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId)
       ' Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name)
       If CultureInfo.CurrentCulture.Name = "fr-FR" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If
       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CurrentCulture
       Console.WriteLine()                  
       
       ' 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:") 
       Dim t1 = Task.Run(formatDelegate)
       Console.WriteLine(t1.Result)
       
       Console.WriteLine("Executing a task synchronously:")
       Dim t2 = New Task(Of String)(formatDelegate) 
       t2.RunSynchronously()
       Console.WriteLine(t2.Result)
   End Sub
End Module
' 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 e sono proprietà di dominio per app, cio' stabiliscono impostazioni cultura predefinite per tutti i thread non assegnati in modo esplicito a impostazioni cultura DefaultThreadCurrentUICulture in un dominio applicazione specifico. Tuttavia, per le app che hanno come destinazione .NET Framework 4.6 o versione successiva, le impostazioni cultura del thread chiamante rimangono parte del contesto di un'attività asincrona anche se l'attività supera i limiti del dominio dell'app.

L'esempio seguente mostra che le impostazioni cultura del thread chiamante rimangono le impostazioni cultura correnti di un'operazione asincrona basata su attività anche se il metodo eseguito dall'attività supera i limiti del dominio applicazione. Definisce una classe, , con un singolo metodo, , che restituisce un numero a virgola mobile e precisione doppia casuale compreso tra 1 e DataRetriever GetFormattedNumber 1.000 formattato come valore di valuta. Viene eseguita una prima attività che crea semplicemente un'istanza DataRetriever di e chiama il relativo metodo GetFormattedNumber . Una seconda attività segnala il dominio applicazione corrente, crea un nuovo dominio applicazione, crea un'istanza di nel nuovo dominio DataRetriever applicazione e chiama il relativo metodo GetFormattedNumber . Come illustrato nell'output dell'esempio, le impostazioni cultura correnti sono rimaste invariate nel thread chiamante, nella prima attività e nella seconda attività sia durante l'esecuzione nel dominio applicazione principale che nel secondo dominio applicazione.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

[assembly:TargetFramework(".NETFramework,Version=v4.6")]

public class Example
{
   public static void Main()
   {
       string formatString = "C2";
       Console.WriteLine("The example is running on thread {0}",
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}",
                         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 {0}.\n",
                         CultureInfo.CurrentCulture.Name);

       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously in the main appdomain:");
       var t1 = Task.Run(() => { DataRetriever d = new DataRetriever();
                                 return d.GetFormattedNumber(formatString);
                               });
       Console.WriteLine(t1.Result);
       Console.WriteLine();

       Console.WriteLine("Executing a task synchronously in two appdomains:");
       var t2 = Task.Run(() => { Console.WriteLine("Thread {0} is running in app domain '{1}'",
                                                   Thread.CurrentThread.ManagedThreadId,
                                                   AppDomain.CurrentDomain.FriendlyName);
                                 AppDomain domain = AppDomain.CreateDomain("Domain2");
                                 DataRetriever d = (DataRetriever) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName,
                                                   "DataRetriever");
                                 return d.GetFormattedNumber(formatString);
                               });
       Console.WriteLine(t2.Result);
   }
}

public class DataRetriever : MarshalByRefObject
{
   public string GetFormattedNumber(String format)
   {
      Thread thread = Thread.CurrentThread;
      Console.WriteLine("Current culture is {0}", thread.CurrentCulture);
      Console.WriteLine("Thread {0} is running in app domain '{1}'",
                        thread.ManagedThreadId,
                        AppDomain.CurrentDomain.FriendlyName);
      Random rnd = new Random();
      Double value = rnd.NextDouble() * 1000;
      return value.ToString(format);
   }
}
// The example displays output like the following:
//     The example is running on thread 1
//     The current culture is en-US
//     Changed the current culture to fr-FR.
//
//     Executing a task asynchronously in a single appdomain:
//     Current culture is fr-FR
//     Thread 3 is running in app domain 'AsyncCulture4.exe'
//     93,48 €
//
//     Executing a task synchronously in two appdomains:
//     Thread 4 is running in app domain 'AsyncCulture4.exe'
//     Current culture is fr-FR
//     Thread 4 is running in app domain 'Domain2'
//     288,66 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

<Assembly:TargetFramework(".NETFramework,Version=v4.6")>

Module Example
   Public Sub Main()
       Dim formatString As String = "C2"
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId)
       ' Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name)
       If CultureInfo.CurrentCulture.Name = "fr-FR" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If

       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       Console.WriteLine()
       
       ' Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously in the main appdomain:") 
       Dim t1 = Task.Run(Function()
                            Dim d As New DataRetriever()
                            Return d.GetFormattedNumber(formatString)
                         End Function)
       Console.WriteLine(t1.Result)
       Console.WriteLine() 
       
       Console.WriteLine("Executing a task synchronously in two appdomains:")
       Dim t2 = Task.Run(Function()
                            Console.WriteLine("Thread {0} is running in app domain '{1}'", 
                                              Thread.CurrentThread.ManagedThreadId, 
                                              AppDomain.CurrentDomain.FriendlyName)
                            Dim domain As AppDomain = AppDomain.CreateDomain("Domain2")
                            Dim d As DataRetriever = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName,
                                                                                          "DataRetriever"), DataRetriever)
                            Return d.GetFormattedNumber(formatString) 
                         End Function) 
       Console.WriteLine(t2.Result)
   End Sub
End Module

Public Class DataRetriever : Inherits MarshalByRefObject
   Public Function GetFormattedNumber(format As String) As String
      Dim thread As Thread = Thread.CurrentThread
      Console.WriteLine("Current culture is {0}", thread.CurrentCulture)
      Console.WriteLine("Thread {0} is running in app domain '{1}'", 
                        thread.ManagedThreadId, 
                        AppDomain.CurrentDomain.FriendlyName)
      Dim rnd As New Random()
      Dim value As Double = rnd.NextDouble() * 1000
      Return value.ToString(format)
   End Function
End Class
' The example displays output like the following:
'     The example is running on thread 1
'     The current culture is en-US
'     Changed the current culture to fr-FR.
'     
'     Executing a task asynchronously in a single appdomain:
'     Current culture is fr-FR
'     Thread 3 is running in app domain 'AsyncCulture4.exe'
'     93,48 €
'     
'     Executing a task synchronously in two appdomains:
'     Thread 4 is running in app domain 'AsyncCulture4.exe'
'     Current culture is fr-FR
'     Thread 4 is running in app domain 'Domain2'
'     288,66 €

Serializzazione di oggetti CultureInfo

Quando un CultureInfo oggetto viene serializzato, tutto ciò che viene effettivamente archiviato è Name e UseUserOverride . Viene deserializzata correttamente solo in un ambiente in cui Name ha lo stesso significato. I tre esempi seguenti illustrano perché questo non è sempre il caso:

  • Se il valore della proprietà è e le impostazioni cultura sono state introdotte per la prima volta in una versione specifica del sistema operativo Windows, non è possibile deserializzarlo in una versione precedente di CultureTypes CultureTypes.InstalledWin32Cultures Windows. Ad esempio, se le impostazioni cultura sono state introdotte in Windows 10, non possono essere deserializzate in Windows 8.

  • Se il valore è e nel computer in cui viene deserializzato non sono installate le impostazioni cultura personalizzate dell'utente, non è possibile CultureTypes CultureTypes.UserCustomCulture deserializzarlo.

  • Se il valore è e il computer in cui viene deserializzato non ha queste impostazioni cultura di sostituzione, viene deserializzato con lo stesso nome, ma non tutte CultureTypes CultureTypes.ReplacementCultures le stesse caratteristiche. Se, ad esempio, sono impostazioni cultura sostitutive nel computer A, ma non nel computer B e se un oggetto che fa riferimento a queste impostazioni cultura viene serializzato nel computer A e deserializzato nel computer B, nessuna delle caratteristiche personalizzate delle impostazioni cultura viene en-US CultureInfo trasmessa. Le impostazioni cultura vengono deserializzate correttamente, ma con un significato diverso.

Pannello di controllo override

L'utente può scegliere di eseguire l'override di alcuni dei valori associati alle impostazioni cultura correnti Windows tramite la parte relativa alle opzioni internazionali e linguistiche di Pannello di controllo. Ad esempio, l'utente potrebbe scegliere di visualizzare la data in un formato diverso o di usare una valuta diversa da quella predefinita per le impostazioni cultura. In generale, le applicazioni devono rispettare queste sostituzioni utente.

Se è e le impostazioni cultura specificate corrispondono alle impostazioni cultura correnti di Windows, usa tali override, incluse le impostazioni utente per le proprietà dell'istanza restituita dalla proprietà e le proprietà dell'istanza restituita dalla UseUserOverride true proprietà CultureInfo DateTimeFormatInfo DateTimeFormat NumberFormatInfo NumberFormat . Se le impostazioni utente non sono compatibili con le impostazioni cultura associate a , ad esempio se il calendario selezionato non è uno dei , i risultati dei metodi e i valori delle proprietà non CultureInfo OptionalCalendars sono definiti.

Ordinamento alternativo

Alcune impostazioni cultura supportano più di un ordinamento. Ad esempio:

  • Le impostazioni cultura spagnole (Spagna) hanno due tipi di ordinamento: l'ordinamento internazionale predefinito e l'ordinamento tradizionale. Quando si crea CultureInfo un'istanza di un oggetto con il nome delle impostazioni es-ES cultura, viene usato l'ordinamento internazionale. Quando si crea CultureInfo un'istanza di un oggetto con il nome delle impostazioni es-ES-tradnl cultura, viene usato l'ordinamento tradizionale.

  • Le impostazioni cultura (cinese (semplificato, RPC) supportano due ordinamenti: per zh-CN pronuncia (impostazione predefinita) e per numero di tratti. Quando si crea CultureInfo un'istanza di un oggetto con il nome delle impostazioni zh-CN cultura, viene usato l'ordinamento predefinito. Quando si crea un'istanza di un oggetto con un identificatore 0x00020804, le stringhe CultureInfo vengono ordinate in base al conteggio dei tratti.

Nella tabella seguente sono elencate le impostazioni cultura che supportano gli ordinamenti alternativi e gli identificatori per gli ordinamenti predefiniti e alternativi.

Nome lingua culture Nome e identificatore di ordinamento predefiniti Nome e identificatore di ordinamento alternativi
es-ES Spagnolo (Spagna) Internazionale: 0x00000C0A Tradizionale: 0x0000040A
zh-TW Cinese (Taiwan) Conteggio tratti: 0x00000404 Bopomofo: 0x00030404
zh-CN Cinese (RPC) Pronuncia: 0x00000804 Conteggio tratti: 0x00020804
zh-HK Cinese (Hong Kong - R.A.S.) Conteggio tratti: 0x00000c04 Conteggio tratti: 0x00020c04
zh-SG Cinese (Singapore) Pronuncia: 0x00001004 Conteggio tratti: 0x00021004
zh-MO Cinese (RAS di Macao) Pronuncia: 0x00001404 Conteggio tratti: 0x00021404
ja-JP Giapponese (Giappone) Impostazione predefinita: 0x00000411 Unicode: 0x00010411
ko-KR Coreano (Corea) Impostazione predefinita: 0x00000412 Coreano Xwansung - Unicode: 0x00010412
de-DE Tedesco (Germania) Dizionario: 0x00000407 Telefono BOOK Sort DIN: 0x00010407
hu-HU Ungherese (Ungheria) Impostazione predefinita: 0x0000040e Ordinamento tecnico: 0x0001040e
ka-GE Georgiano (Georgia) Tradizionale: 0x00000437 Ordinamento moderno: 0x00010437

Impostazioni cultura correnti e app UWP

Nelle app UWP (Universal Windows Platform), le proprietà e sono di lettura/scrittura, così come sono nelle app CurrentCulture CurrentUICulture .NET Framework e .NET Core. Tuttavia, le app UWP riconoscono impostazioni cultura singole. Le CurrentCulture proprietà e vengono CurrentUICulture mappate al primo valore nell'Windows. Raccolta ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages.

Nelle .NET Framework e nelle app .NET Core, le impostazioni cultura correnti sono un'impostazione per thread e le proprietà e riflettono solo le impostazioni cultura e le impostazioni cultura dell'interfaccia utente del CurrentCulture CurrentUICulture thread corrente. Nelle app UWP le impostazioni cultura correnti vengono mappate Windows. Raccolta ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages, che è un'impostazione globale. CurrentCultureL'impostazione della proprietà o modifica le impostazioni cultura dell'intera app. Le impostazioni cultura non CurrentUICulture possono essere impostate per ogni thread.

Costruttori

CultureInfo(Int32)

Inizializza una nuova istanza della classe CultureInfo in base alle impostazioni cultura specificate dall'identificatore delle impostazioni cultura.

CultureInfo(Int32, Boolean)

Inizializza una nuova istanza della classe CultureInfo in base alle impostazioni cultura specificate dall'identificatore di impostazioni cultura e al valore booleano che specifica se usare le impostazioni cultura del sistema selezionate dall'utente.

CultureInfo(String)

Inizializza una nuova istanza della classe CultureInfo in base alle impostazioni cultura specificate per nome.

CultureInfo(String, Boolean)

Inizializza una nuova istanza della classe CultureInfo in base alle impostazioni cultura specificate per nome e al valore booleano che indica se usare le impostazioni cultura del sistema selezionate dall'utente.

Proprietà

Calendar

Ottiene il calendario predefinito usato per le impostazioni cultura.

CompareInfo

Ottiene l'oggetto CompareInfo che definisce come confrontare le stringhe per le impostazioni cultura.

CultureTypes

Ottiene i tipi di impostazioni cultura che riguardano l'oggetto CultureInfo corrente.

CurrentCulture

Ottiene o imposta l'oggetto CultureInfo che rappresenta le impostazioni cultura usate dal thread corrente.

CurrentUICulture

Ottiene o imposta l'oggetto CultureInfo che rappresenta le impostazioni cultura correnti dell'interfaccia utente usate da Gestione risorse per cercare le risorse specifiche delle impostazioni cultura in fase di esecuzione.

DateTimeFormat

Ottiene o imposta un oggetto DateTimeFormatInfo che definisce il formato culturalmente appropriato per la visualizzazione della data e dell'ora.

DefaultThreadCurrentCulture

Ottiene o imposta le impostazioni cultura predefinite per i thread nel dominio dell'applicazione corrente.

DefaultThreadCurrentUICulture

Ottiene o imposta le impostazioni cultura predefinite dell'interfaccia utente per i thread nel dominio dell'applicazione corrente.

DisplayName

Ottiene il nome completo delle impostazioni cultura localizzate.

EnglishName

Ottiene il nome delle impostazioni cultura nel formato lingua [paese] in inglese.

IetfLanguageTag

Deprecato. Ottiene l'identificazione dello standard RFC 4646 per una lingua.

InstalledUICulture

Ottiene l'oggetto CultureInfo che rappresenta le impostazioni cultura installate con il sistema operativo.

InvariantCulture

Ottiene l'oggetto CultureInfo indipendente dalle impostazioni cultura.

IsNeutralCulture

Ottiene un valore che indica se la classe CultureInfo corrente rappresenta impostazioni cultura non associate ad alcun paese.

IsReadOnly

Ottiene un valore che indica se la classe CultureInfo corrente è di sola lettura.

KeyboardLayoutId

Ottiene l'ID delle impostazioni locali di input attivo.

LCID

Ottiene l'identificatore di impostazioni cultura per la classe CultureInfo corrente.

Name

Ottiene il nome delle impostazioni cultura nel formato codicelingua2-codicepaese2.

NativeName

Ottiene il nome delle impostazioni cultura, costituito dalla lingua, dal paese dallo script facoltativo impostati per la visualizzazione.

NumberFormat

Ottiene o imposta un oggetto NumberFormatInfo che definisce il formato culturalmente appropriato per la visualizzazione di numeri, valute e percentuali.

OptionalCalendars

Ottiene l'elenco dei calendari utilizzabili con le impostazioni cultura.

Parent

Ottiene l'oggetto CultureInfo che rappresenta le impostazioni cultura padre dell'oggetto CultureInfo corrente.

TextInfo

Ottiene l'oggetto TextInfo che definisce il sistema di scrittura associato alle impostazioni cultura.

ThreeLetterISOLanguageName

Ottiene il codice ISO 639-2 di tre lettere per la lingua della classe CultureInfo corrente.

ThreeLetterWindowsLanguageName

Ottiene il codice di tre lettere per la lingua come definito nell'API di Windows.

TwoLetterISOLanguageName

Ottiene il codice ISO 639-1 di due lettere per la lingua della classe CultureInfo corrente.

UseUserOverride

Ottiene un valore che indica se l'oggetto CultureInfo corrente usa le impostazioni cultura selezionate dall'utente.

Metodi

ClearCachedData()

Aggiorna le informazioni relative alle impostazioni cultura memorizzate nella cache.

Clone()

Crea una copia dell'oggetto CultureInfo corrente.

CreateSpecificCulture(String)

Crea un oggetto CultureInfo che rappresenta le impostazioni cultura specifiche associate al nome specificato.

Equals(Object)

Determina se l'oggetto specificato coincide con le stesse impostazioni cultura della classe CultureInfo corrente.

GetConsoleFallbackUICulture()

Ottiene impostazioni cultura dell'interfaccia utente alternative adatte per le applicazioni di console quando le impostazioni cultura predefinite dell'interfaccia utente grafica non sono adatte.

GetCultureInfo(Int32)

Recupera un'istanza di sola lettura e memorizzata nella cache di determinate impostazioni cultura utilizzando l'identificatore delle impostazioni cultura specificato.

GetCultureInfo(String)

Recupera un'istanza di sola lettura e inserita nella cache di determinate impostazioni cultura utilizzando il nome delle impostazioni cultura specificato.

GetCultureInfo(String, Boolean)

Recupera un'istanza di sola lettura e memorizzata nella cache di determinate impostazioni cultura.

GetCultureInfo(String, String)

Recupera un'istanza di sola lettura e memorizzata nella cache di determinate impostazioni cultura. I parametri specificano le impostazioni cultura inizializzate con gli oggetti TextInfo e CompareInfo specificati da altre impostazioni cultura.

GetCultureInfoByIetfLanguageTag(String)

Deprecato. Recupera un oggetto CultureInfo di sola lettura con caratteristiche linguistiche identificate dal tag della lingua RFC 4646 specificato.

GetCultures(CultureTypes)

Ottiene l'elenco delle impostazioni cultura supportate filtrate dal parametro CultureTypes specificato.

GetFormat(Type)

Ottiene un oggetto che definisce le modalità di formattazione del tipo specificato.

GetHashCode()

Viene usato come funzione hash per l'oggetto CultureInfo corrente, adatto per algoritmi hash e strutture di dati, ad esempio una tabella hash.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
ReadOnly(CultureInfo)

Restituisce un wrapper di sola lettura per l'oggetto CultureInfo specificato.

ToString()

Restituisce una stringa contenente il nome della classe CultureInfo corrente nel formato codicelingua2-codicepaese2.

Si applica a

Vedi anche