Hacer la primera letra de una mayúscula de cuerda (con el máximo rendimiento)

Tengo un DetailsView con un TextBox y quiero que los datos de entrada se guarden siempre con la PRIMERA CARTA EN CAPITAL.

Ejemplo:

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

¿Cómo puedo lograr este rendimiento maximizador ?


NOTA :
En función de las respuestas y los comentarios en las respuestas, muchas personas piensan que esto es una pregunta sobre cómo capitalizar todas las palabras de la cadena. Ej => Red House No lo es, pero si eso es lo que buscas , busca una de las respuestas que usa el método ToTitleCase . (NOTA: Esas respuestas son incorrectas para la pregunta realmente hecha).
Consulte TextInfo.ToTitleCase doc para advertencias (no toca palabras mayúsculas: se consideran acrónimos; puede que las letras minúsculas estén en medio de palabras que “no deberían” reducirse, por ejemplo, “McDonald” => “Mcdonald”; no se garantiza). para manejar todas las sutilezas específicas de cultura, las reglas de capitalización).


NOTA :
La pregunta es ambigua sobre si las letras después de la primera deben ser forzadas a minúsculas . La respuesta aceptada asume que solo la primera letra debe ser alterada . Si desea forzar todas las letras de la cadena, excepto la primera minúscula, busque una respuesta que contenga ToLower y no contenga ToTitleCase .

EDITAR: actualizado a la syntax más nueva (y más respuesta correcta), también como método de extensión.

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

ANTIGUAS RESPUESTAS

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

EDITAR : Esta versión es más corta. Para una solución más rápida, eche un vistazo a la respuesta de 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 : Probablemente la solución más rápida es la de Darren (incluso hay un punto de referencia) aunque cambiaría su validación string.IsNullOrEmpty(s) para lanzar una excepción ya que el requisito original espera que exista una primera letra para que pueda ser mayúscula. Tenga en cuenta que este código funciona para una cadena genérica y no particularmente en los valores válidos de 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(); } 

Respuesta anterior: esto hace que cada primera letra en mayúscula

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

La forma correcta es usar Cultura:

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

Puede usar el “método ToTitleCase”

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

este método de extensión resuelve cada problema de título.

fácil de usar

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

el método de extensión

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

Tomé el método más rápido de http://www.dotnetperls.com/uppercase-firstletter y convertí al método de extensión:

  ///  /// 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: El motivo por el que se utiliza ToCharArray es más rápido que la alternativa char.ToUpper(s[0]) + s.Substring(1) , es que solo se asigna una cadena, mientras que el enfoque de Substring asigna una cadena para la subcadena, luego un segundo cuerda para componer el resultado final.


EDITAR : Así es como se ve este enfoque, combinado con la prueba inicial de la respuesta aceptada de 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); } 

Para la primera letra, con comprobación de errores:

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

Y aquí es lo mismo que una extensión útil

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

Si el rendimiento / el uso de la memoria es un problema, este solo crea un (1) StringBuilder y una (1) nueva Cadena del mismo tamaño que la Cadena original.

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

Prueba esto:

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

Esta es una forma de hacerlo como método de extensión:

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

Se puede llamar así:

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

Y aquí hay algunas pruebas unitarias para ello:

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

Como yo también estaba trabajando en esto y estaba buscando ideas, esta es la solución a la que llegué. Utiliza LINQ y podrá escribir en mayúscula la primera letra de una cadena, incluso si la primera aparición no es una letra. Aquí está el método de extensión que terminé haciendo.

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

Estoy seguro de que hay una forma de optimizar o limpiar esto un poco.

Encontré algo aquí http://www.dotnetperls.com/uppercase-firstletter :

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

tal vez esto ayude !!

Si solo le importa que la primera letra esté en mayúscula y no importa el rest de la cadena, puede seleccionar el primer carácter, hacerlo en mayúscula y concatenarlo con el rest de la cadena sin el primer carácter original.

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

Necesitamos convertir el primer carácter ToString () porque lo estamos leyendo como una matriz Char, y el tipo Char no tiene el método ToUpper ().

Esto lo hará aunque también se asegurará de que no haya mayúsculas errantes que no estén al principio de la palabra.

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

Parece que hay mucha complejidad aquí cuando todo lo que necesitas es:

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

Puntos destacables:

  1. Es un método de extensión.

  2. Si la entrada es nula, vacía o en blanco, la entrada se devuelve tal como está.

  3. String.IsNullOrWhiteSpace se introdujo con .NET Framework 4. Esto no funcionará con frameworks anteriores.

El método más rápido.

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

Las pruebas muestran los resultados siguientes (cadena con 10000000 símbolos como entrada): Resultados de la prueba

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

Quería proporcionar una respuesta de “RENDIMIENTO MÁXIMO”. En mi opinión, una respuesta de “RENDIMIENTO MÁXIMO” capta todos los escenarios y proporciona la respuesta a la pregunta que explica esos escenarios. Entonces, aquí está mi respuesta. Con estas razones:

  1. Las cuentas IsNullOrWhiteSpace para cadenas que son solo espacios o nulas / vacías.
  2. .Trim () elimina el espacio en blanco de la parte frontal y posterior de la cadena.
  3. .First () toma el primer carácter de un ienumerable (o cadena).
  4. Deberíamos verificar si es una carta que puede / debe estar en mayúscula.
  5. Luego agregamos el rest de la cadena, solo si la longitud indica que deberíamos.
  6. Por la mejor práctica de .Net, debemos proporcionar una cultura en System.Globalization.CultureInfo.
  7. Proporcionarlos como parámetros opcionales hace que este método sea totalmente reutilizable, sin tener que escribir la cultura elegida cada vez.

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

Esto pone en mayúscula esta primera letra y cada letra que sigue un espacio y los casos más bajos cualquier otra letra.

 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 el siguiente código:

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

Parece que ninguna de las soluciones dadas aquí tratará con un espacio en blanco antes de la cadena.

Simplemente agregando esto como un pensamiento:

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

Debe manejar this won't work on other answers (esa oración tiene un espacio al principio), y si no le gusta el espacio de recorte, simplemente pase un parámetro false como segundo (o cambie el valor predeterminado a false , y pase true si quieres ocuparte del espacio)

Es la manera más rápida:

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

Sin cambiar la secuencia original:

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

La forma más fácil de capitalizar la primera carta es:

1- Usando Sytem.Globalization;

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

`

la siguiente función es correcta para todas las formas:

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

Encontré eso aquí

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