1. 全栈程序员必看首页

CultureInfo

全栈程序员-用户IM • • 未分类

CultureInfo // ==++==// //   //    Copyright (c) 2002 Microsoft Corporation.  All rights reserved.//   //    The use and distribution terms for this software are contained in the file//  

大家好，又见面了，我是你们的朋友全栈君。 

  1. // ==++==
  2. // 
  3. //   
  4. //    Copyright (c) 2002 Microsoft Corporation.  All rights reserved.
  5. //   
  6. //    The use and distribution terms for this software are contained in the file
  7. //    named license.txt, which can be found in the root of this distribution.
  8. //    By using this software in any fashion, you are agreeing to be bound by the
  9. //    terms of this license.
  10. //   
  11. //    You must not remove this notice, or any other, from this software.
  12. //   
  13. // 
  14. // ==–==
  16. //
  17. //  Class:    CultureInfo
  18. //
  19. //
  20. //  Purpose:  This class represents the software preferences of a particular
  21. //            culture or community.  It includes information such as the
  22. //            language, writing system, and a calendar used by the culture
  23. //            as well as methods for common operations such as printing
  24. //            dates and sorting strings.
  25. //
  26. //  Date:     March 31, 1999
  27. //
  30. namespace System.Globalization {    
  31.     using System;
  32.     using System.Threading;
  33.     using System.Runtime.CompilerServices;
  34.     
  35.     /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo”]/*’ />
  36.     [Serializable] public class CultureInfo : ICloneable, IFormatProvider {
  38.         //
  39.         // Special culture IDs
  40.         //
  41.         internal const int InvariantCultureID = 0x007f;
  42.         internal const int zh_CHT_CultureID = 0x7c04;
  43.         
  44.         //——————————————————————–//
  45.         //                        Internal Information                        //
  46.         //——————————————————————–//
  47.     
  48.         // This is the string used to construct CultureInfo.
  49.         // It is in the format of ISO639 (2 letter language name) plus dash plus
  50.         // ISO 3166 (2 letter region name).  The language name is in lowercase and region name
  51.         // are in uppercase.
  52.         internal String m_name = null;
  53.     
  54.         //
  55.         // This points to a record in the Culture Data Table.  That record contains several fields
  56.         // There are two kinds of fields.  One is 16-bit integer data and another one is string data.
  57.         // These fields contains information about a particular culture.
  58.         // You can think of m_dataItem as a handle that can be used to call the following metdhos:
  59.         //      CultureTable.GetInt32Value()
  60.         //      CultureTable.GetStringValue()
  61.         //      CultureTable.GetMultipleStringValues()
  62.         //
  63.         // By calling these methods, you can get information about a culture.
  64.         internal int m_dataItem;
  66.         //
  67.         // This indicates that if we need to check for user-override values for this CultureInfo instance.
  68.         // For the user default culture of the system, user can choose to override some of the values
  69.         // associated with that culture.  For example, the default short-date format for en-US is
  70.         // “M/d/yyyy”, however, one may change it to “dd/MM/yyyy” from the Regional Option in
  71.         // the control panel.
  72.         // So when a CultureInfo is created, one can specify if the create CultureInfo should check
  73.         // for user-override values, or should always get the default values.
  74.         //
  75.         internal bool m_useUserOverride;
  77.         //
  78.         // This is the culture ID used in the NLS+ world.  The concept of cultureID is similar
  79.         // to the concept of LCID in Win32.  However, NLS+ support “neutral” culture 
  80.         // which Win32 doesn’t support.
  81.         //
  82.         // The format of culture ID (32 bits) is:
  83.         // 
  84.         // 31 – 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
  85.         // +—–+ +———+ +—————+ +—————–+
  86.         //    |         |           |            Primary language ID (10 bits)
  87.         //    |         |           +———– Sublanguage ID (6 its)
  88.         //    |         +———————– Sort ID (4 bits)
  89.         //    +——————————— Reserved (12 bits)
  90.         //
  91.         // Primary language ID and sublanguage ID can be zero to specify ‘neutral’ language.
  92.         // For example, cultureID 0x(0000)0009 is the English neutral culture.
  93.         // cultureID 0x(0000)0000 means the invariant culture (or called neutral culture).
  94.         //
  95.         internal int cultureID;
  97.         //Get the current user default culture.  This one is almost always used, so we create it by default.
  98.         internal static CultureInfo m_userDefaultCulture   = null;
  99.         
  100.         //
  101.         // All of the following will be created on demand.
  102.         //
  103.         
  104.         //The Invariant culture;
  105.         internal static CultureInfo m_InvariantCultureInfo = null; 
  106.         
  107.         //The culture used in the user interface. This is mostly used to load correct localized resources.
  108.         internal static CultureInfo m_userDefaultUICulture = null;
  110.         //This is the UI culture used to install the OS.
  111.         internal static CultureInfo m_InstalledUICultureInfo = null;
  112.         internal bool m_isReadOnly=false;        
  114.         internal CompareInfo compareInfo = null;
  115.         internal TextInfo textInfo = null;
  116.         internal NumberFormatInfo numInfo = null;
  117.         internal DateTimeFormatInfo dateTimeInfo = null;
  118.         internal Calendar calendar = null;
  119.             
  120.         //
  121.         //  Helper Methods.
  122.         //
  123.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  124.         internal static extern bool IsInstalledLCID(int LCID);
  126.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  127.         internal static extern int nativeGetUserDefaultLCID();
  129.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  130.         internal static extern int nativeGetUserDefaultUILanguage();
  131.         
  132.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  133.         internal static extern int nativeGetSystemDefaultUILanguage();
  135.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  136.         internal static extern int nativeGetThreadLocale();
  138.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  139.         internal static extern bool nativeSetThreadLocale(int LCID);
  141.         internal const int SPANISH_TRADITIONAL_SORT = 0x040a;
  142.         internal const int SPANISH_INTERNATIONAL_SORT = 0x0c0a;
  144.         static CultureInfo() {
  145.             CultureInfo temp = new CultureInfo(nativeGetUserDefaultLCID());
  146.             temp.m_isReadOnly = true;
  147.             m_userDefaultCulture = temp;
  148.         }
  150.         
  151.         //
  152.         //  CultureInfo Constructors
  153.         //
  154.         
  155.         
  156.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.CultureInfo”]/*’ />
  157.         public CultureInfo(String name) : this(name, true) {
  158.         }
  159.         
  160.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.CultureInfo1″]/*’ />
  161.         public CultureInfo(String name, bool useUserOverride) {
  162.             if (name==null) {
  163.                 throw new ArgumentNullException(“name”,
  164.                     Environment.GetResourceString(“ArgumentNull_String”));
  165.                 
  166.             }
  167.     
  168.             this.m_dataItem = CultureTable.GetDataItemFromName(name);
  169.             if (m_dataItem < 0) {
  170.                 throw new ArgumentException(
  171.                     String.Format(Environment.GetResourceString(“Argument_InvalidCultureName”), name), “name”);
  172.             }
  173.             this.m_useUserOverride = useUserOverride;
  174.             
  175.             this.cultureID = CultureTable.GetDefaultInt32Value(m_dataItem, CultureTable.ILANGUAGE);
  176.         }
  177.     
  178.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.CultureInfo2″]/*’ />
  179.         public CultureInfo(int culture) : this(culture, true) {
  180.         }
  182.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.CultureInfo3″]/*’ />
  183.         public CultureInfo(int culture, bool useUserOverride) {
  184.             if (culture < 0) {
  185.                 throw new ArgumentOutOfRangeException(“culture”, 
  186.                     Environment.GetResourceString(“ArgumentOutOfRange_NeedPosNum”));
  187.             }
  189.             if (culture==SPANISH_TRADITIONAL_SORT) {
  190.                 // We are removing 0x040a (Spanish Traditional sort) in NLS+.  
  191.                 // So if you create 0x040a, it’s just like 0x0c0a (Spanish International sort).
  192.                 // For a table setup reason, we can not really remove the data item for 0x040a in culture.nlp.
  193.                 // As a workaround, what we do is to make the data for 0x040a to be exactly the same as 0x0c0a.
  194.                 // Unfortunately, the culture name is the only exception.  
  195.                 // So in the table, we still have “es-ES-Ts” in there which we can not make it “es-ES”.
  196.                 // Again, this is for table setup reason.  So if we are creating
  197.                 // CultureInfo using 0x040a, hardcode culture name to be “es-ES” here so that we won’t
  198.                 // get “es-ES-Ts” in the table.
  199.                 m_name = “es-ES”;
  200.             }
  201.             m_dataItem = CultureTable.GetDataItemFromCultureID(GetLangID(culture));            
  203.             if (m_dataItem < 0) {
  204.                 throw new ArgumentException(
  205.                     String.Format(Environment.GetResourceString(“Argument_CultureNotSupported”), culture), “culture”);
  206.             }
  207.             this.m_useUserOverride = useUserOverride;            
  209.             int sortID;
  210.             if ((sortID = GetSortID(culture))!= 0) {
  211.                 //
  212.                 // Check if the sort ID is valid.
  213.                 //
  214.                 if (!CultureTable.IsValidSortID(m_dataItem, sortID)) {
  215.                     throw new ArgumentException(
  216.                         String.Format(Environment.GetResourceString(“Argument_CultureNotSupported”), culture), “culture”);            
  217.                 }
  218.             }
  219.             this.cultureID = culture;
  220.         }
  222.         private const int NEUTRAL_SPANISH_CULTURE = 0x0A; //This is the lcid for neutral spanish.
  223.         private const int INTERNATIONAL_SPANISH_CULTURE = 0x0C0A;  //This is the LCID for international spanish.
  225.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.CreateSpecificCulture”]/*’ />
  226.         public static CultureInfo CreateSpecificCulture(String name) {
  227.             CultureInfo culture = new CultureInfo(name);
  229.             //In the most common case, they’ve given us a specific culture, so we’ll just return that.
  230.             if (!(culture.IsNeutralCulture)) {
  231.                 return culture;
  232.             }
  233.             
  234.             int lcid = culture.LCID;
  235.             //If we have the Chinese locale, we have no way of producing a 
  236.             //specific culture without encountering significant geopolitical
  237.             //issues.  Based on that, we have no choice but to bail.
  238.             if ((lcid & 0x3FF)==0x04) {
  239.                 throw new ArgumentException(Environment.GetResourceString(“Argument_NoSpecificCulture”));
  240.             }
  242.             //I’ve made this a switch statement because I believe that the number fo exceptions which we’re going
  243.             //to have is going to grow.
  244.             switch(lcid) {
  245.             case NEUTRAL_SPANISH_CULTURE:
  246.                 return new CultureInfo(INTERNATIONAL_SPANISH_CULTURE);
  247.             }
  249.             //This is the algorithm that windows uses for determing the “first”
  250.             //culture associated with a neutral language.  The low-order 18 bits
  251.             //of an LCID are consumed with the language ID, so this is essentially
  252.             //a 1 in the culture id field.
  253.             lcid |= 0x0400;
  254.                 
  255.             return new CultureInfo(lcid);
  256.         }
  258.         internal static bool VerifyCultureName(CultureInfo culture, bool throwException) {
  259.             BCLDebug.Assert(culture!=null, “[CultureInfo.VerifyCultureName]culture!=null”);
  261.             //If we have an instance of one of our CultureInfos, the user can’t have changed the
  262.             //name and we know that all names are valid in files.
  263.             if (culture.GetType()==typeof(CultureInfo)) {
  264.                 return true;
  265.             }
  266.             
  267.             String name = culture.Name;
  268.             
  269.             for (int i=0; i<name.Length; i++) {
  270.                 char c = name[i];
  271.                 if (Char.IsLetterOrDigit(c) || c==‘-‘ || c==‘_’) {
  272.                     continue;
  273.                 }
  274.                 if (throwException) {
  275.                     throw new ArgumentException(Environment.GetResourceString(“Argument_InvalidResourceCultureName”, name));
  276.                 }
  277.                 return false;
  278.             }
  279.             return true;
  280.         }
  282.         //——————————————————————–//
  283.         //                        Misc static functions                       //
  284.         //——————————————————————–//
  285.     
  286.         internal static int GetPrimaryLangID(int culture)
  287.         {
  288.             return (culture & 0x03ff);            
  289.         }
  290.     
  291.         internal static int GetSubLangID(int culture)
  292.         {
  293.             return ((culture >> 10) & 0x3f);
  294.         }
  295.     
  296.         internal static int GetLangID(int culture)
  297.         {
  298.             return (culture & 0xffff);
  299.         }
  300.     
  301.         internal static int MakeLangID(int primaryLangID, int subLangID)
  302.         {
  303.             BCLDebug.Assert(primaryLangID >= 0 && primaryLangID < 1024, “CultureInfo.makeLangID(): primaryLangID >= 0 && primaryLangID < 1024”);
  304.             BCLDebug.Assert(subLangID >= 0 && subLangID < 64, “CultureInfo.makeLangID(): subLangID >= 0 && subLangID < 64”);
  305.             return ((subLangID << 10)| primaryLangID);
  306.         }
  307.     
  308.         internal static int GetSortID(int lcid)   
  309.         {
  310.             return ((lcid >> 16) & 0xf);
  311.         }
  312.             
  313.         
  314.         //
  315.         //  CurrentCulture
  316.         //
  317.         //  This instance provides methods based on the current user settings.
  318.         //  These settings are volatile and may change over the lifetime of the
  319.         //  thread.
  320.         //
  321.         
  322.     
  323.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.CurrentCulture”]/*’ />
  324.         public static CultureInfo CurrentCulture
  325.         {
  326.             get {
  327.                 return Thread.CurrentThread.CurrentCulture;
  328.             }
  329.         }
  331.         //
  332.         // This is the equivalence of the Win32 GetUserDefaultLCID()
  333.         //
  334.         internal static CultureInfo UserDefaultCulture {
  335.             get {
  336.                 return (m_userDefaultCulture);
  337.             }
  338.         }
  339.     
  340.         //
  341.         //  This is the equivalence of the Win32 GetUserDefaultUILanguage()
  342.         //
  343.     
  344.         internal static CultureInfo UserDefaultUICulture {
  345.             get {
  346.                 if (m_userDefaultUICulture == null) {
  347.                     CultureInfo temp = new CultureInfo(nativeGetUserDefaultUILanguage()); ;
  348.                     temp.m_isReadOnly = true;
  349.                     m_userDefaultUICulture = temp;
  350.                 }
  351.                 return (m_userDefaultUICulture);    
  352.             }
  353.         }
  354.     
  355.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.CurrentUICulture”]/*’ />
  356.         public static CultureInfo CurrentUICulture {
  357.             get {
  358.                 return Thread.CurrentThread.CurrentUICulture;
  359.             }
  360.         }
  362.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.InstalledUICulture”]/*’ />
  363.         //
  364.         // This is the equivalence of the Win32 GetSystemDefaultUILanguage()
  365.         //
  366.         public static CultureInfo InstalledUICulture {
  367.             get {
  368.                 if (m_InstalledUICultureInfo == null) {
  369.                     CultureInfo temp = new CultureInfo(nativeGetSystemDefaultUILanguage());
  370.                     temp.m_isReadOnly = true;
  371.                     m_InstalledUICultureInfo = temp;
  372.                 }
  373.                 return (m_InstalledUICultureInfo);
  374.             }
  375.         }
  376.     
  377.         
  378.         //
  379.         //  InvariantCulture
  380.         //
  381.         //  This instance provides methods, for example for casing and sorting,
  382.         //  that are independent of the system and current user settings.  It
  383.         //  should be used only by processes such as some system services that
  384.         //  require such invariant results (eg. file systems).  In general,
  385.         //  the results are not linguistically correct and do not match any
  386.         //  culture info.
  387.         //
  388.         
  389.     
  390.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.InvariantCulture”]/*’ />
  391.         public static CultureInfo InvariantCulture {
  392.             get {
  393.                 if (m_InvariantCultureInfo == null) {
  394.                     CultureInfo temp = new CultureInfo(InvariantCultureID, false);
  395.                     temp.m_isReadOnly = true;
  396.                     m_InvariantCultureInfo = temp;
  397.                 }
  398.                 return (m_InvariantCultureInfo);
  399.             }
  400.         }
  401.     
  402.     
  403.         
  404.         //
  405.         //  Parent
  406.         //
  407.         //  Return the parent CultureInfo for the current instance.
  408.         //
  409.         
  410.     
  411.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.Parent”]/*’ />
  412.         public virtual CultureInfo Parent {
  413.             get {
  414.                 int parentCulture = CultureTable.GetDefaultInt32Value(m_dataItem, CultureTable.IPARENT);
  415.                 if (parentCulture == InvariantCultureID) {
  416.                     return (InvariantCulture);
  417.                 }
  418.                 return (new CultureInfo(parentCulture, m_useUserOverride));
  419.             }
  420.         }
  421.     
  422.         
  423.         //
  424.         //  LCID
  425.         //
  426.         //  Returns a properly formed culture identifier for the current
  427.         //  culture info.
  428.         //
  429.         
  430.     
  431.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.LCID”]/*’ />
  432.         public virtual int LCID {
  433.             get {
  434.                 return (this.cultureID);
  435.             }
  436.         }
  437.             
  438.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.GetCultures”]/*’ />
  439.         public static CultureInfo[] GetCultures(CultureTypes types) {
  440.             return (CultureTable.GetCultures(types));
  441.         }
  442.     
  443.         
  444.         //
  445.         //  Name
  446.         //
  447.         //  Returns the full name of the CultureInfo. The name is in format like
  448.         //  “en-US”
  449.         //
  450.         
  451.     
  452.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.Name”]/*’ />
  453.         public virtual String Name {
  454.             get {
  455.                 if (m_name==null) {
  456.                     m_name = CultureTable.GetDefaultStringValue(m_dataItem, CultureTable.SNAME);
  457.                 }
  458.                 return m_name;    
  459.             }
  460.         }
  462.         
  463.         //
  464.         //  DisplayName
  465.         //
  466.         //  Returns the full name of the CultureInfo in the localized language.
  467.         //  For example, if the localized language of the runtime is Spanish and the CultureInfo is
  468.         //  US English, “Ingles (Estados Unidos)” will be returned.
  469.         //
  470.         
  471.         
  472.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.DisplayName”]/*’ />
  473.         public virtual String DisplayName {
  474.             get {
  475.                 return (Environment.GetResourceString(“Globalization.ci_”+Name));
  476.             }
  477.         }
  478.         
  479.         
  480.         //
  481.         //  GetNativeName
  482.         //
  483.         //  Returns the full name of the CultureInfo in the native language.
  484.         //  For example, if the CultureInfo is US English, “English
  485.         //  (United States)” will be returned.
  486.         //
  487.         
  488.     
  489.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.NativeName”]/*’ />
  490.         public virtual String NativeName {
  491.             get {
  492.                 return (CultureTable.GetDefaultStringValue(m_dataItem, CultureTable.SNATIVEDISPLAYNAME));
  493.             }
  494.         }
  495.         
  496.         
  497.         //
  498.         //  GetEnglishName
  499.         //
  500.         //  Returns the full name of the CultureInfo in English.
  501.         //  For example, if the CultureInfo is US English, “English
  502.         //  (United States)” will be returned.
  503.         //
  504.         
  505.     
  506.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.EnglishName”]/*’ />
  507.         public virtual String EnglishName {
  508.             get {
  509.                 return (CultureTable.GetDefaultStringValue(m_dataItem, CultureTable.SENGDISPLAYNAME));
  510.             }
  511.         }
  512.     
  513.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.TwoLetterISOLanguageName”]/*’ />
  514.         public virtual String TwoLetterISOLanguageName {
  515.             get {
  516.                 return (CultureTable.GetDefaultStringValue(m_dataItem, CultureTable.SISO639LANGNAME));        
  517.             }
  518.         }
  519.         
  520.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.ThreeLetterISOLanguageName”]/*’ />
  521.         public virtual String ThreeLetterISOLanguageName {
  522.             get {
  523.                 return (CultureTable.GetDefaultStringValue(m_dataItem, CultureTable.SISO639LANGNAME2));        
  524.             }
  525.         }
  526.     
  527.         
  528.         //
  529.         //  GetAbbreviatedName
  530.         //
  531.         //  Returns the abbreviated name for the current instance.  The
  532.         //  abbreviated form is usually based on the ISO 639 standard, for
  533.         //  example the two letter abbreviation for English is “en”.
  534.         //
  535.         
  536.     
  537.        /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.ThreeLetterWindowsLanguageName”]/*’ />
  538.        public virtual String ThreeLetterWindowsLanguageName {
  539.             get {
  540.                 return (CultureTable.GetDefaultStringValue(m_dataItem, CultureTable.SABBREVLANGNAME));
  541.             }
  542.         }
  544.         
  545.         //
  546.         //  CompareInfo               Read-Only Property
  547.         //
  548.         //  Gets the CompareInfo for this culture.
  549.         //
  550.         
  551.     
  552.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.CompareInfo”]/*’ />
  553.         public virtual CompareInfo CompareInfo {
  554.             get {
  555.                 if (compareInfo==null) {
  556.                     compareInfo = CompareInfo.GetCompareInfo(cultureID);
  557.                 }                            
  558.                 return (compareInfo);
  559.             }
  560.         }
  561.     
  562.         
  563.         //
  564.         //  TextInfo
  565.         //
  566.         //  Gets the TextInfo for this culture.
  567.         //
  568.         
  569.     
  570.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.TextInfo”]/*’ />
  571.         public virtual TextInfo TextInfo {
  572.             get {            
  573.                 if (textInfo==null) {
  574.                     textInfo = new TextInfo(cultureID, m_dataItem, m_useUserOverride);
  575.                 }
  576.                 return (textInfo);
  577.             }
  578.         } 
  579.     
  580.         
  581.         //
  582.         //  Equals
  583.         //
  584.         //  Implements Object.Equals().  Returns a boolean indicating whether
  585.         //  or not object refers to the same CultureInfo as the current instance.
  586.         //
  587.         
  588.     
  589.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.Equals”]/*’ />
  590.         public override bool Equals(Object value) {
  591.             //
  592.             //  See if the object name is the same as the culture info object.
  593.             //
  594.             if ((value != null) && (value is CultureInfo)) {
  595.                 CultureInfo culture = (CultureInfo)value;
  596.     
  597.                 //
  598.                 //  See if the member variables are equal.  If so, then
  599.                 //  return true.
  600.                 //
  601.                 if (this.cultureID == culture.cultureID) {
  602.                     return (true);
  603.                 }
  604.             }
  605.     
  606.             //
  607.             //  Objects are not the same, so return false.
  608.             //
  609.             return (false);
  610.         }
  611.     
  612.     
  613.         
  614.         //
  615.         //  GetHashCode
  616.         //
  617.         //  Implements Object.GetHashCode().  Returns the hash code for the
  618.         //  CultureInfo.  The hash code is guaranteed to be the same for CultureInfo A
  619.         //  and B where A.Equals(B) is true.
  620.         //
  621.         
  622.     
  623.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.GetHashCode”]/*’ />
  624.         public override int GetHashCode() {
  625.             return (this.LCID);
  626.         }
  627.     
  628.     
  629.         
  630.         //
  631.         //  ToString
  632.         //
  633.         //  Implements Object.ToString().  Returns the name of the CultureInfo,
  634.         //  eg. “English (United States)”.
  635.         //
  636.         
  637.     
  638.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.ToString”]/*’ />
  639.         public override String ToString() {
  640.             return (Name);
  641.         }
  642.     
  643.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.GetFormat”]/*’ />
  644.         public virtual Object GetFormat(Type formatType) {
  645.             if (formatType == typeof(NumberFormatInfo)) {
  646.                 return (NumberFormat);
  647.             }
  648.             if (formatType == typeof(DateTimeFormatInfo)) {
  649.                 return (DateTimeFormat);
  650.             }
  651.             return (null);
  652.         }        
  653.         
  654.         private static readonly char[] groupSeparator = new char[] {
    ‘;’};
  656.         /*=================================ParseGroupString==========================
  657.         **Action: The number grouping information is stored as string.  The group numbers
  658.         **        are separated by comma.  The function split the numbers and return
  659.         **        the result as an int array.
  660.         **Returns: An array of int for the number grouping information.
  661.         **Arguments: a number grouping string.
  662.         **Exceptions: None.
  663.         ============================================================================*/
  664.         
  665.         internal static int[] ParseGroupString(String groupStr) {
  666.             BCLDebug.Assert(groupStr != null, “groupStr should not be null. There is data error in culture.nlp.”);
  667.             String[] groupDigits = groupStr.Split(groupSeparator);
  669.             BCLDebug.Assert(groupDigits.Length > 0, “There is data error in culture.nlp.”);
  670.             int[] result = new int[groupDigits.Length];
  672.             try {
  673.                 for (int i=0; i < groupDigits.Length; i++) {
  674.                     result[i] = Int32.Parse(groupDigits[i], NumberStyles.None, NumberFormatInfo.InvariantInfo);
  675.                 }
  676.             } catch (Exception) {
  677.                 BCLDebug.Assert(true, “There is data error in culture.nlp.”);
  678.             }
  679.             return (result);
  680.         }
  681.     
  682.         internal static void CheckNeutral(CultureInfo culture) {
  683.             if (culture.IsNeutralCulture) {
  684.                     throw new NotSupportedException(
  685.                                                     Environment.GetResourceString(“Argument_CultureInvalidFormat”, 
  686.                                                     culture.Name));
  687.             }
  688.         }
  690.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.IsNeutralCulture”]/*’ />
  691.         public virtual bool IsNeutralCulture {
  692.             get {
  693.                 return (cultureID!=InvariantCultureID && CultureTable.IsNeutralCulture(cultureID));
  694.             }
  695.         }
  696.         
  697.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.NumberFormat”]/*’ />
  698.         public virtual NumberFormatInfo NumberFormat {
  699.             get {
  700.                 CultureInfo.CheckNeutral(this);
  701.                 if (numInfo == null) {
  702.                     NumberFormatInfo temp = new NumberFormatInfo(m_dataItem, m_useUserOverride);
  703.                     temp.isReadOnly = m_isReadOnly;
  704.                     numInfo = temp;
  705.                 }
  706.                 return (numInfo);
  707.             }
  708.             set {
  709.                 VerifyWritable();
  710.                 if (value == null) {
  711.                     throw new ArgumentNullException(“value”,
  712.                         Environment.GetResourceString(“ArgumentNull_Obj”));                    
  713.                 }
  714.                 numInfo = value;
  715.             }
  716.         }
  718.         
  719.         //
  720.         // GetDateTimeFormatInfo
  721.         // 
  722.         // Create a DateTimeFormatInfo, and fill in the properties according to
  723.         // the CultureID.
  724.         //
  725.         
  726.         
  727.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.DateTimeFormat”]/*’ />
  728.         public virtual DateTimeFormatInfo DateTimeFormat {
  729.             get {
  730.                 CultureInfo.CheckNeutral(this);
  731.                 if (dateTimeInfo == null) { 
  732.                     lock(this) {
  733.                         if (dateTimeInfo == null) {
  734.                             // Change the calendar of DTFI to the specified calendar of this CultureInfo.
  735.                             DateTimeFormatInfo temp = new DateTimeFormatInfo(GetLangID(cultureID), m_dataItem, m_useUserOverride, this.Calendar);
  736.                             temp.m_isReadOnly = m_isReadOnly;
  737.                             dateTimeInfo = temp;
  738.                         }
  739.                     }
  740.                 }
  741.                 return (dateTimeInfo);
  742.             }
  744.             set {
  745.                 VerifyWritable();
  746.                 if (value == null) {
  747.                     throw new ArgumentNullException(“value”,
  748.                         Environment.GetResourceString(“ArgumentNull_Obj”));                    
  749.                 }                
  750.                 dateTimeInfo = value;
  751.             }                            
  752.         }
  755.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.ClearCachedData”]/*’ />
  756.         public void ClearCachedData() {
  757.             lock(typeof(CultureInfo)) {
  758.                 m_userDefaultUICulture = null;
  759.                 CultureInfo temp = new CultureInfo(nativeGetUserDefaultLCID());
  760.                 temp.m_isReadOnly = true;
  761.                 m_userDefaultCulture = temp;
  763.                 RegionInfo.m_currentRegionInfo = null;                
  764.                 
  765.                 TimeZone.ResetTimeZone();
  766.             }
  767.         }
  769.         /*=================================GetCalendarInstance==========================
  770.         **Action: Map a Win32 CALID to an instance of supported calendar.
  771.         **Returns: An instance of calendar.
  772.         **Arguments: calType    The Win32 CALID
  773.         **Exceptions:
  774.         **      Shouldn’t throw exception since the calType value is from our data table or from Win32 registry.
  775.         **      If we are in trouble (like getting a weird value from Win32 registry), just return the GregorianCalendar.
  776.         ============================================================================*/
  777.         internal Calendar GetCalendarInstance(int calType) {
  778.             if (calType==Calendar.CAL_GREGORIAN) {
  779.                 return (GregorianCalendar.GetDefaultInstance());
  780.             }
  781.             return GetCalendarInstanceRare(calType);
  782.         }
  783.         
  784.         //This function exists as a hack to prevent us from loading all of the non-gregorian
  785.         //calendars unless they’re required.  
  786.         internal Calendar GetCalendarInstanceRare(int calType) {
  787.             BCLDebug.Assert(calType!=Calendar.CAL_GREGORIAN, “calType!=Calendar.CAL_GREGORIAN”);
  789.             switch (calType) {
  790.                 case Calendar.CAL_GREGORIAN_US:               // Gregorian (U.S.) calendar
  791.                 case Calendar.CAL_GREGORIAN_ME_FRENCH:        // Gregorian Middle East French calendar
  792.                 case Calendar.CAL_GREGORIAN_ARABIC:           // Gregorian Arabic calendar
  793.                 case Calendar.CAL_GREGORIAN_XLIT_ENGLISH:     // Gregorian Transliterated English calendar
  794.                 case Calendar.CAL_GREGORIAN_XLIT_FRENCH:      // Gregorian Transliterated French calendar
  795.                     return (new GregorianCalendar((GregorianCalendarTypes)calType));
  796.                 case Calendar.CAL_TAIWAN:                     // Taiwan Era calendar
  797.                     return (TaiwanCalendar.GetDefaultInstance());
  798.                 case Calendar.CAL_JAPAN:                      // Japanese Emperor Era calendar
  799.                     return (JapaneseCalendar.GetDefaultInstance());
  800.                 case Calendar.CAL_KOREA:                      // Korean Tangun Era calendar
  801.                     return (KoreanCalendar.GetDefaultInstance());
  802.                 case Calendar.CAL_HIJRI:                      // Hijri (Arabic Lunar) calendar
  803.                     return (HijriCalendar.GetDefaultInstance());
  804.                 case Calendar.CAL_THAI:                       // Thai calendar
  805.                     return (ThaiBuddhistCalendar.GetDefaultInstance());
  806.                 case Calendar.CAL_HEBREW:                     // Hebrew (Lunar) calendar            
  807.                     return (HebrewCalendar.GetDefaultInstance());
  808.             }
  809.             return (GregorianCalendar.GetDefaultInstance());
  810.         }
  811.         
  813.         /*=================================Calendar==========================
  814.         **Action: Return/set the calendar used by this culture.
  815.         **Returns:
  816.         **Arguments:
  817.         **Exceptions:
  818.         **  ArgumentNull_Obj if the set value is null.
  819.         ============================================================================*/
  820.         
  821.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.Calendar”]/*’ />
  822.         public virtual Calendar Calendar {
  823.             get {
  824.                 if (calendar == null) {
  825.                     lock(this) {
  826.                         if (calendar == null) {
  827.                             // Get the default calendar for this culture.  Note that the value can be
  828.                             // from registry if this is a user default culture.
  829.                             int calType = CultureTable.GetInt32Value(m_dataItem, CultureTable.ICALENDARTYPE, m_useUserOverride);
  830.                             calendar = GetCalendarInstance(calType);
  831.                         }
  832.                     }
  833.                 }
  834.                 return (calendar);
  835.             }
  836.         }
  838.         /*=================================OptionCalendars==========================
  839.         **Action: Return an array of the optional calendar for this culture.
  840.         **Returns: an array of Calendar.
  841.         **Arguments:
  842.         **Exceptions:
  843.         ============================================================================*/
  845.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.OptionalCalendars”]/*’ />
  846.         public virtual Calendar[] OptionalCalendars {
  847.             get {
  848.                 //
  849.                 // This property always returns a new copy of the calendar array.
  850.                 //
  851.                 int[] calID = ParseGroupString(CultureTable.GetDefaultStringValue(m_dataItem, CultureTable.NLPIOPTIONCALENDAR));
  852.                 Calendar [] cals = new Calendar[calID.Length];
  853.                 for (int i = 0; i < cals.Length; i++) {
  854.                     cals[i] = GetCalendarInstance(calID[i]);
  855.                 }
  856.                 return (cals);
  857.             }
  858.         }        
  860.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.UseUserOverride”]/*’ />
  861.         public bool UseUserOverride { 
  862.             get {
  863.                 return (m_useUserOverride);
  864.             }
  865.         }        
  866.     
  867.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.Clone”]/*’ />
  868.         public virtual Object Clone()
  869.         {
  870.             CultureInfo ci = (CultureInfo)MemberwiseClone();
  871.             //If this is exactly our type, we can make certain optimizations so that we don’t allocate NumberFormatInfo or DTFI unless
  872.             //they’ve already been allocated.  If this is a derived type, we’ll take a more generic codepath.
  873.             if (ci.GetType()==typeof(CultureInfo)) {
  874.                 if (dateTimeInfo != null) {
  875.                     ci.dateTimeInfo = (DateTimeFormatInfo)dateTimeInfo.Clone();
  876.                 }
  877.                 if (numInfo != null) {
  878.                     ci.numInfo = (NumberFormatInfo)numInfo.Clone();
  879.                 }
  880.                 ci.m_isReadOnly = false;
  881.             } else {
  882.                 ci.m_isReadOnly = false;
  883.                 ci.DateTimeFormat = (DateTimeFormatInfo)this.DateTimeFormat.Clone();
  884.                 ci.NumberFormat   = (NumberFormatInfo)this.NumberFormat.Clone();
  885.             }
  886.             return (ci);
  887.         }        
  889.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.ReadOnly”]/*’ />        
  890.         public static CultureInfo ReadOnly(CultureInfo ci) {
  891.             if (ci == null) {
  892.                 throw new ArgumentNullException(“ci”);
  893.             }
  894.             if (ci.IsReadOnly) {
  895.                 return (ci);
  896.             }
  897.             CultureInfo info = (CultureInfo)(ci.MemberwiseClone());
  899.             //If this is exactly our type, we can make certain optimizations so that we don’t allocate NumberFormatInfo or DTFI unless
  900.             //they’ve already been allocated.  If this is a derived type, we’ll take a more generic codepath.
  901.             if (ci.GetType()==typeof(CultureInfo)) {
  902.                 if (ci.dateTimeInfo != null) {
  903.                     info.dateTimeInfo = DateTimeFormatInfo.ReadOnly(ci.dateTimeInfo);
  904.                 }
  905.                 if (ci.numInfo != null) {
  906.                     info.numInfo = NumberFormatInfo.ReadOnly(ci.numInfo);
  907.                 }
  908.             } else {
  909.                 info.DateTimeFormat = DateTimeFormatInfo.ReadOnly(ci.DateTimeFormat);
  910.                 info.NumberFormat = NumberFormatInfo.ReadOnly(ci.NumberFormat);
  911.             }
  912.             // Don’t set the read-only flag too early.
  913.             // We should set the read-only flag here.  Otherwise, info.DateTimeFormat will not be able to set.
  914.             info.m_isReadOnly = true;
  915.             
  916.             return (info);
  917.         }
  919.         /// <include file=’doc/CultureInfo.uex’ path=’docs/doc[@for=”CultureInfo.IsReadOnly”]/*’ />
  920.         public bool IsReadOnly {
  921.             get {
  922.                 return (m_isReadOnly);
  923.             }
  924.         }
  926.         private void VerifyWritable() {
  927.             if (m_isReadOnly) {
  928.                 throw new InvalidOperationException(Environment.GetResourceString(“InvalidOperation_ReadOnly”));
  929.             }
  930.         }        
  931.     }    
  932. }
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/150946.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号