CultureInfo Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Proporciona información sobre una referencia cultural concreta (lo que se denomina configuración regional en desarrollo de código no administrado). La información incluye los nombres de la referencia cultural, el sistema de escritura, el calendario usado, el criterio de ordenación y el formato de las fechas y los números.
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- Herencia
-
CultureInfo
- Atributos
- Implementaciones
Ejemplos
En el ejemplo siguiente se muestra cómo crear un CultureInfo objeto para español (España) con la ordenación internacional y otro CultureInfo objeto con la ordenación tradicional.
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
Comentarios
La CultureInfo clase proporciona información específica de la referencia cultural, como el idioma, la sublanguaje, el país o la región, el calendario y las convenciones asociadas a una referencia cultural determinada. Esta clase también proporciona acceso a instancias específicas de la referencia cultural de los DateTimeFormatInfoobjetos , NumberFormatInfoCompareInfo, y TextInfo . Estos objetos contienen la información necesaria para las operaciones específicas de la referencia cultural, como mayúsculas y minúsculas, fechas y números, y la comparación de cadenas. La CultureInfo clase se usa directa o indirectamente por clases que formatear, analizar o manipular datos específicos de la referencia cultural, como String, DateTimeDateTimeOffset, y los tipos numéricos.
En esta sección:
Nombres e identificadores de referencia cultural
Referencias culturales invariables, neutras y específicas
Referencias culturales personalizadas
Datos de referencia cultural dinámica
CultureInfo y datos culturales
La referencia cultural actual y la referencia cultural de la interfaz de usuario actual
Obtener todas las referencias culturales
Referencia cultural y subprocesos
Dominios de referencia cultural y de aplicación
Referencia cultural y operaciones asincrónicas basadas en tareas
Serialización de objetos CultureInfo
invalidaciones de Panel de control
Pedidos de ordenación alternativos
Referencia cultural y aplicaciones de Windows
Nombres e identificadores de referencia cultural
La CultureInfo clase especifica un nombre único para cada referencia cultural, basada en RFC 4646. El nombre es una combinación de un código de referencia cultural en minúsculas iso 639 de dos letras o tres letras asociado a un idioma y un código de subcultivo en mayúsculas iso 3166 de dos letras asociado a un país o región. Además, para las aplicaciones destinadas a .NET Framework 4 o posterior y que se ejecutan en Windows 10 o posterior, se admiten nombres de referencia cultural que corresponden a etiquetas de idioma BCP-47 válidas.
Nota
Cuando se pasa un nombre de referencia cultural a un constructor de clase o a un método como CreateSpecificCulture o CultureInfo, su caso no es significativo.
El formato del nombre de referencia cultural basado en RFC 4646 es languagecode2-country/regioncode2, donde languagecode2 es el código de idioma de dos letras y country/regioncode2 es el código de subculture de dos letras. Entre los ejemplos se incluyen ja-JP japonés (Japón) y en-US para inglés (Estados Unidos). En los casos en los que un código de lenguaje de dos letras no está disponible, se usa un código de tres letras tal y como se define en ISO 639-3.
Algunos nombres de referencia cultural también especifican un script ISO 15924. Por ejemplo, Cyrl especifica el script cirílico y Latn especifica el script latino. Un nombre de referencia cultural que incluye un script usa el patrón languagecode2country/regioncode2-scripttag-. Un ejemplo de este tipo de nombre cultural es uz-Cyrl-UZ para Uzbek (Cirílico, Uzbekistán). En los sistemas operativos Windows antes de Windows Vista, un nombre de referencia cultural que incluye un script usa el patrón languagecode2--country/regioncode2scripttag, por ejemplo, uz-UZ-Cyrl para Uzbek (cirílico, Uzbekistán).
Solo el código de idioma en minúsculas de dos letras especifica una referencia cultural neutra. Por ejemplo, fr especifica la referencia cultural neutra para francés y de especifica la referencia cultural neutra para alemán.
Nota
Hay dos nombres de referencia cultural que contradigan esta regla. Las referencias culturales chinas (simplificadas), denominadas zh-Hans, y china (tradicional), denominadas zh-Hant, son referencias culturales neutras. Los nombres de referencia cultural representan el estándar actual y deben usarse a menos que tenga un motivo para usar los nombres zh-CHS anteriores y zh-CHT.
Un identificador de referencia cultural es una abreviatura numérica internacional estándar y tiene los componentes necesarios para identificar de forma única una de las referencias culturales instaladas. La aplicación puede usar identificadores de referencia cultural predefinidos o definir identificadores personalizados.
Este y otras clases del System.Globalization espacio de nombres usan determinados nombres de referencia cultural predefinidos e identificadores. Para obtener información detallada sobre la referencia cultural de los sistemas Windows, consulte la columna Etiqueta de idioma en la lista de nombres de idioma o región admitidos por Windows. Los nombres de las referencias culturales siguen el estándar definido por BCP 47.
Los nombres de referencia cultural y los identificadores representan solo un subconjunto de referencias culturales que se pueden encontrar en un equipo determinado. Las versiones de Windows o Service Pack pueden cambiar las referencias culturales disponibles. Las aplicaciones pueden agregar referencias culturales personalizadas mediante la CultureAndRegionInfoBuilder clase . Los usuarios pueden agregar sus propias referencias culturales personalizadas mediante la herramienta Microsoft Locale Builder . Microsoft Locale Builder se escribe en código administrado mediante la CultureAndRegionInfoBuilder clase .
Varios nombres distintos están estrechamente asociados a una referencia cultural, en particular los nombres asociados a los siguientes miembros de clase:
Referencias culturales invariables, neutras y específicas
Las referencias culturales se agrupan generalmente en tres conjuntos: referencias culturales invariables, referencias culturales neutras y referencias culturales específicas.
Una referencia cultural invariable no distingue la referencia cultural. La aplicación especifica la referencia cultural invariable por nombre mediante una cadena vacía ("") o por su identificador. InvariantCulture define una instancia de la referencia cultural invariable. Está asociado al idioma inglés, pero no a ningún país o región. Se usa en casi cualquier método del Globalization espacio de nombres que requiera una referencia cultural.
Una referencia cultural neutra es una referencia cultural asociada a un idioma, pero no a un país o región. Una referencia cultural específica es una referencia cultural asociada a un idioma y a un país o región. Por ejemplo, fr es el nombre neutro de la referencia cultural francesa y fr-FR es el nombre de la referencia cultural específica de francés (Francia). Tenga en cuenta que los chinos (simplificados) y chinos (tradicionales) también se consideran culturas neutras.
No se recomienda crear una instancia de una CompareInfo clase para una referencia cultural neutra porque los datos que contiene son arbitrarios. Para mostrar y ordenar los datos, especifique el idioma y la región. Además, la Name propiedad de un CompareInfo objeto creado para una referencia cultural neutra devuelve solo el país y no incluye la región.
Las referencias culturales definidas tienen una jerarquía en la que el elemento primario de una referencia cultural específica es una referencia cultural neutra y el elemento primario de una referencia cultural neutra es la referencia cultural invariable. La Parent propiedad contiene la referencia cultural neutra asociada a una referencia cultural específica. Las referencias culturales personalizadas deben definir la Parent propiedad conforme a este patrón.
Si los recursos de una referencia cultural específica no están disponibles en el sistema operativo, se usan los recursos de la referencia cultural neutra asociada. Si los recursos de la referencia cultural neutra no están disponibles, se usan los recursos insertados en el ensamblado principal. Para obtener más información sobre el proceso de reserva de recursos, consulte Empaquetado e implementación de recursos.
La lista de configuraciones regionales de la API de Windows es ligeramente diferente de la lista de referencias culturales admitidas por .NET. Si se requiere interoperabilidad con Windows, por ejemplo, mediante el mecanismo p/invoke, la aplicación debe usar una referencia cultural específica definida para el sistema operativo. El uso de la referencia cultural específica garantiza la coherencia con la configuración regional equivalente de Windows, que se identifica con un identificador de configuración regional que es el mismo LCIDque .
Un DateTimeFormatInfo o NumberFormatInfo se puede crear solo para la referencia cultural invariable o para referencias culturales específicas, no para referencias culturales neutras.
Si DateTimeFormatInfo.Calendar es , TaiwanCalendar pero Thread.CurrentCulture no se establece zh-TWen , , DateTimeFormatInfo.NativeCalendarNameDateTimeFormatInfo.GetEraNamey DateTimeFormatInfo.GetAbbreviatedEraName devuelve una cadena vacía ("").
Referencias culturales personalizadas
En Windows, puede crear configuraciones regionales personalizadas. Para obtener más información, consulte Configuraciones regionales personalizadas.
CultureInfo y datos culturales
.NET deriva sus datos culturales de una de varias fuentes, según la implementación, la plataforma y la versión:
En .NET Framework 3.5 y versiones anteriores, tanto el sistema operativo Windows como .NET Framework proporcionan datos culturales.
En .NET Framework 4 y versiones posteriores, el sistema operativo Windows proporciona datos culturales.
En todas las versiones de .NET Core que se ejecutan en Windows, el sistema operativo Windows proporciona datos culturales.
En todas las versiones de .NET Core que se ejecutan en plataformas Unix, la biblioteca International Components for Unicode (ICU) proporciona datos culturales. La versión específica de la biblioteca de ICU depende del sistema operativo individual.
Debido a esto, es posible que una referencia cultural disponible en una implementación, plataforma o versión de .NET determinada no esté disponible en otra implementación, plataforma o versión de .NET.
Algunos CultureInfo objetos difieren en función de la plataforma subyacente. En particular, , zh-CNo chino (simplificado, China) y zh-TW, o chino (tradicional, Taiwán), están disponibles referencias culturales en sistemas Windows, pero son referencias culturales alias en sistemas Unix. "zh-CN" es un alias para la referencia cultural "zh-Hans-CN", y "zh-TW" es un alias para la referencia cultural "zh-Hant-TW". Las referencias culturales con alias no se devuelven mediante llamadas al GetCultures método y pueden tener valores de propiedad diferentes, incluidas referencias culturales diferentes Parent , que sus homólogos de Windows. Para las zh-CN referencias culturales y zh-TW , estas diferencias incluyen lo siguiente:
En los sistemas Windows, la cultura primaria de la cultura "zh-CN" es "zh-Hans", y la cultura primaria de la cultura "zh-TW" es "zh-Hant". La cultura primaria de ambas culturas es "zh". En los sistemas Unix, los elementos primarios de ambas culturas son "zh". Esto significa que, si no proporciona recursos específicos de la referencia cultural para las referencias culturales "zh-CN" o "zh-TW", pero proporciona recursos para la referencia cultural neutra "zh-Hans" o "zh-Hant", la aplicación cargará los recursos para la referencia cultural neutral en Windows, pero no en Unix. En sistemas Unix, debe establecer explícitamente el del CurrentUICulture subproceso en "zh-Hans" o "zh-Hant".
En los sistemas Windows, llamar a CultureInfo.Equals en una instancia que representa la referencia cultural "zh-CN" y pasarla a una instancia de "zh-Hans-CN" devuelve
true. En los sistemas Unix, la llamada al método devuelvefalse. Este comportamiento también se aplica a llamar Equals a en una instancia de "zh-TW" CultureInfo y pasarla a una instancia de "zh-Hant-Tw".
Datos de referencia cultural dinámica
Excepto para la referencia cultural invariable, los datos de referencia cultural son dinámicos. Esto es cierto incluso para las referencias culturales predefinidas. Por ejemplo, los países o regiones adoptan nuevas monedas, cambian sus ortografías de palabras, o cambian su calendario preferido y las definiciones de referencia cultural cambian para realizar un seguimiento de esto. Las referencias culturales personalizadas están sujetas a cambios sin previo aviso y cualquier referencia cultural específica puede invalidarse mediante una referencia cultural de reemplazo personalizada. Además, como se describe a continuación, un usuario individual puede invalidar las preferencias culturales. Las aplicaciones siempre deben obtener datos de referencia cultural en tiempo de ejecución.
Precaución
Al guardar datos, la aplicación debe usar la referencia cultural invariable, un formato binario o un formato específico independiente de la referencia cultural. Los datos guardados según los valores actuales asociados a una referencia cultural determinada, aparte de la referencia cultural invariable, podrían ser ilegibles o podrían cambiar en sentido si esa referencia cultural cambia.
La referencia cultural actual y la referencia cultural de la interfaz de usuario actual
Cada subproceso de una aplicación .NET tiene una referencia cultural actual y una referencia cultural de interfaz de usuario actual. La referencia cultural actual determina las convenciones de formato para las fechas, las horas, los números y los valores de moneda, el criterio de ordenación del texto, las convenciones de mayúsculas y minúsculas y las formas en que se comparan las cadenas. La referencia cultural de la interfaz de usuario actual se usa para recuperar recursos específicos de la referencia cultural en tiempo de ejecución.
Nota
Para obtener información sobre cómo se determina la referencia cultural de interfaz de usuario actual y actual por subproceso, consulte la sección Referencia cultural y subprocesos . Para obtener información sobre cómo se determina la referencia cultural de la interfaz de usuario actual y actual en los subprocesos que se ejecutan en un nuevo dominio de aplicación y en subprocesos que cruzan los límites del dominio de la aplicación, consulte la sección Referencia cultural y dominios de aplicación . Para obtener información sobre cómo se determina el actual y el actual en los subprocesos que realizan operaciones asincrónicas basadas en tareas, consulte la sección Referencia cultural y operaciones asincrónicas basadas en tareas .
Para obtener información más detallada sobre la referencia cultural actual, consulte el tema de propiedades CultureInfo.CurrentCulture . Para obtener información más detallada sobre la referencia cultural de la interfaz de usuario actual, consulte el tema de CultureInfo.CurrentUICulture propiedades.
Recuperación de las referencias culturales actuales y actuales de la interfaz de usuario
Puede obtener un CultureInfo objeto que represente la referencia cultural actual de dos maneras:
Recuperando el valor de la CultureInfo.CurrentCulture propiedad .
Recuperando el valor de la propiedad Thread.CurrentThread.CurrentCulture .
En el ejemplo siguiente se recuperan ambos valores de propiedad, se comparan para mostrar que son iguales y se muestra el nombre de la referencia cultural actual.
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
Puede obtener un CultureInfo objeto que represente la referencia cultural de la interfaz de usuario actual de cualquiera de estas dos maneras:
Recuperando el valor de la CultureInfo.CurrentUICulture propiedad .
Recuperando el valor de la propiedad Thread.CurrentThread.CurrentUICulture .
En el ejemplo siguiente se recuperan ambos valores de propiedad, se comparan para mostrar que son iguales y se muestra el nombre de la referencia cultural de la interfaz de usuario actual.
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
Establecimiento de las referencias culturales actuales y actuales de la interfaz de usuario
Para cambiar la referencia cultural y la referencia cultural de la interfaz de usuario de un subproceso, haga lo siguiente:
Cree una instancia de un CultureInfo objeto que represente esa referencia cultural llamando a un CultureInfo constructor de clase y pasando el nombre de la referencia cultural. El CultureInfo(String) constructor crea una instancia de un CultureInfo objeto que refleja invalidaciones de usuario si la nueva referencia cultural es la misma que la referencia cultural actual de Windows. El CultureInfo(String, Boolean) constructor permite especificar si el objeto recién creado CultureInfo refleja las invalidaciones de usuario si la nueva referencia cultural es la misma que la referencia cultural actual de Windows.
Asigne el CultureInfo objeto a la CultureInfo.CurrentCulture propiedad o CultureInfo.CurrentUICulture en .NET Core y .NET Framework 4.6 y versiones posteriores. (En .NET Framework 4.5.2 y versiones anteriores, puede asignar el
CultureInfoobjeto a la Thread.CurrentCulture propiedad o Thread.CurrentUICulture ).
En el ejemplo siguiente se recupera la referencia cultural actual. Si es algo distinto de la cultura francesa (Francia), cambia la referencia cultural actual a francés (Francia). De lo contrario, cambia la referencia cultural actual a francés (Luxemburgo).
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
En el ejemplo siguiente se recupera la referencia cultural actual. Si es cualquier otra cultura eslovena (Eslovenia), cambia la cultura actual a Eslovenia (Eslovenia). De lo contrario, cambia la cultura actual a croata (Croacia).
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
Obtener todas las referencias culturales
Puede recuperar una matriz de categorías culturales específicas o de todas las referencias culturales disponibles en el equipo local llamando al GetCultures método . Por ejemplo, puede recuperar referencias culturales personalizadas, referencias culturales específicas o referencias culturales neutras, ya sea solas o combinadas.
En el ejemplo siguiente se llama al GetCultures método dos veces, primero con el miembro de System.Globalization.CultureTypes enumeración para recuperar todas las referencias culturales personalizadas y, a continuación, con el miembro de System.Globalization.CultureTypes enumeración para recuperar todas las referencias culturales de reemplazo.
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.
Referencia cultural y subprocesos
Cuando se inicia un nuevo subproceso de aplicación, la referencia cultural actual y la referencia cultural de la interfaz de usuario actual se definen mediante la referencia cultural del sistema actual y no la referencia cultural del subproceso actual. En el siguiente ejemplo se ilustra la diferencia. Establece la referencia cultural actual y la referencia cultural actual de la interfaz de usuario de un subproceso de aplicación en la referencia cultural francesa (Francia) (fr-FR). Si la referencia cultural actual ya es fr-FR, el ejemplo lo establece en la referencia cultural inglés (Estados Unidos) (en-US). Muestra tres números aleatorios como valores de moneda y, a continuación, crea un nuevo subproceso, que, a su vez, muestra tres números aleatorios más como valores de moneda. Pero como se muestra en la salida del ejemplo, los valores de moneda mostrados por el nuevo subproceso no reflejan las convenciones de formato de la referencia cultural francesa (Francia), a diferencia de la salida del subproceso de aplicación principal.
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
En versiones de .NET Framework anteriores a .NET Framework 4.5, la manera más común de asegurarse de que el subproceso de aplicación principal comparte la misma referencia cultural con todos los demás subprocesos de trabajo es pasar el nombre de la referencia cultural de toda la aplicación o un CultureInfo objeto que representa la referencia cultural de toda la aplicación a un System.Threading.ParameterizedThreadStart delegado. En el ejemplo siguiente se usa este enfoque para asegurarse de que los valores de moneda mostrados por dos subprocesos reflejan las convenciones de formato de la misma referencia cultural.
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 €
Puede establecer la referencia cultural y la referencia cultural de la interfaz de usuario de los subprocesos del grupo de subprocesos de forma similar llamando al ThreadPool.QueueUserWorkItem(WaitCallback, Object) método .
A partir de .NET Framework 4.5, puede establecer la referencia cultural y la referencia cultural de la interfaz de usuario de todos los subprocesos de un dominio de aplicación más directamente asignando un CultureInfo objeto que representa esa referencia cultural a las DefaultThreadCurrentCulture propiedades y DefaultThreadCurrentUICulture . En el ejemplo siguiente se usan estas propiedades para asegurarse de que todos los subprocesos del dominio de aplicación predeterminado comparten la misma referencia cultural.
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 €
Advertencia
Aunque las DefaultThreadCurrentCulture propiedades y DefaultThreadCurrentUICulture son miembros estáticos, definen la referencia cultural predeterminada y la referencia cultural de interfaz de usuario predeterminada solo para el dominio de aplicación que está activo en el momento en que se establecen estos valores de propiedad. Para obtener más información, consulte la sección siguiente, Referencia cultural y dominios de aplicación.
Al asignar valores a las DefaultThreadCurrentCulture propiedades y DefaultThreadCurrentUICulture , la referencia cultural y la referencia cultural de la interfaz de usuario de los subprocesos del dominio de aplicación también cambian si no se les ha asignado explícitamente una referencia cultural. Sin embargo, estos subprocesos reflejan la nueva configuración de referencia cultural solo mientras se ejecutan en el dominio de aplicación actual. Si estos subprocesos se ejecutan en otro dominio de aplicación, su referencia cultural se convierte en la referencia cultural predeterminada definida para ese dominio de aplicación. Como resultado, se recomienda establecer siempre la referencia cultural del subproceso de aplicación principal y no confiar en las DefaultThreadCurrentCulture propiedades y DefaultThreadCurrentUICulture para cambiarla.
Dominios de referencia cultural y de aplicación
DefaultThreadCurrentCulture y DefaultThreadCurrentUICulture son propiedades estáticas que definen explícitamente una referencia cultural predeterminada solo para el dominio de aplicación que es actual cuando se establece o recupera el valor de la propiedad. En el ejemplo siguiente se establece la referencia cultural predeterminada y la referencia cultural predeterminada de la interfaz de usuario en el dominio de aplicación predeterminado en francés (Francia) y, a continuación, se usa la AppDomainSetup clase y el delegado para establecer la referencia cultural predeterminada y la AppDomainInitializer referencia cultural de la interfaz de usuario en un nuevo dominio de aplicación en ruso (Rusia). A continuación, un único subproceso ejecuta dos métodos en cada dominio de aplicación. Tenga en cuenta que la referencia cultural y la referencia cultural de la interfaz de usuario del subproceso no se establecen explícitamente; se derivan de la referencia cultural predeterminada y la referencia cultural de la interfaz de usuario del dominio de aplicación en el que se ejecuta el subproceso. Tenga en cuenta también que las DefaultThreadCurrentCulture propiedades y DefaultThreadCurrentUICulture devuelven los valores predeterminados CultureInfo del dominio de aplicación que es actual cuando se realiza la llamada al método.
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
Para obtener más información sobre las referencias culturales y los dominios de aplicación, vea la sección "Dominios de aplicación y subprocesos" del tema Dominios de aplicación .
Referencia cultural y operaciones asincrónicas basadas en tareas
El patrón de programación asincrónica basado en tareas usa Task objetos y Task<TResult> para ejecutar de forma asincrónica delegados en subprocesos del grupo de subprocesos. El subproceso específico en el que se ejecuta una tarea determinada no se conoce de antemano, pero solo se determina en tiempo de ejecución.
En el caso de las aplicaciones destinadas a .NET Framework 4.6 o una versión posterior, la referencia cultural forma parte del contexto de una operación asincrónica. En otras palabras, a partir de aplicaciones destinadas a .NET Framework 4.6, las operaciones asincrónicas heredan de forma predeterminada los valores de las CurrentCulture propiedades y CurrentUICulture del subproceso desde el que se inician. Si la referencia cultural actual o la referencia cultural actual de la interfaz de usuario difieren de la referencia cultural del sistema, la referencia cultural actual cruza los límites de subprocesos y se convierte en la referencia cultural actual del subproceso del grupo de subprocesos que ejecuta una operación asincrónica.
Esto se muestra en el ejemplo siguiente. Usa el TargetFrameworkAttribute atributo para tener como destino .NET Framework 4.6. En el ejemplo se define un Func<TResult> delegado, formatDelegate, que devuelve algunos números con formato de valores de moneda. En el ejemplo se cambia la referencia cultural del sistema actual a francés (Francia) o, si francés (Francia) ya es la referencia cultural actual, inglés (Estados Unidos). Después:
Invoca el delegado directamente para que se ejecute de forma sincrónica en el subproceso de la aplicación principal.
Crea una tarea que ejecuta el delegado de forma asincrónica en un subproceso del grupo de subprocesos.
Crea una tarea que ejecuta el delegado de forma sincrónica en el subproceso principal de la aplicación llamando al Task.RunSynchronously método .
Como se muestra en la salida del ejemplo, cuando la referencia cultural actual cambia a francés (Francia), la referencia cultural actual del subproceso desde el que se invocan tareas de forma asincrónica se convierte en la referencia cultural actual para esa operación asincrónica.
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 €
En el caso de las aplicaciones destinadas a versiones de .NET Framework anteriores a .NET Framework 4.6 o para aplicaciones que no tienen como destino una versión determinada de .NET Framework, la referencia cultural del subproceso que realiza la llamada no forma parte del contexto de una tarea. En su lugar, a menos que se defina explícitamente, la referencia cultural de los nuevos subprocesos de forma predeterminada es la referencia cultural del sistema. En el ejemplo siguiente, que es idéntico al ejemplo anterior, salvo que carece del TargetFrameworkAttribute atributo , se muestra esto. Dado que la referencia cultural del sistema del sistema en la que se ejecutó el ejemplo era inglés (Estados Unidos), la referencia cultural de la tarea que se ejecuta de forma asincrónica en un subproceso del grupo de subprocesos es en-US en lugar de 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 €
En el caso de las aplicaciones destinadas a versiones de .NET Framework desde .NET Framework 4.5 y versiones posteriores, pero anteriores a .NET Framework 4.6, puede usar las DefaultThreadCurrentCulture propiedades y DefaultThreadCurrentUICulture para asegurarse de que la referencia cultural del subproceso de llamada se usa en tareas asincrónicas que se ejecutan en subprocesos del grupo de subprocesos. El ejemplo siguiente es idéntico al ejemplo anterior, salvo que usa la DefaultThreadCurrentCulture propiedad para asegurarse de que los subprocesos del grupo de subprocesos tienen la misma referencia cultural que el subproceso de la aplicación principal.
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 y DefaultThreadCurrentUICulture son propiedades de dominio por aplicación; es decir, establecen una referencia cultural predeterminada para todos los subprocesos no asignados explícitamente a una referencia cultural en un dominio de aplicación específico. Sin embargo, en el caso de las aplicaciones destinadas a .NET Framework 4.6 o posterior, la referencia cultural del subproceso de llamada sigue siendo parte del contexto de una tarea asincrónica incluso si la tarea cruza los límites del dominio de la aplicación.
En el ejemplo siguiente se muestra que la referencia cultural del subproceso que realiza la llamada sigue siendo la referencia cultural actual de una operación asincrónica basada en tareas incluso si el método que la tarea está ejecutando cruza los límites del dominio de la aplicación. Define una clase, DataRetriever, con un único método, GetFormattedNumber, que devuelve un número de punto flotante de precisión doble aleatorio entre 1 y 1000 con formato de valor de moneda. Se ejecuta una primera tarea que simplemente crea instancias de una DataRetriever instancia y llama a su GetFormattedNumber método. Una segunda tarea informa de su dominio de aplicación actual, crea un nuevo dominio de aplicación, crea una instancia de una DataRetriever instancia en el nuevo dominio de aplicación y llama a su GetFormattedNumber método. Como se muestra en la salida del ejemplo, la referencia cultural actual se ha mantenido igual en el subproceso de llamada, la primera tarea y la segunda tarea cuando se estaba ejecutando en el dominio de aplicación principal y en el segundo dominio de aplicación.
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 €
Serialización de objetos CultureInfo
Cuando se serializa un CultureInfo objeto, todo lo que realmente se almacena es Name y UseUserOverride. Solo se deserializa correctamente en un entorno donde tiene Name el mismo significado. Los tres ejemplos siguientes muestran por qué esto no siempre es el caso:
Si el valor de la propiedad es CultureTypes.InstalledWin32Culturesy si esa CultureTypes referencia cultural se introdujo por primera vez en una versión determinada del sistema operativo Windows, no es posible deserializarla en una versión anterior de Windows. Por ejemplo, si se introdujo una referencia cultural en Windows 10, no se puede deserializar en Windows 8.
Si el CultureTypes valor es CultureTypes.UserCustomCulturey el equipo en el que está deserializado no tiene instalada esta referencia cultural personalizada de usuario, no es posible deserializarla.
Si el CultureTypes valor es CultureTypes.ReplacementCulturesy el equipo en el que se deserializa no tiene esta referencia cultural de reemplazo, deserializa con el mismo nombre, pero no todas las mismas características. Por ejemplo, si
en-USes una referencia cultural de reemplazo en el equipo A, pero no en el equipo B, y si un CultureInfo objeto que hace referencia a esta referencia cultural se serializa en el equipo A y se deserializa en el equipo B, no se transmite ninguna de las características personalizadas de la referencia cultural. La referencia cultural deserializa correctamente, pero con un significado diferente.
invalidaciones de Panel de control
El usuario puede optar por invalidar algunos de los valores asociados a la referencia cultural actual de Windows a través de la parte de opciones regionales y de idioma de Panel de control. Por ejemplo, el usuario podría optar por mostrar la fecha en un formato diferente o usar una moneda distinta de la predeterminada para la referencia cultural. En general, las aplicaciones deben respetar estas invalidaciones de usuario.
Si UseUserOverride es true y la referencia cultural especificada coincide con la referencia cultural actual de Windows, usa CultureInfo esas invalidaciones, incluida la configuración de usuario para las propiedades de la DateTimeFormatInfo instancia devuelta por la DateTimeFormat propiedad y las propiedades de la NumberFormatInfo instancia devuelta por la NumberFormat propiedad . Si la configuración de usuario no es compatible con la referencia cultural asociada a CultureInfo, por ejemplo, si el calendario seleccionado no es uno de los OptionalCalendars, los resultados de los métodos y los valores de las propiedades no están definidos.
Pedidos de ordenación alternativos
Algunas referencias culturales admiten más de un criterio de ordenación. Por ejemplo:
La cultura española (España) tiene dos órdenes de ordenación: el criterio de ordenación internacional predeterminado y el criterio de ordenación tradicional. Al crear una instancia de un CultureInfo objeto con el nombre de la
es-ESreferencia cultural, se usa el criterio de ordenación internacional. Al crear una instancia de un CultureInfo objeto con el nombre de laes-ES-tradnlreferencia cultural, se usa el criterio de ordenación tradicional.La
zh-CNreferencia cultural (chino (simplificado, PRC)) admite dos órdenes de ordenación: por pronunciación (valor predeterminado) y por recuento de trazos. Cuando se crea una instancia de un CultureInfo objeto con el nombre de lazh-CNreferencia cultural, se usa el criterio de ordenación predeterminado. Cuando se crea una instancia de un CultureInfo objeto con un identificador local de 0x00020804, las cadenas se ordenan por recuento de trazos.
En la tabla siguiente se enumeran las referencias culturales que admiten criterios de ordenación alternativos, y los identificadores para los criterios de ordenación predeterminados y alternativos.
| Nombre de referencia cultural | culture | Nombre e identificador de ordenación predeterminada | Nombre e identificador de ordenación alternativa |
|---|---|---|---|
| es-ES | Español (España) | Internacional: 0x00000C0A | Tradicional: 0x0000040A |
| zh-TW | Chino (Taiwán) | Número de trazos: 0x00000404 | Bopomofo: 0x00030404 |
| zh-CN | Chino (RPC) | Pronunciación: 0x00000804 | Número de trazos: 0x00020804 |
| zh-HK | Chino (Zona administrativa especial de Hong Kong) | Número de trazos: 0x00000c04 | Número de trazos: 0x00020c04 |
| zh-sg | Chino (Singapur) | Pronunciación: 0x00001004 | Número de trazos: 0x00021004 |
| zh-MO | Chino (Macao RAE) | Pronunciación: 0x00001404 | Número de trazos: 0x00021404 |
| ja-JP | Japonés (Japón) | Predeterminada: 0x00000411 | Unicode: 0x00010411 |
| ko-KR | Coreano (Corea) | Predeterminada: 0x00000412 | Xwansung coreano - Unicode: 0x00010412 |
| de-DE | Alemán (Alemania) | Diccionario: 0x00000407 | Ordenación de libreta de teléfonos DIN: 0x00010407 |
| hu-HU | Húngaro (Hungría) | Predeterminada: 0x0000040e | Ordenación técnica: 0x0001040e |
| ka-GE | Georgiano (Georgia) | Tradicional: 0x00000437 | Alfabetización internacional: 0x00010437 |
La referencia cultural actual y las aplicaciones para UWP
En las aplicaciones de Plataforma universal de Windows (UWP), las CurrentCulture propiedades y CurrentUICulture son de lectura y escritura, al igual que en las aplicaciones de .NET Framework y .NET Core. Sin embargo, las aplicaciones para UWP reconocen una única referencia cultural. Las CurrentCulture propiedades y CurrentUICulture se asignan al primer valor de la colección Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages .
En las aplicaciones de .NET Framework y .NET Core, la referencia cultural actual es una configuración por subproceso y las CurrentCulture propiedades y CurrentUICulture reflejan la referencia cultural y la referencia cultural de la interfaz de usuario del subproceso actual únicamente. En las aplicaciones para UWP, la referencia cultural actual se asigna a la colección Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages , que es una configuración global. Establecer la CurrentCulture propiedad o CurrentUICulture cambia la referencia cultural de toda la aplicación; la referencia cultural no se puede establecer por subproceso.
Constructores
| CultureInfo(Int32) |
Inicializa una nueva instancia de la clase CultureInfo de acuerdo con la referencia cultural especificada por el identificador de dicha referencia. |
| CultureInfo(Int32, Boolean) |
Inicializa una nueva instancia de la CultureInfo clase basándose en la referencia cultural especificada por el identificador de referencia cultural y en un valor que especifica si se debe usar la configuración de referencia cultural seleccionada por el usuario de Windows. |
| CultureInfo(String) |
Inicializa una nueva instancia de la clase CultureInfo de acuerdo con la referencia cultural especificada mediante un nombre. |
| CultureInfo(String, Boolean) |
Inicializa una nueva instancia de la CultureInfo clase basándose en la referencia cultural especificada por nombre y en un valor que especifica si se debe usar la configuración de referencia cultural seleccionada por el usuario de Windows. |
Propiedades
| Calendar |
Obtiene el calendario predeterminado utilizado por la referencia cultural. |
| CompareInfo |
Obtiene el objeto CompareInfo que define el modo en que se comparan las cadenas para la referencia cultural. |
| CultureTypes |
Obtiene los tipos de referencia cultural que pertenecen al objeto CultureInfo actual. |
| CurrentCulture |
Obtiene o establece el CultureInfo objeto que representa la referencia cultural utilizada por el subproceso actual y las operaciones asincrónicas basadas en tareas. |
| CurrentUICulture |
Obtiene o establece el objeto CultureInfo que representa la referencia cultural de la interfaz de usuario actual utilizada por el Administrador de recursos para buscar los recursos específicos de la referencia cultural en tiempo de ejecución. |
| DateTimeFormat |
Obtiene o establece un objeto DateTimeFormatInfo que define el formato de presentación de fechas y horas culturalmente apropiado. |
| DefaultThreadCurrentCulture |
Obtiene o establece la referencia cultural predeterminada para los subprocesos del dominio de aplicación actual. |
| DefaultThreadCurrentUICulture |
Obtiene o establece la referencia cultural predeterminada de la interfaz de usuario para los subprocesos del dominio de aplicación actual. |
| DisplayName |
Obtiene el nombre de referencia cultural localizado completo. |
| EnglishName |
Obtiene el nombre de la referencia cultural en el formato languagefull [country/regionfull] en inglés. |
| IetfLanguageTag |
Desusado. Obtiene la identificación del estándar RFC 4646 de un idioma. |
| InstalledUICulture |
Obtiene el objeto CultureInfo que representa la referencia cultural instalada con el sistema operativo. |
| InvariantCulture |
Obtiene el objeto CultureInfo que es independiente de la referencia cultural (invariable). |
| IsNeutralCulture |
Obtiene un valor que indica si el CultureInfo actual representa una referencia cultural neutra. |
| IsReadOnly |
Obtiene un valor que indica si el CultureInfo actual es de solo lectura. |
| KeyboardLayoutId |
Obtiene el identificador de configuración regional de entrada activo. |
| LCID |
Obtiene el identificador de referencia cultural del objeto CultureInfo actual. |
| Name |
Obtiene el nombre de la referencia cultural en el formato languagecode2-country/regioncode2. |
| NativeName |
Obtiene el nombre de la referencia cultural, que consta del idioma, país o región y alfabeto opcional establecidos para que los muestre la referencia cultural. |
| NumberFormat |
Obtiene o establece un objeto NumberFormatInfo que define el formato de presentación de números, moneda y porcentaje culturalmente apropiado. |
| OptionalCalendars |
Obtiene la lista de calendarios que puede utilizar la referencia cultural. |
| Parent |
Obtiene el objeto CultureInfo que representa la referencia cultural principal del CultureInfo actual. |
| TextInfo |
Obtiene el objeto TextInfo que define el sistema de escritura asociado a la referencia cultural. |
| ThreeLetterISOLanguageName |
Obtiene el código de tres letras ISO 639-2 del idioma del objetoCultureInfo actual. |
| ThreeLetterWindowsLanguageName |
Obtiene el código de tres letras del idioma tal como se ha definido en la API de Windows. |
| TwoLetterISOLanguageName |
Obtiene el código de tres letras ISO 639-1 o ISO 639-3 de tres letras para el idioma del actual CultureInfo. |
| UseUserOverride |
Obtiene un valor que indica si el objeto CultureInfo actual usa la configuración de la referencia cultural seleccionada por el usuario. |
Métodos
| ClearCachedData() |
Actualiza la información relativa a la referencia cultural almacenada en caché. |
| Clone() |
Crea una copia del objeto CultureInfo actual. |
| CreateSpecificCulture(String) |
Crea un objeto CultureInfo que representa la referencia cultural específica asociada al nombre especificado. |
| Equals(Object) |
Determina si el objeto especificado es la misma referencia cultural que el objeto CultureInfo actual. |
| GetConsoleFallbackUICulture() |
Obtiene una referencia cultural de la interfaz de usuario alternativa apta para las aplicaciones de consola cuando la referencia cultural de la interfaz gráfica de usuario predeterminada no es apropiada. |
| GetCultureInfo(Int32) |
Recupera una instancia almacenada en memoria caché, de solo lectura, de una referencia cultural usando el identificador de referencia cultural especificado. |
| GetCultureInfo(String) |
Recupera una instancia almacenada en memoria caché, de solo lectura, de una referencia cultural utilizando el nombre de referencia cultural especificado. |
| GetCultureInfo(String, Boolean) |
Recupera una instancia almacenada en memoria caché, de solo lectura, de una referencia cultural. |
| GetCultureInfo(String, String) |
Recupera una instancia almacenada en memoria caché, de solo lectura, de una referencia cultural. Los parámetros especifican una referencia cultural que se inicializa con los objetos TextInfo y CompareInfo especificados por otra referencia cultural. |
| GetCultureInfoByIetfLanguageTag(String) |
Desusado. Recupera un objeto CultureInfo de solo lectura cuyas características lingüísticas se identifican por la etiqueta de idioma RFC 4646 especificada. |
| GetCultures(CultureTypes) |
Obtiene la lista de referencias culturales admitidas filtradas por el parámetro CultureTypes especificado. |
| GetFormat(Type) |
Obtiene un objeto que define cómo se aplica el formato al tipo especificado. |
| GetHashCode() |
Sirve como función hash para la CultureInfo actual, que se puede usar en algoritmos hash y estructuras de datos, como una tabla hash. |
| GetType() |
Obtiene el Type de la instancia actual. (Heredado de Object) |
| MemberwiseClone() |
Crea una copia superficial del Object actual. (Heredado de Object) |
| ReadOnly(CultureInfo) |
Devuelve un contenedor de solo lectura en torno al objeto CultureInfo especificado. |
| ToString() |
Devuelve una cadena que contiene el nombre del elemento CultureInfo actual en el formato languagecode2-country/regioncode2. |