Bir var DetailsViewbir ile TextBox ve istediğim giriş veri edilmesi her zaman kaydedilir İLK MEKTUP SERMAYE ile.

Misal:

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

Bu maksimum performansa nasıl ulaşabilirim ?

NOT :
Cevaplara ve cevapların altındaki yorumlara dayanarak, birçok kişi bunun dizedeki tüm kelimeleri büyük harfle yazmayı istediğini düşünmektedir . Örneğin => Red House O değil, ama bu ne arıyorsun ise , cevapların that use biri için göz TextInfo'in ToTitleCaseyöntemi. (NOT: Bu yanıtlar, gerçekten sorulan soru için yanlıştır .) Uyarılar için TextInfo.ToTitleCase belgesine
bakın (tüm harflere sahip kelimelere dokunmazlar - kısaltma olarak kabul edilirler; "olmaması gereken" kelimelerin ortasındaki harfleri küçük harflerle yazabilirler indirgenmiş, örneğin "McDonald" => "Mcdonald"; büyük harf kullanım kurallarıyla ilgili tüm kültüre özgü incelikleri ele alacağı garanti edilmez.)

NOT :
sorudur belirsiz ilk sonra harfler gerekip gerekmediğini konusunda zorladı için harfe . Kabul edilen cevap sadece ilk harfin değiştirilmesi gerektiğini varsayar . Dizedeki ilk harflerin küçük harf olması için zorlamak istiyorsanız ToLower, ToTitleCase içeren ve içermeyen bir yanıt arayın .

C # 8 olarak güncellendi

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

Gerçekten eski cevaplar

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 : Bu sürüm daha kısadır. Daha hızlı bir çözüm için Equiso'nun cevabına bir göz atın

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

DÜZENLEME 2 : Muhtemelen en hızlı çözüm Darren'tır (Bir kıyaslama bile var), ancak string.IsNullOrEmpty(s)orijinal gereksinimin ilk harfin var olmasını beklediği için bir istisna atma doğrulamasını değiştireceğim . Bu kodun genel bir dize için çalıştığını ve özellikle 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();
}

Eski cevap: Bu her ilk harfi büyük harfe çevirir

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

Doğru yol Kültürü kullanmaktır:

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

Not: Bu, bir dizgideki her kelimeyi büyük harf olarak kullanır, örneğin "kırmızı ev" -> "Kırmızı Ev". Çözüm aynı zamanda kelimelerdeki büyük / küçük harfleri de azaltır, örneğin "eski McDonald" -> "Eski Mcdonald".

En hızlı yöntemi http://www.dotnetperls.com/uppercase-first-letter adresinden aldım ve uzantı yöntemine dönüştürdüm:

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

Not: ToCharArraykullanım alternatifinden daha hızlı char.ToUpper(s[0]) + s.Substring(1), yalnızca bir dize tahsis edilirken, Substringyaklaşım alt dize için bir dize, sonra nihai sonucu oluşturmak için ikinci bir dize ayırır olmasıdır.

EDIT : İşte bu yaklaşım CarlosMuñoz kabul cevap ilk test ile birlikte nasıl görünüyor :

    /// <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 yöntemini" kullanabilirsiniz

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

bu genişletme yöntemi her titlecase problemini çözer.

kullanımı kolay

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

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

Genişletme yöntemi

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

İlk harf için hata denetimi ile:

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

İşte kullanışlı bir uzantı ile aynı

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

Performans / bellek kullanımı bir sorunsa, bu yalnızca Orijinal dize ile aynı boyutta bir (1) StringBuilder ve bir (1) yeni Dize oluşturur.

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

En hızlı yöntem.

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

Testler sonraki sonuçları gösterir (giriş olarak 10000000 sembollü dize): Test sonuçları

Bunu dene:

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

Yalnızca ilk harfi büyük yazmayı önemsiyorsanız ve dizenin geri kalanı önemli değilse, sadece ilk karakteri seçebilir, büyük harf yapabilir ve orijinal ilk karakteri olmadan dizenin geri kalanıyla birleştirebilirsiniz.

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

İlk karakteri ToString () dönüştürmeliyiz çünkü bir Char dizisi olarak okuyoruz ve Char tipinde ToUpper () yöntemi yok.

İşte bunu bir uzantı yöntemi olarak yapmanın bir yolu:

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

Daha sonra şöyle çağrılabilir:

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

Ve işte bunun için bazı birim testleri:

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

Bu konuda da çalıştığımdan ve herhangi bir fikir aradığından, bu geldiğim çözüm. LINQ kullanır ve ilk oluşum bir harf olmasa bile, bir dizenin ilk harfini büyük yazabilir. İşte yaptığım uzantı yöntemi.

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

Eminim bunu biraz optimize etmenin veya temizlemenin bir yolu var.

Burada bir şey buldum 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);
}

belki bu yardımcı olur !!

Dizenin boş olup olmadığını kontrol edin, ardından ilk karakteri büyük harfe ve geri kalanını küçük harfe dönüştürün:

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

Bu, kelimenin başında olmayan hatalı başkentlerin olmadığından emin olmasına rağmen bunu yapacaktır.

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

İhtiyacınız olan tek şey burada çok fazla karmaşıklık var gibi görünüyor:

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

Dikkate değer noktalar:

1. Bu bir uzatma yöntemidir.

2. Giriş null, boş veya beyazsa giriş olduğu gibi döndürülür.

3. String.IsNullOrWhiteSpace , .NET Framework 4 ile tanıtıldı. Bu, eski çerçevelerle çalışmaz.

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

"MAKSİMUM PERFORMANS" cevabını vermek istedim. Zihnimde, bir "MAKSİMUM PERFORMANS" yanıtı tüm senaryoları yakalar ve bu senaryolar için soru muhasebesine cevap verir. İşte cevabım. Bu nedenlerle:

1. IsNullOrWhiteSpace yalnızca boşluk veya boş / boş olan dizeleri açıklar.
2. .Trim (), boşlukları dizenin önünden ve arkasından kaldırır.
3. .First (), bir numaralandırılabilir (veya dize) ilk karakterini alır.
4. Büyük harf olabilecek / olması gereken bir harf olup olmadığını kontrol etmeliyiz.
5. Daha sonra dizenin geri kalanını ekleriz, ancak uzunluk yapmamız gerektiğini gösterirse.
6. Net en iyi uygulama ile, System.Globalization.CultureInfo altında bir kültür sağlamalıyız.

7. İsteğe bağlı parametreler olarak sağlanması, bu yöntemi seçilen kültürü her seferinde yazmak zorunda kalmadan tamamen yeniden kullanılabilir hale getirir.

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

Son zamanlarda benzer bir gereksinim vardı ve LINQ işlevi Select () bir dizin sağlar hatırladı:

string input;
string output;

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

Çok sık ihtiyaç duyduğumdan dize türü için bir uzantı yöntemi yaptım:

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

Lütfen yalnızca ilk harfe büyük harfe dönüştürüldüğünü unutmayın; kalan tüm karakterlere dokunulmaz. Diğer karakterlerin küçük harf olması gerekiyorsa, dizin> 0 için Char.ToLower (currentChar) öğesini veya ilk sırada tüm dizede ToLower () öğesini de çağırabilirsiniz.

Performans açısından kodu Darren'ın çözümü ile karşılaştırdım. Makinemde Darren'ın kodu yaklaşık 2 kat daha hızlı, bu sadece bir char dizisindeki sadece ilk harfi düzenlediğinden sürpriz değil. Bu yüzden mevcut en hızlı çözüme ihtiyacınız varsa Darren kodunu almanızı öneririm. Diğer dize manipülasyonlarını da entegre etmek istiyorsanız, giriş dizesinin karakterlerine dokunan bir lambda işlevinin etkileyici gücüne sahip olmak uygun olabilir - bu işlevi kolayca genişletebilirsiniz - böylece bu çözümü burada bırakıyorum.

Aşağıdaki yöntemin en iyi çözüm olduğunu düşünüyorum

    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

Bu soru performansı en üst düzeye çıkarmakla ilgili olarak Span, çöpü azaltan ve hızı yaklaşık% 10 artıran Darren'ın s sürümünü kullanmaya başladım .

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

Verim

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

Tam test kodu

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

}

Düzenleme: s [0] yerine bir [0] yerine bir typeo vardı - bu, ayrılan Span a'ya cupying aynı, boş değerle sonuçlanır.

Bu, bu ilk harfi ve bir boşluktan sonraki her harfi büyük harflerle ve diğer harfleri küçük harflerle yazıyor.

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

Aşağıdaki kodu kullanın:

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

Burada verilen çözümlerin hiçbiri dizeden önce beyaz bir alanla uğraşmayacak gibi görünüyor.

Sadece bunu bir düşünce olarak eklemek:

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

Bu işlemesi gerektiğini this won't work on other answers(cümle başında bir boşluk olmadığını) ve kırpma boşluk gibi yapmazsanız sadece geçiş falseikinci parametre olarak (veya varsayılan değiştirmek falseve pas trueUzayda başa istiyorsanız)

FluentSharp bunu yapan bir lowerCaseFirstLetteryönteme sahiptir

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

Köknar mektubunu büyük harfle yazmanın en kolay yolu:

1- Sistem Kullanımı; Küreselleşme;

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

  myTI.ToTitleCase(textboxname.Text)

'

aşağıdaki işlev tüm yollar için doğrudur:

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

Onu burada buldum

Yukarıdaki Carlos'un sorusunu genişleterek, birden fazla cümleyi büyük harfle yazmak istiyorsanız bu kodu kullanabilirsiniz:

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

Sorununuzu çözmek için olası çözüm.

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