it-swarm-pt.tech

Como faço para capitalizar a primeira letra do primeiro nome e sobrenome em c #?

Existe uma maneira fácil de capitalizar a primeira letra de uma string e diminuir o resto dela? Existe um método embutido ou eu preciso fazer o meu próprio?

139
Mike Roosa

TextInfo.ToTitleCase() capitaliza o primeiro caractere em cada token de uma string.
Se não houver necessidade de manter a sigla Uppercasing, inclua ToLower().

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

Se CurrentCulture estiver indisponí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.

256
ageektrapped
CultureInfo.CurrentCulture.TextInfo.ToTitleCase("hello world");
117
Nathan Baulch
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 por converter para mais baixo, em seguida, aplique a função

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

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

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

Um regex também pode ser usado \b[a-zA-Z] para identificar o caractere inicial de uma palavra após um limite de palavra \b, então precisamos apenas substituir a correspondência por sua parte superior equivalência de casos graças ao método 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

O regex pode ser ajustado se necessário, por exemplo, se quisermos lidar com os casos MacDonald e McFry 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, precisamos apenas modificar o grupo (?:mc|mac), por exemplo, para adicionar prefixos em francês du, de: (?:mc|mac|du|de).

Finalmente, podemos perceber que isso regex também corresponderá ao caso MacDonald'S para o último 's, então precisamos lidar com isso no regex com um aspecto negativo por trás de (?<!'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
12
polkduran

Mc e Mac são prefixos de sobrenome comuns em todos os EUA, e há outros. TextInfo.ToTitleCase não lida com esses casos e não deve ser usado para essa finalidade. Aqui está como eu 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;
    }
7
Jamie Ide

ToTitleCase () deve funcionar para você.

http://support.Microsoft.com/kb/31289

5
ckal

A opção mais direta será usar a função ToTitleCase disponível no .NET, que deve cuidar do nome a maior parte do tempo. Como edg apontou há alguns nomes que não vai funcionar, mas estes são bastante raros, a menos que você está alvejando uma cultura onde esses nomes são comuns, não é necessário algo que você tem que se preocupar também muito sobre.

No entanto, se você não está trabalhando com um langauge .NET, então depende de como a entrada se parece - se você tem dois campos separados para o primeiro nome e o último nome, então você pode apenas capitalizar a primeira letra para abaixar o resto 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 dividir de acordo. Portanto, se você estiver obtendo 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 separá-lo, basta aplicar o código mostrado anteriormente.

4
rjzii

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

Por exemplo, a frase: "hello world. Olá, este é o mundo do stackoverflow". será "Hello World. Olá, este é o mundo do Stackoverflow." Regex\b (início de uma palavra)\w (primeiro caracterizador da palavra) fará o truque.

/// <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;
}
3
Ton Snoei

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

retorna ~ meu nome

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

3
David C

Esta classe faz o truque. Você pode adicionar novos prefixos à matriz de cadeia estática _ prefixos.

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

As sugestões para usar o ToTitleCase não funcionarão para sequências todas em maiúsculas. Então você vai ter que chamar ToUpper no primeiro char e ToLower nos personagens restantes.

2
Tundey

Se você estiver usando o vS2k8, poderá usar um método de extensão para incluí-lo na classe String:

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

Para contornar alguns dos problemas/problemas que foram destacados eu sugiro converter a string para minúsculas primeiro 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);
}
0
Andy Rose
 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;

        }
0
Govind Singh Rawat

Eu gosto desse jeito:

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 do MSDN .

0
TrentVB

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