Como coloco a primeira letra do nome e do sobrenome em maiúscula em C#?

Question

Existe uma maneira fácil de colocar a primeira letra de uma string em maiúscula e diminuir o restante?Existe um método integrado ou preciso criar o meu próprio?

Answer 1

TextInfo.ToTitleCase() coloca em maiúscula o primeiro caractere em cada token de uma string.
Se não houver necessidade de manter a sigla em maiúsculas, você deve incluir ToLower().

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

Se CurrentCulture não estiver disponível, use:

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

Veja o Link do MSDN para uma descrição detalhada.

Answer 2

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

Answer 3

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

O código acima não funcionará .....

então coloque o código abaixo convertendo para diminuir e aplique a função

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

Answer 4

Existem alguns casos que CultureInfo.CurrentCulture.TextInfo.ToTitleCase não consegue lidar, por exemplo:o apóstrofo '.

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

A expressão regular também pode ser usado \b[a-zA-Z] para identificar o caractere inicial de uma palavra após o limite de uma palavra \b, então precisamos apenas substituir a correspondência por sua equivalência em maiúsculas graças ao Regex.Replace(string input,string pattern,MatchEvaluator evaluator) método:

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

O expressão regular pode ser ajustado se necessário, por exemplo, se quisermos lidar com o MacDonald e McFry casos o regex se torna: (?<=\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

Se precisarmos lidar com mais prefixos, só precisamos modificar o grupo (?:mc|mac), por exemplo, para adicionar prefixos franceses du, de : (?:mc|mac|du|de).

Finalmente, podemos perceber que isso expressão regular também corresponderá ao caso MacDonald'S por último 's então precisamos lidar com isso no expressão regular com um olhar negativo para trás (?<!'s\b).No final temos:

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 5

Mc e Mac são prefixos de sobrenome comuns nos EUA e existem outros.TextInfo.ToTitleCase não lida com esses casos e não deve ser usado para essa finalidade.Veja como estou fazendo isso:

    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 6

ToTitleCase() deve funcionar para você.

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

Answer 7

A opção mais direta será usar o ToTitleCase função que está disponível no .NET que deve cuidar do nome na maioria das vezes.Como borda apontou que existem alguns nomes para os quais não funcionará, mas estes são bastante raros, portanto, a menos que você esteja almejando uma cultura onde tais nomes são comuns, não é necessário algo com que você tenha que se preocupar muito.

No entanto, se você não estiver trabalhando com uma linguagem .NET, isso depende da aparência da entrada - se você tiver dois campos separados para o nome e o sobrenome, poderá apenas colocar a primeira letra em maiúscula e diminuir o restante usando substrings.

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

No entanto, se você receber vários nomes como parte da mesma sequência, precisará saber como está obtendo as informações e divida de acordo.Portanto, se você estiver recebendo um nome como "John Doe", divida a string com base no caractere de espaço.Se estiver em um formato como "Doe, John", você precisará dividi-lo com base na vírgula.No entanto, depois de dividi-lo, basta aplicar o código mostrado anteriormente.

Answer 8

CultureInfo.CurrentCulture.TextInfo.ToTitleCase ("meu nome");

retorna ~ Meu nome

Mas o problema ainda existe com nomes como McFly, conforme mencionado anteriormente.

Answer 9

Eu uso meu próprio método para consertar isso:

Por exemplo a frase:"Olá Mundo.Olá, este é o mundo stackoverflow." será "Olá, mundo.Olá, este é o mundo Stackoverflow.".Regex \b (início de uma palavra) \w (primeiro caractere da palavra) resolverá o problema.

/// <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 10

As sugestões para usar ToTitleCase não funcionarão para strings todas em maiúsculas.Então você terá que chamar ToUpper no primeiro caractere e ToLower nos caracteres restantes.

Answer 11

Esta classe faz o truque.Você pode adicionar novos prefixos ao _prefixos matriz de string estática.

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 12

Se estiver usando vS2k8, você pode usar um método de extensão para adicioná-lo à classe String:

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

Answer 13

Para contornar alguns dos problemas/questões que foram destacados, sugiro primeiro converter a string para minúscula e depois chamar o método ToTitleCase.Você poderia então usar IndexOf(" Mc") ou IndexOf(" O\'") para determinar casos especiais que precisam de atenção mais 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 14

Eu gosto assim:

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

Levantado deste Artigo MSDN.

Answer 15

Espero que isso ajude você.

String fName = "firstname";
String lName = "lastname";
String capitalizedFName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(fName);
String capitalizedLName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(lName);

Answer 16

 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 17

Como indicado por edg, você precisará de um algoritmo mais complexo para lidar com nomes especiais (é provavelmente por isso que muitos lugares forçam tudo para letras maiúsculas).

Algo como este c# não testado deve lidar com o caso simples que você solicitou:

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