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 objeto para español (España) con la ordenación internacional y CultureInfo otro objeto con la CultureInfo 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 clase proporciona información específica de la referencia cultural, como el idioma, el sublenguaje, el país o región, el calendario y las convenciones CultureInfo asociadas a una referencia cultural determinada. Esta clase también proporciona acceso a instancias específicas de la referencia cultural de los objetos DateTimeFormatInfo NumberFormatInfo , , y CompareInfo TextInfo . Estos objetos contienen la información necesaria para las operaciones específicas de la referencia cultural, como mayúsculas y minúsculas, formato de fechas y números y comparación de cadenas. Las clases que formatear, analizar o manipular datos específicos de la referencia cultural usan directa o indirectamente la clase, como CultureInfo , , y los tipos String DateTime DateTimeOffset numéricos.

En esta sección:

Nombres e identificadores de referencia cultural
Referencia cultural invariable, neutra y específica
Referencia cultural personalizada
Datos de referencia cultural dinámica
CultureInfo y datos culturales
Referencia cultural actual y referencia cultural de la interfaz de usuario actual
Obtener todas las referencia culturales
Referencia cultural y subprocesos
Dominios de referencia cultural y de aplicación
Referencia cultural y operaciones asincrónicas basadas en tareas
Serialización de objetos CultureInfo
Panel de control invalidaciones
Ordenaciones alternativas
Referencia cultural y Windows aplicaciones\

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 iso 639 de dos letras minúsculas asociado a un idioma y un código de subcultivo iso 3166 de dos letras mayúsculas asociado a un país o región. Además, para las aplicaciones que tienen como destino .NET Framework 4 o posterior y se ejecutan en Windows 10 o posterior, 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 , su caso no es CultureInfo significativo.

El formato del nombre de referencia cultural basado en RFC 4646 es , donde es el código de idioma de dos letras y es el código de languagecode2 - country/regioncode2 languagecode2 country/regioncode2 subculture de dos letras. Algunos ejemplos ja-JP son el japonés (Japón) en-US y 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 script latino. Un nombre de referencia cultural que incluye un script usa el patrón languagecode2 - scripttag - country/regioncode2 . Un ejemplo de este tipo de nombre de referencia cultural uz-Cyrl-UZ es para Uzorgán (cirílico, insóptico). En Windows sistemas operativos anteriores a Windows Vista, un nombre de referencia cultural que incluye un script usa el patrón , por languagecode2 - country/regioncode2 - scripttag ejemplo, uz-UZ-Cyrl para Uzorgán (cirílico, infiel).

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

Nota

Hay dos nombres de referencia cultural que contradicen esta regla. Las referencia culturales chino (simplificado), denominado zh-Hans y chino (tradicional), denominado zh-Hant , son las referencia culturales neutras. Los nombres de referencia cultural representan el estándar actual y deben usarse a menos que tenga una razón para usar los nombres anteriores zh-CHS 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 referencia 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 e identificadores de referencia cultural System.Globalization predefinidos. Para obtener información detallada sobre la referencia cultural Windows, vea 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 las referencia culturales que se pueden encontrar en un equipo determinado. Windows versiones o Service Pack pueden cambiar las referencia culturales disponibles. Las aplicaciones pueden agregar referencia cultural personalizada mediante la CultureAndRegionInfoBuilder clase . Los usuarios pueden agregar sus propias referencia 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 referencia culturales se agrupan generalmente en tres conjuntos: referencia cultural invariable, referencia cultural neutra y referencia cultural específica.

Una referencia cultural invariable no tiene en cuenta 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 espacio Globalization de nombres que requiera una referencia cultural.

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

No se recomienda crear una instancia de una clase para una referencia cultural CompareInfo neutra porque los datos que contiene son arbitrarios. Para mostrar y ordenar los datos, especifique el idioma y la región. Además, la propiedad de un objeto creado para una referencia cultural neutra devuelve Name solo el país y no incluye la CompareInfo región.

Las referencia 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 referencia culturales personalizadas deben Parent definir la propiedad de acuerdo con 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, vea Empaquetado e implementación de recursos.

La lista de configuraciones regionales de Windows API es ligeramente diferente de la lista de referencia culturales admitidas por .NET. Si se requiere interoperabilidad con Windows, por ejemplo, a través del 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 Windows equivalente, que se identifica con un identificador de configuración regional que es el mismo que LCID .

Un o un solo se puede crear para la referencia cultural invariable o para las referencia culturales DateTimeFormatInfo NumberFormatInfo específicas, no para las referencia culturales neutras.

Si DateTimeFormatInfo.Calendar es pero no se establece en , , y TaiwanCalendar Thread.CurrentCulture zh-TW DateTimeFormatInfo.NativeCalendarName DateTimeFormatInfo.GetEraName DateTimeFormatInfo.GetAbbreviatedEraName devuelven una cadena vacía ("").

Referencia cultural personalizada

En Windows, puede crear configuraciones regionales personalizadas. Para obtener más información, vea Configuraciones regionales personalizadas.

CultureInfo y datos culturales

.NET deriva sus datos culturales de una de varias fuentes, en función de la implementación, la plataforma y la versión:

  • En .NET Framework 3.5 y versiones anteriores, el sistema operativo de Windows y .NET Framework.

  • En .NET Framework 4 y versiones posteriores, el sistema operativo proporciona datos culturales Windows.

  • En todas las versiones de .NET Core que se ejecutan Windows, el sistema operativo proporciona Windows 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 problema, 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, , o chino (simplificado, China) y , o chino (tradicional, Taiwán), son referencia culturales disponibles en sistemas Windows, pero son referencia culturales con alias en sistemas zh-CN zh-TW 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 llamadas al método no devuelven las referencia culturales con alias y pueden tener valores de propiedad diferentes, incluidas las distintas referencia culturales, que sus GetCultures Parent Windows equivalentes. Para las zh-CN referencia zh-TW culturales y , estas diferencias incluyen lo siguiente:

  • En Windows, la referencia cultural primaria de la referencia cultural "zh-CN" es "zh-Hans" y la referencia cultural primaria de la referencia cultural "zh-TW" es "zh-Hant". La referencia cultural primaria de ambas culturas es "zh". En sistemas Unix, los padres de ambas referencia culturales son "zh". Esto significa que, si no proporciona recursos específicos de la referencia cultural para las referencia 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 de la referencia cultural neutra en Windows pero no en Unix. En sistemas Unix, debe establecer explícitamente el del subproceso en CurrentUICulture "zh-Hans" o "zh-Hant".

  • En Windows, llamar a en una instancia de que representa la referencia cultural CultureInfo.Equals "zh-CN" y pasarle una instancia de "zh-Hans-CN" devuelve true . En sistemas Unix, la llamada al método devuelve false . Este comportamiento también se aplica a llamar a en una instancia Equals de "zh-TW" y CultureInfo pasarle una instancia de "zh-Hant-Tw".

Datos de referencia cultural dinámica

Excepto para la referencia cultural invariable, los datos de referencia cultural son dinámicos. Esto es así incluso para las referencia culturales predefinidas. Por ejemplo, los países o regiones adoptan nuevas monedas, cambian la ortografía de las palabras o cambian su calendario preferido y las definiciones de referencia cultural cambian para realizar el seguimiento. Las referencia culturales personalizadas están sujetas a cambios sin previo aviso y una referencia cultural de reemplazo personalizada podría invalidar cualquier referencia cultural específica. 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 cambiar de significado si esa referencia cultural cambia.

Referencia cultural actual y 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 actual y actual de la interfaz de usuario por subproceso, consulte la sección Referencia cultural y subprocesos. Para obtener información sobre cómo se determina la referencia cultural actual y actual de la interfaz de usuario en los subprocesos que se ejecutan en un nuevo dominio de aplicación y en los subprocesos que cruzan los límites del dominio de aplicación, consulte la sección Referencia cultural y dominios de aplicación. Para obtener información sobre cómo se determinan el actual y el actual en los subprocesos que realizan operaciones asincrónicas basadas en tareas, vea la sección Referencia cultural y operaciones asincrónicas basadas en tareas.

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

Recuperación de las referencia culturales de interfaz de usuario actuales y actuales

Puede obtener un objeto CultureInfo 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 objeto que represente la referencia cultural de la interfaz de CultureInfo 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 referencia culturales de interfaz de usuario actuales y actuales

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 objeto que represente esa referencia cultural llamando a un constructor de clase y CultureInfo pasando el nombre de la referencia CultureInfo cultural. El constructor crea una instancia de un objeto que refleja las invalidaciones de usuario si la nueva referencia cultural es la misma que la referencia CultureInfo(String) CultureInfo cultural Windows actual. El constructor permite especificar si el objeto del que se acaba de crear una instancia refleja las invalidaciones del usuario si la nueva referencia cultural es la misma que la referencia CultureInfo(String, Boolean) CultureInfo cultural Windows actual.

  2. Asigne el CultureInfo objeto a la propiedad o en CultureInfo.CurrentCulture CultureInfo.CurrentUICulture .NET Core y .NET Framework 4.6 y versiones posteriores. (En .NET Framework 4.5.2 y versiones anteriores, puede asignar el objeto CultureInfo a la propiedad o Thread.CurrentCulture Thread.CurrentUICulture ).

En el ejemplo siguiente se recupera la referencia cultural actual. Si es algo distinto de la referencia cultural francés (Francia), cambia la referencia cultural actual a francés (Francia). De lo contrario, cambia la referencia cultural actual a Francés (Irlanda).

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 algo distinto de la referencia cultural de la esloveno ,cambia la referencia cultural actual a Esloveno (Esloveno). De lo contrario, cambia la referencia cultural actual a la japonesa (Asoia).

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 referencia culturales

Puede recuperar una matriz de categorías específicas de referencia cultural o de todas las referencia culturales disponibles en el equipo local llamando al GetCultures método . Por ejemplo, puede recuperar las referencia culturales personalizadas, las referencia culturales específicas o las neutras, ya sea solas o combinadas.

En el ejemplo siguiente se llama al método dos veces, primero con el miembro de enumeración para recuperar todas las referencia culturales personalizadas y, después, con el miembro de enumeración para recuperar todas las referencia GetCultures System.Globalization.CultureTypes System.Globalization.CultureTypes 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 actual de la interfaz de usuario se definen mediante la referencia cultural actual del sistema y no por la referencia cultural del subproceso actual. En el siguiente ejemplo se ilustra la diferencia. Establece la referencia cultural actual y la referencia cultural actual de la interfaz de usuario de un subproceso de aplicación en la referencia cultural de francés (Francia) (fr-FR). Si la referencia cultural actual ya es fr-FR, en el ejemplo se 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 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 francés (Francia), a diferencia de la salida del subproceso de aplicación principal.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   static Random rnd = new Random();

   public static void Main()
   {
      if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
         // If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      }
      else {
         // Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
      }
      ThreadProc();

      Thread worker = new Thread(ThreadProc);
      worker.Name = "WorkerThread";
      worker.Start();
   }

   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'",
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name);
   }

   private static void DisplayValues()
   {
      // Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:");
      for (int ctr = 0; ctr <= 3; ctr++)
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10);
   }

   private static void ThreadProc()
   {
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          8,11 €
//          1,48 €
//          8,99 €
//          9,04 €
//
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: en-US/en-US
//       Some currency values:
//          $6.72
//          $6.35
//          $2.90
//          $7.72
Imports System.Globalization
Imports System.Threading

Module Example
   Dim rnd As New Random()
   
   Public Sub Main()
      If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
         ' If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR")
      Else
         ' Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US")
      End If
      ThreadProc()
          
       Dim worker As New Thread(AddressOf ThreadProc)
       worker.Name = "WorkerThread"
       worker.Start()
   End Sub
   
   Private Sub DisplayThreadInfo()
      Console.WriteLine()
      Console.WriteLine("Current Thread Name: '{0}'", 
                        Thread.CurrentThread.Name)
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name)                        
   End Sub
   
   Private Sub DisplayValues()
      ' Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:")
      For ctr As Integer = 0 To 3
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10)                        
      Next
   End Sub
   
   Private Sub ThreadProc()
      DisplayThreadInfo()
      DisplayValues()
   End Sub
End Module
' The example displays output similar to the following:
'       Current Thread Name: ''
'       Current Thread Culture/UI Culture: fr-FR/fr-FR
'       Some currency values:
'          8,11 €
'          1,48 €
'          8,99 €
'          9,04 €
'       
'       Current Thread Name: 'WorkerThread'
'       Current Thread Culture/UI Culture: en-US/en-US
'       Some currency values:
'          $6.72
'          $6.35
'          $2.90
'          $7.72

En versiones de .NET Framework anteriores a .NET Framework 4.5, la manera más común de asegurarse de que el subproceso de aplicación principal comparte la misma referencia cultural con todos los demás subprocesos de trabajo es pasar el nombre de la referencia cultural de toda la aplicación o un objeto que representa la referencia cultural de toda la aplicación CultureInfo 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 mediante la asignación de un objeto que represente esa referencia cultural a las propiedades y CultureInfo DefaultThreadCurrentCulture 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 propiedades y son miembros estáticos, definen la referencia cultural predeterminada y la referencia cultural predeterminada de la interfaz de usuario solo para el dominio de aplicación actual en el momento en que se establecen DefaultThreadCurrentCulture DefaultThreadCurrentUICulture estos valores de propiedad. Para más información, consulte la sección siguiente, Dominios de referencia cultural y de aplicación.

Al asignar valores a las propiedades y , 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 DefaultThreadCurrentCulture DefaultThreadCurrentUICulture explícitamente una referencia cultural. Sin embargo, estos subprocesos reflejan la nueva configuración de referencia cultural solo mientras se ejecutan en el dominio de aplicación actual. Si estos subprocesos se ejecutan en otro dominio de aplicación, su referencia cultural se convierte en la referencia cultural predeterminada definida para ese dominio de aplicación. Como resultado, se recomienda establecer siempre la referencia cultural del subproceso de aplicación principal y no confiar en las DefaultThreadCurrentCulture propiedades DefaultThreadCurrentUICulture y para cambiarlo.

Dominios de referencia cultural y de aplicación

DefaultThreadCurrentCulture y son propiedades estáticas que definen explícitamente una referencia cultural predeterminada solo para el dominio de aplicación actual cuando se establece o recupera DefaultThreadCurrentUICulture 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 clase y el delegado para establecer la referencia cultural predeterminada y la referencia cultural de la interfaz de usuario en un nuevo dominio de aplicación en ruso AppDomainSetup AppDomainInitializer (Rusia). A continuación, un único subproceso ejecuta dos métodos en cada dominio de aplicación. Tenga en cuenta que la referencia cultural del subproceso y la referencia cultural de la interfaz de usuario 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 propiedades y devuelven los valores predeterminados del dominio de aplicación actual DefaultThreadCurrentCulture cuando se realiza la llamada al DefaultThreadCurrentUICulture CultureInfo 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 referencia culturales y los dominios de aplicación, vea la sección "Dominios de aplicación y subprocesos" en el tema Dominios de aplicación.

Referencia cultural y operaciones asincrónicas basadas en tareas

El patrón de programación asincrónica basado en tareas usa objetos y para ejecutar delegados de forma asincrónica en Task Task<TResult> 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.

Para las aplicaciones que tienen .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 que tienen como destino .NET Framework 4.6, las operaciones asincrónicas heredan de forma predeterminada los valores de las propiedades y del subproceso desde el que se CurrentCulture CurrentUICulture inician. Si la referencia cultural actual o la referencia cultural actual de la interfaz de usuario difiere de la referencia cultural del sistema, la referencia cultural actual cruza los límites de subprocesos y se convierte en la referencia cultural actual del subproceso del grupo de subprocesos que ejecuta una operación asincrónica.

Esto se muestra en el ejemplo siguiente. Usa el atributo TargetFrameworkAttribute para tener como destino .NET Framework 4.6. En el ejemplo se define Func<TResult> un 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). A continuación:

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

  • 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 de aplicación principal llamando al Task.RunSynchronously método .

Como se muestra en la salida del ejemplo, cuando la referencia cultural actual se cambia a francés (Francia), la referencia cultural actual del subproceso desde el que se invocan las tareas de forma asincrónica se convierte en la referencia cultural actual de 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 €

Para las aplicaciones que tienen como destino versiones de .NET Framework anteriores a .NET Framework 4.6 o para aplicaciones que no tienen como destino una versión determinada de .NET Framework, la referencia cultural del subproceso que realiza la llamada no forma parte del contexto de una tarea. En su lugar, a menos que se defina explícitamente uno, 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 en el 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 lugar de en-US 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 que tienen como destino versiones de .NET Framework de .NET Framework 4.5 y versiones posteriores pero anteriores a .NET Framework 4.6, puede usar las propiedades y 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 DefaultThreadCurrentCulture DefaultThreadCurrentUICulture subprocesos. El ejemplo siguiente es idéntico al ejemplo anterior, salvo que usa la propiedad para asegurarse de que los subprocesos del grupo de subprocesos tienen la misma referencia cultural que el DefaultThreadCurrentCulture subproceso de aplicación principal.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));

                                             output += Environment.NewLine;
                                             return output;
                                           };

       Console.WriteLine("The example is running on thread {0}",
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}",
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);
       CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CurrentCulture;

       // Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:");
       Console.WriteLine(formatDelegate());

       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:");
       var t1 = Task.Run(formatDelegate);
       Console.WriteLine(t1.Result);

       Console.WriteLine("Executing a task synchronously:");
       var t2 = new Task<String>(formatDelegate);
       t2.RunSynchronously();
       Console.WriteLine(t2.Result);
   }
}
// The example displays the following output:
//     The example is running on thread 1
//     The current culture is en-US
//     Changed the current culture to fr-FR.
//
//     Executing the delegate synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163 025 412,32 €   18 905 365,59 €
//
//     Executing a task asynchronously:
//     Formatting using the fr-FR culture on thread 3.
//     163 025 412,32 €   18 905 365,59 €
//
//     Executing a task synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163 025 412,32 €   18 905 365,59 €
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 son propiedades de dominio por aplicación; es decir, establecen una referencia cultural predeterminada para todos los subprocesos que no tienen asignada explícitamente una referencia cultural DefaultThreadCurrentUICulture 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 realiza la llamada sigue formando 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 ejecuta cruza los límites del dominio de aplicación. Define una clase, , con un único método, , que devuelve un número de punto flotante aleatorio de precisión doble entre 1 y DataRetriever 1000 con formato de valor GetFormattedNumber de moneda. Se ejecuta una primera tarea que simplemente crea una instancia de DataRetriever y llama a su método GetFormattedNumber . Una segunda tarea notifica su dominio de aplicación actual, crea un nuevo dominio de aplicación, crea una instancia de en el nuevo dominio de aplicación y llama a DataRetriever su GetFormattedNumber método . Como se muestra en la salida del ejemplo, la referencia cultural actual ha seguido siendo la misma 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 CultureInfo serializa un objeto , todo lo que se almacena realmente es y Name UseUserOverride . Solo se deserializa correctamente en un entorno donde Name tiene el mismo significado. En los tres ejemplos siguientes se muestra por qué no siempre es así:

  • Si el valor de propiedad es y 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 CultureTypes CultureTypes.InstalledWin32Cultures Windows. Por ejemplo, si se introdujo una referencia cultural en Windows 10, no se puede deserializar en Windows 8.

  • Si el valor es y el equipo en el que se deserializa no tiene instalada esta referencia cultural personalizada del usuario, no es posible CultureTypes CultureTypes.UserCustomCulture deserializarla.

  • Si el valor es y el equipo en el que se deserializa no tiene esta referencia cultural de CultureTypes reemplazo, se deserializa con el mismo nombre, pero no todas las mismas CultureTypes.ReplacementCultures características. Por ejemplo, si es una referencia cultural de reemplazo en el equipo A, pero no en el equipo B, y si un 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 en-US CultureInfo cultural. La referencia cultural se deserializa correctamente, pero con un significado diferente.

Panel de control invalidaciones

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 regional 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 para la referencia cultural. En general, las aplicaciones deben respetar estas invalidaciones de usuario.

Si es y la referencia cultural especificada coincide con la referencia cultural actual de Windows, utiliza esas invalidaciones, incluida la configuración de usuario para las propiedades de la instancia devuelta por la propiedad y las propiedades de la instancia devuelta por la UseUserOverride true propiedad CultureInfo DateTimeFormatInfo DateTimeFormat NumberFormatInfo NumberFormat . Si la configuración del usuario no es compatible con la referencia cultural asociada a , por ejemplo, si el calendario seleccionado no es uno de los , los resultados de los métodos y los valores de las propiedades son CultureInfo OptionalCalendars indefinidos.

Ordenaciones alternativas

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

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

  • La zh-CN referencia cultural (chino (simplificado, PRC)) admite dos ordenaciones: por pronunciación (valor predeterminado) y por recuento de trazos. Cuando se crea una instancia de CultureInfo un objeto con el nombre de referencia zh-CN cultural, se usa el criterio de ordenación predeterminado. Cuando se crea una instancia de un objeto con un identificador local de 0x00020804, las cadenas se CultureInfo 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 Windows Universal Windows Platform (UWP), las propiedades y son de lectura y escritura, igual que en las CurrentCulture CurrentUICulture aplicaciones .NET Framework y .NET Core. Sin embargo, las aplicaciones para UWP reconocen una sola referencia cultural. Las CurrentCulture propiedades y se asignan al primer valor de la CurrentUICulture 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 propiedades y reflejan solo la referencia cultural y la referencia cultural de la interfaz de CurrentCulture CurrentUICulture usuario del subproceso actual. En las aplicaciones para UWP, la referencia cultural actual se asigna al Windows. Colección ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages, que es una configuración global. Al establecer la propiedad o se cambia la referencia cultural de toda la aplicación; la referencia cultural CurrentCulture no se puede establecer por CurrentUICulture 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 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 CultureInfo usuario 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 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 CultureInfo 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 objeto que representa la referencia cultural utilizada por el subproceso actual y CultureInfo 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