Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase CultureInfo

 

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.

Espacio de nombres:   System.Globalization
Ensamblado:  mscorlib (en mscorlib.dll)

System.Object
  System.Globalization.CultureInfo

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class CultureInfo : ICloneable, IFormatProvider

NombreDescripción
System_CAPS_pubmethodCultureInfo(Int32)

Inicializa una nueva instancia de la clase CultureInfo de acuerdo con la referencia cultural especificada por el identificador de dicha referencia.

System_CAPS_pubmethodCultureInfo(Int32, Boolean)

Inicializa una nueva instancia de la clase CultureInfo de acuerdo con la referencia cultural especificada por el identificador y con el valor booleano que especifica si se va a utilizar la configuración de referencia cultural del sistema seleccionada por el usuario.

System_CAPS_pubmethodCultureInfo(String)

Inicializa una nueva instancia de la clase CultureInfo de acuerdo con la referencia cultural especificada mediante un nombre.

System_CAPS_pubmethodCultureInfo(String, Boolean)

Inicializa una nueva instancia de la clase CultureInfo de acuerdo con la referencia cultural especificada mediante un nombre y con el valor booleano que indica si se va a utilizar la configuración de referencia cultural del sistema seleccionada por el usuario.

NombreDescripción
System_CAPS_pubpropertyCalendar

Obtiene el calendario predeterminado utilizado por la referencia cultural.

System_CAPS_pubpropertyCompareInfo

Obtiene el objeto CompareInfo que define el modo en que se comparan las cadenas para la referencia cultural.

System_CAPS_pubpropertyCultureTypes

Obtiene los tipos de referencia cultural que pertenecen al objeto CultureInfo actual.

System_CAPS_pubpropertySystem_CAPS_staticCurrentCulture

Obtiene o establece el objeto CultureInfo que representa la referencia cultural utilizada por el subproceso actual.

System_CAPS_pubpropertySystem_CAPS_staticCurrentUICulture

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.

System_CAPS_pubpropertyDateTimeFormat

Obtiene o establece un objeto DateTimeFormatInfo que define el formato de presentación de fechas y horas culturalmente apropiado.

System_CAPS_pubpropertySystem_CAPS_staticDefaultThreadCurrentCulture

Obtiene o establece la referencia cultural predeterminada para los subprocesos del dominio de aplicación actual.

System_CAPS_pubpropertySystem_CAPS_staticDefaultThreadCurrentUICulture

Obtiene o establece la referencia cultural predeterminada de la interfaz de usuario para los subprocesos del dominio de aplicación actual.

System_CAPS_pubpropertyDisplayName

Obtiene el nombre de referencia cultural localizado completo.

System_CAPS_pubpropertyEnglishName

Obtiene el nombre de la referencia cultural en el formato languagefull [country/regionfull], en inglés.

System_CAPS_pubpropertyIetfLanguageTag

Desusado. Obtiene la identificación del estándar RFC 4646 de un idioma.

System_CAPS_pubpropertySystem_CAPS_staticInstalledUICulture

Obtiene el objeto CultureInfo que representa la referencia cultural instalada con el sistema operativo.

System_CAPS_pubpropertySystem_CAPS_staticInvariantCulture

Obtiene el objeto CultureInfo que es independiente de la referencia cultural (invariable).

System_CAPS_pubpropertyIsNeutralCulture

Obtiene un valor que indica si el CultureInfo actual representa una referencia cultural neutra.

System_CAPS_pubpropertyIsReadOnly

Obtiene un valor que indica si el CultureInfo actual es de solo lectura.

System_CAPS_pubpropertyKeyboardLayoutId

Obtiene el identificador de configuración regional de entrada activo.

System_CAPS_pubpropertyLCID

Obtiene el identificador de referencia cultural del objeto CultureInfo actual.

System_CAPS_pubpropertyName

Obtiene el nombre de la referencia cultural en el formato languagecode2-country/regioncode2.

System_CAPS_pubpropertyNativeName

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.

System_CAPS_pubpropertyNumberFormat

Obtiene o establece un objeto NumberFormatInfo que define el formato de presentación de números, moneda y porcentaje culturalmente apropiado.

System_CAPS_pubpropertyOptionalCalendars

Obtiene la lista de calendarios que puede utilizar la referencia cultural.

System_CAPS_pubpropertyParent

Obtiene el objeto CultureInfo que representa la referencia cultural principal del CultureInfo actual.

System_CAPS_pubpropertyTextInfo

Obtiene el objeto TextInfo que define el sistema de escritura asociado a la referencia cultural.

System_CAPS_pubpropertyThreeLetterISOLanguageName

Obtiene el código de tres letras ISO 639-2 del idioma del objetoCultureInfo actual.

System_CAPS_pubpropertyThreeLetterWindowsLanguageName

Obtiene el código de tres letras del idioma tal como se ha definido en la API de Windows.

System_CAPS_pubpropertyTwoLetterISOLanguageName

Obtiene el código de dos letras ISO 639-1 del idioma del objeto CultureInfo actual.

System_CAPS_pubpropertyUseUserOverride

Obtiene un valor que indica si el objeto CultureInfo actual usa la configuración de la referencia cultural seleccionada por el usuario.

NombreDescripción
System_CAPS_pubmethodClearCachedData()

Actualiza la información relativa a la referencia cultural almacenada en caché.

System_CAPS_pubmethodClone()

Crea una copia del objeto CultureInfo actual.

System_CAPS_pubmethodSystem_CAPS_staticCreateSpecificCulture(String)

Crea un objeto CultureInfo que representa la referencia cultural específica asociada al nombre especificado.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es la misma referencia cultural que el objeto CultureInfo actual.(Invalida Object.Equals(Object)).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodGetConsoleFallbackUICulture()

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.

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfo(Int32)

Recupera una instancia almacenada en memoria caché, de solo lectura, de una referencia cultural usando el identificador de referencia cultural especificado.

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfo(String)

Recupera una instancia almacenada en memoria caché, de solo lectura, de una referencia cultural utilizando el nombre de referencia cultural especificado.

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfo(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.

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfoByIetfLanguageTag(String)

Desusado. Recupera un objeto CultureInfo de solo lectura cuyas características lingüísticas se identifican por la etiqueta de idioma RFC 4646 especificada.

System_CAPS_pubmethodSystem_CAPS_staticGetCultures(CultureTypes)

Obtiene la lista de referencias culturales admitidas filtradas por el parámetro CultureTypes especificado.

System_CAPS_pubmethodGetFormat(Type)

Obtiene un objeto que define cómo se aplica el formato al tipo especificado.

System_CAPS_pubmethodGetHashCode()

Sirve como función hash para el objeto CultureInfo actual, que se puede utilizar en algoritmos hash y estructuras de datos, como una tabla hash.(Invalida Object.GetHashCode()).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_pubmethodSystem_CAPS_staticReadOnly(CultureInfo)

Devuelve un contenedor de solo lectura en torno al objeto CultureInfo especificado.

System_CAPS_pubmethodToString()

Devuelve una cadena que contiene el nombre del objeto CultureInfo actual en el formato languagecode2-country/regioncode2.(Invalida Object.ToString()).

System_CAPS_noteNota

Para ver el código fuente de .NET Framework para este tipo, consulte el Reference Source. Puede examinar el código fuente en línea, descargue la referencia para verla sin conexión y recorrer (incluidas las revisiones y actualizaciones) durante la depuración; see instructions.

La CultureInfo clase proporciona información específica de la referencia cultural, como el lenguaje variante de idioma, país o región, calendario y convenciones asociadas a una referencia cultural determinada. Esta clase también proporciona acceso a instancias específicas de la referencia cultural de la DateTimeFormatInfo, NumberFormatInfo, CompareInfo, y TextInfo objetos. Estos objetos contienen la información necesaria para las operaciones de la referencia cultural específica, como mayúsculas y minúsculas, formato de fechas y números y comparar cadenas. La CultureInfo clase se usa directa o indirectamente por las clases que dar formato, analizarán o manipulan datos específicos de la referencia cultural, tales como String, DateTime, DateTimeOffset, y los tipos numéricos.

En esta sección:

Identificadores y nombres de referencia cultural
Referencias culturales invariables, neutras y específicas
Referencias culturales personalizadas
Datos de referencia cultural dinámico
La referencia cultural actual y la referencia cultural de interfaz de usuario actual
Obtener todas las referencias culturales
Referencia cultural y subprocesos
Dominios de aplicación y de referencia cultural
Referencia cultural y operaciones asincrónicas basadas en tareas
Serialización de objetos CultureInfo
Reemplazos del Panel de control
Criterios de ordenación alternativos
Aplicaciones de Windows y de referencia cultural

La CultureInfo clase especifica un nombre único para cada referencia cultural basándose en RFC 4646. El nombre es una combinación de un código de referencia cultural de dos letras en minúscula ISO 639 asociado con un idioma y un código ISO 3166 de secundaria de dos letras en mayúscula asociado con un país o región. Además, para las aplicaciones que tienen como destino .NET Framework 4 o posterior y se ejecutan en Windows 10 o posterior, los nombres de referencia cultural que se corresponden con el idioma BCP-47 válido etiquetas son compatibles.

System_CAPS_noteNota

Cuando se pasa un nombre de referencia cultural a un constructor de clase o un método como CreateSpecificCulture o CultureInfo, su caso no es significativo.

El formato de nombre de referencia cultural basándose 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 referencia cultural secundaria de dos letras. Algunos ejemplos son a ja-JP para japonés (Japón) y en-US para inglés (Estados Unidos). En casos donde no hay disponible un código de idioma de dos letras, se utiliza un código de tres letras proveniente de ISO 639-2.

Tenga en cuenta que algunos nombres de referencia cultural también especifican un script ISO 15924. Por ejemplo, Cyrl especifica el alfabeto cirílico y Latn especifica el alfabeto latino. Un nombre de referencia cultural que incluye una secuencia de comandos usa el patrón de languagecode2-scripttag-country/regioncode2. Un ejemplo de este tipo de nombre de referencia cultural es uz-Cyrl-UZ para Uzbeko (cirílico, Uzbekistán). En sistemas operativos de Windows anteriores a Windows Vista, un nombre de referencia cultural que incluye una secuencia de comandos usa el patrón de languagecode2-country/regioncode2-scripttag, por ejemplo, uz-UZ-Cyrl para Uzbeko (cirílico, Uzbekistán).

Una referencia cultural neutra se especifica únicamente el código de idioma de dos letras en minúsculas. Por ejemplo, fr especifica la referencia cultural neutra para francés y de especifica la referencia cultural neutra para alemán.

System_CAPS_noteNota

Hay dos nombres de referencias culturales que contradicen esta regla. Las referencias culturales, chino (simplificado), denominado zh-Hans y chino (tradicional), denominado zh-Hant, son referencias culturales neutras. Los nombres de referencia cultural representan el estándar actual y deben utilizarse a menos que tenga una razón para usar los nombres zh-CHS y zh-CHT anteriores.

Identificador de referencia cultural es una abreviatura numérica internacional estándar y tiene los componentes necesarios para identificar una de las referencias culturales instaladas. La aplicación puede utilizar identificadores de referencia cultural predefinidos o definir identificadores personalizados.

Determinados predefinidos nombres de referencia cultural y los identificadores se usan por esta y otras clases en el System.Globalization espacio de nombres. Información de referencia cultural detallada aparece en el National Language Support (NLS) API Reference en Go Global Developer Center.

Recuerde que los identificadores y nombres de referencia cultural representan sólo un subconjunto de las referencias culturales que se pueden encontrar en un equipo determinado. Versiones de Windows o service packs pueden cambiar las referencias culturales disponibles. Las aplicaciones agregan referencias culturales personalizadas mediante la CultureAndRegionInfoBuilder clase. Los usuarios agregar sus propias referencias culturales personalizadas mediante la herramienta Microsoft Locale Builder. Microsoft Locale Builder está escrito en código administrado mediante la CultureAndRegionInfoBuilder clase.

Algunos nombres están estrechamente asociados a una referencia cultural, en particular los nombres asociados con los miembros de clase siguientes:

Las referencias culturales se suelen agrupar en tres grupos: referencias culturales de todos los idiomas, referencias culturales neutras y referencias culturales específicas.

Una referencia cultural invariable es la referencia cultural. La aplicación especifica la referencia cultural de todos los idiomas por nombre mediante una cadena vacía ("") o por su identificador. InvariantCulture define una instancia de la referencia cultural invariable. Está asociado con el idioma inglés, pero no con cualquier país o región. Se utiliza en casi todos los métodos en el Globalization espacio de nombres que requiera una referencia cultural.

Una referencia cultural neutra es una referencia cultural asociada con un idioma, pero no con un país o región. Una referencia cultural específica es una referencia cultural que está asociada a un idioma y un país o región. Por ejemplo, fr es el nombre neutro para la referencia cultural francés y fr-FR es el nombre de la referencia cultural de francés (Francia) específica. Tenga en cuenta que chino (simplificado) y chino (tradicional) también se considera referencias culturales neutras.

Crear una instancia de un CompareInfo la clase para una referencia cultural neutra no se recomienda porque los datos que contiene son arbitrarios. Para ver y ordenar los datos, especificar el idioma y la región. Además, el Name propiedad de un CompareInfo objeto creada para una referencia cultural neutra devuelve sólo 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. El Parent propiedad contiene la referencia cultural neutra asociada a una referencia cultural concreta. Deben definir las referencias culturales personalizadas del Parent propiedad cumple con este patrón.

Si los recursos para una referencia cultural concreta no están disponibles en el sistema operativo, se usan los recursos de la referencia cultural neutra asociada. Si no están disponibles los recursos para la referencia cultural neutra, se utilizan los recursos incrustados en el ensamblado principal. Para obtener más información sobre el proceso de reserva de recursos, consulte Empaquetar e implementar recursos en aplicaciones de escritorio.

La lista de las configuraciones regionales en la API de Windows es ligeramente diferente de la lista de referencias culturales que admite .NET Framework. Si se requiere la interoperabilidad con Windows, por ejemplo, mediante el mecanismo p/invoke, la aplicación debe utilizar una referencia cultural específica que se define para el sistema operativo. Uso de la referencia cultural específica garantiza la coherencia con la configuración regional de Windows equivalente, que se identifica con un identificador de configuración regional es el mismo que LCID.

Un DateTimeFormatInfo o NumberFormatInfo pueden crearse únicamente para la referencia cultural invariable o para referencias culturales específicas, pero no para referencias culturales neutras.

Si DateTimeFormatInfo.Calendar es el TaiwanCalendar pero la Thread.CurrentCulture no está establecido en zh-TW, a continuación, DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraName, y DateTimeFormatInfo.GetAbbreviatedEraName devuelven una cadena vacía ("").

Además de las referencias culturales predefinidas admitidas por el sistema operativo Windows y .NET Framework, .NET Framework admite tres tipos de referencias culturales personalizadas:

  • Nuevas referencias culturales que complementa las referencias culturales en Windows o .NET Framework. Por ejemplo, una aplicación podría instalar una CultureInfo objeto que representa el fj-FJ (o Fijan (de Fiyi)) de la referencia cultural en un sistema.

  • Referencias culturales de reemplazo cuyas propiedades son diferentes de las propiedades de las referencias culturales estándares admitidas por Windows y .NET Framework.

  • Referencias culturales estándares con invalidaciones del usuario. El usuario puede utilizar el idioma y región aplicación en Panel de Control para personalizar los valores de propiedad de una referencia cultural existente.

System_CAPS_noteNota

Puede usar el CultureAndRegionInfoBuilder clase para definir, guardar y registrar las referencias culturales personalizadas que complementan o reemplazar el existente. El CultureAndRegionInfoBuilder.Save método crea un archivo de Locale Data Markup Language (LDML) que puede utilizarse para instalar una referencia cultural personalizada en sistemas de destino. Para información de pasos de paso por sobre el uso de la CultureAndRegionInfoBuilder clase para crear una nueva o la referencia cultural de reemplazo, consulte el CultureAndRegionInfoBuilder tema de la clase.

Dado que .NET Framework admite las referencias culturales personalizadas, debe considerar lo siguiente al trabajar con datos específicos de la referencia cultural:

  • Las referencias culturales personalizadas pueden tener valores que superen los intervalos de las referencias culturales predefinidas. Por ejemplo, algunas referencias culturales tienen nombres de mes largos, fechas inesperados o formatos de hora u otros datos inusuales.

  • Cuando se muestran datos específicos de la referencia cultural en la interfaz de usuario, debe respetar las personalizaciones del usuario; Por ejemplo, el usuario quizás desee un reloj de 24 horas o un formato de fecha AAAAMMDD.

  • Recuerde que las referencias culturales personalizadas invalidan los valores de forma predeterminada. Por tanto, no se puede considerar los datos de referencia cultural que sean estables. Nombres de países, formatos de número y fecha y ortografía puede cambiar en el futuro. Si desea serializar los datos de la referencia cultural como cadenas de fecha y hora en que se pasan a la fecha y hora de las funciones de análisis, debe usar la referencia cultural o una específica.

El CultureTypes incluye el valor de propiedad de las referencias culturales personalizadas instalado en un sistema el CultureTypes.UserCustomCulture marca y las referencias culturales personalizadas se asignan un LCID valor de propiedad de LOCALE_CUSTOM_UNSPECIFIED (0 x 1000 ó 4096). Tenga en cuenta que, a partir de Windows 10, este valor también está asignado a referencias culturales definidas por el sistema que no tienen datos de referencia culturales completa.

Excepto para la referencia cultural, los datos de referencia cultural están dinámicos. Esto es verdad incluso para las referencias culturales predefinidas. Por ejemplo, los países o regiones adoptan nuevas monedas, cambian la ortografía de sus palabras o modifican su calendario preferidos y cambiarán las definiciones de la referencia cultural para realizar un seguimiento de esto. Las referencias culturales personalizadas están sujetos a cambios sin previo aviso y cualquier referencia cultural específica podría reemplazarse por una referencia cultural 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.

System_CAPS_cautionPrecaución

Al guardar los datos, la aplicación debe utilizar la referencia cultural invariable, un formato binario o un formato independiente de la referencia cultural específico. Datos guardados según los valores actuales asociados a una referencia cultural determinada, que no sea la referencia cultural, podrían ser ilegibles o variar su significado si cambia esa referencia cultural.

Cada subproceso en una aplicación de .NET Framework tiene una referencia cultural actual y una referencia cultural de interfaz de usuario actual. La referencia cultural actual determina las convenciones de formato de fechas, horas, números y valores de moneda, el criterio de ordenación de texto, las convenciones de mayúsculas y minúsculas y las maneras en que se comparan las cadenas. La referencia cultural de interfaz de usuario actual se utiliza para recuperar recursos específicos de la referencia cultural en tiempo de ejecución.

System_CAPS_noteNota

Para obtener información sobre cómo se determina la referencia cultural de interfaz de usuario actual y actual por subproceso, vea la Referencia cultural y subprocesos sección. Para obtener información sobre cómo se determina la referencia cultural de interfaz de usuario actual y actual de subprocesos en ejecución en un nuevo dominio de aplicación y en los subprocesos que cruzan los límites del dominio de aplicación, consulte la Dominios de aplicación y de referencia cultural sección. Para obtener información sobre cómo se determina el actual y la actual en el subproceso que realiza operaciones asincrónicas basadas en tareas, consulte la Referencia cultural y operaciones asincrónicas basadas en tareas sección.

Para obtener más información sobre la referencia cultural actual, vea el CultureInfo.CurrentCulture tema de la propiedad. Para obtener más información sobre la referencia cultural de interfaz de usuario actual, consulte el CultureInfo.CurrentUICulture tema de la propiedad.

Puede obtener un CultureInfo objeto que representa la referencia cultural actual de dos maneras:

El siguiente ejemplo recupera los valores de propiedad, se compara para mostrar que son iguales y 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

Puede obtener un CultureInfo objeto que representa la referencia cultural de interfaz de usuario actual de dos maneras:

El siguiente ejemplo recupera los valores de propiedad, se compara para mostrar que son iguales y muestra el nombre de la referencia cultural de 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

Para cambiar la referencia cultural y la referencia cultural de la interfaz de usuario de un subproceso, haga lo siguiente:

  1. Crear una instancia de un CultureInfo objeto que representa esa referencia cultural mediante una llamada a un CultureInfo clase constructor y le pasa el nombre de la referencia cultural. El CultureInfo(String) constructor crea instancias de un CultureInfo objeto que refleja el usuario invalida si la nueva referencia cultural es igual que la referencia cultural actual de Windows. El CultureInfo(String, Boolean) constructor permite especificar si la instancia recién creada CultureInfo objeto refleja las invalidaciones de usuario si la nueva referencia cultural es igual que la referencia cultural actual de Windows.

  2. Asigne el CultureInfo de objeto para el Thread.CurrentCulture oThread.CurrentUICulture propiedad. Además, para las aplicaciones que se ejecutan en la versión 4.6 o posterior de .NET Framework escritorio, también puede asignar la CultureInfo objeto en el CultureInfo.CurrentCulture o CultureInfo.CurrentUICulture propiedad.

En el ejemplo siguiente se recupera la referencia cultural actual. Si es distinto de la referencia cultural Francés (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

En el ejemplo siguiente se recupera la referencia cultural actual. Si todo lo demás es la referencia cultural esloveno (Eslovenia), cambia la referencia cultural actual a esloveno (Eslovenia). De lo contrario, cambia la referencia cultural 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

Puede recuperar un categorías específicas de matriz de referencias culturales o de las referencias culturales disponibles en el equipo local llamando el GetCultures método. Por ejemplo, puede recuperar las referencias culturales personalizadas, referencias culturales específicas o referencias culturales neutras solos o en combinación.

El ejemplo siguiente se llama el GetCultures método dos veces, primero con la CultureTypes.UserCustomCulture miembro de enumeración para recuperar todas las referencias culturales personalizadas y, a continuación, con el CultureTypes.ReplacementCultures miembro de 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.

Cuando se inicia un nuevo subproceso de la aplicación, su referencia cultural actual y la referencia cultural de interfaz de usuario actual se definen por la referencia cultural actual del sistema y no por la referencia cultural del subproceso actual. En el siguiente ejemplo se ilustra la diferencia. Establece la referencia cultural actual y la referencia cultural de interfaz de usuario actual de un subproceso de aplicación para la referencia cultural de francés (Francia) (fr-FR). Si la referencia cultural actual ya está fr-FR, en el ejemplo se establece en la referencia cultural de 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 valores de moneda. Pero como la salida de muestra en el ejemplo, los valores de moneda que se muestra el nuevo subproceso no reflejan las convenciones de formato de la referencia cultural Francés (Francia), a diferencia de la salida desde el subproceso principal de la aplicación.

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

En las versiones de .NET Framework anteriores a la .NET Framework 4.5, más forma común para asegurarse de que el subproceso de aplicación principal comparte la misma referencia cultural con todos los otros 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 delegar. En el ejemplo siguiente se utiliza 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 €

Puede establecer la referencia cultural y la referencia cultural de la interfaz de usuario del subproceso del grupo de subprocesos de manera similar mediante una llamada a la ThreadPool.QueueUserWorkItem(WaitCallback, Object) (método).

A partir de la .NET Framework 4.5, puede establecer la referencia cultural y la referencia cultural de la interfaz de usuario de todos los subprocesos en un dominio de aplicación más directamente mediante la asignación de un CultureInfo objeto que representa esa referencia cultural a la DefaultThreadCurrentCulture y DefaultThreadCurrentUICulture Propiedades. El ejemplo siguiente utiliza estas propiedades para asegurarse de que todos los subprocesos en el 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 €
System_CAPS_warningAdvertencia

Aunque el DefaultThreadCurrentCulture y DefaultThreadCurrentUICulture las propiedades son miembros estáticos, definen la referencia cultural predeterminada y la referencia cultural de interfaz de usuario predeterminada sólo para el dominio de aplicación actual 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 los dominios de aplicación.

Al asignar valores a los DefaultThreadCurrentCulture y DefaultThreadCurrentUICulture Propiedades, la referencia cultural y la referencia cultural de la interfaz de usuario de los subprocesos del dominio de aplicación también cambiarán si no se les explícitamente se ha asignado una referencia cultural. Sin embargo, estos subprocesos reflejan la nueva configuración de referencia cultural sólo 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 que establezca siempre la referencia cultural del subproceso principal de la aplicación y no confiar en la DefaultThreadCurrentCulture y DefaultThreadCurrentUICulture Propiedades para cambiarlo.

DefaultThreadCurrentCulture y DefaultThreadCurrentUICulture son propiedades estáticas que definen explícitamente una referencia cultural predeterminada sólo para el dominio de aplicación actual cuando se establece o recupera el valor de propiedad. En el ejemplo siguiente se establece la referencia cultural predeterminada y la referencia cultural de interfaz de usuario predeterminada en el dominio de aplicación predeterminado a francés (Francia) y, a continuación, utiliza el AppDomainSetup clase y el AppDomainInitializer delegado para establecer la referencia cultural predeterminada y la referencia cultural de interfaz de usuario en un nuevo dominio de aplicación en ruso (Rusia). Un único subproceso, a continuación, ejecuta dos métodos en cada dominio de aplicación. Tenga en cuenta que el subproceso de la referencia cultural y referencia cultural de la interfaz de usuario no se establecen explícitamente; se deriven de la referencia cultural predeterminada y la referencia cultural de la interfaz de usuario del dominio de aplicación en el que se está ejecutando el subproceso. Tenga en cuenta también que la DefaultThreadCurrentCulture y DefaultThreadCurrentUICulture devuelven el valor predeterminado CultureInfo valores del dominio de aplicación 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

Para obtener más información acerca de las referencias culturales y dominios de aplicación, consulte la sección "Dominios de aplicación y subprocesos" en el tema.

El modelo de programación asincrónico basado en tareas utiliza Task y Task<TResult> objetos que se van a ejecutar de manera asincrónica los delegados en subprocesos del grupo de subprocesos. El subproceso concreto en el que se ejecuta una tarea determinada no se conoce de antemano, pero se determina en tiempo de ejecución.

Para las aplicaciones que tienen como destino el .NET Framework 4.6 o versiones posteriores, la referencia cultural es parte del contexto de la operación asincrónica. En otras palabras, a partir de las aplicaciones que tienen como destino el .NET Framework 4.6, operaciones asincrónicas de forma predeterminada heredan los valores de la CurrentCulture y CurrentUICulture Propiedades del subproceso desde el que se inició. Si la referencia cultural actual o la referencia cultural de interfaz de usuario actual difiere 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 que se está ejecutando una operación asincrónica.

Esto se muestra en el ejemplo siguiente. Usa el TargetFrameworkAttribute atributo de destino del .NET Framework 4.6. El ejemplo define un Func<TResult> delegar, formatDelegate, que devuelve algunos números con formato de valores de moneda. El ejemplo cambia la referencia cultural del sistema actual a francés (Francia) o, si francés (Francia) es la referencia cultural actual, el inglés (Estados Unidos). A continuación:

  • Invoca al delegado directamente para que se ejecute sincrónicamente en el subproceso de aplicación principal.

  • Crea una tarea que ejecuta al delegado de forma asincrónica en un subproceso del grupo.

  • Crea una tarea que se ejecuta el delegado sincrónicamente en el subproceso de aplicación principal mediante una llamada a la Task.RunSynchronously (método).

Como muestra el resultado del ejemplo, cuando se cambia la referencia cultural actual a francés (Francia), la referencia cultural actual del subproceso desde el que las tareas se invocan 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 �

Para las aplicaciones destinadas a versiones de .NET Framework anteriores a la .NET Framework 4.6, o para las aplicaciones que tienen como destino una versión concreta de .NET Framework, la referencia cultural del subproceso de llamada no es parte del contexto de la tarea. En su lugar, a menos que se define explícitamente, la referencia cultural de nuevos subprocesos de forma predeterminada es la referencia cultural del sistema. El ejemplo siguiente, que es idéntico al ejemplo anterior, excepto en que carece de la TargetFrameworkAttribute atributo, se muestra cómo hacerlo. Puesto que la referencia cultural del sistema en el que se ejecuta 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 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 �

Para las aplicaciones destinadas a versiones de .NET Framework desde el .NET Framework 4.5 y más adelante, pero antes de la .NET Framework 4.6, puede utilizar el DefaultThreadCurrentCulture y DefaultThreadCurrentUICulture subprocesos de grupo de propiedades para asegurarse de que la referencia cultural del subproceso de llamada se usa en las tareas asincrónicas que se ejecutan en el subproceso. El ejemplo siguiente es idéntico al ejemplo anterior, salvo que usa el DefaultThreadCurrentCulture propiedad para garantizar que ese subproceso del grupo de subprocesos tiene la misma referencia cultural que el subproceso de 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 �

DefaultThreadCurrentCulture y DefaultThreadCurrentUICulture es por la aplicación de propiedades de dominio; es decir, que establece una referencia cultural predeterminada para todos los subprocesos asignan no explícitamente una referencia cultural en un dominio de aplicación concreto. Sin embargo, para las aplicaciones que tienen como destino la .NET Framework 4.6 o posterior, la referencia cultural del subproceso que realiza la llamada permanecerá parte del contexto de una tarea asincrónica, incluso si la tarea cruza los límites del dominio de aplicación.

En el ejemplo siguiente se muestra que la referencia cultural del subproceso que realiza la llamada permanece la referencia cultural actual de una operación asincrónica basada en tareas incluso si el método que se está ejecutando la tarea cruza los límites del dominio de aplicación. Se 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 1.000 con formato de moneda. Se ejecuta una tarea de la primera que simplemente crea una instancia de un DataRetriever instancia y llama 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 un DataRetriever instancia en el nuevo dominio de aplicación y llama su GetFormattedNumber método. Como se muestra en el resultado del ejemplo, la referencia cultural actual sigue siendo el mismo en ambos el subproceso de llamada, la primera tarea y la segunda tarea cuando estaba ejecutando en el dominio de aplicación principal y 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 �

Cuando un CultureInfo se serializa el objeto, todo lo que está realmente almacenado es Name y UseUserOverride. Es correctamente deserializado en un entorno donde que Name tiene el mismo significado. Los tres ejemplos siguientes muestran por qué no es siempre el caso:

  • Si la CultureTypes es el valor de la propiedad CultureTypes.WindowsOnlyCultures, y si esa referencia cultural se presentó en Windows Vista o una versión posterior del sistema operativo Windows, no es posible anular su serialización en Windows XP. De forma similar, si la referencia cultural se presentó en Windows XP Service Pack 2, no es posible anular su serialización en un sistema Windows XP en el que no se ha instalado la referencia cultural.

  • Si la CultureTypes es el valor CultureTypes.UserCustomCulture, y el equipo en el que se deserializa no tiene esta referencia cultural personalizada instalada, no es posible anular su serialización.

  • Si la CultureTypes es el valor CultureTypes.ReplacementCultures, y el equipo en el que se deserializa no tiene esta referencia cultural de reemplazo, se deserializa en el mismo nombre, pero no todas las mismas características. Por ejemplo, si en-US es una referencia cultural de reemplazo en el equipo, pero no en el equipo B y si un CultureInfo de objeto que hace referencia a esta referencia cultural se serializa en el equipo y se deserializa en el equipo B, a continuación, se transmiten a ninguna de las características personalizadas de la referencia cultural. La referencia cultural se deserializará correctamente, pero con un significado diferente.

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 las opciones regionales y de idioma del Panel de Control. Por ejemplo, el usuario podría elegir para mostrar la fecha en un formato diferente o utilizar una divisa distinta a la predeterminada para la referencia cultural. En general, las aplicaciones deben respetar estas invalidaciones del usuario.

Si UseUserOverride es true y la referencia cultural especificada coincide con la referencia cultural actual de Windows, la CultureInfo utiliza las nuevas, 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 es incompatible con la referencia cultural asociada con el 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.

Algunas referencias culturales admiten más de un criterio de ordenación. Por ejemplo:

  • La referencia cultural Español (España) tiene dos criterios de ordenación: el criterio de ordenación internacional predeterminado y el criterio de ordenación tradicional. Cuando se crea una instancia una CultureInfo de objeto con el nombre de referencia cultural es-es, se utiliza el criterio de ordenación internacional. Cuando se crea una instancia una CultureInfo de objeto con el nombre de la referencia cultural es-ES-tradnl, se utiliza el criterio de ordenación tradicional.

  • La referencia cultural zh-CN (chino (simplificado, PRC)) admite dos criterios de ordenación: por pronunciación (predeterminado) y por número de trazos. Cuando se crea una instancia una CultureInfo de objeto con el nombre de la referencia cultural zh-CN, se utiliza el criterio de ordenación predeterminado. Cuando se crea una instancia una CultureInfo de objeto con un identificador local de 0 x 00020804, las cadenas se ordenan por número 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

Referencia cultural

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

En las aplicaciones de Windows, la CurrentCulture y CurrentUICulture propiedades son de sólo lectura. Puede establecer la referencia cultural actual y la referencia cultural de interfaz de usuario actual con Microsoft ResourceContext.Languages propiedad. En el ejemplo siguiente se utiliza para cambiar la referencia cultural actual y la referencia cultural de interfaz de usuario actual de la aplicación a inglés (Estados Unidos) o, si la referencia cultural actual es inglés (Estados Unidos), francés (Francia). El valor de la CurrentCulture y CurrentUICulture propiedades se muestran a continuación un TextBlock control denominado block. Como se muestra en el resultado del ejemplo, ambos valores de propiedad reflejan el nuevo valor de la ResourceContext.Languages propiedad.


ResourceContext context = ResourceManager.Current.DefaultContext;
var list = new List<String>();
if (CultureInfo.CurrentCulture.Name == "en-US")
   list.Add("fr-FR");
else
   list.Add("en-US");

context.Languages = list;
block.Text += String.Format("\nThe current culture is {0}\n",
                            CultureInfo.CurrentCulture);
block.Text += String.Format("The current culture UI is {0}\n",
                            CultureInfo.CurrentUICulture);
// The example displays output like the following if run on a system
// whose current culture is English (United States):
// The current culture is fr-FR
// The current UI culture is fr-FR   


Dim context As ResourceContext = ResourceManager.Current.DefaultContext
Dim list As New List(Of String)()
If CultureInfo.CurrentCulture.Name = "en-US" Then
   list.Add("fr-FR")
Else
   list.Add("en-US")
End If
context.Languages = list
block.Text += String.Format("{1}The current culture is {0}{1}",
                            CultureInfo.CurrentCulture, vbCrLf)
block.Text += String.Format("The current culture UI is {0}\n",
                            CultureInfo.CurrentUICulture)
' The example displays output Like the following if run on a system
' whose current culture Is English (United States):
'    The current culture Is fr-FR
'    The current UI culture Is fr-FR   

En el ejemplo siguiente se muestra cómo crear un CultureInfo objeto para español (España) con la ordenación internacional y otra CultureInfo objeto con la ordenación tradicional.

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

*/

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: