C# String.ToUpper方法代码示例

		/// <summary> Parses the value string into a recognized type. If
		/// the type specified is not supported, the data will
		/// be held and returned as a string.
		/// *
		/// </summary>
		/// <param name="key">the context key for the data
		/// </param>
		/// <param name="type">the data type
		/// </param>
		/// <param name="value">the data
		///
		/// </param>
		public DataInfo(String key, String type, String value)
		{
			this.key = key;

			if (type.ToUpper().Equals(TYPE_BOOLEAN.ToUpper()))
			{
				data = Boolean.Parse(value);
			}
			else if (type.ToUpper().Equals(TYPE_NUMBER.ToUpper()))
			{
				if (value.IndexOf('.') >= 0)
				{
					//UPGRADE_TODO: Format of parameters of constructor 'java.lang.Double.Double' are different in the equivalent in .NET. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1092"'
					data = Double.Parse(value);
				}
				else
				{
					data = Int32.Parse(value);
				}
			}
			else
			{
				data = value;
			}
		}

 public bool addEventJump( String inMemberId, String inEventGroup, String inEventClass, String inAgeDiv, String inTeamCode )
 {
     if ( myTourRow == null ) {
         return false;
     } else {
         if ( ( (byte)myTourRow["JumpRounds"] ) > 0 ) {
             String curAgeDiv = inAgeDiv;
             String curEventGroup = inEventGroup;
             if ( curAgeDiv.ToUpper().Equals( "B1" ) ) {
                 curAgeDiv = "B2";
                 if ( inEventGroup.ToUpper().Equals( "B1" ) ) {
                     curEventGroup = curAgeDiv;
                 }
             } else if ( curAgeDiv.ToUpper().Equals( "G1" ) ) {
                 curAgeDiv = "G2";
                 if ( inEventGroup.ToUpper().Equals( "G1" ) ) {
                     curEventGroup = curAgeDiv;
                 }
             }
             return addEvent( inMemberId, "Jump", curEventGroup, inEventClass, curAgeDiv, inTeamCode );
         } else {
             MessageBox.Show( "Request to add skier to jump event but tournament does not include this event." );
             return false;
         }
     }
 }

        public override FreeRefFunction FindFunction(String name)
        {
            if (!_functionsByName.ContainsKey(name.ToUpper()))
                return null;

            return _functionsByName[name.ToUpper()];
        }

 private String CheckPrimitivType(String mehtodName)
 {
     if (mehtodName.ToUpper().Contains("INT")) return typeof(int).ToString();
     if (mehtodName.ToUpper().Contains("STRING")) return typeof(string).ToString();
     if (mehtodName.ToUpper().Contains("FLOAT")) return typeof(float).ToString();
     if (mehtodName.ToUpper().Contains("DOUBLE")) return typeof(double).ToString();
     return mehtodName;
 }

 public long getUserID(String user_name)
 {
     if (user_name_list.ContainsKey(user_name.ToUpper()))
     {
         return user_name_list[user_name.ToUpper()];
     }
     return -1;
 }

        public List<string> ListFieldData(String SQLColumn)
        {
            //Create our list that will return our data to SmartSearch. This must be named 'FieldData'.
            List<String> FieldData = new List<String>();

            //Creating SQL related objects
            SqlConnection oConnection = new SqlConnection();
            SqlDataReader oReader = null;
            SqlCommand oCmd = new SqlCommand();

            //Setting our connection string for connection to the database, this will be different depending on your enviroment.
            oConnection.ConnectionString = "Data Source=(local)\\FULL2008;Initial Catalog=GrapeLanes;Integrated Security=SSPI;";

            //Check for valid column name
            if ((SQLColumn.ToUpper() == "VENDNAME") || (SQLColumn.ToUpper() == "CSTCTR"))
            {
                //Setting SQL query to return a list of data
                oCmd.CommandText = "SELECT DISTINCT " + SQLColumn.ToUpper() + " FROM INVDATA";
            }
            else
            {
                //Returns an empty list in case of invalid column
                FieldData.Clear();
                return FieldData;
            }

            try
            {
                //Attempt to open the SQL connection and get the data.
                oConnection.Open();
                oCmd.Connection = oConnection;
                oReader = oCmd.ExecuteReader();

                //Take our SQL return and place it into our return object
                while (oReader.Read())
                {
                    FieldData.Add(oReader.GetString(0));
                }

                //Clean up
                oReader.Close();
                oConnection.Close();
            }
            catch (Exception)
            {
                //Returns an empty list in case of error
                FieldData.Clear();
                return FieldData;
            }

            //Return our list data to SmartSearch if successful
            return FieldData;
        }

 public static String GetOID(String name)
 {
     if (name == null)
     {
         return null;
     }
     if (!OIDS.ContainsKey(name.ToUpper()))
     {
         throw new ArgumentException("Se deconoce el algoritmo '" + name + "'");
     }
     return OIDS[name.ToUpper()];
 }

        /// <summary>
        /// The search algorithm.
        /// </summary>
        int Search(String text, int index)
        {
            // Get a reference to the diagram.
            Diagram datagram = mainUI.GetDiagramView().Diagram;

            // Check if the index needs to be wrapped around.
            if (index > datagram.Items.Count)
            {
                index = 0;
            }

            // Iterate through all the nodes and check them for the search string.
            for (int i = index; i < datagram.Items.Count; i++)
            {
                // Get a reference to a node.
                DiagramItem item = datagram.Items[i];
                if (item is ShapeNode)
                {
                    ShapeNode note = (ShapeNode)item;
                    // Check if the node contains the search string.
                    if (note.Text.ToUpper().Contains(text.ToUpper()) |
                        (note.Tag != null && note.Tag.ToString().ToUpper().Contains(text.ToUpper())))
                    {
                        mainUI.FocusOn(note);
                        return i;
                    }
                }
            }

            for (int i = 0; i < index; i++)
            {
                // Get a reference to a node.
                DiagramItem item = datagram.Items[i];
                if (item is ShapeNode)
                {
                    ShapeNode note = (ShapeNode)item;
                    // Check if the node contains the search string.
                    if (note.Text.ToUpper().Contains(text.ToUpper()) |
                        (note.Tag != null && note.Tag.ToString().ToUpper().Contains(text.ToUpper())))
                    {
                        mainUI.FocusOn(note);
                        return i;
                    }
                }
            }

            // If nothing is found, return 0.
            return 0;
        }

        public virtual Boolean Open(String DevicePath)  
        {
            m_Path = DevicePath.ToUpper();
            m_WinUsbHandle = (IntPtr) INVALID_HANDLE_VALUE;

            if (GetDeviceHandle(m_Path))
            {
                if (WinUsb_Initialize(m_FileHandle, ref m_WinUsbHandle))
                {
                    if (InitializeDevice())
                    {
                        m_IsActive = true;
                    }
                    else
                    {
                        WinUsb_Free(m_WinUsbHandle);
                        m_WinUsbHandle = (IntPtr) INVALID_HANDLE_VALUE;
                    }
                }
                else
                {
                    m_FileHandle.Close();
                }
            }

            return m_IsActive;
        }

 public SequiturComplexity(String s)
 {
     S = s;
     chars =  "qwertyuiopåasdfghjklöäzxcvbnm";
     chars += chars.ToUpper();
     chars += "1234567890+-.,<>|;:!?\"()";
 }

        public static HREngine.Private.HREngineRules GetRulesForCard(String CardID)
        {
            if (!HasRule(CardID))
                return null;

            try
            {
                string strFilePath = String.Format("{0}{1}.xml",
                   HRSettings.Get.CustomRuleFilePath,
                   CardID.ToUpper());

                byte[] buffer = File.ReadAllBytes(strFilePath);
                if (buffer.Length > 0)
                {
                    XmlSerializer serialzer = new XmlSerializer(typeof(HREngine.Private.HREngineRules));
                    object result = serialzer.Deserialize(new MemoryStream(buffer));
                    if (result != null)
                        return (HREngine.Private.HREngineRules)result;
                }
            }
            catch (Exception e)
            {
                HRLog.Write("Exception when deserialize XML Rule.");
                HRLog.Write(e.Message);
            }

            return null;
        }

        public int lookupToken(int bas, String key)
        {
            int start = SPECIAL_CASES_INDEXES[bas];
            int end = SPECIAL_CASES_INDEXES[bas + 1] - 1;

            key = key.ToUpper();

            while (start <= end)
            {
                int half = (start + end) / 2;
                int comp = SPECIAL_CASES_KEYS[half].CompareTo(key);

                if (comp == 0)
                {
                    return SPECIAL_CASES_VALUES[half];
                }
                else if (comp < 0)
                {
                    start = half + 1;
                }
                else
                { //(comp > 0)
                    end = half - 1;
                }
            }

            return bas;
        }

 /// <summary>
 /// 效果点数的表达式计算
 /// </summary>
 /// <param name="strEffectPoint"></param>
 /// <returns></returns>
 public static int GetEffectPoint(ActionStatus game, String strEffectPoint)
 {
     int point = 0;
     strEffectPoint = strEffectPoint.ToUpper();
     if (!String.IsNullOrEmpty(strEffectPoint))
     {
         if (strEffectPoint.StartsWith("="))
         {
             switch (strEffectPoint.Substring(1))
             {
                 case "MYWEAPONAP":
                     //本方武器攻击力
                     if (game.AllRole.MyPublicInfo.Hero.Weapon != null) point = game.AllRole.MyPublicInfo.Hero.Weapon.攻击力;
                     break;
                 default:
                     break;
             }
         }
         else
         {
             point = int.Parse(strEffectPoint);
         }
     }
     return point;
 }

 /// <summary>
 /// Creates a new WordNode.
 /// </summary>
 /// <param name="text">The actual text of the word.</param>
 /// <param name="tag">The part-of-speech of the word.</param>
 /// <param name="confidence">A rating of the confidence of the part-of-speech tagging for this word.</param>
 public WordNode(String text, PartOfSpeechTag tag, double confidence) {
     if(text == null) { throw new ArgumentNullException("text"); }
     this.Text = text;
     this.Tag = tag;
     this.Confidence = confidence;
     if(text == text.ToUpper()) { this.AllCaps = true; }
 }

 /// <summary>
 /// 注册资源索引键类型
 /// </summary>
 /// <param name="key">索引键</param>
 /// <param name="type">索引键类型</param>
 /// <returns>是否注册成功</returns>
 public static Boolean RegistType(String key, Type type)
 {
     try
     {
         if (KeyTypeList.ContainsKey(key.ToUpper()))
         {
             throw new Exception("不允许重复注册的KEY");
         }
         KeyTypeList.Add(key.ToUpper(), type);
         return true;
     }
     catch (Exception)
     {
         return false;
     }
 }