CultureInfo Classe
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
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 : IFormatProviderpublic ref class CultureInfo : ICloneable, IFormatProviderpublic class CultureInfo : IFormatProviderpublic class CultureInfo : ICloneable, IFormatProvider[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class CultureInfo : ICloneable, IFormatProvidertype CultureInfo = class
interface IFormatProvidertype 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 IFormatProviderPublic Class CultureInfo
Implements IFormatProviderPublic Class CultureInfo
Implements ICloneable, IFormatProvider- Ereditarietà
-
CultureInfo
- Attributi
- Implementazioni
Esempio
Nell'esempio seguente viene illustrato come creare un CultureInfo oggetto per lo 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 iso 639 a due lettere o a tre lettere minuscole 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 linguistico di due lettere, viene usato un codice di tre lettere definito in ISO 639-3.
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 languagecode2country/regioncode2-scripttag-. Un esempio di questo tipo di nome di cultura è uz-Cyrl-UZ per Uzbeko (cirillico, Uzbekistan). Nei sistemi operativi Windows precedenti a Windows Vista, un nome delle impostazioni cultura che include uno script usa il modello languagecode2--country/regioncode2scripttag, ad esempio per uz-UZ-Cyrl 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 cultura che scondiscono questa regola. Le culture cinesi (semplificate), denominate zh-Hanse cinesi (tradizionali), denominate zh-Hant, sono culture neutrali. I nomi delle impostazioni cultura rappresentano lo standard corrente e devono essere usati a meno che non si disponga di un motivo per l'uso dei nomi zh-CHS precedenti e zh-CHT.
Un identificatore di 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 cultura predefiniti o definire identificatori personalizzati.
Alcuni nomi e identificatori delle impostazioni cultura predefiniti vengono usati da questa e altre classi nello System.Globalization spazio dei nomi. Per informazioni dettagliate sulle impostazioni cultura per i sistemi Windows, vedere la colonna Tag linguanell'elenco dei nomi di lingua/area supportati da Windows. I nomi delle impostazioni cultura seguono lo standard definito da BCP 47.
I nomi e gli identificatori delle impostazioni cultura rappresentano solo un subset di impostazioni cultura che possono essere trovate in un determinato computer. Le versioni di Windows o i 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 una cultura, in particolare i nomi associati ai membri della classe seguenti:
Culture invarianti, neutrali e specifiche
Le culture sono in genere raggruppate in tre set: culture invarianti, culture neutrali e culture specifiche.
Una cultura invariante è insensibile. L'applicazione specifica le impostazioni cultura invarianti in base al nome usando una stringa vuota ("") o tramite il relativo identificatore. InvariantCulture definisce un'istanza delle impostazioni cultura invarianti. È associato alla lingua inglese, ma non a nessun paese/area geografica. Viene usato in quasi qualsiasi metodo nello Globalization spazio dei nomi che richiede impostazioni cultura.
Una cultura neutrale è una cultura associata a una lingua, ma non a un paese/area geografica. Una cultura specifica è una cultura associata a una lingua e a un paese/area geografica. Ad esempio, fr è il nome neutrale per la cultura francese ed fr-FR è il nome della cultura francese (Francia) specifica. Si noti che il cinese (semplificato) e il cinese (tradizionale) sono considerate anche culture neutrali.
La creazione di un'istanza di una classe per impostazioni CompareInfo cultura neutrali non è consigliata perché i dati contenuti sono arbitrari. Per visualizzare e ordinare i dati, specificare sia la lingua che l'area. Inoltre, la Name proprietà di un oggetto creato per una CompareInfo cultura neutrale restituisce solo il paese e non include l'area.
Le impostazioni cultura definite hanno una gerarchia in cui l'elemento padre di una cultura specifica è una cultura neutrale e l'elemento padre di una cultura neutrale è la cultura invariante. La Parent proprietà contiene le impostazioni cultura neutrali associate a impostazioni cultura specifiche. Le impostazioni cultura personalizzate devono definire la Parent proprietà in conformità con questo modello.
Se le risorse per una cultura specifica non sono disponibili nel sistema operativo, vengono usate le risorse per le impostazioni cultura neutrali associate. Se le risorse per le impostazioni cultura neutrali 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 di Windows equivalenti, identificate con un identificatore delle impostazioni locali uguale LCIDa .
Un o un DateTimeFormatInfoNumberFormatInfo può essere creato solo per le impostazioni cultura invarianti o per impostazioni cultura specifiche, non per le culture neutrali.
Se DateTimeFormatInfo.Calendar è l'oggetto Thread.CurrentCultureTaiwanCalendar ma non è impostato su zh-TW, quindi 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 ICU dipende dal singolo sistema operativo.
A causa di questo, le impostazioni cultura disponibili in una determinata implementazione di .NET, piattaforma o versione potrebbero non essere disponibili in un'implementazione diversa di .NET, piattaforma o versione.
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 aliaste nei sistemi Unix. "zh-CN" è un alias per la cultura "zh-Hans-CN" e "zh-TW" è un alias per la cultura "zh-Hant-TW". Le impostazioni cultura aliaste non vengono restituite dalle chiamate al GetCultures metodo e possono avere valori di proprietà diversi, incluse impostazioni cultura diverse Parent rispetto alle rispettive controparti di 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 per le impostazioni cultura per le impostazioni cultura "zh-CN" o "zh-TW", ma fornire risorse per le impostazioni cultura "zh-Hans" neutrali o "zh-Hant", l'applicazione caricherà le risorse per le impostazioni cultura neutrali in Windows ma non in Unix. Nei sistemi Unix è necessario impostare in modo esplicito il thread CurrentUICulture su "zh-Hans" o "zh-Hant".
Nei sistemi Windows, la chiamata CultureInfo.Equals a un'istanza che rappresenta le impostazioni cultura "zh-CN" e il passaggio di un'istanza "zh-Hans-CN" restituisce
true. Nei sistemi Unix, la chiamata al metodo restituiscefalse. Questo comportamento si applica anche alla chiamata Equals in un'istanza "zh-TW" CultureInfo e passarla a 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 le impostazioni cultura dell'interfaccia utente correnti e correnti sono determinate su thread che eseguono operazioni asincrone basate su attività, vedere la sezione Impostazioni cultura e operazioni asincrone basate sulle 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:
Recuperando il valore della CultureInfo.CurrentCulture proprietà.
Recuperando il valore della proprietà Thread.CurrentThread.CurrentCulture .
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:
Recuperando il valore della CultureInfo.CurrentUICulture proprietà.
Recuperando il valore della proprietà Thread.CurrentThread.CurrentUICulture .
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:
Creare un'istanza di un oggetto che rappresenta le impostazioni cultura chiamando un CultureInfoCultureInfo 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.
Assegnare l'oggetto CultureInfoCultureInfo.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
CultureInfoalla Thread.CurrentCulture proprietà o Thread.CurrentUICulture .
Nell'esempio seguente vengono recuperate le impostazioni cultura correnti. Se si tratta di impostazioni cultura diverse dalla lingua francese (Francia), le impostazioni cultura correnti vengono modificate in francese (Francia). In caso contrario, le impostazioni cultura correnti vengono modificate 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 altre culture slovene (Slovenia), cambia la cultura attuale 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 impostazioni cultura neutre da sole o in combinazione.
Nell'esempio seguente il GetCultures metodo viene chiamato due volte, prima con il System.Globalization.CultureTypes membro di enumerazione per recuperare tutte le impostazioni cultura personalizzate e quindi con il System.Globalization.CultureTypes membro di enumerazione per recuperare tutte le impostazioni cultura di sostituzione.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
// Get all custom cultures.
CultureInfo[] custom = CultureInfo.GetCultures(CultureTypes.UserCustomCulture);
if (custom.Length == 0) {
Console.WriteLine("There are no user-defined custom cultures.");
}
else {
Console.WriteLine("Custom cultures:");
foreach (var culture in custom)
Console.WriteLine(" {0} -- {1}", culture.Name, culture.DisplayName);
}
Console.WriteLine();
// Get all replacement cultures.
CultureInfo[] replacements = CultureInfo.GetCultures(CultureTypes.ReplacementCultures);
if (replacements.Length == 0) {
Console.WriteLine("There are no replacement cultures.");
}
else {
Console.WriteLine("Replacement cultures:");
foreach (var culture in replacements)
Console.WriteLine(" {0} -- {1}", culture.Name, culture.DisplayName);
}
Console.WriteLine();
}
}
// The example displays output like the following:
// Custom cultures:
// x-en-US-sample -- English (United States)
// fj-FJ -- Boumaa Fijian (Viti)
//
// There are no replacement cultures.
Imports System.Globalization
Module Example
Public Sub Main()
' Get all custom cultures.
Dim custom() As CultureInfo = CultureInfo.GetCultures(CultureTypes.UserCustomCulture)
If custom.Length = 0 Then
Console.WriteLine("There are no user-defined custom cultures.")
Else
Console.WriteLine("Custom cultures:")
For Each culture In custom
Console.WriteLine(" {0} -- {1}", culture.Name, culture.DisplayName)
Next
End If
Console.WriteLine()
' Get all replacement cultures.
Dim replacements() As CultureInfo = CultureInfo.GetCultures(CultureTypes.ReplacementCultures)
If replacements.Length = 0 Then
Console.WriteLine("There are no replacement cultures.")
Else
Console.WriteLine("Replacement cultures:")
For Each culture in replacements
Console.WriteLine(" {0} -- {1}", culture.Name, culture.DisplayName)
Next
End If
Console.WriteLine()
End Sub
End Module
' The example displays output like the following:
' Custom cultures:
' x-en-US-sample -- English (United States)
' fj-FJ -- Boumaa Fijian (Viti)
'
' There are no replacement cultures.
Impostazioni cultura e thread
Quando viene avviato un nuovo thread dell'applicazione, le impostazioni cultura correnti e le impostazioni cultura correnti dell'interfaccia utente vengono definite dalle impostazioni cultura di 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 sulle 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 nell'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 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 precedenti a .NET Framework 4.5, il modo più comune per garantire che il thread dell'applicazione principale condivida le stesse impostazioni cultura con tutti gli altri thread di lavoro consiste nel 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 simile chiamando il ThreadPool.QueueUserWorkItem(WaitCallback, Object) metodo .
A partire da .NET Framework 4.5, è possibile impostare le impostazioni cultura e le impostazioni cultura dell'interfaccia utente di tutti i thread in un dominio applicazione in modo più diretto assegnando un CultureInfo oggetto che rappresenta tali DefaultThreadCurrentCulture impostazioni cultura alle proprietà e DefaultThreadCurrentUICulture . Nell'esempio seguente vengono usate queste proprietà per garantire che tutti i thread nel dominio applicazione predefinito convidano 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 applicazione corrente al momento dell'impostazione di questi valori di proprietà. Per altre informazioni, vedere la sezione successiva , Impostazioni cultura e domini applicazione.
Quando si assegnano valori alle DefaultThreadCurrentCulture proprietà e DefaultThreadCurrentUICulture , le impostazioni cultura e 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 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 applicazione principale e non basarsi sulle DefaultThreadCurrentCulture proprietà e DefaultThreadCurrentUICulture per modificarle.
Impostazioni cultura e domini applicazione
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 applicazione predefinito su Francese (Francia) e quindi usa la AppDomainSetup classe e il AppDomainInitializer delegato per impostare le impostazioni cultura predefinite e le impostazioni cultura dell'interfaccia utente in un nuovo dominio 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 effettuata 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 i domini applicazione, vedere la sezione "Domini applicazione e thread" nell'argomento Domini applicazione .
Impostazioni cultura e operazioni asincrone basate su attività
Il modello di programmazione asincrona basato su attività usa Task oggetti e Task<TResult> 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 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 specificare come destinazione .NET Framework 4.6. L'esempio definisce un Func<TResult> delegato, formatDelegate, che restituisce alcuni numeri formattati come valori di valuta. Nell'esempio le impostazioni cultura di sistema correnti vengono modificate in francese (Francia) o, se francese (Francia) è già le impostazioni cultura correnti, inglese (Stati Uniti). E poi:
Richiama direttamente il delegato 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 principale dell'app chiamando il Task.RunSynchronously metodo .
Come illustrato nell'output dell'esempio, quando le impostazioni cultura correnti vengono modificate in francese (Francia), le impostazioni cultura correnti del thread da cui le attività vengono richiamate in modo asincrono diventano le impostazioni cultura correnti per l'operazione asincrona.
using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
[assembly:TargetFramework(".NETFramework,Version=v4.6")]
public class Example
{
public static void Main()
{
decimal[] values = { 163025412.32m, 18905365.59m };
string formatString = "C2";
Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
CultureInfo.CurrentCulture.Name,
Thread.CurrentThread.ManagedThreadId);
foreach (var value in values)
output += String.Format("{0} ", value.ToString(formatString));
output += Environment.NewLine;
return output;
};
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId);
// Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name);
if (CultureInfo.CurrentCulture.Name == "fr-FR")
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");
Console.WriteLine("Changed the current culture to {0}.\n",
CultureInfo.CurrentCulture.Name);
// Execute the delegate synchronously.
Console.WriteLine("Executing the delegate synchronously:");
Console.WriteLine(formatDelegate());
// Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously:");
var t1 = Task.Run(formatDelegate);
Console.WriteLine(t1.Result);
Console.WriteLine("Executing a task synchronously:");
var t2 = new Task<String>(formatDelegate);
t2.RunSynchronously();
Console.WriteLine(t2.Result);
}
}
// The example displays the following output:
// The example is running on thread 1
// The current culture is en-US
// Changed the current culture to fr-FR.
//
// Executing the delegate synchronously:
// Formatting using the fr-FR culture on thread 1.
// 163 025 412,32 € 18 905 365,59 €
//
// Executing a task asynchronously:
// Formatting using the fr-FR culture on thread 3.
// 163 025 412,32 € 18 905 365,59 €
//
// Executing a task synchronously:
// Formatting using the fr-FR culture on thread 1.
// 163 025 412,32 € 18 905 365,59 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks
<Assembly:TargetFramework(".NETFramework,Version=v4.6")>
Module Example
Public Sub Main()
Dim values() As Decimal = { 163025412.32d, 18905365.59d }
Dim formatString As String = "C2"
Dim formatDelegate As Func(Of String) = Function()
Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
CultureInfo.CurrentCulture.Name,
Thread.CurrentThread.ManagedThreadId)
output += Environment.NewLine
For Each value In values
output += String.Format("{0} ", value.ToString(formatString))
Next
output += Environment.NewLine
Return output
End Function
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId)
' Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name)
If CultureInfo.CurrentCulture.Name = "fr-FR" Then
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
Else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
End If
Console.WriteLine("Changed the current culture to {0}.",
CultureInfo.CurrentCulture.Name)
Console.WriteLine()
' Execute the delegate synchronously.
Console.WriteLine("Executing the delegate synchronously:")
Console.WriteLine(formatDelegate())
' Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously:")
Dim t1 = Task.Run(formatDelegate)
Console.WriteLine(t1.Result)
Console.WriteLine("Executing a task synchronously:")
Dim t2 = New Task(Of String)(formatDelegate)
t2.RunSynchronously()
Console.WriteLine(t2.Result)
End Sub
End Module
' The example displays the following output:
' The example is running on thread 1
' The current culture is en-US
' Changed the current culture to fr-FR.
'
' Executing the delegate synchronously:
' Formatting Imports the fr-FR culture on thread 1.
' 163 025 412,32 € 18 905 365,59 €
'
' Executing a task asynchronously:
' Formatting Imports the fr-FR culture on thread 3.
' 163 025 412,32 € 18 905 365,59 €
'
' Executing a task synchronously:
' Formatting Imports the fr-FR culture on thread 1.
' 163 025 412,32 € 18 905 365,59 €
Per le app destinate a versioni di .NET Framework precedenti a .NET Framework 4.6 o per le app che non hanno come destinazione una determinata versione di .NET Framework, le impostazioni cultura del thread chiamante non fanno parte del contesto di un'attività. A meno che non venga definito in modo esplicito, le impostazioni cultura dei nuovi thread per impostazione predefinita sono le impostazioni cultura del sistema. Nell'esempio seguente, identico all'esempio precedente, ad eccezione del fatto che manca l'attributo TargetFrameworkAttribute , viene illustrato questo. 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 a 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 assegnate in modo esplicito a impostazioni 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 del dominio dell'app.
L'esempio seguente mostra che le impostazioni cultura del thread chiamante rimangono le impostazioni cultura correnti di un'operazione asincrona basata su attività anche se il metodo che l'attività sta eseguendo supera i limiti del dominio 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 relativo GetFormattedNumber metodo. Una seconda attività segnala il dominio applicazione corrente, crea un nuovo dominio applicazione, crea un'istanza DataRetriever nel nuovo dominio applicazione e chiama il relativo GetFormattedNumber metodo. Come illustrato nell'output dell'esempio, le impostazioni cultura correnti sono rimaste invariate nel thread chiamante, nella prima attività e nella seconda attività sia durante l'esecuzione nel dominio applicazione principale che nel secondo dominio applicazione.
using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
[assembly:TargetFramework(".NETFramework,Version=v4.6")]
public class Example
{
public static void Main()
{
string formatString = "C2";
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId);
// Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name);
if (CultureInfo.CurrentCulture.Name == "fr-FR")
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");
Console.WriteLine("Changed the current culture to {0}.\n",
CultureInfo.CurrentCulture.Name);
// Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously in the main appdomain:");
var t1 = Task.Run(() => { DataRetriever d = new DataRetriever();
return d.GetFormattedNumber(formatString);
});
Console.WriteLine(t1.Result);
Console.WriteLine();
Console.WriteLine("Executing a task synchronously in two appdomains:");
var t2 = Task.Run(() => { Console.WriteLine("Thread {0} is running in app domain '{1}'",
Thread.CurrentThread.ManagedThreadId,
AppDomain.CurrentDomain.FriendlyName);
AppDomain domain = AppDomain.CreateDomain("Domain2");
DataRetriever d = (DataRetriever) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName,
"DataRetriever");
return d.GetFormattedNumber(formatString);
});
Console.WriteLine(t2.Result);
}
}
public class DataRetriever : MarshalByRefObject
{
public string GetFormattedNumber(String format)
{
Thread thread = Thread.CurrentThread;
Console.WriteLine("Current culture is {0}", thread.CurrentCulture);
Console.WriteLine("Thread {0} is running in app domain '{1}'",
thread.ManagedThreadId,
AppDomain.CurrentDomain.FriendlyName);
Random rnd = new Random();
Double value = rnd.NextDouble() * 1000;
return value.ToString(format);
}
}
// The example displays output like the following:
// The example is running on thread 1
// The current culture is en-US
// Changed the current culture to fr-FR.
//
// Executing a task asynchronously in a single appdomain:
// Current culture is fr-FR
// Thread 3 is running in app domain 'AsyncCulture4.exe'
// 93,48 €
//
// Executing a task synchronously in two appdomains:
// Thread 4 is running in app domain 'AsyncCulture4.exe'
// Current culture is fr-FR
// Thread 4 is running in app domain 'Domain2'
// 288,66 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks
<Assembly:TargetFramework(".NETFramework,Version=v4.6")>
Module Example
Public Sub Main()
Dim formatString As String = "C2"
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId)
' Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name)
If CultureInfo.CurrentCulture.Name = "fr-FR" Then
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
Else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
End If
Console.WriteLine("Changed the current culture to {0}.",
CultureInfo.CurrentCulture.Name)
Console.WriteLine()
' Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously in the main appdomain:")
Dim t1 = Task.Run(Function()
Dim d As New DataRetriever()
Return d.GetFormattedNumber(formatString)
End Function)
Console.WriteLine(t1.Result)
Console.WriteLine()
Console.WriteLine("Executing a task synchronously in two appdomains:")
Dim t2 = Task.Run(Function()
Console.WriteLine("Thread {0} is running in app domain '{1}'",
Thread.CurrentThread.ManagedThreadId,
AppDomain.CurrentDomain.FriendlyName)
Dim domain As AppDomain = AppDomain.CreateDomain("Domain2")
Dim d As DataRetriever = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName,
"DataRetriever"), DataRetriever)
Return d.GetFormattedNumber(formatString)
End Function)
Console.WriteLine(t2.Result)
End Sub
End Module
Public Class DataRetriever : Inherits MarshalByRefObject
Public Function GetFormattedNumber(format As String) As String
Dim thread As Thread = Thread.CurrentThread
Console.WriteLine("Current culture is {0}", thread.CurrentCulture)
Console.WriteLine("Thread {0} is running in app domain '{1}'",
thread.ManagedThreadId,
AppDomain.CurrentDomain.FriendlyName)
Dim rnd As New Random()
Dim value As Double = rnd.NextDouble() * 1000
Return value.ToString(format)
End Function
End Class
' The example displays output like the following:
' The example is running on thread 1
' The current culture is en-US
' Changed the current culture to fr-FR.
'
' Executing a task asynchronously in a single appdomain:
' Current culture is fr-FR
' Thread 3 is running in app domain 'AsyncCulture4.exe'
' 93,48 €
'
' Executing a task synchronously in two appdomains:
' Thread 4 is running in app domain 'AsyncCulture4.exe'
' Current culture is fr-FR
' Thread 4 is running in app domain 'Domain2'
' 288,66 €
Serializzazione di oggetti CultureInfo
Quando un CultureInfo oggetto viene serializzato, tutto ciò che viene effettivamente archiviato è Name e UseUserOverride. Viene deserializzato correttamente solo in un ambiente in cui Name ha lo stesso significato. I tre esempi seguenti illustrano perché questo non è sempre il caso:
Se il valore della CultureTypes proprietà è CultureTypes.InstalledWin32Culturese se tali impostazioni cultura sono state introdotte per la prima volta in una determinata versione del sistema operativo Windows, non è possibile deserializzarla in una versione precedente di Windows. Ad esempio, se sono state introdotte impostazioni cultura in Windows 10, non può essere deserializzata in Windows 8.
Se il CultureTypes valore è CultureTypes.UserCustomCulturee il computer in cui viene deserializzato non dispone di impostazioni cultura personalizzate dell'utente installate, non è possibile deserializzarlo.
Se il CultureTypes valore è CultureTypes.ReplacementCulturese il computer in cui viene deserializzato non dispone di queste impostazioni cultura di sostituzione, deserializza con lo stesso nome, ma non tutte le stesse caratteristiche. Ad esempio, se
en-USsi tratta di impostazioni cultura sostitutive nel computer A, ma non nel computer B e se un CultureInfo oggetto che fa riferimento a queste impostazioni cultura viene serializzato nel computer A e deserializzato nel computer B, nessuna delle caratteristiche personalizzate delle impostazioni cultura viene trasmessa. La cultura deserializza correttamente, ma con un significato diverso.
Pannello di controllo sostituzioni
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 da quella predefinita per le impostazioni cultura. In generale, le applicazioni devono rispettare queste sostituzioni utente.
Se UseUserOverride è true e le impostazioni cultura specificate corrispondono alle impostazioni cultura correnti di Windows, CultureInfo vengono utilizzate le sostituzioni, incluse le impostazioni utente per le proprietà dell'istanza DateTimeFormatInfo restituita dalla DateTimeFormat proprietà e le proprietà dell'istanza NumberFormatInfo restituita dalla NumberFormat proprietà . Se le impostazioni utente non sono compatibili con le impostazioni cultura associate a CultureInfo, ad esempio, se il calendario selezionato non è uno di OptionalCalendars, i risultati dei metodi e i valori delle proprietà non sono definiti.
Ordinamenti alternativi
Alcune impostazioni cultura supportano più di un ordinamento. Ad esempio:
Le impostazioni cultura spagnola (Spagna) hanno due ordini di ordinamento: l'ordinamento internazionale predefinito e l'ordinamento tradizionale. Quando si crea un'istanza di un CultureInfo oggetto con il nome delle
es-ESimpostazioni cultura, viene usato l'ordinamento internazionale. Quando si crea un'istanza di un CultureInfo oggetto con il nome dellees-ES-tradnlimpostazioni cultura, viene usato l'ordinamento tradizionale.Le
zh-CNimpostazioni 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 dellezh-CNimpostazioni cultura, viene usato l'ordinamento predefinito. Quando si crea un'istanza di un CultureInfo oggetto con un identificatore locale di 0x00020804, le stringhe vengono ordinate in base al conteggio dei tratti.
Nella tabella seguente sono elencate le impostazioni cultura che supportano gli ordini di ordinamento alternativi e gli identificatori per gli ordini di ordinamento predefiniti e alternativi.
| Nome lingua | Impostazioni cultura | 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 | Ordinamento rubrica telefonica: 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 dell'insieme Windows.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 vengono mappate all'insieme Windows.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 a un valore che specifica se utilizzare 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 in base al nome e a un valore che specifica se utilizzare 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 utilizzate 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 a due lettere o ISO 639-3 a tre lettere per la lingua dell'oggetto corrente CultureInfo. |
| 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
Commenti e suggerimenti
Invia e visualizza il feedback per