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 CultureInfo oggetto per spagnolo (Spagna) con l'ordinamento internazionale e un altro 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 CultureInfo classe fornisce informazioni specifiche delle impostazioni cultura, ad esempio lingua, sottolanguage, paese/area geografica, calendario e convenzioni associate a impostazioni cultura specifiche. Questa classe fornisce anche l'accesso a istanze specifiche delle impostazioni cultura degli DateTimeFormatInfooggetti , NumberFormatInfo, CompareInfoe TextInfo . Questi oggetti contengono le informazioni necessarie per operazioni specifiche delle impostazioni cultura, ad esempio l'uso di maiuscole e minuscole, la formattazione di date e numeri e il confronto delle stringhe. La CultureInfo classe viene usata direttamente o indirettamente dalle classi che formattano, analizzano o modificano dati specifici delle impostazioni cultura, ad esempio String, DateTimeDateTimeOffset, e i tipi numerici.

Contenuto della sezione:

Nomi e identificatori delle impostazioni cultura
Culture invarianti, neutre e specifiche
Impostazioni cultura personalizzate
Dati delle impostazioni cultura dinamiche
CultureInfo e dati culturali
Impostazioni cultura correnti e impostazioni cultura correnti dell'interfaccia utente
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 sostituzioni
Ordinamenti alternativi
Impostazioni cultura e app di Windows\

Nomi e identificatori delle impostazioni cultura

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

Nota

Quando un nome delle impostazioni cultura viene passato a un costruttore di classe o a un metodo come CreateSpecificCulture o CultureInfo, il relativo caso non è significativo.

Il formato per il nome delle impostazioni cultura basato su RFC 4646 è languagecode2-country/regioncode2, dove languagecode2 è il codice di lingua a due lettere ed country/regioncode2 è il codice di sottoculture a due lettere. Gli esempi includono ja-JP per il giapponese (Giappone) e en-US 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 delle impostazioni cultura specificano anche uno script ISO 15924. Ad esempio, Cyrl specifica lo script cirillico e Latn specifica lo script latino. Un nome delle impostazioni cultura che include uno script usa il modello languagecode2**country/regioncode2-scripttag-. Un esempio di questo tipo di nome di cultura è uz-Cyrl-UZ per Uzbeko (cirillico, Uzbekistan). In Windows sistemi operativi prima di Windows Vista, un nome delle impostazioni cultura che include uno script usa il modello languagecode2--country/regioncode2**scripttag, ad esempio, uz-UZ-Cyrl per Uzbeko (cirillico, Uzbekistan).

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

Nota

Esistono due nomi di impostazioni cultura che contraddicono questa regola. Le impostazioni cultura cinesi (semplificate), denominate zh-Hanse cinesi (tradizionali), denominate zh-Hant, sono culture neutre. I nomi delle impostazioni cultura rappresentano lo standard corrente e devono essere usati a meno che non si disponga di un motivo per usare i nomi zh-CHS precedenti 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 nomi e identificatori delle impostazioni cultura predefiniti vengono usati da questa e da altre classi nello System.Globalization spazio dei nomi . Per informazioni dettagliate sulle impostazioni cultura per Windows sistemi, vedere la colonna Tag lingua nell'elenco dei nomi di lingua/area geografica supportati da Windows. I nomi delle impostazioni cultura seguono lo standard definito da BCP 47.

I nomi delle impostazioni cultura e gli identificatori rappresentano solo un subset di impostazioni cultura disponibili in un determinato computer. 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 viene scritto nel codice gestito usando la CultureAndRegionInfoBuilder classe .

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

Culture invarianti, neutre e specifiche

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

Una cultura invariante è indipendente dalle impostazioni cultura. L'applicazione specifica le impostazioni cultura invarianti in base al nome usando una stringa vuota ("") o il relativo identificatore. InvariantCulture definisce un'istanza delle impostazioni cultura invarianti. È associato alla lingua inglese, ma non a nessun paese/area geografica. Viene usato in quasi tutti i metodi nello Globalization spazio dei nomi che richiede impostazioni cultura.

Una cultura neutra è una cultura associata a una lingua, ma non a un paese o a un'area geografica. Una cultura specifica è una cultura associata a una lingua e a un paese/area geografica. Ad esempio, fr è il nome neutro per le impostazioni cultura francesi ed fr-FR è il nome delle impostazioni cultura francese (Francia) specifiche. Si noti che anche i cinesi (semplificati) e il cinese (tradizionale) sono considerati culture neutre.

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

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

Se le risorse per impostazioni cultura specifiche non sono disponibili nel sistema operativo, vengono usate le risorse per le impostazioni cultura neutre associate. Se le risorse per le impostazioni cultura neutre 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 DateTimeFormatInfo oggetto o può NumberFormatInfo essere creato solo per le impostazioni cultura invarianti o per impostazioni cultura specifiche, non per le impostazioni cultura neutre.

Se DateTimeFormatInfo.Calendar è ma TaiwanCalendar Thread.CurrentCulture non è impostato su zh-TW, DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraNamee DateTimeFormatInfo.GetAbbreviatedEraName restituisce 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 una delle diverse origini, a seconda dell'implementazione, della piattaforma e della versione:

  • In .NET Framework 3.5 e versioni precedenti, i dati culturali vengono forniti sia dal sistema operativo Windows che da .NET Framework.

  • In .NET Framework 4 e versioni successive i dati culturali vengono forniti dal sistema operativo Windows.

  • In tutte le versioni di .NET Core in esecuzione in Windows, i dati culturali vengono forniti dal sistema operativo Windows.

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

Per questo motivo, 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 .NET diversa.

Alcuni CultureInfo oggetti differiscono a seconda della piattaforma sottostante. In particolare, zh-CNo cinese (semplificato, cina) e zh-TW, o cinese (tradizionale, Taiwan), sono disponibili impostazioni cultura nei sistemi Windows, ma sono impostazioni cultura con alias nei sistemi 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 GetCultures metodo e possono avere valori di proprietà diversi, incluse impostazioni cultura diverseParent, rispetto alle rispettive controparti Windows. Per le zh-CN impostazioni cultura e zh-TW , queste differenze includono quanto segue:

  • Nei sistemi Windows, la cultura padre della cultura "zh-CN" è "zh-Hans" e la cultura padre della cultura "zh-TW" è "zh-Hant". La cultura padre di entrambe queste culture è "zh". Nei sistemi Unix i genitori di entrambe le culture 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 forniscono risorse per le impostazioni cultura neutre "zh-Hans" o "zh-Hant", l'applicazione caricherà le risorse per le impostazioni cultura neutre in Windows ma non in Unix. Nei sistemi Unix è necessario impostare in modo esplicito il thread su CurrentUICulture "zh-Hans" o "zh-Hant".

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

Dati delle impostazioni cultura dinamiche

Ad eccezione delle impostazioni cultura invarianti, i dati cultura sono dinamici. Questo vale anche per le impostazioni cultura predefinite. Ad esempio, i paesi o le aree geografiche adottano nuove valute, modificare le ortografie delle parole o modificare il calendario preferito e le definizioni cultura cambiano per tenere traccia di questo. 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ò sostituire le preferenze culturali. Le applicazioni devono sempre ottenere dati cultura in fase di esecuzione.

Attenzione

Quando si salvano 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 una determinata cultura, diversa dalla cultura invariante, potrebbero diventare leggibili o modificare il significato se tale cultura cambia.

Impostazioni cultura correnti e impostazioni cultura dell'interfaccia utente correnti

Ogni thread in un'applicazione .NET include impostazioni cultura correnti e impostazioni cultura dell'interfaccia utente correnti. Le impostazioni cultura correnti determinano le convenzioni di formattazione per date, orari, numeri e valori di valuta, l'ordine di testo, le convenzioni di maiuscole e minuscole e i modi in cui vengono confrontate le stringhe. Le impostazioni cultura dell'interfaccia utente correnti vengono usate per recuperare risorse specifiche delle impostazioni cultura in fase di esecuzione.

Nota

Per informazioni sul modo in cui le impostazioni cultura correnti e correnti dell'interfaccia utente sono determinate in base a thread, vedere la sezione Impostazioni cultura e thread . Per informazioni sul modo in cui le impostazioni cultura correnti e correnti dell'interfaccia utente vengono determinate nei thread in esecuzione in un nuovo dominio applicazione e nei thread che superano i limiti di dominio dell'applicazione, vedere la sezione Impostazioni cultura e domini dell'applicazione . Per informazioni sul modo in cui l'oggetto corrente e corrente viene determinato 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 l'argomento della CultureInfo.CurrentCulture proprietà. Per informazioni più dettagliate sulle impostazioni cultura dell'interfaccia utente correnti, vedere l'argomento della CultureInfo.CurrentUICulture 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:

L'esempio seguente recupera entrambi i valori delle proprietà, li confronta per mostrare che sono uguali e visualizza 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 CultureInfo oggetto che rappresenta le impostazioni cultura dell'interfaccia utente correnti 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 dell'interfaccia utente correnti.

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 CultureInfo CultureInfo costruttore di classi e passandolo il nome delle impostazioni cultura. Il CultureInfo(String) costruttore crea un'istanza di un CultureInfo oggetto che riflette l'override dell'utente se le nuove impostazioni cultura sono uguali alle impostazioni cultura di Windows correnti. Il CultureInfo(String, Boolean) costruttore consente di specificare se l'oggetto appena creato CultureInfo riflette l'override dell'utente se le nuove impostazioni cultura sono uguali alle impostazioni cultura di Windows correnti.

  2. Assegnare l'oggetto CultureInfo CultureInfo.CurrentCulture alla proprietà o CultureInfo.CurrentUICulture in .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 è qualcosa di diverso dalla cultura francese (Francia), cambia la cultura corrente in francese (Francia). In caso contrario, cambia le impostazioni cultura correnti in francese (Lussemburgo).

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 un'altra cultura slovena (Slovenia), cambia la cultura corrente in Sloveno (Slovenia). In caso contrario, cambia la cultura corrente in Croato (Croazia).

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 culture neutrali o in combinazione.

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

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 dell'interfaccia utente correnti vengono definite dalle impostazioni cultura del sistema correnti 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 applicazione alle impostazioni cultura francese (Francia) (fr-FR). Se le impostazioni cultura correnti sono già fr-FR, l'esempio lo imposta sulle 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 tre numeri casuali come valori di valuta. Tuttavia, come illustrato dall'output dell'esempio, 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 dell'applicazione principale.

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 prima di .NET Framework 4.5, il modo più comune per garantire che il thread dell'applicazione principale condivide le stesse impostazioni cultura con tutti gli altri thread di lavoro sia passare il nome delle impostazioni cultura a livello di applicazione o un CultureInfo oggetto che rappresenta le impostazioni cultura a livello di applicazione a un System.Threading.ParameterizedThreadStart delegato. Nell'esempio seguente viene usato 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 analogo 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 più direttamente assegnando un CultureInfo oggetto che rappresenta le impostazioni cultura alle DefaultThreadCurrentCulture proprietà e DefaultThreadCurrentUICulture . Nell'esempio seguente vengono usate queste proprietà per assicurarsi che tutti i thread nel dominio applicazione predefinito condividono 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 DefaultThreadCurrentCulture proprietà e DefaultThreadCurrentUICulture sono membri statici, definiscono le impostazioni cultura predefinite e le impostazioni cultura predefinite dell'interfaccia utente solo per il dominio dell'applicazione corrente al momento in cui vengono impostati questi valori di proprietà. Per altre informazioni, vedere la sezione successiva, Impostazioni cultura e domini dell'applicazione.

Quando si assegnano valori alle DefaultThreadCurrentCulture proprietà e, le impostazioni cultura e DefaultThreadCurrentUICulture le impostazioni cultura dell'interfaccia utente dei thread nel dominio dell'applicazione cambiano anche se non sono state assegnate in modo esplicito a impostazioni cultura. Tuttavia, questi thread riflettono le nuove impostazioni cultura solo durante l'esecuzione nel dominio dell'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 DefaultThreadCurrentCulture proprietà e DefaultThreadCurrentUICulture per modificarle.

Domini cultura e applicazioni

DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture sono proprietà statiche che definiscono in modo esplicito impostazioni cultura predefinite solo per il dominio applicazione corrente 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 dell'applicazione predefinita su Francese (Francia) e quindi usa la classe e il AppDomainSetup AppDomainInitializer delegato per impostare le impostazioni cultura predefinite e le impostazioni cultura dell'interfaccia utente in un nuovo dominio dell'applicazione su russo (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 dell'applicazione in cui viene eseguito il thread. Si noti anche che le DefaultThreadCurrentCulture proprietà e DefaultThreadCurrentUICulture restituiscono i valori predefiniti CultureInfo del dominio applicazione corrente quando viene eseguita la chiamata al metodo.

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 applicazioni e thread" nell'argomento Domini applicazione.

Impostazioni cultura e operazioni asincrone basate su attività

Il modello di programmazione asincrona basato su attività usa Task e Task<TResult> oggetti per eseguire i delegati in modo asincrono 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 destinate a .NET Framework 4.6 o una versione successiva, le impostazioni cultura fanno parte del contesto di un'operazione asincrona. In altre parole, a partire dalle app destinate a .NET Framework 4.6, le operazioni asincrone ereditano per impostazione predefinita i valori delle CurrentCulture proprietà e CurrentUICulture del thread da cui vengono avviate. Se le impostazioni cultura correnti o le impostazioni cultura correnti dell'interfaccia utente differiscono 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 l'attributo TargetFrameworkAttribute per destinazione .NET Framework 4.6. L'esempio definisce un Func<TResult> delegato, formatDelegate, che restituisce alcuni numeri formattati come valori di valuta. Nell'esempio vengono modificate le impostazioni cultura di sistema correnti in francese (Francia) o, se francese (Francia) è già la cultura corrente, l'inglese (Stati Uniti). Quindi:

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

  • 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 dall'esempio, quando le impostazioni cultura correnti vengono modificate in francese (Francia), le impostazioni cultura correnti del thread da cui vengono richiamate le attività diventano in modo asincrono le impostazioni cultura correnti per tale 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 destinate alle versioni di .NET Framework precedenti a .NET Framework 4.6 o per le app che non fanno riferimento a una determinata versione di .NET Framework, le impostazioni cultura del thread chiamante non fanno parte del contesto di un'attività. Invece, a meno che non sia definito in modo esplicito, le impostazioni cultura dei nuovi thread per impostazione predefinita sono le impostazioni cultura di sistema. L'esempio seguente, identico all'esempio precedente, ad eccezione del fatto che non contiene l'attributo TargetFrameworkAttribute , illustra questa operazione. Poiché le impostazioni cultura di sistema del sistema in cui l'esempio eseguito è inglese (Stati Uniti), le impostazioni cultura dell'attività che viene eseguita in modo asincrono in un thread del pool di thread sono en-US anziché 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 destinate alle versioni di .NET Framework da .NET Framework 4.5 e versioni successive, ma prima di .NET Framework 4.6, è possibile usare le DefaultThreadCurrentCulture proprietà e DefaultThreadCurrentUICulture per assicurarsi che le impostazioni cultura del thread chiamante vengano usate nelle attività asincrone eseguite nei thread del pool di thread. L'esempio seguente è identico all'esempio precedente, ad eccezione del fatto che usa la DefaultThreadCurrentCulture proprietà per garantire che i thread del pool di thread abbiano le stesse impostazioni cultura 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 DefaultThreadCurrentUICulture sono proprietà di dominio per app, ovvero stabiliscono impostazioni cultura predefinite per tutti i thread non assegnati in modo esplicito a una cultura in un dominio applicazione specifico. Tuttavia, per le app destinate a .NET Framework 4.6 o versioni successive, le impostazioni cultura del thread chiamante rimangono parte del contesto di un'attività asincrona anche se l'attività supera i limiti di dominio dell'app.

Nell'esempio seguente viene illustrato che le impostazioni cultura del thread chiamante rimangono le impostazioni cultura correnti di un'operazione asincrona basata su attività anche se il metodo che l'attività sta eseguendo supera i limiti di dominio dell'applicazione. Definisce una classe, DataRetriever, con un singolo metodo , GetFormattedNumberche restituisce un numero a virgola mobile a precisione doppia casuale compreso tra 1 e 1.000 formattato come valore di valuta. Una prima attività viene eseguita che crea semplicemente un'istanza di un'istanza DataRetriever e chiama il GetFormattedNumber relativo metodo. Una seconda attività segnala il dominio dell'applicazione corrente, crea un nuovo dominio applicazione, crea un'istanza di un'istanza DataRetriever nel nuovo dominio dell'applicazione e chiama il GetFormattedNumber relativo metodo. Come illustrato dall'output dell'esempio, le impostazioni cultura correnti sono rimaste invariate nel thread chiamante, la prima attività e la seconda attività sia quando è in esecuzione nel dominio dell'applicazione principale che nel secondo dominio dell'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 dell'oggetto CultureInfo

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

  • Se il valore della CultureTypes proprietà è , e se tale cultura è CultureTypes.InstalledWin32Culturesstata introdotta prima in una determinata versione del sistema operativo Windows, non è possibile deserializzarla in una versione precedente di Windows. Ad esempio, se una cultura è stata introdotta in Windows 10, non può essere deserializzata in Windows 8.

  • Se il valore è CultureTypes.UserCustomCulturee il CultureTypes computer in cui è deserializzato non ha installato le impostazioni cultura personalizzate dell'utente, non è possibile deserializzarlo.

  • Se il valore è CultureTypes.ReplacementCultures, e il CultureTypes computer in cui è deserializzato non ha questa cultura sostitutiva, deserializza allo stesso nome, ma non tutte le stesse caratteristiche. Ad esempio, se en-US è una cultura sostitutiva nel computer A, ma non nel computer B e se un CultureInfo oggetto che fa riferimento a questa cultura viene serializzato nel computer A e deserializzato nel computer B, none le caratteristiche personalizzate delle impostazioni cultura vengono trasmesse. La cultura deserializza correttamente, ma con un significato diverso.

Pannello di controllo override

L'utente potrebbe scegliere di eseguire l'override di alcuni dei valori associati alle impostazioni cultura correnti di Windows tramite la parte delle opzioni internazionali e della lingua di Pannello di controllo. Ad esempio, l'utente potrebbe scegliere di visualizzare la data in un formato diverso o di usare una valuta diversa dall'impostazione predefinita per le impostazioni cultura. In generale, le applicazioni devono rispettare questi overridi utente.

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

Ordini di ordinamento alternativi

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

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

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

Nella tabella seguente sono elencate le impostazioni cultura che supportano ordini di ordinamento alternativi e gli identificatori per gli ordini di ordinamento 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 Xwansung coreano - Unicode: 0x00010412
de-DE Tedesco (Germania) Dizionario: 0x00000407 Telefono ordinamento libro 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 piattaforma UWP (Universal Windows Platform) (UWP), le CurrentCulture proprietà e CurrentUICulture sono di lettura-scrittura, proprio come sono nelle app .NET Framework e .NET Core. Tuttavia, le app UWP riconoscono una singola cultura. Le CurrentCulture proprietà e CurrentUICulture mappano al primo valore nella Windows. Insieme ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages.

Nelle app .NET Framework e .NET Core, le impostazioni cultura correnti sono un'impostazione per thread e le CurrentCulture proprietà e CurrentUICulture riflettono solo le impostazioni cultura e le impostazioni dell'interfaccia utente del thread corrente. Nelle app UWP le impostazioni cultura correnti sono mappate alla Windows. Insieme ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages, ovvero un'impostazione globale. L'impostazione della CurrentCulture proprietà o CurrentUICulture modifica le impostazioni cultura dell'intera app. Le impostazioni cultura non possono essere impostate su base 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 CultureInfo classe in base alle impostazioni cultura specificate dall'identificatore delle impostazioni cultura e su un valore che specifica se usare le impostazioni cultura selezionate dall'utente da Windows.

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 CultureInfo classe in base alle impostazioni cultura specificate dal nome e su un valore che specifica se usare le impostazioni cultura selezionate dall'utente da Windows.

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 e dalle operazioni asincrone basate su attività.

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