¿Cómo puedo escribir en mayúscula la primera letra del nombre y el apellido en C #?
¿Hay una manera fácil de poner en mayúscula la primera letra de una cadena y bajar el resto? ¿Hay un método incorporado o necesito hacer el mío?
TextInfo.ToTitleCase() pone en mayúscula el primer carácter de cada token de una cadena.
Si no es necesario mantener el acrónimo en mayúsculas y minúsculas, 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());
Consulte el MSDN Link 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á ...
a continuación, coloque el código de abajo para convertir a una baja y luego aplique 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óstrofe '.
string input = CultureInfo.CurrentCulture.TextInfo.ToTitleCase("o'reilly, m'grego, d'angelo");
// input = O'reilly, M'grego, D'angelo
A regex también se puede usar \b[a-zA-Z] para identificar el carácter inicial de una Palabra después de un límite de Palabra \b, entonces solo necesitamos reemplazar la coincidencia por su mayúscula en mayúsculas gracias al método Regex.Replace(string input,string pattern,MatchEvaluator evaluator) method:
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 regex se puede ajustar si es necesario, por ejemplo, si queremos manejar los casos 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 prefijos en francés du, de: (?:mc|mac|du|de).
Finalmente, podemos darnos cuenta de que este regex también coincidirá con el caso MacDonald'S para el último 's, por lo que necesitamos manejarlo en el regex con un aspecto negativo detrás de (?<!'s\b). 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](?<!'s\b)", m => m.Value.ToUpper());
// input = O'Reilly, M'Grego, D'Angelo, MacDonald's, McFry
Mc y Mac son prefijos de apellidos 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.
La opción más directa será utilizar la función ToTitleCase que está disponible en .NET y que debería ocuparse del nombre la mayor parte del tiempo. Como edg señaló, hay algunos nombres para los que no funcionará, pero estos son bastante raros, así que, a menos que esté apuntando a una cultura en la que dichos nombres sean comunes, no es necesario algo de lo que deba preocuparse demasiado.
Sin embargo, si no está trabajando con un lenguaje .NET, entonces dependerá de cómo se vea la entrada: si tiene dos campos separados para el nombre y el apellido, simplemente puede poner en mayúscula la primera letra y el resto del texto. subcadenas.
firstName = firstName.Substring(0, 1).ToUpper() + firstName.Substring(1).ToLower();
lastName = lastName.Substring(0, 1).ToUpper() + lastName.Substring(1).ToLower();
Sin embargo, si se le proporcionan varios nombres como parte de la misma cadena, entonces necesita saber cómo está obteniendo la información y dividirla en consecuencia. Entonces, si obtienes un nombre como "John Doe", divides la cadena según el 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 haya separado, simplemente aplique el código que se muestra anteriormente.
Utilizo mi propio método para arreglar esto:
Por ejemplo, la frase: "hola mundo. Hola, este es el mundo de stackoverflow". será "Hello World. Hello This is The Stackoverflow World". Regex\b (inicio de una palabra)\w (primer carácter de la palabra) hará el truco.
/// <summary>
/// Makes each first letter of a Word uppercase. The rest will be lowercase
/// </summary>
/// <param name="Phrase"></param>
/// <returns></returns>
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;
}
CultureInfo.CurrentCulture.TextInfo.ToTitleCase ("mi nombre");
devuelve ~ mi nombre
Pero el problema todavía existe con nombres como McFly como se dijo anteriormente.
Esta clase hace el truco. Puede agregar nuevos prefijos a la matriz de cadenas _prefixes static.
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();
}
}
Las sugerencias para usar ToTitleCase no funcionarán para cadenas que estén en mayúsculas. Así que tendrás que llamar a ToUpper en la primera char y ToLower en los caracteres restantes.
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, sugeriría convertir primero la cadena a minúsculas y luego llamar al método ToTitleCase. Luego puede usar IndexOf ("Mc") o IndexOf ("O '') para determinar casos especiales que requieren 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);
}
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;
}
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);