¿Cómo capitalizo la primera letra del primer nombre y apellido en C #?

¿Hay alguna manera fácil de capitalizar la primera letra de una cadena y bajar el rest? ¿Hay un método integrado o tengo que hacer el mío?

TextInfo.ToTitleCase() escribe en mayúscula el primer carácter en cada token de una cadena.
Si no es necesario mantener Acronym Uppercasing, entonces debe incluir ToLower() .

 string s = "JOHN DOE"; s = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(s.ToLower()); // Produces "John Doe" 

Si CurrentCulture no está disponible, use:

 string s = "JOHN DOE"; s = new System.Globalization.CultureInfo("en-US", false).TextInfo.ToTitleCase(s.ToLower()); 

Vea el enlace de MSDN para una descripción detallada.

 CultureInfo.CurrentCulture.TextInfo.ToTitleCase("hello world"); 
 String test = "HELLO HOW ARE YOU"; string s = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(test); 

El código anterior no funcionará …

así que pon el código de abajo por convertir a menor y luego aplica la función

 String test = "HELLO HOW ARE YOU"; string s = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(test.ToLower()); 

Hay algunos casos que CultureInfo.CurrentCulture.TextInfo.ToTitleCase no puede manejar, por ejemplo: el apóstrofo ' .

 string input = CultureInfo.CurrentCulture.TextInfo.ToTitleCase("o'reilly, m'grego, d'angelo"); // input = O'reilly, M'grego, D'angelo 

También se puede usar una expresión regular \b[a-zA-Z] para identificar el carácter inicial de una palabra después de un límite de palabra \b , luego solo necesitamos reemplazar la coincidencia por su equivalencia en mayúscula gracias a Regex.Replace(string input,string pattern,MatchEvaluator evaluator) método de Regex.Replace(string input,string pattern,MatchEvaluator evaluator) :

 string input = "o'reilly, m'grego, d'angelo"; input = Regex.Replace(input.ToLower(), @"\b[a-zA-Z]", m => m.Value.ToUpper()); // input = O'Reilly, M'Grego, D'Angelo 

La expresión regular se puede sintonizar si es necesario, por ejemplo, si queremos manejar los casos de MacDonald y McFry , la expresión regular se convierte en: (?<=\b(?:mc|mac)?)[a-zA-Z]

 string input = "o'reilly, m'grego, d'angelo, macdonald's, mcfry"; input = Regex.Replace(input.ToLower(), @"(?<=\b(?:mc|mac)?)[a-zA-Z]", m => m.Value.ToUpper()); // input = O'Reilly, M'Grego, D'Angelo, MacDonald'S, McFry 

Si necesitamos manejar más prefijos, solo necesitamos modificar el grupo (?:mc|mac) , por ejemplo para agregar los prefijos franceses du, de : (?:mc|mac|du|de) .

Finalmente, podemos darnos cuenta de que esta expresión regular también coincidirá con el caso MacDonald'S para el último 's así que tenemos que manejarlo en la expresión regular con una mirada negativa detrás (? . Al final tenemos:

 string input = "o'reilly, m'grego, d'angelo, macdonald's, mcfry"; input = Regex.Replace(input.ToLower(), @"(?<=\b(?:mc|mac)?)[a-zA-Z](? m.Value.ToUpper()); // input = O'Reilly, M'Grego, D'Angelo, MacDonald's, McFry 

Mc y Mac son prefijos de apellido comunes en todos los Estados Unidos, y hay otros. TextInfo.ToTitleCase no maneja esos casos y no debe usarse para este propósito. Así es como lo estoy haciendo:

  public static string ToTitleCase(string str) { string result = str; if (!string.IsNullOrEmpty(str)) { var words = str.Split(' '); for (int index = 0; index < words.Length; index++) { var s = words[index]; if (s.Length > 0) { words[index] = s[0].ToString().ToUpper() + s.Substring(1); } } result = string.Join(" ", words); } return result; } 

ToTitleCase () debería funcionar para usted.

http://support.microsoft.com/kb/312890

La opción más directa será usar la función ToTitleCase que está disponible en .NET que debería cuidar el nombre la mayor parte del tiempo. Como edg señaló, hay algunos nombres con los que no funcionará, pero son bastante raros, así que, a menos que esté apuntando a una cultura donde esos nombres son comunes, no es algo necesario de lo que deba preocuparse demasiado.

Sin embargo, si no está trabajando con un .NET langauge, depende de cómo se ve la entrada: si tiene dos campos separados para el primer nombre y el apellido, puede simplemente escribir en mayúscula la primera letra y bajar el rest utilizando subcadenas.

 firstName = firstName.Substring(0, 1).ToUpper() + firstName.Substring(1).ToLower(); lastName = lastName.Substring(0, 1).ToUpper() + lastName.Substring(1).ToLower(); 

Sin embargo, si le proporcionan varios nombres como parte de la misma cadena, entonces necesita saber cómo obtiene la información y dividirla en consecuencia. Entonces, si obtiene un nombre como “John Doe”, divide la cadena en función del carácter de espacio. Si está en un formato como “Doe, John”, tendrá que dividirlo según la coma. Sin embargo, una vez que lo divida, simplemente aplique el código que se mostró anteriormente.

CultureInfo.CurrentCulture.TextInfo.ToTitleCase (“mi nombre”);

devuelve ~ Mi nombre

Pero el problema todavía existe con nombres como McFly, como se dijo anteriormente.

Yo uso mi propio método para arreglar esto:

Por ejemplo, la frase: “hola mundo. Hola este es el mundo stackoverflow”. será “Hola mundo. Hola, este es el mundo de Stackoverflow”. Regex \ b (comienzo de una palabra) \ w (primer carácter de la palabra) hará el truco.

 ///  /// Makes each first letter of a word uppercase. The rest will be lowercase ///  ///  ///  public static string FormatWordsWithFirstCapital(string Phrase) { MatchCollection Matches = Regex.Matches(Phrase, "\\b\\w"); Phrase = Phrase.ToLower(); foreach (Match Match in Matches) Phrase = Phrase.Remove(Match.Index, 1).Insert(Match.Index, Match.Value.ToUpper()); return Phrase; } 

Las sugerencias para usar ToTitleCase no funcionarán para las cadenas que son todas mayúsculas. Así que tendrás que llamar a ToUpper en el primer char y a ToLower en los caracteres restantes.

Esta clase hace el truco. Puede agregar nuevos prefijos a la matriz de cadenas estáticas _prefixes .

 public static class StringExtensions { public static string ToProperCase( this string original ) { if( String.IsNullOrEmpty( original ) ) return original; string result = _properNameRx.Replace( original.ToLower( CultureInfo.CurrentCulture ), HandleWord ); return result; } public static string WordToProperCase( this string word ) { if( String.IsNullOrEmpty( word ) ) return word; if( word.Length > 1 ) return Char.ToUpper( word[0], CultureInfo.CurrentCulture ) + word.Substring( 1 ); return word.ToUpper( CultureInfo.CurrentCulture ); } private static readonly Regex _properNameRx = new Regex( @"\b(\w+)\b" ); private static readonly string[] _prefixes = { "mc" }; private static string HandleWord( Match m ) { string word = m.Groups[1].Value; foreach( string prefix in _prefixes ) { if( word.StartsWith( prefix, StringComparison.CurrentCultureIgnoreCase ) ) return prefix.WordToProperCase() + word.Substring( prefix.Length ).WordToProperCase(); } return word.WordToProperCase(); } } 

Si usa vS2k8, puede usar un método de extensión para agregarlo a la clase String:

 public static string FirstLetterToUpper(this String input) { return input = input.Substring(0, 1).ToUpper() + input.Substring(1, input.Length - 1); } 

Para resolver algunos de los problemas / problemas que se han resaltado, le sugiero que convierta primero la cadena en minúsculas y luego llame al método ToTitleCase. Luego puede usar IndexOf (“Mc”) o IndexOf (“O \ ‘”) para determinar casos especiales que requieren una atención más específica.

 inputString = inputString.ToLower(); inputString = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(inputString); int indexOfMc = inputString.IndexOf(" Mc"); if(indexOfMc > 0) { inputString.Substring(0, indexOfMc + 3) + inputString[indexOfMc + 3].ToString().ToUpper() + inputString.Substring(indexOfMc + 4); } 

Me gusta de esta manera:

 using System.Globalization; ... TextInfo myTi = new CultureInfo("en-Us",false).TextInfo; string raw = "THIS IS ALL CAPS"; string firstCapOnly = myTi.ToTitleCase(raw.ToLower()); 

Levantado de este artículo de MSDN .

Espero que esto te ayude.

 String fName = "firstname"; String lName = "lastname"; String capitalizedFName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(fName); String capitalizedLName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(lName); 
  public static string ConvertToCaptilize(string input) { if (!string.IsNullOrEmpty(input)) { string[] arrUserInput = input.Split(' '); // Initialize a string builder object for the output StringBuilder sbOutPut = new StringBuilder(); // Loop thru each character in the string array foreach (string str in arrUserInput) { if (!string.IsNullOrEmpty(str)) { var charArray = str.ToCharArray(); int k = 0; foreach (var cr in charArray) { char c; c = k == 0 ? char.ToUpper(cr) : char.ToLower(cr); sbOutPut.Append(c); k++; } } sbOutPut.Append(" "); } return sbOutPut.ToString(); } return string.Empty; } 

Al igual que edg indicó, necesitará un algoritmo más complejo para manejar nombres especiales (esta es probablemente la razón por la cual muchos lugares fuerzan todo a mayúsculas).

Algo como este c # no probado debe manejar el caso simple que solicitó:

 public string SentenceCase(string input) { return input(0, 1).ToUpper + input.Substring(1).ToLower; }