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

uppercase first c#

Question

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

Answer 1

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

Answer 2

CultureInfo.CurrentCulture.TextInfo.ToTitleCase ("mi nombre");

devuelve ~ Mi nombre

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

Answer 3

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

Answer 4

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

Answer 5

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 (?<!''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

Answer 6

La opción más directa será usar la función http://support.microsoft.com/kb/312890 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 resto 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.

Answer 7

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.

Answer 8

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

Answer 9

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 .

Answer 10

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

Answer 11

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

Answer 12

ToTitleCase () debería funcionar para usted.

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

Answer 13

Yo uso mi propio método para arreglar esto:

Por ejemplo, la frase: "hola mundo. Hola este es el mundo ". será "Hola mundo. Hola, este es el mundo de ". Regex / b (comienzo 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;
}

Answer 14

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.

Answer 15

 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;

        }

Answer 16

CultureInfo.CurrentCulture.TextInfo.ToTitleCase("hello world");

Answer 17

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