Форматирование предложений в строке с помощью C#

На мой взгляд, когда дело доходит до потенциально сложного сопоставления и замены строк на основе правил, вы не сможете добиться большего успеха, чем решение на основе регулярных выражений (несмотря на то, что их так трудно читать!). На мой взгляд, это обеспечивает наилучшую производительность и эффективность использования памяти — вы будете удивлены, насколько быстро это будет.

Я бы использовал перегрузку Regex.Replace, которая принимает входную строку, шаблон регулярного выражения и делегат MatchEvaluator. MatchEvaluator — это функция, которая принимает объект Match в качестве входных данных и возвращает замену строки.

Вот код:

public static string Capitalise(string input)
{
  //now the first character
  return Regex.Replace(input, @"(?<=(^|[.;:])\s*)[a-z]",
    (match) => { return match.Value.ToUpper(); });
}

Регулярное выражение использует конструкцию (?‹=) (положительный просмотр назад с нулевой шириной), чтобы ограничить захват только символами az, которым предшествует начало строки, или нужными вам знаками препинания. В бит [.;:] вы можете добавить дополнительные, которые хотите (например, [.;:?."], чтобы добавить символы ? и ".

Это также означает, что вашему MatchEvaluator не нужно выполнять ненужное соединение строк (которого вы хотите избежать из соображений производительности).

Все остальное, упомянутое одним из других респондентов об использовании RegexOptions.Compiled, также актуально с точки зрения производительности. Однако статический метод Regex.Replace предлагает очень похожие преимущества в производительности (есть только дополнительный поиск по словарю).

Как я уже сказал, я буду удивлен, если какое-либо из других решений, не использующих регулярные выражения, будет работать лучше и будет таким же быстрым.

ИЗМЕНИТЬ

Сопоставили это решение с решением Ахмада, поскольку он совершенно справедливо указал, что осмотр может быть менее эффективным, чем делать это по-своему.

Вот грубый тест, который я сделал:

public string LowerCaseLipsum
{
  get
  {
    //went to lipsum.com and generated 10 paragraphs of lipsum
    //which I then initialised into the backing field with @"[lipsumtext]".ToLower()
    return _lowerCaseLipsum;
  }
 }
 [TestMethod]
 public void CapitaliseAhmadsWay()
 {
   List<string> results = new List<string>();
   DateTime start = DateTime.Now;
   Regex r = new Regex(@"(^|\p{P}\s+)(\w+)", RegexOptions.Compiled);
   for (int f = 0; f < 1000; f++)
   {
     results.Add(r.Replace(LowerCaseLipsum, m => m.Groups[1].Value
                      + m.Groups[2].Value.Substring(0, 1).ToUpper()
                           + m.Groups[2].Value.Substring(1)));
   }
   TimeSpan duration = DateTime.Now - start;
   Console.WriteLine("Operation took {0} seconds", duration.TotalSeconds);
 }

 [TestMethod]
 public void CapitaliseLookAroundWay()
 {
   List<string> results = new List<string>();
   DateTime start = DateTime.Now;
   Regex r = new Regex(@"(?<=(^|[.;:])\s*)[a-z]", RegexOptions.Compiled);
   for (int f = 0; f < 1000; f++)
   {
     results.Add(r.Replace(LowerCaseLipsum, m => m.Value.ToUpper()));
   }
   TimeSpan duration = DateTime.Now - start;
   Console.WriteLine("Operation took {0} seconds", duration.TotalSeconds);
 }

В релизной сборке мое решение было примерно на 12% быстрее, чем у Ахмада (1,48 секунды против 1,68 секунды).

Интересно, однако, что если это было сделано с помощью статического метода Regex.Replace, оба они были примерно на 80% медленнее, и мое решение было медленнее, чем у Ахмада.

Вот решение регулярного выражения, которое использует категорию пунктуации, чтобы избежать необходимости указывать .!?" и т. д., хотя вы обязательно должны проверить, соответствует ли оно вашим потребностям или установить их явно. Прочтите категорию «P» в разделе «Поддерживаемые общие категории Unicode». ", расположенный на странице классов символов MSDN.

string input = @"this is some code. the code is in C#? it's great! In ""quotes."" after quotes.";
string pattern = @"(^|\p{P}\s+)(\w+)";

// compiled for performance (might want to benchmark it for your loop)
Regex rx = new Regex(pattern, RegexOptions.Compiled);

string result = rx.Replace(input, m => m.Groups[1].Value
                                + m.Groups[2].Value.Substring(0, 1).ToUpper()
                                + m.Groups[2].Value.Substring(1));

Если вы решите не использовать класс \p{P}, вам придется указать символы самостоятельно, например:

string pattern = @"(^|[.?!""]\s+)(\w+)";

EDIT: ниже приведен обновленный пример, демонстрирующий 3 шаблона. Первый показывает, как все знаки препинания влияют на регистр. Во втором показано, как выбирать определенные категории пунктуации с помощью вычитания классов. Он использует все знаки препинания, удаляя определенные группы пунктуации. Третий похож на второй, но использует другие группы.

В ссылке MSDN не указано, к чему относятся некоторые категории пунктуации, поэтому вот разбивка:

• P: все знаки препинания (включает все перечисленные ниже категории)
• ПК: подчеркивание _
• Pd: тире -
• Ps: открывающая скобка, скобки и фигурные скобки ( [ {
• Pe: закрывающие круглые скобки, скобки и фигурные скобки ) ] }
• Pi: начальные одинарные/двойные кавычки (MSDN говорит, что это "может вести себя как Ps/Pe в зависимости от использования")
• Pf: конечные одинарные/двойные кавычки (применяется примечание MSDN Pi)
• Po: другие знаки препинания, такие как запятые, двоеточия, точки с запятой и косые черты ,, :, ;, \, /

Внимательно сравните, как эти группы влияют на результаты. Это должно дать вам большую степень гибкости. Если это кажется нежелательным, вы можете использовать определенные символы в классе символов, как показано ранее.

string input = @"foo ( parens ) bar { braces } foo [ brackets ] bar. single ' quote & "" double "" quote.
dash - test. Connector _ test. Comma, test. Semicolon; test. Colon: test. Slash / test. Slash \ test.";

string[] patterns = { 
    @"(^|\p{P}\s+)(\w+)", // all punctuation chars
    @"(^|[\p{P}-[\p{Pc}\p{Pd}\p{Ps}\p{Pe}]]\s+)(\w+)", // all punctuation chars except Pc/Pd/Ps/Pe
    @"(^|[\p{P}-[\p{Po}]]\s+)(\w+)" // all punctuation chars except Po
};

// compiled for performance (might want to benchmark it for your loop)
foreach (string pattern in patterns)
{
    Console.WriteLine("*** Current pattern: {0}", pattern);
    string result = Regex.Replace(input, pattern,
                            m => m.Groups[1].Value
                                 + m.Groups[2].Value.Substring(0, 1).ToUpper()
                                 + m.Groups[2].Value.Substring(1));
    Console.WriteLine(result);
    Console.WriteLine();
}

Обратите внимание, что «Dash» не пишется с заглавной буквы в последнем шаблоне и находится на новой строке. Один из способов сделать его заглавным — использовать опцию RegexOptions.Multiline. Попробуйте приведенный выше фрагмент с этим, чтобы увидеть, соответствует ли он желаемому результату.

Кроме того, для примера я не использовал RegexOptions.Compiled в приведенном выше цикле. Чтобы использовать обе опции ИЛИ их вместе: RegexOptions.Compiled | RegexOptions.Multiline.

У вас есть несколько вариантов:

1. Ваш подход к разделению строки, использованию заглавных букв и повторному объединению
2. Использование регулярных выражений для замены выражений (что может быть немного сложно для случая)
3. Напишите итератор C#, который перебирает каждый символ и возвращает новый IEnumerable<char> с первой буквой после точки в верхнем регистре. Может предложить преимущество потокового решения.
4. Перебирайте каждый символ и вводите в верхний регистр те, которые появляются сразу после точки (пробелы игнорируются) — StringBuffer может упростить эту задачу.

В приведенном ниже коде используется итератор:

public static string ToSentenceCase( string someString )
{
  var sb = new StringBuilder( someString.Length );
  bool wasPeriodLastSeen = true; // We want first letter to be capitalized
  foreach( var c in someString )
  {
      if( wasPeriodLastSeen && !c.IsWhiteSpace ) 
      {
          sb.Append( c.ToUpper() );
          wasPeriodLastSeen = false;         
      }        
      else
      {
          if( c == '.' )  // you may want to expand this to other punctuation
              wasPeriodLastSeen = true;
          sb.Append( c );
      }
  }

  return sb.ToString();
}

Не знаю почему, но я решил попробовать доходность, основываясь на том, что предложил Л. Бушкин. Просто для удовольствия.

static IEnumerable<char> CapitalLetters(string sentence)
        {
            //capitalize first letter
            bool capitalize = true;
            char lastLetter;
            for (int i = 0; i < sentence.Length; i++)
            {
                lastLetter = sentence[i];
                yield return (capitalize) ? Char.ToUpper(sentence[i]) : sentence[i];


                if (Char.IsWhiteSpace(lastLetter) && capitalize == true)
                    continue;

                capitalize = false;
                if (lastLetter == '.' || lastLetter == '!') //etc
                    capitalize = true;
            }
        }

Чтобы использовать его:

string sentence = new String(CapitalLetters("this is some code. the code is in C#.").ToArray());

1. Делайте свою работу в StringBuffer.
2. В нижнем регистре все это.
3. Цикл и прописные начальные символы.
4. Вызов ToString.