CultureInfo Clase

Definición

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 : IFormatProvider
public ref class CultureInfo : ICloneable, IFormatProvider
public class CultureInfo : IFormatProvider
public class CultureInfo : ICloneable, IFormatProvider
[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class CultureInfo : ICloneable, IFormatProvider
type CultureInfo = class
    interface IFormatProvider
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
Public Class CultureInfo
Implements IFormatProvider
Public Class CultureInfo
Implements ICloneable, IFormatProvider
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, el 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 , NumberFormatInfo, CompareInfoy TextInfo . Estos objetos contienen la información necesaria para las operaciones específicas de la referencia cultural, como el uso de mayúsculas y minúsculas, el formato de 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 aplicación
Referencia cultural y operaciones asincrónicas basadas en tareas
Serialización de objetos CultureInfo
invalidaciones de Panel de control
Criterios de ordenación alternativos
Aplicaciones de referencia cultural y Windows\

Nombres e identificadores de referencia cultural

La CultureInfo clase especifica un nombre único para cada referencia cultural, según RFC 4646. El nombre es una combinación de un código de referencia cultural en minúsculas iso 639 de dos letras asociado a un idioma y un código de subcultura en mayúsculas iso 3166 de dos letras asociado a un país o región. Además, para las aplicaciones que tienen como destino .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 subcultura de dos letras. Entre los ejemplos se incluyen ja-JP el japonés (Japón) y en-US el inglés (Estados Unidos). En casos donde un código de idioma de dos letras no está disponible, se usa un código de tres letras derivado de ISO 639-2.

Algunos nombres de referencia cultural también especifican un script ISO 15924. Por ejemplo, Cyrl especifica el script cirílico y Latn especifica el alfabeto latino. Un nombre de referencia cultural que incluye un script usa el patrón languagecode2**country/regioncode2-scripttag-. Un ejemplo de este tipo de nombre cultural es uz-Cyrl-UZ para Uzbek (Cirílico, Uzbekistán). En Windows sistemas operativos antes de Windows Vista, un nombre de referencia cultural que incluye un script usa el patrón languagecode2--country/regioncode2**scripttag, 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.

Esta y otras clases del espacio de nombres usan determinados nombres y identificadores de referencia cultural predefinidos System.Globalization . 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. Windows versiones o Service Packs 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 requiere 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 francesa específica (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 incrustados 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 Windows, que se identifica con un identificador de configuración regional que es el mismo LCIDque .

Un DateTimeFormatInfo objeto o NumberFormatInfo solo se puede crear 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.NativeCalendarName, DateTimeFormatInfo.GetEraNamey DateTimeFormatInfo.GetAbbreviatedEraName devuelven 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 uno de varios orígenes, 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 el .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.

Por este motivo, 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 concreto, zh-CN, o chino (simplificado, China) y zh-TW, o chino (tradicional, Taiwán), están disponibles referencias culturales en sistemas Windows, pero son referencias culturales de 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 diferentesParent, que sus equivalentes de Windows. Para las zh-CN referencias culturales y zh-TW , estas diferencias incluyen lo siguiente:

  • En Windows sistemas, la cultura primaria de la cultura "zh-CN" es "zh-Hans" y la cultura primaria de la cultura "zh-TW" es "zh-Hant". La referencia cultural primaria de ambas culturas es "zh". En los sistemas Unix, los elementos primarios de ambas referencias culturales 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 neutra en Windows pero no en Unix. En los sistemas Unix, debe establecer explícitamente el de CurrentUICulture en "zh-Hans" o "zh-Hant".

  • En Windows sistemas, llamar a CultureInfo.Equals en una instancia que representa la referencia cultural "zh-CN" y pasarla una instancia "zh-Hans-CN" devuelve true. En los sistemas Unix, la llamada al método devuelve false. Este comportamiento también se aplica a llamar a Equals en una instancia "zh-TW" CultureInfo y pasarla a una instancia "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 una referencia cultural específica podría 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, pueden volverse ilegibles o pueden cambiar de significado 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 fechas, horas, números y 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 la CultureInfo.CurrentCulture propiedad. Para obtener información más detallada sobre la referencia cultural de la interfaz de usuario actual, consulte el CultureInfo.CurrentUICulture tema de 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:

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 dos maneras:

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

Establecer 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:

  1. Cree una instancia de un CultureInfo objeto que represente esa referencia cultural llamando a un CultureInfo constructor de clase y pasándola el nombre de la referencia cultural. El CultureInfo(String) constructor crea una instancia de un CultureInfo objeto que refleja las invalidaciones del usuario si la nueva referencia cultural es la misma que la referencia cultural Windows actual. El CultureInfo(String, Boolean) constructor permite especificar si el objeto recién creado CultureInfo refleja invalidaciones de usuario si la nueva referencia cultural es la misma que la referencia cultural actual Windows.

  2. 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 CultureInfo objeto 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 específicas de referencias culturales 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 System.Globalization.CultureTypes 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.
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 de la interfaz de usuario actual 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 las 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 para toda la aplicación o un CultureInfo objeto que represente 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 la 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 depender de las DefaultThreadCurrentCulture propiedades y DefaultThreadCurrentUICulture para cambiarla.

Dominios de referencia cultural y 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 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ónico 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 que tienen como destino .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 las 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 de la interfaz de usuario actual 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 actual del sistema 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 las 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 de .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 que realiza la 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 principal de la aplicación.

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, para las aplicaciones que tienen como destino .NET Framework 4.6 o posterior, la referencia cultural del subproceso que llama 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 aleatoria entre 1 y 1000 con formato de valor de moneda. Se ejecuta una primera tarea que simplemente crea una instancia 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 que realiza la llamada, la primera tarea y la segunda tarea, tanto cuando se estaba ejecutando en el dominio de aplicación principal como 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 se almacena realmente 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 CultureTypes propiedad es CultureTypes.InstalledWin32Cultures, y si esa 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 deserializarlo.

  • Si el CultureTypes valor es CultureTypes.ReplacementCulturesy el equipo en el que está deserializado no tiene esta referencia cultural de reemplazo, se deserializa con el mismo nombre, pero no todas las mismas características. Por ejemplo, si en-US es 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 se 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 del valor predeterminado de 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.

Criterios de ordenación alternativos

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

  • La referencia cultural española (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 de un CultureInfo objeto con el nombre de la es-ES referencia cultural, se usa el criterio de ordenación internacional. Cuando se crea una instancia de un CultureInfo objeto con el nombre de la es-ES-tradnl referencia cultural, se usa el criterio de ordenación tradicional.

  • La zh-CN referencia cultural (chino (simplificado, PRC)) admite dos órdenes de ordenación: por pronunciación (el valor predeterminado) y por recuento de trazos. Cuando se crea una instancia de un CultureInfo objeto con el nombre de referencia zh-CN 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 propiedades y CurrentUICulture son de CurrentCulture 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 Windows. Colección ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages.

En .NET Framework y aplicaciones de .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. En las aplicaciones para UWP, la referencia cultural actual se asigna a la Windows. Colección 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; no se puede establecer la referencia cultural 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 dos letras ISO 639-1 del idioma del objeto CultureInfo actual.

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.

Se aplica a

Consulte también