Mam znak „ DetailsViewa” TextBox i chcę, aby dane wejściowe były zapisywane zawsze z PIERWSZYM LITEREM W KAPITALE.

Przykład:

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

Jak mogę osiągnąć maksymalizację wydajności ?

UWAGA :
W oparciu o odpowiedzi i komentarze pod odpowiedziami wiele osób uważa, że ​​chodzi tu o wielkie litery wszystkich słów w ciągu. Np => Red House ona nie jest, ale jeśli to jest to, czego szukać , szukać jednej z odpowiedzi, które używa TextInfo„s ToTitleCasemetod. (UWAGA: Odpowiedzi te są niepoprawne dla faktycznie zadanego pytania.)
Zobacz doktrynę TextInfo.ToTitleCase, aby uzyskać zastrzeżenia (nie dotyka słów wielkimi literami - są uważane za akronimy; mogą zawierać małe litery w środku słów, które „nie powinny” być obniżony, np. „McDonald” => „Mcdonald”; nie ma gwarancji, że poradzi sobie z wszystkimi regułami rekapitalizacji dla określonych subtelności).

UWAGA :
Pytanie jest dwuznaczne, czy litery po pierwszej powinny być zmuszone do małych liter . Przyjęta odpowiedź zakłada, że należy zmienić tylko pierwszą literę . Jeśli chcesz wymusić, aby wszystkie litery w łańcuchu oprócz pierwszej były pisane małymi literami, poszukaj odpowiedzi zawierającej ToLower, a nie zawierającej ToTitleCase .

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

Naprawdę stare odpowiedzi

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

EDYCJA : Ta wersja jest krótsza. Aby uzyskać szybsze rozwiązanie, spójrz na odpowiedź Equiso

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

EDYCJA 2 : Prawdopodobnie najszybszym rozwiązaniem jest rozwiązanie Darrena (istnieje nawet test porównawczy), chociaż zmieniłbym jego string.IsNullOrEmpty(s)walidację, aby zgłosić wyjątek, ponieważ pierwotne wymaganie przewiduje istnienie pierwszej litery, aby można ją było pisać dużymi literami. Zauważ, że ten kod działa na ogólny ciąg, a nie szczególnie na prawidłowe wartości z 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();
}

Stara odpowiedź: powoduje to, że każda pierwsza litera jest pisana wielkimi literami

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

Właściwy sposób to użycie Kultury:

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

Uwaga: Spowoduje to wielkie litery każdego słowa w ciągu, np. „Czerwony dom” -> „czerwony dom”. Rozwiązanie to będzie także używać wielkich liter w słowach, np. „Stary McDonald” -> „stary Mcdonald”.

Wybrałem najszybszą metodę z http://www.dotnetperls.com/uppercase-first-letter i przekonwertowałem na metodę rozszerzenia:

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

UWAGA: Powodem użycia ToCharArrayjest szybszy niż alternatywa char.ToUpper(s[0]) + s.Substring(1), ponieważ przydzielany jest tylko jeden ciąg, podczas gdy Substringpodejście przydziela ciąg dla podłańcucha, a następnie drugi ciąg, aby skomponować wynik końcowy.

EDYCJA : Oto jak to podejście wygląda w połączeniu ze wstępnym testem zaakceptowanym przez 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);
    }

Możesz użyć „metody ToTitleCase”

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

ta metoda rozszerzenia rozwiązuje każdy problem z tytułem.

łatwy w użyciu

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

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

metoda rozszerzenia

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

Dla pierwszej litery ze sprawdzaniem błędów:

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

A oto to samo, co przydatne rozszerzenie

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

Jeśli problemem jest użycie wydajności / pamięci, ten tworzy tylko jeden (1) StringBuilder i jeden (1) nowy Ciąg o tym samym rozmiarze co Ciąg Oryginalny.

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

Najszybsza metoda.

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

Testy pokazują kolejne wyniki (ciąg znaków z wejściowymi symbolami 10000000): Wyniki testu

Spróbuj tego:

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

Jeśli zależy Ci tylko na pisaniu wielkiej litery i nie ma znaczenia reszta ciągu, możesz po prostu wybrać pierwszy znak, ustawić wielkie litery i połączyć go z resztą ciągu bez oryginalnego pierwszego znaku.

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

Musimy przekonwertować pierwszy znak na ToString (), ponieważ odczytujemy go jako tablicę Char, a typ Char nie ma metody ToUpper ().

Oto sposób, aby to zrobić jako metodę rozszerzenia:

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

Można wtedy nazwać:

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

A oto kilka testów jednostkowych:

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

Ponieważ akurat nad tym pracowałem i szukałem pomysłów, oto rozwiązanie, do którego doszedłem. Używa LINQ i będzie w stanie zapisać wielką literę ciągu, nawet jeśli pierwsze wystąpienie nie jest literą. Oto metoda rozszerzenia, którą ostatecznie opracowałem.

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

Jestem pewien, że istnieje sposób, aby to trochę zoptymalizować lub oczyścić.

Znalazłem coś tutaj 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);
}

może to pomaga !!

Sprawdź, czy łańcuch nie jest pusty, a następnie przekonwertuj pierwszy znak na wielkie litery, a resztę na małe:

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

To zrobi, chociaż upewni się również, że nie ma błędnych liter, które nie byłyby na początku słowa.

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

Wydaje się, że jest tutaj dużo złożoności, gdy wszystko, czego potrzebujesz, to:

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

Godne uwagi punkty:

1. Jest to metoda rozszerzenia.

2. Jeśli dane wejściowe są puste, puste lub spacja, dane wejściowe są zwracane w niezmienionej postaci.

3. String.IsNullOrWhiteSpace został wprowadzony w .NET Framework 4. To nie będzie działać ze starszymi frameworkami.

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

Chciałem udzielić odpowiedzi „MAKSYMALNA WYDAJNOŚĆ”. Moim zdaniem odpowiedź „MAKSYMALNA WYDAJNOŚĆ” obejmuje wszystkie scenariusze i zapewnia odpowiedź na pytanie uwzględniające te scenariusze. Oto moja odpowiedź. Z tych powodów:

1. IsNullOrWhiteSpace uwzględnia ciągi znaków, które są tylko spacjami lub pustymi / pustymi.
2. .Trim () usuwa białe znaki z przodu i tyłu łańcucha.
3. .First () przyjmuje pierwszy znak niezliczonej liczby (lub łańcucha).
4. Powinniśmy sprawdzić, czy jest to litera, która może / powinna być pisana wielkimi literami.
5. Następnie dodajemy resztę ciągu, tylko jeśli długość wskazuje, że powinniśmy.
6. Zgodnie z najlepszą praktyką .Net powinniśmy zapewnić kulturę w System.Globalization.CultureInfo.

7. Podanie ich jako parametrów opcjonalnych sprawia, że ​​ta metoda jest w pełni wielokrotnego użytku, bez konieczności wpisywania wybranej kultury za każdym razem.

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

Ostatnio miałem podobne wymaganie i pamiętałem, że funkcja LINQ Select () zapewnia indeks:

string input;
string output;

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

Ponieważ potrzebuję tego bardzo często, stworzyłem metodę rozszerzenia dla typu ciągu:

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

Pamiętaj, że tylko pierwsza litera jest konwertowana na wielkie litery - wszystkie pozostałe znaki nie są dotykane. Jeśli potrzebujesz, aby pozostałe znaki były pisane małymi literami, możesz także wywołać Char.ToLower (currentChar) dla indeksu> 0 lub wywołać ToLower () na całym ciągu.

Jeśli chodzi o wydajność, porównałem kod z rozwiązaniem Darrena. Na mojej maszynie kod Darrena jest około 2 razy szybszy, co nie jest zaskoczeniem, ponieważ bezpośrednio edytuje tylko pierwszą literę w tablicy znaków. Proponuję więc wziąć kod Darrena, jeśli potrzebujesz najszybszego dostępnego rozwiązania. Jeśli chcesz zintegrować również inne manipulacje ciągami znaków, może być wygodne, aby ekspresyjna moc funkcji lambda dotykała znaków ciągu wejściowego - możesz łatwo rozszerzyć tę funkcję - więc zostawiam to rozwiązanie tutaj.

Myślę, że poniższa metoda jest najlepszym rozwiązaniem

    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

ref

Ponieważ pytanie dotyczy maksymalizacji wydajności , zaadaptowałem wersję Darrena do Spans, która redukuje śmieci i poprawia prędkość o około 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);
        }

Wydajność

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

Pełny kod testowy

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

}

Edycja: Wystąpiła literówka, zamiast s [0], było [0] - to skutkuje spłaszczeniem tej samej, pustej wartości do przydzielonego zakresu a.

W ten sposób pierwsza litera i każda litera następująca po spacji i małe litery są pisane wielką literą.

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

Użyj następującego kodu:

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

Wygląda na to, że żadne z podanych tutaj rozwiązań nie zajmie się białą spacją przed ciągiem.

Dodając to jako myśl:

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

Powinien obsłużyć this won't work on other answers(to zdanie ma spację na początku), a jeśli nie podoba ci się przycinanie spacji, po prostu przekaż falsejako drugi parametr (lub zmień wartość domyślną na falsei podaj, truejeśli chcesz zajmować się spacją)

FluentSharp ma lowerCaseFirstLettermetodę, która to robi

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

Najłatwiejszym sposobem na pisanie wielkich liter jest:

1- Korzystanie z Sytem.Globalization;

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

  myTI.ToTitleCase(textboxname.Text)

`

następująca funkcja jest poprawna na wszystkie sposoby:

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

Znalazłem to tutaj

Rozwijając powyższe pytanie Carlosa, jeśli chcesz użyć wielu zdań, możesz użyć tego kodu:

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

Możliwe rozwiązanie problemu.

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