Crea prima lettera di una stringa maiuscola (con prestazioni massime)

Ho un DetailsView con un TextBox e voglio che i dati di input vengano salvati sempre con la FIRST LETTER IN CAPITAL.

Esempio:

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

Come posso raggiungere questa prestazione massimizzante ?


NOTA :
Sulla base delle risposte e dei commenti sotto le risposte, molte persone pensano che questo stia chiedendo di capitalizzare tutte le parole nella stringa. Es. => Red House Non lo è, ma se questo è ciò che cerchi , cerca una delle risposte che usa il metodo ToTitleCase . (NOTA: quelle risposte non sono corrette per la domanda effettivamente posta).
Vedi TextInfo.ToTitleCase doc per avvertimenti (non tocca le parole in maiuscolo – sono considerati acronimi; può contenere lettere minuscole nel mezzo di parole che “non dovrebbero” essere abbassate, ad esempio “McDonald” => “Mcdonald”; non garantito per gestire tutte le sottigliezze specifiche della cultura e le regole di maiuscole.)


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

EDIT: aggiornato alla syntax più recente (e una risposta più corretta), anche come metodo di estensione.

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

VECCHIE RISPOSTE

 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ù veloce 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 è Darren (c’è persino un benchmark) anche se cambierei la sua string.IsNullOrEmpty(s) per lanciare un’eccezione poiché il requisito originale si aspetta che esista una prima lettera in modo che possa essere in maiuscolo. Si noti che questo codice funziona per una stringa generica e non particolarmente per i valori validi dalla 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 la cultura:

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

Puoi utilizzare “Metodo ToTitleCase”

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

questo metodo di estensione risolve ogni problema di titlecase.

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

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

  ///  /// Returns the input string with the first character converted to uppercase, or mutates any nulls passed into string.Empty ///  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 che utilizza ToCharArray è più veloce del char.ToUpper(s[0]) + s.Substring(1) alternativo char.ToUpper(s[0]) + s.Substring(1) , è che viene allocata solo una stringa, mentre l’approccio Substring alloca una stringa per la sottostringa, quindi un secondo stringa per comporre il risultato finale.


EDIT : Ecco come appare questo approccio, combinato con il test iniziale della risposta accettata da CarlosMuñoz :

  ///  /// Returns the input string with the first character converted to uppercase ///  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); } 

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 come un’estensione a portata di mano

 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 di prestazioni / memoria è un problema, questo crea solo uno (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; } 

Prova questo:

 static public string UpperCaseFirstCharacter(this string text) { return Regex.Replace(text, "^[az]", m => m.Value.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); } 

Dal momento che mi è capitato di lavorare anche a questo, e stavo cercando idee, questa è la soluzione a cui sono arrivato. Usa 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 fare.

 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 pulire un po ‘questo.

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

Se ti interessa solo che la prima lettera sia 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" 

Abbiamo bisogno di convertire il primo carattere ToString () perché lo stiamo leggendo come array Char, e il tipo Char non ha il metodo ToUpper ().

Questo lo farà anche se farà anche in modo che non ci siano maiuscole errate che non siano 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 che ci sia molta complessità qui quando tutto ciò che serve è:

  ///  /// Returns the input string with the first character converted to uppercase if a letter ///  /// Null input returns null 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 spazio vuoto, l’input viene restituito così com’è.

  3. String.IsNullOrWhiteSpace è stato introdotto con .NET Framework 4. Ciò non funzionerà con i framework precedenti.

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

 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 PERFORMANCE” cattura tutti gli scenari e fornisce la risposta alla domanda che tiene conto di tali scenari. Quindi, ecco la mia risposta. Con questi motivi:

  1. IsNullOrWhiteSpace account per stringhe che sono solo spazi o null / empty.
  2. .Trim () rimuove gli spazi bianchi dalla parte anteriore e posteriore della stringa.
  3. .First () prende il primo carattere di un elemento numerico (o stringa).
  4. Dovremmo controllare se è una lettera che può / dovrebbe essere maiuscola.
  5. Quindi aggiungiamo il resto della stringa, solo se la lunghezza indica che dovremmo.
  6. Secondo le migliori pratiche di .Net, dovremmo fornire una cultura in System.Globalization.CultureInfo.
  7. Fornendoli come parametri opzionali rende questo metodo totalmente riutilizzabile, senza dover digitare la cultura scelta ogni volta.

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

Questo capitalizza questa prima lettera e ogni lettera che segue uno spazio e un numero inferiore di lettere qualsiasi.

 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 si occupi di uno spazio bianco prima della stringa.

Semplicemente aggiungendo questo come un 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, basta passare un false come secondo parametro (o cambiare il valore predefinito in false , e passare true se vuoi occuparti dello spazio)

È il modo più veloce:

 public static unsafe void ToUpperFirst(this string str) { if (str == null) return; fixed (char* ptr = str) *ptr = char.ToUpper(*ptr); } 

Senza cambiare la stringa originale:

 public static unsafe string ToUpperFirst(this string str) { if (str == null) return null; string ret = string.Copy(str); fixed (char* ptr = ret) *ptr = char.ToUpper(*ptr); return ret; } 

Il modo più semplice per scrivere lettere maiuscole è:

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

Expanding on Carlos’ question above, if you want to capitalize multiple sentences you may use this code:

  ///  /// Capitalize first letter of every sentence. ///  ///  ///  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; } 

Recently I had a similar requirement and remembered that the LINQ function Select() provides an index:

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

Since I need that very often I made an extension method for the string type:

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

Please note that only the first letter is converted to upper case – all remaining characters are not touched. If you need the other characters to be lower case you may also call Char.ToLower(currentChar) for index > 0 or call ToLower() on the whole string in the first place.

Regarding performance I compared the code with the solution from Darren. On my machine Darren’s code is about 2 times faster which is no surprise since he’s directly editing only the first letter within a char array. So I suggest you take Darren’s code if you need the fastest solution available. If you want to integrate other string manipulations as well it may be convenient to have the expressive power of a lambda function touching the characters of the input string – you can easily extend this function – so I leave this solution here.

With this method you can upper the first char of every word.

Example “HeLlo wOrld” => “Hello World”

 public static string FirstCharToUpper(string input) { if (String.IsNullOrEmpty(input)) throw new ArgumentException("Error"); return string.Join(" ", input.Split(' ').Select(d => d.First().ToString().ToUpper() + d.ToLower().Substring(1))); } 

send a string to this function. it will first check string is empty or null, if not string will be all lower chars. then return first char of string upper rest of them lower.

 string FirstUpper(string s) { // Check for empty string. if (string.IsNullOrEmpty(s)) { return string.Empty; } s = s.ToLower(); // Return char and concat substring. return char.ToUpper(s[0]) + s.Substring(1); } 

As BobBeechey suggests in his response to this question , the following code will work for this:

 private void txt_fname_TextChanged(object sender, EventArgs e) { char[] c = txt_fname.Text.ToCharArray(); int j; for (j = 0; j < txt_fname.Text.Length; j++) { if (j==0) c[j]=c[j].ToString().ToUpper()[0]; else c[j] = c[j].ToString().ToLower()[0]; } txt_fname.Text = new string(c); txt_fname.Select(txt_fname.Text.Length, 1); }