C# String.ToUpperInvariant方法代码示例

        /// <summary>
        /// <para>Returns a byte array from a string representing a hexadecimal number.</para>
        /// </summary>
        /// <param name="hexadecimalNumber">
        /// <para>The string containing a valid hexadecimal number.</para>
        /// </param>
        /// <returns><para>The byte array representing the hexadecimal.</para></returns>
        public static Byte[] GetBytesFromHexString(String hexadecimalNumber)
        {
            if (hexadecimalNumber == null) throw new ArgumentNullException("hexadecimalNumber");

            var sb = new StringBuilder(hexadecimalNumber.ToUpperInvariant());
            if (sb[0].Equals('0') && sb[1].Equals('X'))
            {
                sb.Remove(0, 2);
            }

            if (sb.Length % 2 != 0)
            {
                throw new ArgumentException("String must represent a valid hexadecimal (e.g. : 0F99DD)");
            }

            var hexBytes = new Byte[sb.Length / 2];
            try
            {
                for (var i = 0; i < hexBytes.Length; i++)
                {
                    var stringIndex = i * 2;
                    hexBytes[i] = Convert.ToByte(sb.ToString(stringIndex, 2), 16);
                }
            }
            catch (FormatException ex)
            {
                throw new ArgumentException("String must represent a valid hexadecimal (e.g. : 0F99DD)", ex);
            }

            return hexBytes;
        }

 /// <summary>
 /// Default-ctor to build a plain literal with language
 /// </summary>
 public RDFPlainLiteral(String value, String language)
     : this(value)
 {
     if (language            != null && Regex.IsMatch(language, "^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$")) {
         this.Language        = language.ToUpperInvariant();
         this.PatternMemberID = RDFModelUtilities.CreateHash(this.ToString());
     }
 }

        /// <summary>
        /// Asserts that the refId is in the proper format
        /// </summary>
        /// <param name="refId"></param>
        private void assertRefId(String refId)
        {
            Assert.AreEqual(32, refId.Length, "Length");

            int pos = refId.IndexOf("-");
            Assert.AreEqual(-1, pos, "Dashes");

            // Assert case
            Assert.AreEqual(refId, refId.ToUpperInvariant(), "Case Compare");
        }

        /// <summary>
        /// Generate a thumbnail for a specified file
        /// </summary>
        /// <param name="background">The background color that item will have</param>
        /// <param name="pathToFile">The complete path to the file to open</param>
        /// <returns>The generated thumbnail</returns>
        private static Item GenerateCacheObjectThumbnail(Color background, String pathToFile)
        {
            Item ans = new Item();
            int targetWidth = 128, targetHeight = 128;

            Image temp = null;
            /// Generate the thumbnail depending on the type of file
            if (pathToFile != null)
            {
                if (Constants.AllowedExtensionsImages().Any(pathToFile.ToUpperInvariant().EndsWith))
                {
                    using (FileStream fs = new FileStream(pathToFile, FileMode.Open, FileAccess.Read))
                    {
                        using (Image image = Image.FromStream(fs, true, false))
                        {
                            //temp = GenerateThumbnailPhoto(pathToFile);
                            temp = ScaleImage(image, 128, 128);
                            ans.Exif = GetExifFromImage(image);
                        }
                    }
                }
                else
                {
                    using (MemoryStream memStream = new MemoryStream())
                    {
                        FFMpegConverter ffmpeg = new FFMpegConverter();
                        ffmpeg.GetVideoThumbnail(pathToFile, memStream);
                        using (Image image = Image.FromStream(memStream, true, false))
                        {
                            temp = ScaleImage(image, 128, 128);
                        }
                    }
                }
            }

            Image target = new Bitmap(1, 1);
            (target as Bitmap).SetPixel(0, 0, background);
            target = new Bitmap(target, targetWidth, targetHeight);

            using (Graphics g = Graphics.FromImage(target))
            {
                g.Clear(background);
                int x = (targetWidth - temp.Width) / 2;
                int y = (targetHeight - temp.Height) / 2;
                g.DrawImage(temp, x, y);
            }

            ans.Thumbnail = target;

            return ans;
        }

        public static string ToInvariant(this string text)
        {
            List<char> newText = new List<char>();

            foreach (char character in text)
            {
                string temp = new String(new char[] { character });

                if (Char.IsUpper(character)) temp.ToUpperInvariant();
                if (Char.IsLower(character)) temp.ToLowerInvariant();

                foreach (char newchar in temp)
                {
                    newText.Add(newchar);
                    temp.NotNullOrDefault("");
                }
            }

            return new String(newText.ToArray());
        }

 /// <summary>
 /// Default-ctor to build a filter on the given variable for the given language 
 /// </summary>
 public RDFLangMatchesFilter(RDFVariable variable, String language) {
     if (variable != null) {
         if (language != null) {
             if (language == String.Empty || language == "*" || Regex.IsMatch(language, "^[a-zA-Z]+([\\-][a-zA-Z0-9]+)*$")) {
                     this.Variable = variable;
                     this.Language = language.ToUpperInvariant();
                     this.FilterID = RDFModelUtilities.CreateHash(this.ToString());
             }
             else {
                 throw new RDFQueryException("Cannot create RDFLangMatchesFilter because given \"language\" parameter (" + language + ") does not represent a valid language.");
             }
         }
         else {
             throw new RDFQueryException("Cannot create RDFLangMatchesFilter because given \"language\" parameter is null.");
         }
     }
     else {
         throw new RDFQueryException("Cannot create RDFLangMatchesFilter because given \"variable\" parameter is null.");
     }
 }

        private String GetFilePath(String fileName)
        {
            if (!fileName.ToUpperInvariant().EndsWith(".VM"))
            {
                fileName += ".vm";
            }

            String virtualPath1 = HttpContext.Current.Server.MapPath(String.Concat("/sites/", this.domainName, "/view/", fileName.Trim('/', '\\')));
            if (File.Exists(virtualPath1))
            {
                return virtualPath1;
            }

            String virtualPath2 = HttpContext.Current.Server.MapPath(String.Concat("/sites/default/view/", fileName.Trim('/', '\\')));
            if (File.Exists(virtualPath2))
            {
                return virtualPath2;
            }

            throw new global::NVelocity.Exception.ResourceNotFoundException(String.Format(CultureInfo.CurrentCulture, "Template '{0}' not found", fileName));
        }

 /// <inheritdoc/>
 public override String GetPaging(String sql, String order, Int32 limit, Int32 offset)
 {
     if (offset > 0)
     {
         if (String.IsNullOrEmpty(order))
             throw new ArgumentException("An order should be specified for paging query.", "order");
         sql = new StringBuilder(sql.Length + order.Length + 9)
             .Append(sql)
             .Append(" ")
             .Append(order)
             .Insert(GetAfterSelectInsertPoint(sql), " TOP " + (limit + offset))
             .ToString();
         String anotherOrderby = order.ToUpperInvariant();
         if (anotherOrderby.Contains(" DESC"))
             anotherOrderby = anotherOrderby.Replace(" DESC", " ASC");
         else if (anotherOrderby.Contains(" ASC"))
             anotherOrderby = anotherOrderby.Replace(" ASC", " DESC");
         else
             anotherOrderby += " DESC";
         // NOTE This may not work properly when the total count of records < (limit + offset)
         return new StringBuilder("SELECT * FROM (SELECT top ")
             .Append(limit)
             .Append(" * FROM (")
             .Append(sql)
             .Append(") t1 ")
             .Append(anotherOrderby)
             .Append(") t2 ")
             .Append(order)
             .ToString();
     }
     else
     {
         return new StringBuilder(sql.Length + (order == null ? 0 : order.Length) + 9)
             .Append(sql)
             .Append(" ")
             .Append(order)
             .Insert(GetAfterSelectInsertPoint(sql), " TOP " + limit)
             .ToString();
     }
 }

        public static String ToNumber(String raw)
        {
            if (String.IsNullOrWhiteSpace(raw))
                return "";
            else
                raw = raw.ToUpperInvariant();

            var newNumber = new StringBuilder();
            foreach (var c in raw)
            {
                if (" -0123456789".Contains(c))
                    newNumber.Append(c);
                else
                {
                    var result = TranslateToNumber(c);
                    if (result != null)
                        newNumber.Append(result);
                }
                    //ohterwise a nonnumeric char is skipped
            }
            return newNumber.ToString();
        }

        /// <summary>
        /// Parses an ImportanceType from a given Importance header value.
        /// </summary>
        /// <param name="headerValue">The value to be parsed</param>
        /// <returns>A <see cref="MailPriority"/>. If the <paramref name="headerValue"/> is not recognized, Normal is returned.</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="headerValue"/> is <see langword="null"/></exception>
        public static MailPriority ParseImportance(String headerValue)
        {
            if (headerValue == null)
                throw new ArgumentNullException("headerValue");

            switch (headerValue.ToUpperInvariant())
            {
                case "5":
                case "HIGH":
                    return MailPriority.High;

                case "3":
                case "NORMAL":
                    return MailPriority.Normal;

                case "1":
                case "LOW":
                    return MailPriority.Low;

                default:
                    return MailPriority.Normal;
            }
        }

        /// <summary>Try to parse a script line into commands and arguments</summary>
        /// <param name="line">The line to parse</param>
        /// <param name="commandData">A <seealso cref="CommandData"/> object with commands and keystrokes</param>
        /// <returns>true on success, false on failure, CommandData will be null for commands not requiring data to be sent</returns>        
        public static bool TryParseScriptLine(String line, out CommandData commandData)
        {
            commandData = null;
            if (string.IsNullOrEmpty(line)
                || line.StartsWith("#")) // a comment line, ignore
            {
                return false;
            }


            string command = string.Empty;
            string args = string.Empty;

            int index = line.IndexOf(' ');
            if (index > 0)
            {
                command = line.Substring(0, index);
                args = line.Substring(index + 1).TrimEnd();
            }
            else
            {
                command = line.ToUpperInvariant().TrimEnd();
            }

            // lookup command and execute action associated with it.                
            Func<String, CommandData> spslCommand = MatchCommand(command);
            if (spslCommand != null)
            {
                commandData = spslCommand(args);
                return true;
            }
            else
            {
                Log.WarnFormat("Command {0} Not Supported", command);
                return false;
            }
        }

    private void RedrawWindow(User32.RECT rect) { }// => User32.InvalidateRect(this.LVHandle, ref rect, false);

    /// <summary>
    /// Returns the index of the first item whose display name starts with the search string.
    /// </summary>
    /// <param name="search">     The string for which to search for. </param>
    /// <param name="startindex">
    /// The index from which to start searching. Enter '0' to search all items.
    /// </param>
    /// <returns> The index of an item within the list view. </returns>
    private Int32 GetFirstIndexOf(String search, Int32 startindex) {
      Int32 i = startindex;
      while (true) {
        if (i >= Items.Count)
          return -1;
        else if (Items[i].DisplayName.ToUpperInvariant().StartsWith(search.ToUpperInvariant()))
          return i;
        else
          i++;
      }
    }

		/*public override long GetItemId (int position)
		{
			return _Posts [position].Id;
		}*/
		public static SpannableString BuildBackgroundColorSpan(SpannableString spannableString,
			String text, String searchString, Color color) {

			int indexOf = text.ToUpperInvariant().IndexOf(searchString.ToUpperInvariant());

			try {
				spannableString.SetSpan(new BackgroundColorSpan(color), indexOf,
					(indexOf + searchString.Length),SpanTypes.ExclusiveExclusive);
			} catch (Exception e) {

			}


			return spannableString;
		}

 /// <summary>
 /// Determines if the message
 /// </summary>
 /// <param name="command"></param>
 /// <returns></returns>
 public virtual Boolean CanParseDccCommand( String command )
 {
     if ( String.IsNullOrEmpty( command ) )
     {
         return false;
     }
     return ( DccCommand.ToUpperInvariant().EndsWith( command.ToUpperInvariant(), StringComparison.Ordinal ) );
 }

		/// <summary>
		/// Parse a character set into an encoding.
		/// </summary>
		/// <param name="characterSet">The character set to parse</param>
		/// <returns>An encoding which corresponds to the character set</returns>
		/// <exception cref="ArgumentNullException">If <paramref name="characterSet"/> is <see langword="null"/></exception>
		public static Encoding ParseCharsetToEncoding(String characterSet)
		{
			if (characterSet == null)
				throw new ArgumentNullException("characterSet");

			String charSetUpper = characterSet.ToUpperInvariant();
			if (charSetUpper.Contains("WINDOWS") || charSetUpper.Contains("CP"))
			{
				// It seems the character set contains an codepage value, which we should use to parse the encoding
				charSetUpper = charSetUpper.Replace("CP", ""); // Remove cp
				charSetUpper = charSetUpper.Replace("WINDOWS", ""); // Remove windows
				charSetUpper = charSetUpper.Replace("-", ""); // Remove - which could be used as cp-1554

				// Now we hope the only thing left in the characterSet is numbers.
				Int32 codepageNumber = Int32.Parse(charSetUpper, CultureInfo.InvariantCulture);

				return Encoding.GetEncoding(codepageNumber);
			}

			// Some emails incorrectly specify the encoding to be utf8 - but it has to be utf-8
			if (characterSet.Equals("utf8", StringComparison.InvariantCultureIgnoreCase))
				characterSet = "utf-8";

			// It seems there is no codepage value in the characterSet. It must be a named encoding
			return Encoding.GetEncoding(characterSet);
		}