String 类

本部分的引用包括以下信息：

• 实例化 String 对象

• Char 对象和 Unicode 字符

• 字符串和嵌入的 Null 字符

• 字符串和索引

• Null 字符串和空字符串

• 不变性和 StringBuilder 类

• 序号与 区分区域性的操作

• 正常化

• 按类别划分的字符串操作

可以通过以下方式实例化 String 对象：

• 通过把字符串文字分配到 String 变量。 这是用于创建一个字符串最常用的方法。 下面的示例利用赋值创建多个字符串。 请注意，在 C# 中，由于反斜杠 (\) 是个转义字符，所以必须转义字符串中的反斜杠，或者必须给整个字符串加上 @ 前缀。

  C#

  VB

  复制

  
  string string1 = "This is a string created by assignment.";
  Console.WriteLine(string1);
  string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
  Console.WriteLine(string2a);
  string string2b = @"The path is C:\PublicDocuments\Report1.doc";
  Console.WriteLine(string2b);
  // The example displays the following output:
  //       This is a string created by assignment.
  //       The path is C:\PublicDocuments\Report1.doc
  //       The path is C:\PublicDocuments\Report1.doc      
  
  
  

• 通过调用 String 类构造函数。 下面的示例通过调用几个类构造函数实例化字符串。 请注意，一些构造函数的参数包括指向字符数组或带符号的字节数组的指针。 Visual Basic 不支持对这些构造函数的调用。

  C#

  VB

  复制

  
  char[] chars = { 'w', 'o', 'r', 'd' };
  sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
  
  // Create a string from a character array.
  string string1 = new string(chars);
  Console.WriteLine(string1);
  
  // Create a string that consists of a character repeated 20 times.
  string string2 = new string('c', 20);
  Console.WriteLine(string2);
  
  string stringFromBytes = null;
  string stringFromChars = null;
  unsafe
  {
     fixed (sbyte* pbytes = bytes)
     {
        // Create a string from a pointer to a signed byte array.
        stringFromBytes = new string(pbytes);
     }
     fixed (char* pchars = chars)
     {
        // Create a string from a pointer to a character array.
        stringFromChars = new string(pchars);
     }
  }
  Console.WriteLine(stringFromBytes);
  Console.WriteLine(stringFromChars);
  // The example displays the following output:
  //       word
  //       cccccccccccccccccccc
  //       ABCDE
  //       word  
  
  
  

• 通过使用字符串串联运算符（+ 在 C# 中，& 或 + 在 Visual Basic 中）以根据 String 实例和字符串文本的任意组合来创建单个字符串。 下面的示例演示了字符串串联运算符的用法。

  C#

  VB

  复制

  
  string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
  Console.WriteLine(string1);
  
  string string2 = "This is one sentence. " + "This is a second. ";
  string2 += "This is a third sentence.";
  Console.WriteLine(string2);
  // The example displays output like the following:
  //    Today is Tuesday, July 06, 2011.
  //    This is one sentence. This is a second. This is a third sentence.
  
  
  

• 通过检索属性或调用返回字符串的方法。 下面的示例使用 String 类的方法以提取来自较大字符串的子字符串。

  C#

  VB

  复制

  
  string sentence = "This sentence has five words.";
  // Extract the second word.
  int startPosition = sentence.IndexOf(" ") + 1;
  string word2 = sentence.Substring(startPosition,
                                    sentence.IndexOf(" ", startPosition) - startPosition);
  Console.WriteLine("Second word: " + word2);
  // The example displays the following output:
  //       Second word: sentence
  
  
  

• 通过调用格式方法把值或对象转换为字符串表示形式。 下面的示例使用 复合格式 功能将两个对象的字符串表示形式嵌入到字符串。

  C#

  VB

  复制

  
  DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
  double temperature = 68.3;
  string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                dateAndTime, temperature);
  Console.WriteLine(result);
  // The example displays the following output:
  //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
  
  
  

返回备注

字符串中的每个字符都是由 Unicode 标量值定义的，Unicode 标量值也称为 Unicode 码位或者 Unicode 字符的序号（数字）值。 每个码位都是使用 UTF-16 编码进行编码的，编码的每个元素的数值都用一个 Char 对象表示。

一个 Char 对象通常表示一个码位，即：Char 的数值等于该码位。 例如，字符“a”的码位为 U+0061。 但是，一个码位可能需要多个编码元素（多个 Char 对象）。 Unicode 标准定义了三种类型的字符，对应多个 Char 对象：字母 、Unicode 补充代码点和辅助平面中的字符。

• 字素由后跟一个或多个组合字符的基本字符表示。 例如，字符 ä 由码位为 U+0061 的 Char 对象表示，该对象后接码位为 U+0308 的 Char 对象。 具有 U + 00E4 代码点的单个 Char 对象也可以定义此字符。 如下示例所示，平等的区分区域性的比较表明虽然普通的序号比较不是平等的，但这两种表示形式是。 但是，如果这两个字符串均正常化，则序号比较还表示它们相等。 （有关正常化字符串的更多信息，请参见 Normalization 部分。）

  C#

  VB

  复制

  
  using System;
  using System.Globalization;
  using System.IO;
  
  public class Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter(@".\graphemes.txt");
        string grapheme = "\u0061\u0308";
        sw.WriteLine(grapheme);
  
        string singleChar = "\u00e4";
        sw.WriteLine(singleChar);
  
        sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                     String.Equals(grapheme, singleChar, 
                                   StringComparison.CurrentCulture));
        sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                     String.Equals(grapheme, singleChar, 
                                   StringComparison.Ordinal));
        sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                     String.Equals(grapheme.Normalize(), 
                                   singleChar.Normalize(), 
                                   StringComparison.Ordinal));
        sw.Close(); 
     }
  }
  // The example produces the following output:
  //       ä
  //       ä
  //       ä = ä (Culture-sensitive): True
  //       ä = ä (Ordinal): False
  //       ä = ä (Normalized Ordinal): True
  
  
  

• Unicode 补充码位（一个代理项对）由 Char 对象表示，该对象的码位为高代理项，其后跟着码位是低代理项的 Char 对象。 高代理项的码位的范围是从 U + D800 到 U + DBFF。 低代理项的码位的范围是从 U + DC00 到 U + DFFF。 代理项对用于表示 16 Unicode 辅助平面中的字符。 下面的示例创建代理项字符，并将它传递到 Char.IsSurrogatePair(Char, Char) 方法以确定其是否为代理项对。

  C#

  VB

  复制

  
  using System;
  
  public class Example
  {
     public static void Main()
     {
        string surrogate = "\uD800\uDC03";
        for (int ctr = 0; ctr < surrogate.Length; ctr++) 
           Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
  
        Console.WriteLine();
        Console.WriteLine("   Is Surrogate Pair: {0}", 
                          Char.IsSurrogatePair(surrogate[0], surrogate[1]));
     }
  }
  // The example displays the following output:
  //       U+D800 U+DC03
  //          Is Surrogate Pair: True
  
  
  

返回备注

在 .NET Framework 中，String 对象可以包含嵌入的 null 字符，这些值将算作字符串长度的一部分。 但是，在某些语言（例如 C 和 C++）中，null 字符指示字符串的结尾；不会将其视为字符串的一部分，并且将不算作字符串长度的一部分。 这意味着当应用于 String 对象时，C 和 C++ 程序员或使用 C 或 C++ 编写的库对字符串作出的下列常规假设不一定有效：

• strlen 或 wcslen 函数返回的值不一定等于 String.Length。

• 由 strcpy_s 或 wcscpy_s 函数创建的字符串不一定与通过 String.Copy 方法创建的字符串相同。

应确保对 String 对象进行实例化的本机 C 和 C++ 代码以及通过平台调用传递 String 对象的代码不假设使用嵌入的 null 字符标记字符串的结尾。

在排序（或比较）字符串时以及搜索字符串时，也将以不同的方式处理嵌入的 null 字符。 在两个字符串之间执行区分区域性的比较时忽略 Null 字符，包括使用固定区域性的比较。 仅在进行序号或不区分大小写的序号比较时考虑它们。 另一方面，在使用 Contains、StartsWith 和 IndexOf 等方法搜索字符串时，始终考虑嵌入的 NULL 字符串。

返回备注

索引是 Char 对象在 String 中的位置（而不是 Unicode 字符的位置）。 索引是从零开始、从字符串的起始位置（其索引为零）计起的非负数字。 一些搜索方法，例如 IndexOf 和 LastIndexOf 返回字符串实例中的字符或子字符串的索引。

Chars 属性可让您按其在字符串中的索引位置访问各个 Char 对象。 因为 Chars 属性为（在 Visual Basic 中的）默认属性或索引器（在 C# 中），所以可使用如下代码在字符串中访问单个 Char 对象。 此代码查找字符串中的空白或标点字符，以确定该字符串包含多少字。

using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      for (int ctr = 0; ctr < s1.Length; ctr++) {
         if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.

如下示例所示，因为 String 类实现 IEnumerable 接口，所以还可以使用 foreach 构造在字符串中通过 Char 对象进行循环访问。

using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      foreach (var ch in s1) {
         if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.

连续的索引值可能并不与连续的 Unicode 字符相对应，这是因为一个 Unicode 字符可能会编码为多个 Char 对象。 为了使用 Unicode 字符而不是 Char 对象，可使用 System.Globalization.StringInfo 和 TextElementEnumerator 类。 下面的示例演示了使用 Char 对象和使用 Unicode 字符的代码之间的区别。 它比较句子的每个单词中字符或文本元素的数目。 该字符串包括两个基字符序列，后接组合字符。

using System;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // First sentence of The Mystery of the Yellow Room, by Leroux.
      string opening = "Ce n'est pas sans une certaine émotion que "+
                       "je commence à raconter ici les aventures " +
                       "extraordinaires de Joseph Rouletabille."; 
      // Character counters.
      int nChars = 0;
      // Objects to store word count.
      List<int> chars = new List<int>();
      List<int> elements = new List<int>();

      foreach (var ch in opening) {
         // Skip the ' character.
         if (ch == '\u0027') continue;

         if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
            chars.Add(nChars);
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      TextElementEnumerator te = StringInfo.GetTextElementEnumerator(opening);
      while (te.MoveNext()) {
         string s = te.GetTextElement();   
         // Skip the ' character.
         if (s == "\u0027") continue;
         if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
            elements.Add(nChars);         
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      // Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters"); 
      for (int ctr = 0; ctr < chars.Count; ctr++) 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars[ctr], elements[ctr]); 
   }
}
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12

返回备注

已声明但尚未分配值的字符串为 null。 尝试对该字符串调用方法引出 NullReferenceException。 空字符串是不同于空的字符串，是其值为“”或 String.Empty 的字符串。 在某些情况下，将 null 字符串或空字符串作为参数传递给方法将引发异常。 例如，把 Null 字符串传递到 Int32.Parse 方法将引出 ArgumentNullException，传递空字符串将引出 FormatException。 在其他情况下，方法参数可以为 null 字符串或空字符串。 例如，要提供类的 IFormattable 实现，则需要用常规（“G”）格式指示符使 Null 字符串等同于空字符串。

String 类包括以下两种方便的方法，使您能够测试字符串是否为 null 或为空：

• IsNullOrEmpty ，指示字符串是否为 null 或等于 String.Empty。 该方法消除了使用如下代码的需要：

  C#

  VB

  复制

  
  if (str == null || str.Equals(String.Empty))
  
  
  

• IsNullOrWhiteSpace ，指示字符串是否为 null，等于 String.Empty，或仅由空白字符组成。 该方法消除了使用如下代码的需要：

  C#

  VB

  复制

  
  if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
  
  
  

下面的示例使用自定义 Temperature 类的 IFormattable.ToString 实现中的 IsNullOrEmpty 方法。 该方法支持"G"、"C"、"F"和"K" 格式字符串。 如将空格式字符串或值为 null 的格式字符串传递到该方法，则其值更改为“G”格式字符串。

public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;

   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}

返回备注

String 对象称为不可变的（只读），因为在创建了该对象之后，就不能修改该对象的值。 看来似乎修改了 String 对象的方法实际上是返回一个包含修改内容的新 String 对象。

因为字符串是不可变的，所以对单个字符串执行字符串加法或减法操作时可以减少重大性能损失。 例如，以下代码使用随机数字生成器来创建含有在 0x0001 到 0x052F 范围之间的 1000 个字符的字符串。 尽管该代码会出现以使用字符串串联来将新的字符追加到命名为 str 的现有字符串，它实际上会为每个串联操作创建新的 String 对象。

using System;
using System.IO;
using System.Text;

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

      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += Convert.ToChar(rnd.Next(1, 0x0530)); 
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}

可使用 StringBuilder 类代替 String 类多次更改字符串值。 不同于 String 类的实例，StringBuilder 对象是可变的；当您串联、 追加或删除字符串中的子字符串，则会对单个字符串执行操作。 完成 StringBuilder 对象的值的修改后，可以调用其 StringBuilder.ToString 方法将其转换为字符串。 下面的示例将替换用在前面示例中的 String 以连接从 0x0001 到 0x052F 范围内并带 StringBuilder 对象的 1000 个随机字符。

using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append(Convert.ToChar(rnd.Next(1, 0x0530))); 
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}

返回备注

String 类的成员对 String 对象执行序号操作或区分区域性（语言）操作。 序号运算是对每个 Char 对象的数值执行的。 区分区域性操作则对考虑了特定于区域性的大小写、排序、格式化和语法分析规则的 String 的值执行。 区分区域性运算在显式声明的区域性或者隐式当前区域性的上下文中执行。 两种操作可以产生非常不同的结果（在相同的字符串上执行它们时）。

安全说明
如果应用程序进行有关符号标识符（如文件名或命名管道）或持久数据（如 XML 文件中基于文本的数据）的安全决策，则该操作应该使用序号比较而不是区分区域性的比较。 这是因为根据起作用的区域性的不同，区分区域性的比较可产生不同的结果，而序号比较则仅依赖于所比较字符的二进制值。

重要事项
执行字符串操作的大多数方法都包括带有 StringComparison 类型的参数的重载，这使您可以指定该方法执行序号或区分区域性的操作。 一般情况下，您应该调用此重载让您的方法的意图明确方法调用的目的。 在字符串上使用序号和区分区域性的操作的最佳做法和指南，请参见 在 .NET Framework 中使用字符串的最佳做法。

casing 、parsing and formatting、comparison and sorting 和 testing for equality 可以是序号操作或区分区域性的操作。 以下各节讨论了操作的每个类别。

大小写

using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));

         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 

分析和格式设置

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10

字符串比较和排序

排序规则确定 Unicode 字符的字母顺序，以及两个字符串如何互相比较。 例如 String.Compare(String, String, StringComparison) 根据 StringComparison 参数比较两个字符串。 如果参数值为 StringComparison.CurrentCulture，则方法执行使用当前区域性的约定的语义比较；如果参数值为 StringComparison.Ordinal，则方法执行序号比较。 因此，如以下示例所示，如果当前区域性是美国。 英语，对 String.Compare(String, String, StringComparison) 方法（使用区分区域性的比较）的第一次调用认为“a”小于“A”，但对相同的方法（使用序号比较）的第二次调用认为“a”大于“A”。

C#

VB

复制

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

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32

.NET Framework 支持单词、字符串和序号排序规则。

• 单词排序会执行区分区域性的字符串比较，在这种比较中，某些非字母数字 Unicode 字符可能会具有特殊的权重。 例如，连字符（“-”）的权重非常小，因此“coop”和“co-op”在排序列表中是紧挨着出现的。 有关使用单词排序规则比较两个字符串的 String 方法列表，请参见 String Operations by Category 部分。

• 字符串排序同时执行区分区域性的比较。 它与单词排序相似，唯一区别是字符串排序中不存在特殊情况，所有非字母数字符号均排在所有字母数字 Unicode 字符之前。 可通过调用 CompareInfo.Compare 方法过载（其具有 options 参数，该参数为 CompareOptions.StringSort 的提供值）来使用字符串排序规则比较两个字符串。 请注意，这是 .NET Framework 提供的唯一一个使用字符串排序规则比较两个字符串的方法。

• 序号排序基于字符串中每个 Char 对象的数值对字符串进行比较。 序号比较自动区分大小写，因为字符的小写和大写版本有着不同的码位。 但是，如果大小写并不重要，则可以指定忽略大小写的序号比较。 这相当于使用固定区域性将字符串转换为大写，然后对结果执行序号比较。 有关比较实用序号排序规则的两个字符串的 String 方法列表，请参见 String Operations by Category 部分。

区分区域性的比较是显式或隐式使用 CultureInfo 对象的任何比较，包括由 CultureInfo.InvariantCulture 属性指定的固定区域性。 隐式区域性为当前区域性，它是由 Thread.CurrentCulture 和 CultureInfo.CurrentCulture 属性指定。 区分区域性的比较通常适用于排序，而序号比较则不适合。 序号比较通常适用于确定两个字符串是否相等（即，确定标识），而区分区域性的比较则不适用。

注意
区分区域性的排序和用于字符串比较的大小写规则取决于 .NET Framework 的版本。 在 .NET Framework 4 中，排序、大小写转换、规范化和 Unicode 字符信息是与 Windows 7 同步的，并符合Unicode 5.1 标准。

有关单词、字符串和序号排序规则的更多信息，请参见 System.Globalization.CompareOptions 主题。 有关何时使用每个规则的建议，请参阅 在 .NET Framework 中使用字符串的最佳做法。

通常，您不要直接调用字符串比较方法（比如 Compare）来确定字符串的排序顺序。 相反，比较方法都是通过排序方法调用的，比如 Array.Sort 或 List<T>.Sort。 下面的示例执行四个不同的排序操作（使用当前区域性的单词排序、使用固定区域性的单词排序、序号排序和使用固定区域性的字符串排序），而无需显式调用字符串比较方法。 请注意，每种排序类型都会在其数组内产生唯一的字符串顺序。

C#

VB

复制

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative

警告
如果您比较字符串的主要目的是确定它们是否相等，则应调用 String.Equals 方法。 通常，您应该使用 Equals 执行初始比较。 该 String.Compare 方法主要用于排序字符串。

字符串搜索方法，比如 String.StartsWith 和 String.IndexOf，也可以执行区分区域性的或序号字符串比较。 下面的示例使用 IndexOf 方法演示了序号和区分区域性比较之间的差异。 区分区域性的搜索，其中当前文化为英语（美国），认为子字符串“oe”要匹配连字“œ”。 由于软连字符 (U+00AD)是一个零宽度字符，搜索将该软连字符视为与 Empty 等同且在字符串开头找到匹配。 另一方面,序号的搜索没有在两种情况中找到匹配。

C#

VB

复制

using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();

      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2

相等性测试

使用 String.Compare 方法来确定按排序顺序时两个字符串的关系。 通常，这是区分区域性的操作。 相比之下，调用 String.Equals 方法测试相等性。 因为平等测试通常比较用户输入和一些已知字符串，例如，有效用户名、 密码或文件系统路径，它通常是序号操作。

警告
通过调用 String.Compare 方法来进行平等性测试并确定返回值是否为零是可能的。 但是，不推荐这种做法。 要确定两个字符串是否相等，应该调用 String.Equals 方法的其中一个过载。 要调用的优选过载为实例 Equals 方法或静态 Equals 方法，因为两种方法都包含明确指定比较类型的 System.StringComparison 参数。

当改用一个序号时，下面的示例演示了执行相等区分区域性的比较的危险。 在这种情况下，代码的目的是通过使用字符串“FILE://”对 URL 的开头进行不区分大小写的比较来禁止由“FILE://”或“file://”开始的 URL 访问文件系统。 然而，如果使用“file://”开头的 URL 上的土耳其 (土耳其) 区域性执行区分区域性的比较，则该相等比较失败，这是因为等同于土耳其小写“i”的大写是“İ”，而不是“I”。 其结果是，无意中允许文件系统访问。 另一方面，如果执行序号比较，那么相等性比较会成功，文件系统访问会被拒绝。

C#

VB

复制

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

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";

      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);

      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.

返回备注

某些 Unicode 字符具有多个表示形式。 例如，以下任意码位可以表示字母“ắ”：

• U+1EAF

• U+0103 U+0301

• U+0061 U+0306 U+0301

如果一个字符存在多种表示形式，会使搜索、排序、匹配和其他字符串操作变得复杂。

Unicode 标准定义了一个称作正常化的过程。对于字符的任何二进制等效表示形式，该过程都可以返回一个 Unicode 字符的二进制表示形式。 正常化可以使用几种算法，这些算法称作正常化形式，它们遵守不同的规则。 目前，.NET Framework 支持 Unicode 正常化形式 C、D、KC 和 KD。 如果字符串被正常化为同一范式，则可以使用序号比较对它们进行比较。 有关正则化和正则化窗体的更多信息，请参见 System.Text.NormalizationForm。

可通过调用 String.IsNormalized() 方法确定是否将字符串正常化为范式 C，也可以调用 String.IsNormalized(NormalizationForm) 方法来确定是否将字符串正常化为指定范式。 还可以调用 String.Normalize() 方法将字符串转换为范式 C，或调用 String.Normalize(NormalizationForm) 方法将字符串转换为指定的范式。

下面的示例阐释了字符串正常化。 它在三个不同的字符串中用三种不同的方式定义了字母“ố”，并使用相等性序号比较来确定每个字符串与其他两个字符串是不同的。 然后它将每个字符串转换为支持的范式，并再次执行指定范式中的每个字符串的序号比较。 在每种情况下，第二次相等测试表明字符串是相等的。

using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;

   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }

      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")); 
      return result.Trim();            
   } 

   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

返回备注

String 类提供成员用于比较字符串，测试字符串是否相等，查找字符串中的字符或子字符串，修改字符串，提取字符串的子字符串，组合字符串，格式化值，复制字符串和使字符串规范化。

比较字符串

字符串相等性测试

查找字符串中的字符

修改 字符串

String 类包括以下方法，可用于修改字符串的值：

• Insert 将一个字符串插入到当前的 String 实例中。

• PadLeft 将指定字符的一个或多个匹配项插入到字符串的开始位置。

• PadRight 将指定字符的一个或多个匹配项插入到字符串的开始位置。

• Remove 从当前的 String 实例中删除一个子字符串。

• Replace 在当前的 String 实例中将一个子字符串替换成另一个子字符串。

• ToLower 和 ToLowerInvariant 将字符串中的所有字符转换为小写。

• ToUpper 和 ToUpperInvariant 将字符串中的所有字符转换为大写。

• Trim 从字符串的开始位置和末尾移除所有空白字符。

• TrimEnd 从字符串的末尾移除所有空白字符。

• TrimStart 从字符串的开始位置移除所有空白字符。

重要事项
所有字符串修改方法都返回新的 String 对象。 它们不修改当前实例的值。

从字符串中提取子字符串

组合字符串

格式化值

复制字符串

将字符串正常化