Reflection mscorlib [00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 ] 1.0.5000.0 2.0.0.0 4.0.0.0 This type is safe for multithreaded operations. System.Object System.ICloneable System.IFormatProvider System.Runtime.InteropServices.ComVisible(true)

Represents locale information used by all culture dependendent types and methods.

The class provides culture-specific information, such as the language, sublanguage, country/region, calendar, and conventions associated with a particular culture. This class also provides access to culture-specific instances of the , , , and objects. These objects contain the information required for culture-specific operations, such as casing, formatting dates and numbers, and comparing strings. The class is used either directly or indirectly by classes that format, parse, or manipulate culture-specific data, such as , , , and the numeric types.

## Culture Names and Identifiers

The class specifies a unique name for each culture, based on RFC 4646. The name is a combination of an ISO 639 two-letter lowercase culture code associated with a language and an ISO 3166 two-letter uppercase subculture code associated with a country or region.

When a culture name is passed to a class constructor or a method such as or , its case is not significant.

The format for the culture name is languagecode2>-country/regioncode2, where languagecode2 is the two-letter language code and country/regioncode2 is the two-letter subculture code. Examples include ja-JP for Japanese (Japan) and en-US for English (United States). In cases where a two-letter language code is not available, a three-letter code derived from ISO 639-2 is used.

Note that some culture names also specify an ISO 15924 script. For example, Cyrl specifies the Cyrillic script and Latn specifies the Latin script. A culture name that includes a script uses the pattern languagecode2-scripttag-country/regioncode2. An example of this type of culture name is uz-Cyrl-UZ for Uzbek (Cyrillic, Uzbekistan). On Windows operating systems before Windows Vista, a culture name that includes a script uses the pattern languagecode2-country/regioncode2-scripttag, for example, uz-UZ-Cyrl for Uzbek (Cyrillic, Uzbekistan).

A neutral culture is specified by only the two-letter lowercase language code. For example, fr specifies the neutral culture for French, and de specifies the neutral culture for German.

There are two culture names that contradict this rule. The cultures Chinese (Simplified), named zh-Hans, and Chinese (Traditional), named zh-Hant, are neutral cultures. The culture names represent the current standard and should be used unless you have a reason for using the older names zh-CHS and zh-CHT.

A culture identifier is a standard international numeric abbreviation and has the components necessary to uniquely identify one of the installed cultures. Your application can use predefined culture identifiers or define custom identifiers.

Certain predefined culture names and identifiers are used by this and other classes in the namespace. Detailed culture information appears in the National Language Support (NLS) API Reference at the Go Global Developer Center.

Remember that the culture names and identifiers represent only a subset of cultures that can be found on a particular computer. Windows versions or service packs can change the available cultures. Applications add custom cultures using the class. Users add their own custom cultures using the Microsoft Locale Builder tool. Microsoft Locale Builder is written in managed code using the CultureAndRegionInfoBuilder class.

Several distinct names are closely associated with a culture, notably the names associated with the following class members:

## Invariant, Neutral, and Specific Cultures

The cultures are generally grouped into three sets: invariant cultures, neutral cultures, and specific cultures.

An invariant culture is culture-insensitive. Your application specifies the invariant culture by name using an empty string ("") or by its identifier. defines an instance of the invariant culture. It is associated with the English language but not with any country/region. It is used in almost any method in the Globalization namespace that requires a culture.

A neutral culture is a culture that is associated with a language but not with a country/region. A specific culture is a culture that is associated with a language and a country/region. For example, fr is the neutral name for the French culture, and fr-FR is the name of the specific French (France) culture. Note that Chinese (Simplified) and Chinese (Traditional) are also considered neutral cultures.

Creating an instance of a class for a neutral culture is not recommended because the data it contains is arbitrary. To display and sort data, specify both the language and region. Additionally, the property of a object created for a neutral culture returns only the country and does not include the region.

The defined cultures have a hierarchy in which the parent of a specific culture is a neutral culture and the parent of a neutral culture is the invariant culture. The property contains the neutral culture associated with a specific culture. Custom cultures should define the property in conformance with this pattern.

If the resources for a specific culture are not available in the operating system, the resources for the associated neutral culture are used. If the resources for the neutral culture are not available, the resources embedded in the main assembly are used. For more information on the resource fallback process, see Resource Fallback Process.

The list of locales in the Windows API is slightly different from the list of cultures supported by the .NET Framework. If interoperability with Windows is required, for example, through the p/invoke mechanism, the application should use a specific culture that is defined for the operating system. Use of the specific culture ensures consistency with the equivalent Windows locale, which is identified with a locale identifier that is the same as .

A or a can be created only for the invariant culture or for specific cultures, not for neutral cultures.

If is the but the is not set to zh-TW, then , , and return an empty string ("").

## Custom Cultures

In addition to the predefined cultures supported by the Windows operating system and the .NET Framework, the .NET Framework supports three types of custom cultures:

New cultures that supplement the cultures available in Windows or the .NET Framework. For example, an application could install a object that represents the fj-FJ (or Fijan (Fiji)) culture on a system.

Replacement cultures whose properties are different from the properties of the standard cultures supported by Windows and the .NET Framework.

Standard cultures with user overrides. The user can use the Region and Language application in Control Panel to customize an existing culture's property values.

You can use the class to define, save, and register custom cultures that either supplement or replace existing cultures. The method creates a Locale Data Markup Language (LDML) file that can be used to install a custom culture on target systems.

Because the .NET Framework supports custom cultures, you should consider the following when working with culture-specific data:

Custom cultures can have values that exceed the ranges of the predefined cultures. For example, some cultures have unusually long month names, unexpected date or time formats, or other unusual data.

When you display culture-specific data in the user interface, you should respect the user's customizations; for example, the user might want a 24-hour clock or a yyyyMMdd date format.

Remember that custom cultures override default values. Therefore, you cannot consider culture data to be stable. Country names, number and date formats, and spellings may change in the future. If you want to serialize culture-sensitive data such as date and time strings to be passed to the date and time parsing functions, you should use the invariant culture or a specific custom format string.

## Dynamic Culture Data

Except for the invariant culture, culture data is dynamic. This is true even for the predefined cultures. For example, countries or regions adopt new currencies, change their spellings of words, or change their preferred calendar, and culture definitions change to track this. Custom cultures are subject to change without notice, and any specific culture might be overridden by a custom replacement culture. Also, as discussed below, an individual user can override cultural preferences. Applications should always obtain culture data at run time.

When saving data, your application should use the invariant culture, a binary format, or a specific culture-independent format. Data saved according to the current values associated with a particular culture, other than the invariant culture, might become unreadable or might change in meaning if that culture changes.

## Culture and Threads

When a new application thread is started, its current culture and current UI culture are defined by the current system culture, and not by the current thread culture. The following example illustrates the difference. It sets the current culture and current UI culture of an application thread to the French (France) culture (fr-FR). If the current culture is already fr-FR, the example sets it to the English (United States) culture (en-US). It displays three random numbers as currency values and then creates a new thread, which, in turn, displays three more random numbers as currency values. But as the output from the example shows, the currency values displayed by the new thread do not reflect the formatting conventions of the French (France) culture, unlike the output from the main application thread.

code reference: System.Globalization.CultureInfo.Class.Thread#1

In versions of the .NET Framework before the net_v45, the most common way to ensure that the main application thread shares the same culture with all other worker threads is to pass either the name of the application-wide culture or a object that represents the application-wide culture to a delegate. The following example uses this approach to ensure that the currency values displayed by two threads reflect the formatting conventions of the same culture.

code reference: System.Globalization.CultureInfo.Class.Thread#2

You can set the culture and UI culture of thread pool threads in a similar manner by calling the method.

Starting with the net_v45, you can set the culture and UI culture of all threads in an application domain more directly by assigning a object that represents that culture to the and properties. The following example uses these properties to ensure that all threads in the default application domain share the same culture.

code reference: System.Globalization.CultureInfo.Class.Thread#3

Although the and properties are static members, they define the default culture and default UI culture only for the application domain that is current at the time these property values are set. For more information, see the next section, Culture and Application Domains.

When you assign values to the and properties, the culture and UI culture of the threads in the application domain also change if they have not explicitly been assigned a culture. However, these threads reflect the new culture settings only while they execute in the current application domain. If these threads execute in another application domain, their culture becomes the default culture defined for that application domain. As a result, we recommend that you always set the culture of the main application thread, and not rely on the and properties to change it.

## Culture and Application Domains

and are static properties that explicitly define a default culture only for the application domain that is current when the property value is set or retrieved. The following example sets the default culture and default UI culture in the default application domain to French (France), and then uses the class and the delegate to set the default culture and UI culture in a new application domain to Russian (Russia). A single thread then executes two methods in each application domain. Note that the thread's culture and UI culture are not explicitly set; they are derived from the default culture and UI culture of the application domain in which the thread is executing. Note also that the and properties return the default values of the application domain that is current when the method call is made.

code reference: System.Globalization.CultureInfo.Class.AppDomain#1

For more information about cultures and application domains, see Application Domains and Threads.

## CultureInfo Object Serialization

When a object is serialized, all that is actually stored is and . It is successfully de-serialized only in an environment where that has the same meaning. The following three examples show why this is not always the case:

If the property value is , and if that culture was first introduced in Windows Vista or a later version of the Windows operating system, it is not possible to de-serialize it on Windows XP. Similarly, if the culture was first introduced in Windows XP Service Pack 2, it is not possible to de-serialize it for a Windows XP system on which the culture has not been installed.

If the value is , and the computer on which it is de-serialized does not have this user custom culture installed, it is not possible to de-serialize it.

If the value is , and the computer on which it is de-serialized does not have this replacement culture, it de-serializes to the same name, but not all of the same characteristics. For example, if en-US is a replacement culture on computer A, but not on computer B, and if a object referring to this culture is serialized on computer A and de-serialized on computer B, then none of the custom characteristics of the culture are transmitted. The culture de-serializes successfully, but with a different meaning.

## Control Panel Overrides

The user might choose to override some of the values associated with the current culture of Windows through the regional and language options portion of Control Panel. For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture. In general, your applications should honor these user overrides.

If is true and the specified culture matches the current culture of Windows, the uses those overrides, including user settings for the properties of the instance returned by the property, and the properties of the instance returned by the property. If the user settings are incompatible with the culture associated with the , for example, if the selected calendar is not one of the , the results of the methods and the values of the properties are undefined.

## Alternate Sort Orders

The Spanish (Spain) culture has two culture identifiers: 0x0C0A, which uses the default international sort order, and 0x040A, which uses the traditional sort order. If the is constructed using the es-ES culture name, the new uses the default international sort order. For the traditional sort order, the object is constructed using the name es-ES_tradnl. For information on other cultures that have alternate sorts, see Using Alternate Sort Orders.

- Constructor
  1.0.5000.0
  2.0.0.0
  4.0.0.0

  Predefined culture identifiers are listed in the National Language Support (NLS) API Reference at the Go Global Developer Center.

  In most cases, the parameter is mapped to the corresponding National Language Support (NLS) locale identifier. The value of the parameter becomes the value of the property of the new .

  The use of the locale name constructor is encouraged, as locale names are preferred to LCIDs. For custom locales the locale name is required.

  The user might choose to override some of the values associated with the current culture of Windows through the regional and language options portion of Control Panel. For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture.

  If the specified culture identifier matches the culture identifier of the current Windows culture, this constructor creates a that uses those overrides, including user settings for the properties of the instance returned by the property, and the properties of the instance returned by the property. If the user settings are incompatible with the culture associated with the (for example, if the selected calendar is not one of the ) the results of the methods and the values of the properties are undefined.

  If the specified culture identifier does not match the identifier of the current Windows culture, this constructor creates a that uses the default values for the specified culture.

  The property is always set to true.

  For example, suppose that Arabic (Saudi Arabia) is the current Windows culture and the user has changed the calendar from Hijri to Gregorian.

  With CultureInfo("0x0401") (culture name ar-SA), is set to (which is the user setting) and is set to true.

  With CultureInfo("0x041E") (culture name th-TH), is set to (which is the default calendar for th-TH) and is set to true.

  For cultures that use the euro, the .NET Framework and Windows XP set the default currency as euro. However, older versions of Windows do not. Therefore, if the user of an older version of Windows has not changed the currency setting through the regional and language options portion of Control Panel, the currency might be incorrect. To use the .NET Framework default setting for the currency, the application should use a constructor overload that accepts a parameter and set it to false.

  For backwards compatibility, a culture constructed using a parameter of 0x0004 or 0x7c04 will have a property of zh-CHS or zh-CHT, respectively. You should instead prefer to construct the culture using the current standard culture names of zh-Hans or zh-Hant, unless you have a reason for using the older names.

  Initializes a new instance of the class based on the culture specified by the culture identifier.

  A predefined identifier, property of an existing object, or Windows-only culture identifier.
- Constructor
  1.0.5000.0
  2.0.0.0
  4.0.0.0

  For a list of predefined culture names, see the National Language Support (NLS) API Reference at the Go Global Developer Center.

  If is , the constructor creates an instance of the invariant culture; this is equivalent to retrieving the value of the property.

  The user might choose to override some of the values associated with the current culture of Windows through the regional and language options portion of Control Panel. For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture. If the culture identifier associated with matches the culture identifier of the current Windows culture, this constructor creates a object that uses those overrides, including user settings for the properties of the instance returned by the property, and the properties of the instance returned by the property. If the user settings are incompatible with the culture associated with the , for example, if the selected calendar is not one of the , the results of the methods and the values of the properties are undefined.

  If the culture identifier associated with does not match the culture identifier of the current Windows culture, this constructor creates a object that uses the default values for the specified culture.

  The property is always set to true.

  For example, suppose that Arabic (Saudi Arabia) is the current culture of Windows and the user changed the calendar from Hijri to Gregorian.

  With CultureInfo("ar-SA"), is set to (which is the user setting) and is set to true.

  With CultureInfo("th-TH"), is set to (which is the default calendar for th-TH) and is set to true.

  The property of the new is set to the culture identifier associated with the specified name.

  For cultures that use the euro, the .NET Framework and Windows XP set the default currency as euro. However, older versions of Windows do not do this. Therefore, if the user of an older version of Windows has not changed the currency setting through the regional and language options portion of Control Panel, the currency might be incorrect. To use the .NET Framework default setting for the currency, the application should use a constructor overload that accepts a parameter and set it to false.

  Initializes a new instance of the class based on the culture specified by name.

  A predefined name, of an existing , or Windows-only culture name. is not case-sensitive.
- Constructor
  1.0.5000.0
  2.0.0.0
  4.0.0.0

  Predefined culture identifiers are listed in the National Language Support (NLS) API Reference at the Go Global Developer Center.

  In most cases, the parameter is mapped to the corresponding National Language Support (NLS) locale identifier. The value of the parameter becomes the value of the property of the new .

  The use of the locale name constructor is encouraged, as locale names are preferred to LCIDs. For custom locales the locale name is required.

  The user might choose to override some of the values associated with the current culture of Windows through the regional and language options portion of Control Panel. For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture.

  Applications should typically not disallow user overrides. Note that disallowing overrides does not itself guarantee data stability; see the blog entry Culture data shouldn't be considered stable (except for Invariant).

  If the property is set to true and the specified culture identifier matches the identifier of the current Windows culture, this constructor creates a that uses those overrides, including user settings for the properties of the instance returned by the property, and the properties of the instance returned by the property. If the user settings are incompatible with the culture associated with the , for example, if the selected calendar is not one of the , the results of the methods and the values of the properties are undefined.

  Otherwise, this constructor creates a that uses the default values for the specified culture.

  The value of the parameter becomes the value of the property.

  For example, suppose that Arabic (Saudi Arabia) is the current culture of Windows and the user has changed the calendar from Hijri to Gregorian.

  With CultureInfo("0x0401", true) (culture name ar-SA), is set to (which is the user setting) and is set to true.

  With CultureInfo("0x0401", false) (culture name ar-SA), is set to (which is the default calendar for ar-SA) and is set to false.

  With CultureInfo("0x041E", true) (culture name th-TH), is set to (which is the default calendar for th-TH) and is set to true.

  With CultureInfo("0x041E", false) (culture name th-TH), is set to (which is the default calendar for th-TH) and is set to false.

  For cultures that use the euro, the .NET Framework and Windows XP set the default currency as euro. However, older versions of Windows do not. Therefore, if the user of an older version of Windows has not changed the currency setting through the regional and language options portion of Control Panel, the currency might be incorrect. To use the .NET Framework default setting for the currency, the application should set the parameter to false.

  For backwards compatibility, a culture constructed using a parameter of 0x0004 or 0x7c04 will have a property of zh-CHS or zh-CHT, respectively. You should instead prefer to construct the culture using the current standard culture names of zh-Hans or zh-Hant, unless you have a reason for using the older names.

  Initializes a new instance of the class based on the culture specified by the culture identifier and on the Boolean that specifies whether to use the user-selected culture settings from the system.

  A predefined identifier, property of an existing object, or Windows-only culture identifier.
  A Boolean that denotes whether to use the user-selected culture settings (true) or the default culture settings (false).
- Constructor
  1.0.5000.0
  2.0.0.0
  4.0.0.0

  For a list of predefined culture names, see the National Language Support (NLS) API Reference at the Go Global Developer Center.

  If is , the constructor creates an instance of the invariant culture; this is equivalent to retrieving the value of the property.

  The user might choose to override some of the values associated with the current Windows culture through the regional and language options portion of Control Panel. For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture.

  Applications should typically not disallow user overrides. Note that disallowing overrides does not itself guarantee data stability; see the blog entry Culture data shouldn't be considered stable (except for Invariant).

  If the property is set to true and the culture identifier associated with the specified culture name matches the culture identifier of the current Windows culture, this constructor creates a that uses those overrides, including user settings for the properties of the instance returned by the property, and the properties of the instance returned by the property. If the user settings are incompatible with the culture associated with the , for example, if the selected calendar is not one of the , the results of the methods and the values of the properties are undefined.

  Otherwise, this constructor creates a that uses the default values for the specified culture.

  The value of the parameter becomes the value of the property.

  For example, suppose that Arabic (Saudi Arabia) is the current culture of Windows and the user changed the calendar from Hijri to Gregorian.

  With CultureInfo("ar-SA", true), is set to (which is the user setting) and is set to true.

  With CultureInfo("ar-SA", false), is set to (which is the default calendar for ar-SA) and is set to false.

  With CultureInfo("th-TH", true), is set to (which is the default calendar for th-TH) and is set to true.

  With CultureInfo("th-TH", false), is set to (which is the default calendar for th-TH) and is set to false.

  The property of the new is set to the culture identifier associated with the specified name.

  For cultures that use the euro, the .NET Framework and Windows XP set the default currency as euro. However, older versions of Windows do not do this. Therefore, if the user of an older version of Windows has not changed the currency setting through the regional and language options portion of Control Panel, the currency might be incorrect. To use the .NET Framework default setting for the currency, the application should set the parameter to false.

  Initializes a new instance of the class based on the culture specified by name and on the Boolean that specifies whether to use the user-selected culture settings from the system.

  A predefined name, of an existing , or Windows-only culture name. is not case-sensitive.
  A Boolean that denotes whether to use the user-selected culture settings (true) or the default culture settings (false).
- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.Calendar To be added.

  The user might choose to override some of the values associated with the current culture of Windows through the regional and language options portion of Control Panel. For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture.

  If is true and the specified culture matches the current culture of Windows, the uses those overrides, including user settings for the properties of the instance returned by the property, and the properties of the instance returned by the property. If the user settings are incompatible with the culture associated with the , for example, if the selected calendar is not one of the , the results of the methods and the values of the properties are undefined.

  Therefore, if is true, the value of this property might be different from the default calendar used by the culture.

  Your application changes the calendar used by the current by setting the property of , which is an instance of the class. The new calendar must be one of the calendars listed in . also includes other properties that customize the date and time formatting associated with that .

  Gets the default calendar used by the culture.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void

  Information, such as the default culture and format patterns, is cached the first time it is requested. That information can change during the life of the , for example, when the user modifies the regional and language options portion of Control Panel. However, the class does not automatically detect changes in the system settings.

  The method clears the cache of objects created by and refreshes the information in the , , and properties, based on the current system settings.

  The method does not refresh the information in the property for existing threads. However, future threads will have any new property values.

  Refreshes cached culture-related information.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Object

  The clone is writable even if the original is read-only. Therefore, the properties of the clone can be modified.

  A shallow copy of an object is a copy of the object only. If the object contains references to other objects, the shallow copy does not create copies of the referred objects. It refers to the original objects instead. In contrast, a deep copy of an object creates a copy of the object and a copy of everything directly or indirectly referenced by that object.

  The method creates an enhanced shallow copy. The objects returned by the , , , and properties are also copied. Consequently, the cloned object can modify its copied properties without affecting the original object.

  Creates a copy of the current .

  A copy of the current .

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.CompareInfo To be added.

  The user might choose to override some of the values associated with the current culture of Windows through the regional and language options portion of Control Panel. For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture.

  If is true and the specified culture matches the current culture of Windows, the uses those overrides, including user settings for the properties of the instance returned by the property, and the properties of the instance returned by the property. If the user settings are incompatible with the culture associated with the , for example, if the selected calendar is not one of the , the results of the methods and the values of the properties are undefined.

  Gets the that defines how to compare strings for the culture.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo ``

  For a list of predefined culture names, see the National Language Support (NLS) API Reference at the Go Global Developer Center.

  Cultures are grouped into three sets: the invariant culture, the neutral cultures, and the specific cultures. For more information, see the description of the class.

  If the culture identifier of the specific culture returned by this method matches the culture identifier of the current Windows culture, this method creates a object that uses the Windows culture overrides. The overrides include user settings for the properties of the object returned by the property and the object returned by the property.

  Although the method name includes the term "Specific", remember that culture data can change between versions, or due to custom cultures, or because of user overrides. Use the invariant culture or binary or fixed forms for saving data.

  Creates a that represents the specific culture that is associated with the specified name.

  A object that represents:

  The invariant culture, if is an empty string ("").

  -or-

  The specific culture associated with , if is a neutral culture.

  -or-

  The culture specified by , if is already a specific culture.

  A predefined name or the name of an existing object. is not case-sensitive.
- Property
  2.0.0.0
  4.0.0.0
  System.Runtime.InteropServices.ComVisible(false)
  System.Globalization.CultureTypes To be added. To be added.

  Gets the culture types that pertain to the current object.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo Initial value for each thread is determined using following rules. When is set its value is used otherwise the framework uses method to map system locate to framework culture name. This operation may fail in rare cases when system locale is set to invalid value or to value which cannot be translated to framework culture name. In such case values is used.

  Gets the object that represents the culture used by the current thread.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo To be added.

  The current UI culture is a per-thread property. That is, each thread has its own current UI culture. This read-only property is equivalent to retrieving the object returned by the System.Threading.Thread.CurrentThread.CurrentUICulture property. When a thread is started, its UI culture is initially determined as follows:

  By retrieving the culture that is specified by the property in the application domain in which the thread is executing, if the property value is not null.

  By calling the Windows GetUserDefaultUILanguage function.

  In the compact, the property is read-only. The current UI culture is determined by the system's regional settings and cannot be changed programmatically.

  To change the user interface culture used by a thread, set the property to the new culture. If you explicitly change a thread's UI culture in this way, that change persists if the thread crosses application domain boundaries.

  ## Explicitly Setting the Current UI Culture

  Although the property is read-only, you can change its value by explicitly setting the property of the current thread. The current UI culture can be set to either a specific culture (such as en-US or de-DE) or to a neutral culture (such as en or de). The following example sets the current UI culture to fr-FR or French (France).

  code reference: System.Globalization.CultureInfo.CurrentUICulture#1

  In a multithreaded application, you can explicitly set the UI culture of any thread by assigning a object that represents that culture to the thread's property. When the UI culture of a thread is set explicitly, that thread retains the same culture even if it crosses application domain boundaries and executes code in another application domain.

  ## Implicitly Setting the Current UI Culture

  When a thread, including the main application thread, is first created, by default its current UI culture is set as follows:

  By using the culture defined by the property for the current application domain if the property value is not null.

  By using the system's default culture. On systems that use the Windows operating system, the common language runtime calls the Windows GetUserDefaultUILanguage function to set the current UI culture. GetUserDefaultUILanguage returns the default UI culture set by the user. If the user has not set a default UI language, it returns the culture originally installed on the system.

  If the thread crosses application boundaries and executes code in another application domain, its culture is determined in the same way as that of a newly created thread.

  Note that if you set a specific UI culture that is different from the system-installed UI culture or the user's preferred UI culture, and your application starts multiple threads, the current UI culture of those threads will be the culture returned by the GetUserDefaultUILanguage function, unless you assign a culture to the property in the application domain in which the thread is executing.

  ## Security Considerations

  Changing the culture of the current thread requires a permission with the value set.

  Manipulating threads is dangerous because of the security state associated with threads. Therefore, this permission should be given only to trustworthy code, and then only as necessary. You cannot change thread culture in semi-trusted code.

  Gets the object that represents the current user interface culture used by the Resource Manager to look up culture-specific resources at run time.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.DateTimeFormatInfo To be added.

  ## Overrides

  The user might choose to override some of the values associated with the current culture of Windows through the regional and language options portion of Control Panel. For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture.

  If is true and the specified culture matches the current culture of Windows, the uses those overrides, including user settings for the properties of the instance returned by the property, and the properties of the instance returned by the property. If the user settings are incompatible with the culture associated with the , for example, if the selected calendar is not one of the , the results of the methods and the values of the properties are undefined.

  The value of the property and the property is not calculated until your application accesses the property. If the user can change the current culture to a new culture while the application is running and then the application accesses the or property, the application retrieves the defaults for the new culture instead of the overrides for the original culture. To preserve the overrides for the original current culture, the application should access the and properties before changing the current culture.

  Gets or sets a that defines the culturally appropriate format of displaying dates and times.

- Property
  4.0.0.0
  System.Globalization.CultureInfo To be added.

  In the net_v40_long and previous versions, by default, the culture of all threads is set to the Windows system culture. For applications whose current culture differs from the default system culture, this behavior is often undesirable. In the net_v45, the property enables an application to define the default culture of all threads in an application domain.

  If you have not explicitly set the culture of any existing threads executing in an application domain, setting the property also changes the culture of these threads. However, if these threads execute in another application domain, their culture is defined by the property in that application domain or, if no default value is defined, by the default system culture. Because of this, we recommend that you always explicitly set the culture of your main application thread, and not rely on the property to define the culture of the main application thread.

  Unless it is set explicitly, the value of the property is null, and the culture of threads in an application domain that have not been assigned an explicit culture is defined by the default Windows system culture.

  For more information about cultures, threads, and application domains, see the "Culture and Threads" and "Culture and Application Domains" sections in the class topic.

  Gets or sets the default culture for threads in the current application domain.

- Property
  4.0.0.0
  System.Globalization.CultureInfo To be added.

  In the net_v40_long and previous versions, by default, the UI culture of all threads is set to the Windows system culture. For applications whose current UI culture differs from the default system culture, this behavior is often undesirable. In the net_v45, the property lets you define the default UI culture of all threads in an application domain.

  If you have not explicitly set the UI culture of any existing threads executing in an application domain, setting the property also changes the culture of these threads. However, if these threads execute in another application domain, their culture is defined by the property in that application domain or, if no default value is defined, by the default system culture. Because of this, we recommend that you always explicitly set the culture of your main application thread and do not rely on the property to define the culture of the main application thread.

  Unless it is set explicitly, the value of the property is null, and the current culture of all threads in an application domain that have not been assigned an explicit culture is defined by the default Windows system culture.

  For more information about cultures, threads, and application domains, see the "Culture and Threads" and "Culture and Application Domains" sections in the class topic.

  Gets or sets the default UI culture for threads in the current application domain.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.String To be added.

  This property represents the localized name of the object.

  Culture names may vary due to scripting or formatting conventions. You should use the returned name for display, and not attempt to parse it.

  If a custom culture is created by means of the class, the property is initialized to the value of the property.

  Gets the full localized culture name.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.String To be added.

  For example, the for the specific culture name en-US is "English (United States)".

  The value of this property is the same, regardless of the language version of the .NET Framework.

  Gets the culture name in the format languagefull [country/regionfull] in English.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean ``

  This method overrides .

  Two objects are considered equal if their and properties are equal.

  Determines whether the specified object is the same culture as the current .

  true if is the same culture as the current ; otherwise, false.

  The object to compare with the current .
- Method
  2.0.0.0
  4.0.0.0
  System.Runtime.InteropServices.ComVisible(false)
  System.Globalization.CultureInfo

  Languages such as Arabic, Hebrew, Urdu, and Syriac are based on bidirectional text. Windows applications, which have a graphical user interface, support bidirectional languages. However, console applications, which employ the text user interface of the operating system console, do not provide bidirectional support. Therefore, if you localize a console application to Arabic or Hebrew, your application displays unreadable text on the console screen.

  The user interface culture specifies the resources an application needs to support user input and output, and by default is the same as the operating system culture. For example, the property returns an Arabic culture for an Arabic operating system. Use the method to retrieve a culture suitable for a console application user interface. After your application retrieves the fallback user interface culture, it should assign the culture to the current user interface culture of the current thread. For more information, see the "Explicitly Setting the Current UI Culture" section of the property.

  The following are predefined cultures that have a different fallback user interface culture name from the predefined culture name.

  Predefined culture

  Culture name

  Fallback user interface culture name

  Amharic

  am

  en-US

  Amharic (Ethiopia)

  am-ET

  en-US

  (neutral Arabic)

  ar

  en-US

  Arabic (U.A.E.)

  ar-AE

  en-US

  Arabic (Bahrain)

  ar-BH

  en-US

  Arabic (Algeria)

  ar-DZ

  fr-FR

  Arabic (Egypt)

  ar-EG

  en-US

  Arabic (Iraq)

  ar-IQ

  en-US

  Arabic (Jordan)

  ar-JO

  en-US

  Arabic (Kuwait)

  ar-KW

  en-US

  Arabic (Lebanon)

  ar-LB

  en-US

  Arabic (Libya)

  ar-LY

  en-US

  Arabic (Morocco)

  ar-MA

  fr-FR

  Arabic (Oman)

  ar-OM

  en-US

  Arabic (Qatar)

  ar-QA

  en-US

  Arabic (Saudi Arabia)

  ar-SA

  en-US

  Arabic (Syria)

  ar-SY

  en-US

  Arabic (Tunisia)

  ar-TN

  fr-FR

  Arabic (Yemen)

  ar-YE

  en-US

  Assamese

  as

  en-US

  Assamese (India)

  as-IN

  en-US

  Bengali

  bn

  en-US

  Bengali (Bangladesh)

  bn-BD

  en-US

  Bengali (India)

  bn-IN

  en-US

  Tibetan

  bo

  en-US

  Tibetan (PRC)

  bo-CN

  en-US

  Divehi

  dv

  en-US

  Divehi (India)

  dv-MV

  en-US

  Persian

  fa

  en-US

  Persian (Iran)

  fa-IR

  en-US

  Gujarati

  gu

  en-US

  Gujarati (India)

  gu-IN

  en-US

  Hebrew

  he

  en-US

  Hebrew (Israel)

  he-IL

  en-US

  Hindi

  hi

  en-US

  Hindi (India)

  hi-IN

  en-US

  Yi

  ii

  en-US

  Yi (PRC)

  ii-CN

  en-US

  Inukitut Syllabics

  iu-Cans

  en-US

  Inukitut Syllabics (Canada)

  iu-Cans-CA

  en-US

  Khmer

  km

  en-US

  Khmer (Cambodia)

  km-KH

  en-US

  Kannada

  kn

  en-US

  Kannada (India)

  kn-IN

  en-US

  Konkani

  kok

  en-US

  Konkani (India)

  kok-IN

  en-US

  Lao

  lo

  en-US

  Lao (Lao P.D.R.)

  lo-LA

  en-US

  Malayalam

  ml

  en-US

  Malayalam (India)

  ml-IN

  en-US

  Mohawk

  moh

  en-US

  Mohawk (Canada)

  moh-CA

  en-US

  Marathi

  mr

  en-US

  Marathi (India)

  mr-IN

  en-US

  Nepali

  ne

  en-US

  Nepali (Nepal)

  ne-NP

  en-US

  Norwegian

  no

  nb-NO

  Oriya

  or

  en-US

  Oriya (India)

  or-IN

  en-US

  Punjabi

  pa

  en-US

  Punjabi (India)

  pa-IN

  en-US

  Dari

  prs

  en-US

  Dari (Afghanistan)

  prs-AF

  en-US

  Pashto

  ps

  en-US

  Pashto (Afghanistan)

  ps-AF

  en-US

  Sanskrit

  sa

  en-US

  Sanskrit (India)

  sa-IN

  en-US

  Sinhala

  si

  en-US

  Sinhala (Sri Lanka)

  si-LK

  en-US

  Syriac

  syr

  en-US

  Syriac (Syria)

  syr-SY

  en-US

  Tamil

  ta

  en-US

  Tamil (India)

  ta-IN

  en-US

  Telugu

  te

  en-US

  Telugu (India)

  te-IN

  en-US

  Thai

  th

  en-US

  Thai (Thailand)

  th-Th

  en-US

  Uighur

  ug

  en-US

  Uighur (PRC)

  ug-CN

  en-US

  Urdu

  ur

  en-US

  Urdu (Pakistan)

  ur-PK

  en-US

  Vietnamese

  vi

  en-US

  Vietnamese (Vietnam)

  vi-VN

  en-US

  Your application can use to create a replacement for a culture, and that culture can have a console fallback culture of your choosing.

  Gets an alternate user interface culture suitable for console applications when the default graphic user interface culture is unsuitable.

  An alternate culture that is used to read and display text on the console.

- Method
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo ``

  We recommend that you use the string overload of this method (), because locale names should be used instead of LCIDs. For custom locales, the locale name is required.

  If is the locale identifier of the current culture, the returned object does not reflect any user overrides.

  Retrieves a cached, read-only instance of a culture by using the specified culture identifier.

  A read-only object.

  A locale identifier (LCID).
- Method
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo ``

  For a list of predefined culture names, see the National Language Support (NLS) API Reference at the Go Global Developer Center.

  The method retrieves a cached, read-only object. It offers better performance than a corresponding call to the constructor.

  If is the name of the current culture, the returned object does not reflect any user overrides. This makes the method suitable for server applications or tools that do not have a real user account on the system and that need to load multiple cultures efficiently.

  If is , the method returns the invariant culture. This is equivalent to retrieving the value of the property.

  Retrieves a cached, read-only instance of a culture using the specified culture name.

  A read-only object.

  The name of a culture. is not case-sensitive.
- Method
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo `` ``

  For a list of predefined culture names, see the National Language Support (NLS) API Reference at the Go Global Developer Center.

  The method obtains a cached, read-only object. It offers better performance than a corresponding call to a constructor. The method is used to create a culture similar to that specified by the parameter, but with different sorting and casing rules.

  If or is the name of the current culture, the returned objects do not reflect any user overrides. If is , the method returns the invariant culture. This is equivalent to retrieving the value of the property. If is , the method uses the writing system and comparison rules specified by the invariant culture.

  Retrieves a cached, read-only instance of a culture. Parameters specify a culture that is initialized with the and objects specified by another culture.

  A read-only object.

  The name of a culture. is not case-sensitive. The name of a culture that supplies the and objects used to initialize . is not case-sensitive.
- Method
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo ``

  This method and the property are deprecated. Instead of using these elements, the application should use a new object and calls to the property. IETF tags and names are identical.

  The RFC 4646 standard that is maintained by the Internet Engineering Task Force (IETF) defines an IETF language tag, which provides a uniform means of identifying a language. The format of an IETF language tag is the same as the culture name returned by the property, but does not identify a culture uniquely. Different cultures share the same IETF language tag if those cultures have identical linguistic characteristics. The linguistic characteristics of a culture are contained in the object associated with a object.

  An IETF language tag consists of a mandatory language identifier, an optional script identifier, and an optional region identifier.

  Your applications should use the retrieved culture to control language-specific tasks, such as managing a spelling or grammar checker. Applications should not use the retrieved culture to control culture-specific tasks, such as sorting text or formatting times and dates.

  For more information, see RFC 4646, "Tags for Identifying Languages," and the most recent draft standard, Draft-phillips-langtags-05.txt, at http://go.microsoft.com/fwlink/?LinkId=100231.

  Deprecated. Retrieves a read-only object having linguistic characteristics that are identified by the specified RFC 4646 language tag.

  A read-only object.

  The name of a language as specified by the RFC 4646 standard.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo[] ``

  The method is most commonly called with the parameter set to the following values:

  , which returns all specific cultures.

  , which returns all neutral cultures and the invariant culture.

  , which returns all neutral and specific cultures, cultures installed in the Windows system, and custom cultures created by the user.

  , which returns all custom cultures, such as those registered by the class.

  Gets the list of supported cultures filtered by the specified parameter.

  An array that contains the cultures specified by the parameter. The array of cultures is unsorted.

  A bitwise combination of the enumeration values that filter the cultures to retrieve.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Object ``

  implements .

  NumberFormatInfo provides the culture-specific numeric format used in conjunction with the Format methods in the base data types. DateTimeFormatInfo controls how the date and time values are formatted for a specific culture.

  Gets an object that defines how to format the specified type.

  The value of the property, which is a containing the default number format information for the current , if is the object for the class.

  -or-

  The value of the property, which is a containing the default date and time format information for the current , if is the object for the class.

  -or-

  null, if is any other object.

  The for which to get a formatting object. This method only supports the and types.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Int32

  This method overrides .

  This method generates the same hash code for two objects that are equal according to the method.

  Serves as a hash function for the current , suitable for hashing algorithms and data structures, such as a hash table.

  A hash code for the current .

- Property
  2.0.0.0
  4.0.0.0
  System.Runtime.InteropServices.ComVisible(false)
  System.String To be added.

  This property and the method are deprecated. Instead, you should use a the property. IETF tags and names are identical.

  The RFC 4646 standard that is maintained by the Internet Engineering Task Force (IETF) defines an IETF language tag, which provides a uniform means of identifying a language. The format of an IETF language tag is similar to the culture name returned by the property, but does not identify a culture uniquely. That is, different cultures share the same IETF language tag if those cultures have identical linguistic characteristics. The linguistic characteristics of a culture are contained in the object associated with a object.

  An IETF language tag consists of a mandatory language identifier, an optional script identifier, and an optional region identifier.

  For more information, see RFC 5646, "Tags for Identifying Languages. For a list of subtags, see The IANA Language Subtag Registry.

  Deprecated. Gets the RFC 4646 standard identification for a language.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo To be added.

  In a localized operating system, such as Japanese Windows 2000 Professional, this property returns the culture of the operating system. This property is the equivalent of GetSystemDefaultUILanguage in the Windows API.

  Gets the that represents the culture installed with the operating system.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo To be added.

  The invariant culture is culture-insensitive; it is associated with the English language but not with any country/region. You specify the invariant culture by name by using an empty string ("") in the call to a instantiation method. also retrieves an instance of the invariant culture. It can be used in almost any method in the namespace that requires a culture. The objects returned by properties such as , , and also reflect the string comparison and formatting conventions of the invariant culture.

  Unlike culture-sensitive data, which is subject to change by user customization or by updates to the .NET Framework or the operating system, invariant culture data is stable over time and across installed cultures and cannot be customized by users. This makes the invariant culture particularly useful for operations that require culture-independent results, such as formatting and parsing operations that persist formatted data, or sorting and ordering operations that require that data be displayed in a fixed order regardless of culture.

  ## String Operations

  You can use the invariant culture for culture-sensitive string operations that are not affected by the conventions of the current thread culture and that are consistent across cultures. For example, you may want sorted data to appear in a fixed order or apply a standard set of casing conventions to strings regardless of the current thread culture. To do this, you pass the object to a method that has a parameter, such as and .

  ## Persisting Data

  The property can be used to persist data in a culture-independent format. This provides a known format that does not change and that can be used to serialize and deserialize data across cultures. After the data is deserialized, it can be formatted appropriately based on the cultural conventions of the current user.

  For example, if you choose to persist date and time data in string form, you can pass the object to the or method to create the string, and you can pass the object to the or method to convert the string back to a date and time value. This technique ensures that the underlying date and time values do not change when the data is read or written by users from different cultures.

  The following example uses the invariant culture to persist a value as a string. It then parses the string and displays its value by using the formatting conventions of the French (France) and German (Germany) cultures.

  code reference: System.Globalization.CultureInfo.InvariantCulture#1

  ## Security Decisions

  If you are making a security decision (such as whether to allow access to a system resource) based on the result of a string comparison or a case change, you should not use the invariant culture. Instead, you should perform a case-sensitive or case-insensitive ordinal comparison by calling a method that includes a parameter and supplying either or as an argument. Code that performs culture-sensitive string operations can cause security vulnerabilities if the current culture is changed or if the culture on the computer that is running the code differs from the culture that is used to test the code. In contrast, an ordinal comparison depends solely on the binary value of the compared characters.

  Gets the object that is culture-independent (invariant).

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  If this property returns false, the culture is either a specific culture or the invariant culture.

  Gets a value indicating whether the current represents a neutral culture.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  If the is read-only, the and instances are also read-only.

  Gets a value indicating whether the current is read-only.

- Property
  2.0.0.0
  4.0.0.0
  System.Runtime.InteropServices.ComVisible(false)
  System.Int32 To be added.

  The input locale identifier was formerly called the keyboard layout. An input locale identifier is a broader concept than a keyboard layout since it can also indicate a speech-to-text converter, an Input Method Editor (IME), or any other form of input.

  Gets the active input locale identifier.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Int32 To be added.

  In most cases, the culture identifier is mapped to the corresponding NLS locale identifier.

  Gets the culture identifier for the current .

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.String To be added.

  For a list of predefined culture names and identifiers that the property can return, see the National Language Support (NLS) API Reference at the Go Global Developer Center. Note that culture names are subject to change, and that they also can reflect the names of custom cultures.

  The property follows the naming standards provided in the class topic. It returns the short form of the culture name that excludes any indication of an alternate sort order. For example, if you instantiate a object by using the string "de-DE_phoneb" to reflect an alternate sort order, the property returns "de-DE".

  To get the full name of the culture, you should use the , , or property.

  Gets the culture name in the format languagecode2-country/regioncode2.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.String To be added.

  The value of this property is the same, regardless of the language version of the .NET Framework.

  Gets the culture name, consisting of the language, the country/region, and the optional script, that the culture is set to display.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.NumberFormatInfo To be added.

  ## Overrides

  The user might choose to override some of the values associated with the current culture of Windows through the regional and language options portion of Control Panel. For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture.

  If is true and the specified culture matches the current culture of Windows, the uses those overrides, including user settings for the properties of the instance returned by the property, and the properties of the instance returned by the property. If the user settings are incompatible with the culture associated with the , for example, if the selected calendar is not one of the , the results of the methods and the values of the properties are undefined.

  The values of the property and the property are not calculated until the user accesses the property. If the user uses the Control Panel to change the current culture to a new culture while the application is running and then accesses the or property, the application retrieves the defaults for the new culture. not the overrides for the original culture. To preserve the overrides for the original current culture, the application should access the and properties before changing the current culture.

  Gets or sets a that defines the culturally appropriate format of displaying numbers, currency, and percentage.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.Calendar[] To be added.

  Your application changes the calendar used by the current by setting the property of , which is an instance of the class. The new calendar must be one of the calendars listed in . also includes other properties that customize the date and time formatting associated with that .

  Gets the list of calendars that can be used by the culture.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo To be added.

  The cultures have a hierarchy in which the parent of a specific culture is a neutral culture, the parent of a neutral culture is the , and the parent of the is the invariant culture itself. The parent culture encompasses only the set of information that is common among its children.

  If the resources for the specific culture are not available in the system, the resources for the neutral culture are used. If the resources for the neutral culture are not available, the resources embedded in the main assembly are used. For more information on the resource fallback process, see Resource Fallback Process.

  Gets the that represents the parent culture of the current .

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.CultureInfo ``

  This wrapper prevents any modifications to , or the objects returned by the . and . properties.

  Returns a read-only wrapper around the specified .

  A read-only wrapper around .

  The to wrap.
- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Globalization.TextInfo To be added.

  The property provides culture-specific casing information for strings. To perform culture-insensitive casing, the application should use the property of .

  Gets the that defines the writing system associated with the culture.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.String To be added.

  For example, the three-letter abbreviation for English is "eng".

  When communicating between processes or persisting data it is usually better to use the full . Using just the language can lose context and data.

  Gets the ISO 639-2 three-letter code for the language of the current .

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.String To be added.

  This property returns the same value as the Windows API method GetLocaleInfo with the LOCALE_SABBREVLANGNAME value. For example, the three-letter code for English (United States) as defined in the Windows API is "enu".

  When communicating between processes or persisting data it is usually better to use the full . Using just the language can lose context and data.

  Gets the three-letter code for the language as defined in the Windows API.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.String

  This method overrides . It returns a normalized version of the culture name that is passed to the or constructor or to the or method. It normalizes the result string by converting characters in languagecode2 to lowercase and converting characters in country/regioncode2 to uppercase if necessary.

  Predefined culture names are listed in the National Language Support (NLS) API Reference page at the Go Global Developer Center.

  Returns a string containing the name of the current in the format languagecode2-country/regioncode2.

  A string containing the name of the current .

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.String To be added.

  For example, the two-letter abbreviation for English is "en". The property value for the invariant culture is "iv".

  When communicating between processes or persisting data it is usually better to use the full . Using just the language can lose context and data.

  If ISO 639-1 does not define a two-letter language code for a particular culture, the property returns a string that consists of three or more letters. For more information, see the example.

  Gets the ISO 639-1 two-letter code for the language of the current .

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  The user might choose to override some of the values associated with the current culture of Windows through the regional and language options portion of Control Panel. For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture.

  If is true and the specified culture matches the current culture of Windows, the uses those overrides, including user settings for the properties of the instance returned by the property, and the properties of the instance returned by the property. If the user settings are incompatible with the culture associated with the , for example, if the selected calendar is not one of the , the results of the methods and the values of the properties are undefined.

  This property is set when the is created.

  Gets a value indicating whether the current uses the user-selected culture settings.

0