У мене є DetailsViewз TextBox і я хочу, щоб вхідні дані будуть збережені завжди з першою літерою КАПІТАЛУ.

Приклад:

"red" --> "Red"
"red house" --> " Red house"

Як я можу досягти цієї максимальної продуктивності ?

ПРИМІТКА .
На підставі відповідей та коментарів під відповідями багато людей думають, що це запитує про використання великих літер у всіх рядках. Наприклад , => Red House це не так , але якщо це те , що ви шукаєте , подивіться на один з відповідей , які використовує TextInfo«и ToTitleCaseметод. (ПРИМІТКА. Ці відповіді є невірними для фактично заданого питання.)
Дивіться документ TextInfo.ToTitleCase для застережень (не торкається слів з великими буквами - вони вважаються абревіатурами; вони можуть мати малі літери посеред слів, які "не повинні" бути знижений, наприклад, "McDonald" => "Макдональд"; не гарантовано обробляти всі специфічні для культури тонкощі щодо капіталізації.)

ПРИМІТКА :
Питання в тому , неоднозначне , чи є листи після того , як перший повинні бути змушені до нижнього регістру . Прийнята відповідь передбачає, що лише перша літера повинна бути змінена . Якщо ви хочете змусити всі літери в рядку, окрім першого, малі, шукайте відповідь, що містить ToLowerі не містить ToTitleCase .

Оновлено до № 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)
        };
}

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

EDIT 2 : Напевно, найшвидше рішення - це Даррен (Є навіть орієнтир), хоча я міняв би свою string.IsNullOrEmpty(s)перевірку, щоб кинути виняток, оскільки початкова вимога очікує існування першого листа, щоб воно могло бути рейтинговим. Зауважте, що цей код працює для загального рядка, а не особливо для дійсних значень з Textbox.

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

Правильний спосіб - це використовувати культуру:

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

Примітка. Це використовує великі літери у кожному рядку, наприклад, "червоний будинок" -> "Червоний дім". Рішення також буде писати великі літери у словах, наприклад, "старий Макдональд" -> "Старий Макдональд".

Я взяв найшвидший метод від 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);
    }

Ви можете використовувати "метод 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
    }
}

Перший лист із перевіркою помилок:

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

Найшвидший метод.

  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 символів як вхід): Результати тесту

Спробуйте це:

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

Якщо ви дбаєте лише про те, щоб перша літера була написана з великої літери, і це не має значення для решти рядка, ви можете просто вибрати перший символ, зробити його великим регістром і з'єднати його з рештою рядка без оригінального першого символу.

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

Нам потрібно перетворити ToString () першого символу (), оскільки ми читаємо його як масив Char, а тип Char не має методу 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);
}

можливо, це допомагає !!

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

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

Це зробить це, хоча він також переконається, що немає жодної великої літери, яка не знаходиться на початку слова.

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. Якщо введення недійсне, порожнє або пробіл, введення повертається таким, як є.

3. String.IsNullOrWhiteSpace був представлений з .NET Framework 4. Це не працюватиме зі старими рамками.

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

Я хотів надати відповідь "МАКСИМАЛЬНА РОБОТА". На мій погляд, відповідь "МАКСИМАЛЬНА ВИКОНАННЯ" охоплює всі сценарії та дає відповідь на питання обліку цих сценаріїв. Отже, ось моя відповідь. З цих причин:

1. IsNullOrWhiteSpace облікових записів для рядків, які є просто пробілами або null / empty.
2. .Trim () видаляє пробіли з передньої та задньої частини рядка.
3. .Перший () приймає перший символ незліченного (або рядка).
4. Ми повинні перевірити, чи є це літерою, яка може / має бути великою літерою.
5. Потім додаємо решту рядка, лише якщо довжина вказує, що ми повинні.
6. За найкращою практикою .Net, ми повинні забезпечити культуру в рамках System.Globalization.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;
   }

Нещодавно у мене виникла подібна вимога і згадав, що функція 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 () у всій рядку в першу чергу.

Щодо продуктивності, я порівняв код із рішенням від Даррена. На моїй машині код Даррена приблизно в 2 рази швидший, що не дивно, оскільки він безпосередньо редагує лише першу букву в масиві char. Тому я пропоную вам взяти код Даррена, якщо вам потрібно найшвидше доступне рішення. Якщо ви хочете також інтегрувати інші рядкові маніпуляції, може бути зручно мати виразну силу функції лямбда, що торкається символів вхідного рядка - ви можете легко розширити цю функцію - тому я залишаю це рішення тут.

Я думаю, що наведений нижче метод - найкраще рішення

    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

реф

Оскільки це питання стосується досягнення максимальної продуктивності, я прийняв версію Даррена для використання Spans, яка зменшує сміття та покращує швидкість приблизно на 10%.

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

            Span<char> a = stackalloc char[s.Length];
            s.AsSpan(1).CopyTo(a.Slice(1));
            a[0] = char.ToUpper(s[0]);
            return new string(a);
        }

Продуктивність

|  Method |      Data |      Mean |     Error |    StdDev |
|-------- |---------- |----------:|----------:|----------:|
|  Carlos |       red | 107.29 ns | 2.2401 ns | 3.9234 ns |
|  Darren |       red |  30.93 ns | 0.9228 ns | 0.8632 ns |
| Marcell |       red |  26.99 ns | 0.3902 ns | 0.3459 ns |
|  Carlos | red house | 106.78 ns | 1.9713 ns | 1.8439 ns |
|  Darren | red house |  32.49 ns | 0.4253 ns | 0.3978 ns |
| Marcell | red house |  27.37 ns | 0.3888 ns | 0.3637 ns |

Повний код тесту

using System;
using System.Linq;

using BenchmarkDotNet.Attributes;

namespace CorePerformanceTest
{
    public class StringUpperTest
    {
        [Params("red", "red house")]
        public string Data;

        [Benchmark]
        public string Carlos() => Data.Carlos();

        [Benchmark]
        public string Darren() => Data.Darren();

        [Benchmark]
        public string Marcell() => Data.Marcell();
    }

    internal static class StringExtensions
    {
        public static string Carlos(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)
            };

        public static string Darren(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 static string Marcell(this string s)
        {
            if (string.IsNullOrEmpty(s))
                throw new ArgumentException("There is no first letter");

            Span<char> a = stackalloc char[s.Length];
            s.AsSpan(1).CopyTo(a.Slice(1));
            a[0] = char.ToUpper(s[0]);
            return new string(a);
        }
    }

}

Редагувати: замість s [0] був тип, а [0] - це призводить до зміни того ж, порожнього значення для виділеного Span a.

Це пише великі літери у цій першій букві та кожній букві, що йде пробілом, а будь-який інший лист пише малі літери.

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

Найпростіший спосіб написання великої літери:

1- Використання Sytem.Globalization;

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

Можливе рішення для вирішення вашої проблеми.

   public static string FirstToUpper(this string lowerWord)
   {
       if (string.IsNullOrWhiteSpace(lowerWord) || string.IsNullOrEmpty(lowerWord))
            return lowerWord;
       return new StringBuilder(lowerWord.Substring(0, 1).ToUpper())
                 .Append(lowerWord.Substring(1))
                 .ToString();
   }