Ho un DetailsViewcon un TextBox e voglio che i dati di input vengano salvati sempre con la PRIMA LETTERA IN CAPITALE.

Esempio:

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

Come posso ottenere questa prestazione massimizzante ?

NOTA : in
base alle risposte e ai commenti sotto le risposte, molte persone pensano che questo stia chiedendo di scrivere in maiuscolo tutte le parole nella stringa. Ad esempio => Red House , non lo è, ma se è quello che cerchi , cerca una delle risposte che utilizza TextInfoil ToTitleCasemetodo. (NOTA: quelle risposte non sono corrette per la domanda effettivamente posta).
Vedi il documento TextInfo.ToTitleCase per avvertimenti (non tocca le parole con tutti i caratteri maiuscoli - sono considerati acronimi; possono contenere lettere minuscole nel mezzo di parole che "non dovrebbero" essere abbassato, ad esempio "McDonald" => "Mcdonald"; non è garantito che gestisca tutte le sottigliezze specifiche della cultura in merito alle regole di capitalizzazione.)

NOTA :
la domanda è ambigua se le lettere dopo la prima debbano essere forzate in lettere minuscole . La risposta accettata presuppone che solo la prima lettera debba essere modificata . Se si desidera forzare tutte le lettere nella stringa tranne la prima in minuscolo, cercare una risposta contenente ToLowere non contenente ToTitleCase .

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

Risposte davvero vecchie

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 : questa versione è più breve. Per una soluzione più rapida dai un'occhiata alla risposta di 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 : Probabilmente la soluzione più veloce è quella di Darren (c'è persino un punto di riferimento) anche se cambierei la sua string.IsNullOrEmpty(s)convalida per generare un'eccezione poiché il requisito originale prevede che esista una prima lettera in modo che possa essere maiuscola. Si noti che questo codice funziona per una stringa generica e non in particolare su valori validi da 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();
}

Vecchia risposta: questo rende ogni prima lettera in maiuscolo

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

Il modo giusto è usare Cultura:

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

Nota: questo renderà maiuscole le parole all'interno di una stringa, ad es. "Casa rossa" -> "casa rossa". La soluzione prevede anche l'uso di lettere minuscole in lettere, ad esempio "vecchio McDonald" -> "Vecchio Mcdonald".

Ho preso il metodo più veloce da http://www.dotnetperls.com/uppercase-first-letter e convertito in metodo di estensione:

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

NOTA: il motivo per cui ToCharArrayè più veloce dell'alternativa char.ToUpper(s[0]) + s.Substring(1)è che è allocata una sola stringa, mentre l' Substringapproccio alloca una stringa per la sottostringa, quindi una seconda stringa per comporre il risultato finale.

EDIT : Ecco come appare questo approccio, combinato con il test iniziale della risposta accettata da 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);
    }

Puoi usare "Metodo ToTitleCase"

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

questo metodo di estensione risolve ogni problema relativo al titolo.

facile da usare

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

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

il metodo di estensione

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

Per la prima lettera, con controllo degli errori:

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

Ed ecco lo stesso di una pratica estensione

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

Se l'utilizzo delle prestazioni / memoria è un problema, questo crea solo un (1) StringBuilder e una (1) nuova stringa della stessa dimensione della stringa originale.

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

Metodo più veloce.

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

I test mostrano i risultati successivi (stringa con 10000000 simboli come input): risultati del test

Prova questo:

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

Se ti interessa solo la prima lettera in maiuscolo e non importa il resto della stringa, puoi semplicemente selezionare il primo carattere, renderlo maiuscolo e concatenarlo con il resto della stringa senza il primo carattere originale.

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

Dobbiamo convertire il primo carattere ToString () perché lo stiamo leggendo come un array Char e il tipo Char non ha il metodo ToUpper ().

Ecco un modo per farlo come metodo di estensione:

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

Può quindi essere chiamato come:

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

Ed ecco alcuni test unitari per questo:

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

Da quando mi è capitato di lavorare anche su questo, e cercavo qualche idea, questa è la soluzione a cui sono arrivato. Utilizza LINQ e sarà in grado di scrivere in maiuscolo la prima lettera di una stringa, anche se la prima occorrenza non è una lettera. Ecco il metodo di estensione che ho finito per creare.

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

Sono sicuro che c'è un modo per ottimizzare o ripulire un po '.

Ho trovato qualcosa qui 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);
}

forse questo aiuta !!

Controlla se la stringa non è nulla quindi converti il ​​primo carattere in maiuscolo e il resto in minuscolo:

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

Questo lo farà anche se farà anche in modo che non ci siano capitali erranti che non sono all'inizio della parola.

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

Sembra esserci molta complessità qui quando tutto ciò che serve è:

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

Punti degni di nota:

1. È un metodo di estensione.

2. Se l'input è nullo, vuoto o vuoto, l'input viene restituito così com'è.

3. String.IsNullOrWhiteSpace è stato introdotto con .NET Framework 4. Questo non funzionerà con i framework più vecchi.

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

Volevo fornire una risposta "MASSIMA PRESTAZIONE". Nella mia mente, una risposta "MASSIMA PRESTAZIONE" cattura tutti gli scenari e fornisce la risposta alla domanda tenendo conto di quegli scenari. Quindi, ecco la mia risposta. Con questi motivi:

1. IsNullOrWhiteSpace tiene conto delle stringhe che sono solo spazi o null / vuote.
2. .Trim () rimuove gli spazi bianchi dalla parte anteriore e posteriore della stringa.
3. .First () accetta il primo carattere di un ienumerable (o stringa).
4. Dovremmo verificare se è una lettera che può / dovrebbe essere maiuscola.
5. Aggiungiamo quindi il resto della stringa, solo se la lunghezza indica che dovremmo.
6. Secondo le migliori pratiche .Net, dovremmo fornire una cultura in System.Globalization.CultureInfo.

7. Fornendoli come parametri opzionali, questo metodo è totalmente riutilizzabile, senza dover digitare ogni volta la cultura scelta.

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

Recentemente ho avuto un requisito simile e ho ricordato che la funzione LINQ Select () fornisce un indice:

string input;
string output;

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

Dato che mi serve molto spesso ho creato un metodo di estensione per il tipo di stringa:

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

Nota che solo la prima lettera viene convertita in maiuscolo, tutti i caratteri rimanenti non vengono toccati. Se hai bisogno che gli altri caratteri siano in minuscolo, puoi anche chiamare Char.ToLower (currentChar) per indice> 0 o chiamare ToLower () sull'intera stringa in primo luogo.

Per quanto riguarda le prestazioni, ho confrontato il codice con la soluzione di Darren. Sulla mia macchina il codice di Darren è circa 2 volte più veloce, il che non sorprende poiché sta modificando direttamente solo la prima lettera all'interno di un array di caratteri. Quindi ti suggerisco di prendere il codice di Darren se hai bisogno della soluzione più veloce disponibile. Se vuoi integrare anche altre manipolazioni di stringhe, può essere conveniente avere il potere espressivo di una funzione lambda che tocca i caratteri della stringa di input - puoi facilmente estendere questa funzione - quindi lascio questa soluzione qui.

Penso che il metodo seguente sia la soluzione migliore

    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

arbitro

Poiché questa domanda riguarda l' ottimizzazione delle prestazioni, ho adottato la versione di Darren per utilizzare Spans, che riduce i rifiuti e migliora la velocità di circa il 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);
        }

Prestazione

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

Codice di prova completo

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

}

Modifica: c'era un errore di battitura, invece di s [0], era un [0] - questo risulta con lo stesso valore vuoto e vuoto allo Span allocato a.

Questo mette in maiuscolo questa prima lettera e ogni lettera che segue uno spazio e minuscole qualsiasi altra lettera.

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

Usa il seguente codice:

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

Sembra che nessuna delle soluzioni fornite qui gestirà uno spazio bianco prima della stringa.

Basta aggiungere questo come pensiero:

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

Dovrebbe gestire this won't work on other answers(quella frase ha uno spazio all'inizio), e se non ti piace il taglio dello spazio, passa un falsesecondo parametro (o modifica il valore predefinito falsee passa truese vuoi occuparti dello spazio)

FluentSharp ha il lowerCaseFirstLetter metodo per

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

Il modo più semplice per capitalizzare la prima lettera è:

1- Utilizzo di Sytem.Globalization;

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

  myTI.ToTitleCase(textboxname.Text)

`

la seguente funzione è corretta per tutti i modi:

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

L'ho trovato qui

Espandendo la domanda di Carlos sopra, se vuoi capitalizzare più frasi puoi usare questo codice:

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

Possibile soluzione per risolvere il tuo problema.

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