Сделать первую букву строки прописной (с максимальной производительностью)

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());
}

правильный способ - использовать культуру:

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

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

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

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

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

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

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
    }
}

я взял самый быстрый метод из 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: вот как выглядит этот подход, в сочетании с начальным тестом от Карлосмуньос принял ответ:

    /// <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);
    }

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

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);
    }

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

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

если производительность / использование памяти является проблемой, то это создает только один (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;
}

попробуйте это:

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

вот способ сделать это как метод расширения:

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's test.":
"this is Brian's 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's test.";
    string result = orig.UpperCaseFirstCharacter();

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

Так как я тоже работал над этим и искал какие-либо идеи, это решение, к которому я пришел. Он использует 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);
}

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

Я нашел кое-что здесь 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);
}

может быть, это помогает!!

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

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

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

это сделает это, хотя он также будет убедиться, что нет странствующих столиц, которые не находятся в начале слова.

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);
}

здесь, кажется, много сложностей, когда все, что вам нужно, это:

    /// <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);
    }

отметить пункты:

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

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

3. строку.IsNullOrWhiteSpace был представлен с .NET Framework 4. Это не будет работать со старыми фреймворками.

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

  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 символов в качестве входных данных): результаты теста

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

Я хотел дать ответ "максимальная производительность". На мой взгляд, ответ "максимальная производительность" улавливает все сценарии и дает ответ на вопрос, учитывающий эти сценарии. Итак, вот мой ответ. По этим причинам:

1. isnullorwhitespace учитывает строки, которые являются просто пробелами или пустыми/пустыми.
2. .Trim () удаляет пробелы из передней и задней части строки.
3. .Во-первых() принимает в качестве первого символа ienumerable (или строка).
4. мы должны проверить, если это буква, которая может / должна быть в верхнем регистре.
5. затем мы добавляем остальную часть строки, только если длина указывает, что мы должны.
6. по лучшей практике .Net, мы должны обеспечить культуру под системой.Глобализация.CultureInfo.

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

   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;
   }
   

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

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;
        }
    }
}

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

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

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

просто добавляя это как мысль:

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 если вы хотите иметь дело с пространством)

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

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

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

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;
}

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

1-Использование Системы.Глобализация;

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

  myTI.ToTitleCase(textboxname.Text)

'

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

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);
}

Я нашел это здесь

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

    /// <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; 
    }

недавно у меня было аналогичное требование и я вспомнил, что функция 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) для индекса > 0 или вызовите ToLower () в целом строка в первую очередь.

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

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

пример "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)));
}

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

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

Как Боббичей предлагает в его ответ на этот вопрос, следующий код будет работать для этого:

private void txt_fname_TextChanged(object sender, EventArgs e)
{
    char[] c = txt_fname.Text.ToCharArray();
    int j;
    for (j = 0; j < txt_fname.Text.Length; j++)
    {
        if (j==0) c[j]=c[j].ToString().ToUpper()[0];
        else c[j] = c[j].ToString().ToLower()[0];
    }
    txt_fname.Text = new string(c); 
    txt_fname.Select(txt_fname.Text.Length, 1);
}