Ответ 1

Обновлено до С# 8

public static class StringExtensions
{
    public static string FirstCharToUpper(this string input) =>
        input switch
        {
            null => throw new ArgumentNullException(nameof(input)),
            "" => throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input)),
            _ => input.First().ToString().ToUpper() + input.Substring(1)
        }
    }
}

С# 7

public static class StringExtensions
{
    public static string FirstCharToUpper(this string input)
    {
        switch (input)
        {
            case null: throw new ArgumentNullException(nameof(input));
            case "": throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input));
            default: return input.First().ToString().ToUpper() + input.Substring(1);
        }
    }
}

Действительно старые ответы

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + String.Join("", input.Skip(1));
}

EDIT: Эта версия короче. Для более быстрого решения взгляните на ответ Equiso

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + input.Substring(1);
}

ОБНОВЛЕНИЕ 2: Вероятно, самым быстрым решением является Даррен (там даже тест), хотя я бы изменил его string.IsNullOrEmpty(s) для проверки исключения, так как исходное требование предполагает существование первой буквы, чтобы ее можно было использовать в верхнем регистре. обратите внимание, что этот код работает для общей строки, а не только для допустимых значений из Textbox.

Ответ 2

public string FirstLetterToUpper(string str)
{
    if (str == null)
        return null;

    if (str.Length > 1)
        return char.ToUpper(str[0]) + str.Substring(1);

    return str.ToUpper();
}

Старый ответ: Это делает каждую первую букву в верхнем регистре

public string ToTitleCase(string str)
{
    return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str.ToLower());
}

Ответ 3

Правильный путь заключается в использовании культуры:

System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(word.ToLower())

Примечание: это будет использовать каждое слово в строке, например, "красный дом" → "красный дом". Решение также будет использовать заглавные буквы в нижнем регистре в словах, например, "старый Макдональд" → "старый Макдональд".

Ответ 4

Я взял самый быстрый метод из http://www.dotnetperls.com/uppercase-first-letter и преобразован в метод расширения:

    /// <summary>
    /// Returns the input string with the first character converted to uppercase, or mutates any nulls passed into string.Empty
    /// </summary>
    public static string FirstLetterToUpperCaseOrConvertNullToEmptyString(this string s)
    {
        if (string.IsNullOrEmpty(s))
            return string.Empty;

        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
    }

ПРИМЕЧАНИЕ. Причина использования ToCharArray выше, чем альтернатива char.ToUpper(s[0]) + s.Substring(1), заключается в том, что выделяется только одна строка, тогда как подход Substring выделяет строку для подстроки, затем вторую строку для составления конечного результата.

EDIT. Вот как выглядит этот подход в сочетании с начальным тестом из CarlosMuñoz принял ответ:

    /// <summary>
    /// Returns the input string with the first character converted to uppercase
    /// </summary>
    public static string FirstLetterToUpperCase(this string s)
    {
        if (string.IsNullOrEmpty(s))
            throw new ArgumentException("There is no first letter");

        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
    }

Ответ 5

Вы можете использовать метод ToTitleCase

string s = new CultureInfo("en-US").TextInfo.ToTitleCase("red house");
//result : Red House

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

простой в использовании

string str = "red house";
str.ToTitleCase();
//result : Red house

string str = "red house";
str.ToTitleCase(TitleCase.All);
//result : Red House

Метод расширения

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace Test
{
    public static class StringHelper
    {
        private static CultureInfo ci = new CultureInfo("en-US");
        //Convert all first latter
        public static string ToTitleCase(this string str)
        {
            str = str.ToLower();
            var strArray = str.Split(' ');
            if (strArray.Length > 1)
            {
                strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
                return string.Join(" ", strArray);
            }
            return ci.TextInfo.ToTitleCase(str);
        }
        public static string ToTitleCase(this string str, TitleCase tcase)
        {
            str = str.ToLower();
            switch (tcase)
            {
                case TitleCase.First:
                    var strArray = str.Split(' ');
                    if (strArray.Length > 1)
                    {
                        strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
                        return string.Join(" ", strArray);
                    }
                    break;
                case TitleCase.All:
                    return ci.TextInfo.ToTitleCase(str);
                default:
                    break;
            }
            return ci.TextInfo.ToTitleCase(str);
        }
    }

    public enum TitleCase
    {
        First,
        All
    }
}

Ответ 6

Для первой буквы с проверкой ошибок:

public string CapitalizeFirstLetter(string s)
{
    if (String.IsNullOrEmpty(s))
        return s;
    if (s.Length == 1)
        return s.ToUpper();
    return s.Remove(1).ToUpper() + s.Substring(1);
}

И здесь то же самое, что и удобное расширение

public static string CapitalizeFirstLetter(this string s)
    {
    if (String.IsNullOrEmpty(s)) return s;
    if (s.Length == 1) return s.ToUpper();
    return s.Remove(1).ToUpper() + s.Substring(1);
    }

Ответ 7

public static string ToInvarianTitleCase(this string self)
{
    if (string.IsNullOrWhiteSpace(self))
    {
        return self;
    }

    return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(self);
}

Ответ 8

Если производительность/использование памяти является проблемой, тогда она создает только одну (1) StringBuilder и одну (1) новую строку того же размера, что и исходная строка.

public static string ToUpperFirst(this string str) {
  if( !string.IsNullOrEmpty( str ) ) {
    StringBuilder sb = new StringBuilder(str);
    sb[0] = char.ToUpper(sb[0]);

    return sb.ToString();

  } else return str;
}

Ответ 9

Попробуйте следующее:

static public string UpperCaseFirstCharacter(this string text) {
    return Regex.Replace(text, "^[a-z]", m => m.Value.ToUpper());
}

Ответ 10

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

String word ="red house";
word = word[0].ToString().ToUpper() + word.Substring(1, word.length -1);
//result: word = "Red house"

Нам нужно преобразовать первый символ ToString(), потому что мы читаем его как массив Char, а тип Char не имеет метода ToUpper().

Ответ 11

Самый быстрый метод.

  private string Capitalize(string s){
        if (string.IsNullOrEmpty(s))
        {
            return string.Empty;
        }
        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
}

Тесты показывают следующие результаты (строка с 10000000 символами в качестве входных данных): Результаты тестирования

Ответ 12

Здесь можно сделать это как метод расширения:

static public string UpperCaseFirstCharacter(this string text)
{
    if (!string.IsNullOrEmpty(text))
    {
        return string.Format(
            "{0}{1}",
            text.Substring(0, 1).ToUpper(),
            text.Substring(1));
    }

    return text;
}

Затем можно вызвать как:

//yields "This is Brian test.":
"this is Brian test.".UpperCaseFirstCharacter(); 

И вот несколько модульных тестов для него:

[Test]
public void UpperCaseFirstCharacter_ZeroLength_ReturnsOriginal()
{
    string orig = "";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual(orig, result);
}

[Test]
public void UpperCaseFirstCharacter_SingleCharacter_ReturnsCapital()
{
    string orig = "c";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("C", result);
}

[Test]
public void UpperCaseFirstCharacter_StandardInput_CapitalizeOnlyFirstLetter()
{
    string orig = "this is Brian test.";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("This is Brian test.", result);
}

Ответ 13

Так как я тоже работал над этим, и искал любые идеи, это решение, к которому я пришел. Он использует LINQ и сможет использовать первую букву строки, даже если первое вхождение не является буквой. Здесь метод расширения, который я закончил.

public static string CaptalizeFirstLetter(this string data)
{
    var chars = data.ToCharArray();

    // Find the Index of the first letter
    var charac = data.First(char.IsLetter);
    var i = data.IndexOf(charac);

    // capitalize that letter
    chars[i] = char.ToUpper(chars[i]);

    return new string(chars);
}

Я уверен, что есть способ немного оптимизировать или очистить его.

Ответ 14

Я нашел что-то здесь http://www.dotnetperls.com/uppercase-first-letter:

static string UppercaseFirst(string s)
{
// Check for empty string.
if (string.IsNullOrEmpty(s))
{
    return string.Empty;
}
// Return char and concat substring.
return char.ToUpper(s[0]) + s.Substring(1);
}

возможно, это помогает!

Ответ 15

Это будет сделано, хотя он также удостоверится, что нет ошибочных капиталов, которые не находятся в начале слова.

public string(string s)
{
System.Globalization.CultureInfo c = new System.Globalization.CultureInfo("en-us", false)
System.Globalization.TextInfo t = c.TextInfo;

return t.ToTitleCase(s);
}

Ответ 16

Здесь, кажется, сложная сложность, когда вам нужно всего лишь:

    /// <summary>
    /// Returns the input string with the first character converted to uppercase if a letter
    /// </summary>
    /// <remarks>Null input returns null</remarks>
    public static string FirstLetterToUpperCase(this string s)
    {
        if (string.IsNullOrWhiteSpace(s))
            return s;

        return char.ToUpper(s[0]) + s.Substring(1);
    }

Заметные моменты:

• Его метод расширения.

• Если вход пустой, пустой или пробельный, вход возвращается как есть.

• String.IsNullOrWhiteSpace. Это не будет работать со старыми фреймворками.

Ответ 17

string emp="TENDULKAR";
string output;
output=emp.First().ToString().ToUpper() + String.Join("", emp.Skip(1)).ToLower();

Ответ 18

Я хотел предоставить ответ "МАКСИМАЛЬНАЯ ПРОИЗВОДИТЕЛЬНОСТЬ". На мой взгляд, ответ "MAXIMUM PERFORMANCE" ловит все сценарии и дает ответ на вопрос, учитывающий эти сценарии. Итак, вот мой ответ. По этим причинам:

• IsNullOrWhiteSpace учитывает строки, которые просто пробелы или null/empty.
• .Trim() удаляет пробелы из передней и задней части строки.
• .First() принимает первый символ ienumerable (или строки).
• Мы должны проверить, является ли это буквой, которая может/должна быть прописной.
• Затем мы добавляем остальную часть строки, только если длина указывает, что мы должны.
• В наилучшей практике .Net мы должны предоставить культуру в System.Globalization.CultureInfo.

• Предоставление им дополнительных параметров делает этот метод полностью повторным, без необходимости набирать выбранную культуру каждый раз.

  public static string capString(string instring, string culture = "en-US", bool useSystem = false)
  {
      string outstring;
      if (String.IsNullOrWhiteSpace(instring))
      {
          return "";
      }
      instring = instring.Trim();
      char thisletter = instring.First();
      if (!char.IsLetter(thisletter))
      {
          return instring;   
      }
      outstring = thisletter.ToString().ToUpper(new CultureInfo(culture, useSystem));
      if (instring.Length > 1)
      {
          outstring += instring.Substring(1);
      }
      return outstring;
  }
  

Ответ 19

Я думаю, что приведенный ниже метод является лучшим решением

    class Program
{
    static string UppercaseWords(string value)
    {
        char[] array = value.ToCharArray();
        // Handle the first letter in the string.
        if (array.Length >= 1)
        {
            if (char.IsLower(array[0]))
            {
                array[0] = char.ToUpper(array[0]);
            }
        }
        // Scan through the letters, checking for spaces.
        // ... Uppercase the lowercase letters following spaces.
        for (int i = 1; i < array.Length; i++)
        {
            if (array[i - 1] == ' ')
            {
                if (char.IsLower(array[i]))
                {
                    array[i] = char.ToUpper(array[i]);
                }
            }
        }
        return new string(array);
    }

    static void Main()
    {
        // Uppercase words in these strings.
        const string value1 = "something in the way";
        const string value2 = "dot net PERLS";
        const string value3 = "String_two;three";
        const string value4 = " sam";
        // ... Compute the uppercase strings.
        Console.WriteLine(UppercaseWords(value1));
        Console.WriteLine(UppercaseWords(value2));
        Console.WriteLine(UppercaseWords(value3));
        Console.WriteLine(UppercaseWords(value4));
    }
}

Output

Something In The Way
Dot Net PERLS
String_two;three
 Sam

ссылка

Ответ 20

Это заглавные буквы этой буквы и каждой буквы, следующих за пробелом и строчными буквами, любую другую букву.

public string CapitalizeFirstLetterAfterSpace(string input)
{
    System.Text.StringBuilder sb = new System.Text.StringBuilder(input);
    bool capitalizeNextLetter = true;
    for(int pos = 0; pos < sb.Length; pos++)
    {
        if(capitalizeNextLetter)
        {
            sb[pos]=System.Char.ToUpper(sb[pos]);
            capitalizeNextLetter = false;
        }
        else
        {
            sb[pos]=System.Char.ToLower(sb[pos]);
        }

        if(sb[pos]=' ')
        {
            capitalizeNextLetter=true;
        }
    }
}

Ответ 21

Используйте следующий код:

string  strtest ="PRASHANT";
strtest.First().ToString().ToUpper() + strtest.Remove(0, 1).ToLower();

Ответ 22

Похоже, что ни одно из приведенных здесь решений не будет иметь дело с пробелом перед строкой.

Просто добавив это как мысль:

public static string SetFirstCharUpper2(string aValue, bool aIgonreLeadingSpaces = true)
{
    if (string.IsNullOrWhiteSpace(aValue))
        return aValue;

    string trimmed = aIgonreLeadingSpaces 
           ? aValue.TrimStart() 
           : aValue;

    return char.ToUpper(trimmed[0]) + trimmed.Substring(1);
}   

Он должен обрабатывать this won't work on other answers (это предложение имеет место в начале), и если вам не нравится обрезка пространства, просто передайте false в качестве второго параметра (или измените значение по умолчанию на false, и пройдите true, если вы хотите иметь дело с пространством)

Ответ 23

FluentSharp имеет метод lowerCaseFirstLetter, который делает это

https://github.com/o2platform/FluentSharp/blob/700dc35759db8e2164771a71f73a801aa9379074/FluentSharp.CoreLib/ExtensionMethods/System/String_ExtensionMethods.cs#L575

Ответ 24

Это самый быстрый способ:

public static unsafe void ToUpperFirst(this string str)
{
    if (str == null) return;
    fixed (char* ptr = str) 
        *ptr = char.ToUpper(*ptr);
}

Без изменения исходной строки:

public static unsafe string ToUpperFirst(this string str)
{
    if (str == null) return null;
    string ret = string.Copy(str);
    fixed (char* ptr = ret) 
        *ptr = char.ToUpper(*ptr);
    return ret;
}

Ответ 25

Самый простой способ заглавной буквы firs:

1- Использование Sytem.Globalization;

  // Creates a TextInfo based on the "en-US" culture.
  TextInfo myTI = new CultureInfo("en-US",false).

  myTI.ToTitleCase(textboxname.Text)

`

Ответ 26

следующая функция верна для всех способов:

static string UppercaseWords(string value)
{
    char[] array = value.ToCharArray();
    // Handle the first letter in the string.
    if (array.Length >= 1)
    {
        if (char.IsLower(array[0]))
        {
            array[0] = char.ToUpper(array[0]);
        }
    }
    // Scan through the letters, checking for spaces.
    // ... Uppercase the lowercase letters following spaces.
    for (int i = 1; i < array.Length; i++)
    {
        if (array[i - 1] == ' ')
        {
            if (char.IsLower(array[i]))
            {
                array[i] = char.ToUpper(array[i]);
            }
        }
    }
    return new string(array);
}

Я обнаружил, что здесь

Ответ 27

Развернув вопрос Карлоса выше, если вы хотите использовать несколько предложений, вы можете использовать этот код:

    /// <summary>
    /// Capitalize first letter of every sentence. 
    /// </summary>
    /// <param name="inputSting"></param>
    /// <returns></returns>
    public string CapitalizeSentences (string inputSting)
    {
        string result = string.Empty;
        if (!string.IsNullOrEmpty(inputSting))
        {
            string[] sentences = inputSting.Split('.');

            foreach (string sentence in sentences)
            {
                result += string.Format ("{0}{1}.", sentence.First().ToString().ToUpper(), sentence.Substring(1)); 
            }
        }

        return result; 
    }

Ответ 28

Недавно у меня было похожее требование, и я вспомнил, что функция LINQ Select() предоставляет индекс:

string input;
string output;

input = "red house";
output = String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
//output = "Red house"

Поскольку мне это нужно очень часто, я сделал метод расширения для строкового типа:

public static class StringExtensions
{
    public static string FirstLetterToUpper(this string input)
    {
        if (string.IsNullOrEmpty(input))
            return string.Empty;
        return String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
    }
}

Обратите внимание, что только первая буква преобразуется в верхний регистр - все остальные символы не затрагиваются. Если вам нужны другие символы в нижнем регистре, вы также можете вызвать Char.ToLower(currentChar) для index> 0 или вызвать ToLower() для всей строки в первую очередь.

Что касается производительности, я сравнил код с решением от Darren. На моей машине код Даррена примерно в 2 раза быстрее, что неудивительно, поскольку он напрямую редактирует только первую букву в массиве символов. Поэтому я предлагаю вам взять код Даррена, если вам нужно самое быстрое из доступных решений. Если вы хотите интегрировать и другие манипуляции со строками, может быть удобно, чтобы выразительная сила лямбда-функции касалась символов входной строки - вы можете легко расширить эту функцию - поэтому я оставлю это решение здесь.

Ответ 29

Проверьте, не является ли строка нулевой, затем преобразуйте первый символ в верхний регистр, а остальные - в нижний регистр:

public static string FirstCharToUpper(string str)
{
    return str?.First().ToString().ToUpper() + str?.Substring(1).ToLower();
}

Ответ 30

С помощью этого метода вы можете выдержать первый char каждого слова.

Пример "HeLlo wOrld" = > "Hello World"

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("Error");
    return string.Join(" ", input.Split(' ').Select(d => d.First().ToString().ToUpper() +  d.ToLower().Substring(1)));
}