Aku punya DetailsViewdengan TextBox dan saya ingin input data akan disimpan selalu dengan PERTAMA SURAT MODAL.

Contoh:

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

Bagaimana saya bisa mencapai kinerja yang memaksimalkan ini ?

CATATAN :
Berdasarkan jawaban dan komentar di bawah jawaban, banyak orang berpikir ini menanyakan tentang menggunakan huruf besar semua kata dalam string. Misalnya => Red House Hal ini tidak, tetapi jika itu adalah apa yang Anda cari , mencari salah satu jawaban yang menggunakan TextInfo's ToTitleCasemetode. (CATATAN: Jawaban-jawaban itu tidak benar untuk pertanyaan yang sebenarnya diajukan.)
Lihat TextInfo.ToTitleCase doc untuk peringatan (tidak menyentuh kata-kata serba - mereka dianggap akronim; dapat huruf kecil di tengah kata-kata yang "tidak boleh" menjadi diturunkan, mis. "McDonald" => "Mcdonald"; tidak dijamin untuk menangani semua seluk beluk budaya spesifik terkait aturan kapitalisasi.)

CATATAN :
Pertanyaannya adalah ambigu apakah huruf setelah yang pertama harus dipaksa untuk menurunkan kasus . Jawaban yang diterima mengasumsikan bahwa hanya huruf pertama yang harus diubah . Jika Anda ingin memaksa semua huruf dalam string kecuali huruf pertama menjadi huruf kecil, cari jawaban yang berisi ToLower, dan tidak mengandung ToTitleCase .

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

Jawaban yang benar-benar tua

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 : Versi ini lebih pendek. Untuk solusi yang lebih cepat lihat jawaban 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 : Mungkin solusi tercepat adalah Darren (Bahkan ada tolok ukur) walaupun saya akan mengubah string.IsNullOrEmpty(s)validasinya untuk membuang pengecualian karena persyaratan asli mengharapkan huruf pertama ada sehingga dapat ditulis dalam huruf besar. Perhatikan bahwa kode ini berfungsi untuk string generik dan tidak terutama pada nilai yang valid dari 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();
}

Jawaban lama: Ini membuat setiap huruf pertama menjadi huruf besar

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

Cara yang benar adalah dengan menggunakan Budaya:

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

Catatan: Ini akan menggunakan huruf besar untuk setiap kata dalam string, mis. "Rumah merah" -> "Rumah Merah". Solusinya juga akan mengurangi penggunaan huruf besar dalam kata-kata, misalnya "McDonald lama" -> "Mcdonald Lama".

Saya mengambil metode tercepat dari http://www.dotnetperls.com/uppercase-first-letter dan dikonversi ke metode ekstensi:

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

CATATAN: Alasan menggunakan ToCharArraylebih cepat daripada alternatif char.ToUpper(s[0]) + s.Substring(1), adalah bahwa hanya satu string yang dialokasikan, sedangkan Substringpendekatan mengalokasikan string untuk substring, kemudian string kedua untuk menyusun hasil akhir.

EDIT : Berikut ini pendekatannya, dikombinasikan dengan tes awal dari CarlosMuñoz jawaban yang diterima :

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

Anda dapat menggunakan "metode ToTitleCase"

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

metode perluasan ini menyelesaikan setiap masalah titlecase.

mudah digunakan

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

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

metode Extention

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

Untuk huruf pertama, dengan pengecekan error:

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

Dan ini sama dengan ekstensi yang berguna

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

Jika penggunaan kinerja / memori adalah masalah maka, ini hanya membuat satu (1) StringBuilder dan satu (1) String baru dengan ukuran yang sama dengan string Asli.

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

Metode tercepat.

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

Tes menunjukkan hasil selanjutnya (string dengan 10000000 simbol sebagai input): Hasil tes

Coba ini:

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

Jika Anda hanya peduli dengan huruf pertama yang ditulis dengan huruf besar dan tidak masalah dengan sisa string Anda cukup memilih karakter pertama, buat huruf besar dan gabungkan dengan sisa string tanpa karakter pertama yang asli.

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

Kita perlu mengonversi karakter pertama ToString () karena kita membacanya sebagai array Char, dan tipe Char tidak memiliki metode ToUpper ().

Berikut cara untuk melakukannya sebagai metode ekstensi:

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

Kemudian bisa disebut seperti:

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

Dan inilah beberapa unit test untuknya:

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

Karena saya kebetulan sedang mengerjakan ini juga, dan mencari-cari ide, inilah solusi yang saya dapatkan. Ini menggunakan LINQ, dan akan dapat menggunakan huruf besar untuk huruf pertama dari string, bahkan jika kemunculan pertama bukanlah huruf. Inilah metode ekstensi yang akhirnya saya buat.

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

Saya yakin ada cara untuk mengoptimalkan atau membersihkan ini sedikit.

Saya menemukan sesuatu di sini 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);
}

mungkin ini bisa membantu !!

Periksa apakah string bukan nol, lalu konversi karakter pertama ke huruf besar dan sisanya menjadi huruf kecil:

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

Ini akan melakukannya walaupun itu juga akan memastikan bahwa tidak ada modal yang salah yang tidak ada di awal kata.

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

Tampaknya ada banyak kerumitan di sini ketika yang Anda butuhkan adalah:

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

Poin penting:

1. Ini merupakan metode ekstensi.

2. Jika inputnya nol, kosong atau kosong, maka input akan dikembalikan apa adanya.

3. String.IsNullOrWhiteSpace diperkenalkan dengan .NET Framework 4. Ini tidak akan bekerja dengan kerangka kerja yang lebih lama.

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

Saya ingin memberikan jawaban "KINERJA MAKSIMUM". Dalam pikiran saya, jawaban "KINERJA MAKSIMUM" menangkap semua skenario dan memberikan jawaban untuk pertanyaan akuntansi untuk skenario tersebut. Jadi, inilah jawaban saya. Dengan alasan ini:

1. Akun IsNullOrWhiteSpace untuk string yang hanya spasi atau null / kosong.
2. .Trim () menghapus spasi putih dari depan dan belakang string.
3. .First () mengambil karakter pertama dari sebuah ienumerable (atau string).
4. Kita harus memeriksa untuk melihat apakah itu huruf yang dapat / harus ditulis dalam huruf besar.
5. Kami kemudian menambahkan sisa string, hanya jika panjang menunjukkan kita harus.
6. Dengan praktik terbaik .Net, kami harus menyediakan budaya di bawah System.Globalization.CultureInfo.

7. Memberikannya sebagai parameter opsional membuat metode ini benar-benar dapat digunakan kembali, tanpa harus mengetik budaya yang dipilih setiap saat.

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

Baru-baru ini saya memiliki persyaratan yang sama dan ingat bahwa fungsi LINQ Select () memberikan indeks:

string input;
string output;

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

Karena saya sangat membutuhkannya, saya membuat metode ekstensi untuk tipe string:

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

Harap dicatat bahwa hanya huruf pertama yang dikonversi menjadi huruf besar - semua karakter yang tersisa tidak tersentuh. Jika Anda membutuhkan karakter lain menjadi huruf kecil, Anda juga dapat memanggil Char.ToLower (currentChar) untuk indeks> 0 atau panggil ToLower () pada seluruh string di tempat pertama.

Mengenai kinerja saya membandingkan kode dengan solusi dari Darren. Di komputer saya, kode Darren sekitar 2 kali lebih cepat yang tidak mengejutkan karena dia langsung mengedit hanya huruf pertama dalam array char. Jadi saya sarankan Anda mengambil kode Darren jika Anda membutuhkan solusi tercepat yang tersedia. Jika Anda ingin mengintegrasikan manipulasi string lain juga mungkin nyaman untuk memiliki kekuatan ekspresif fungsi lambda menyentuh karakter dari string input - Anda dapat dengan mudah memperluas fungsi ini - jadi saya meninggalkan solusi ini di sini.

Saya pikir metode di bawah ini adalah solusi terbaik

    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

Karena pertanyaan ini adalah tentang memaksimalkan kinerja, saya mengadopsi versi Darren untuk digunakan Span, yang mengurangi sampah dan meningkatkan kecepatan sekitar 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);
        }

Performa

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

Kode uji lengkap

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

}

Sunting: Ada typeo, bukannya s [0], adalah [0] - hasil ini dengan cupying sama, nilai kosong untuk Rentang yang dialokasikan a.

Huruf ini menjadi huruf kapital pertama dan setiap huruf setelah spasi dan huruf kecil huruf lainnya.

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

Gunakan kode berikut:

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

Sepertinya tidak ada solusi yang diberikan di sini akan berurusan dengan ruang putih sebelum string.

Hanya menambahkan ini sebagai pemikiran:

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

Seharusnya menangani this won't work on other answers(kalimat itu memiliki spasi di awal), dan jika Anda tidak suka pemangkasan ruang, cukup berikan falseparameter sebagai kedua (atau ubah ke default false, dan berikan truejika Anda ingin berurusan dengan spasi)

FluentSharp memiliki lowerCaseFirstLettermetode yang melakukan ini

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

Cara termudah untuk Memanfaatkan huruf pertama adalah:

1- Menggunakan Sytem.Globalisasi;

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

  myTI.ToTitleCase(textboxname.Text)

`

fungsi berikut ini benar untuk semua cara:

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

Saya menemukan itu di sini

Memperluas pertanyaan Carlos di atas, jika Anda ingin menggunakan banyak kalimat, Anda dapat menggunakan kode ini:

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

Kemungkinan solusi untuk menyelesaikan masalah Anda.

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