Comment mettre en majuscule la première lettre du prénom et du nom en C #?

Existe-t-il un moyen simple de mettre en majuscule la première lettre d'une chaîne et de réduire le reste? Existe-t-il une méthode intégrée ou dois-je créer la mienne?

TextInfo.ToTitleCase()met en majuscule le premier caractère de chaque jeton d'une chaîne.
S'il n'est pas nécessaire de conserver l'acronyme en majuscules, vous devez inclure ToLower().

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

Si CurrentCulture n'est pas disponible, utilisez:

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

Voir le lien MSDN pour une description détaillée.

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

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

Le code ci-dessus ne fonctionnera pas .....

alors mettez le code ci-dessous en convertissant en bas puis appliquez la fonction

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

Certains cas CultureInfo.CurrentCulture.TextInfo.ToTitleCasene peuvent pas gérer, par exemple: l'apostrophe '.

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

Une regex peut également être utilisée \b[a-zA-Z]pour identifier le caractère de départ d'un mot après une limite de mot \b, il suffit alors de remplacer la correspondance par son équivalence en majuscules grâce à la Regex.Replace(string input,string pattern,MatchEvaluator evaluator)méthode:

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

Le regex peut être ajusté si nécessaire, par exemple, si nous voulons gérer les cas MacDonaldet McFry, le regex devient:(?<=\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 nous devons gérer plusieurs préfixes nous ne devons modifier le groupe (?:mc|mac), par exemple pour ajouter des préfixes français du, de: (?:mc|mac|du|de).

Enfin, nous pouvons réaliser que cette expression régulière correspondra également à la casse MacDonald'Sde la dernière 's, nous devons donc la gérer dans l' expression régulière avec un regard négatif derrière (?<!'s\b). À la fin, nous avons:

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 et Mac sont des préfixes de nom de famille courants aux États-Unis, et il y en a d'autres. TextInfo.ToTitleCase ne gère pas ces cas et ne doit pas être utilisé à cette fin. Voici comment je fais:

    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 () devrait fonctionner pour vous.

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

L'option la plus directe sera d'utiliser la fonction ToTitleCase qui est disponible dans .NET qui devrait prendre soin du nom la plupart du temps. Comme edg l'a souligné, il y a certains noms pour lesquels cela ne fonctionnera pas, mais ils sont assez rares, donc à moins que vous ne cibliez une culture où de tels noms sont courants, il n'est pas nécessaire de vous inquiéter trop.

Cependant, si vous ne travaillez pas avec une langue .NET, cela dépend de ce à quoi ressemble l'entrée - si vous avez deux champs séparés pour le prénom et le nom, vous pouvez simplement mettre en majuscule la première lettre en bas du reste en utilisant sous-chaînes.

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

Cependant, si plusieurs noms vous sont fournis dans la même chaîne, vous devez savoir comment vous obtenez les informations et les diviser en conséquence. Donc, si vous obtenez un nom comme "John Doe", vous divisez la chaîne en fonction du caractère d'espace. S'il est dans un format tel que "Doe, John", vous devrez le diviser en fonction de la virgule. Cependant, une fois que vous l'avez séparé, appliquez simplement le code indiqué précédemment.

CultureInfo.CurrentCulture.TextInfo.ToTitleCase ("mon nom");

renvoie ~ Mon nom

Mais le problème existe toujours avec des noms comme McFly comme indiqué précédemment.

J'utilise ma propre méthode pour résoudre ce problème:

Par exemple, la phrase: "bonjour le monde. Bonjour c'est le monde stackoverflow." sera "Hello World. Hello This Is The Stackoverflow World.". Regex \ b (début d'un mot) \ w (premier caractère du mot) fera l'affaire.

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

Les suggestions d'utilisation de ToTitleCase ne fonctionneront pas pour les chaînes qui sont toutes en majuscules. Vous devrez donc appeler ToUpper sur le premier caractère et ToLower sur les caractères restants.

Cette classe fait l'affaire. Vous pouvez ajouter de nouveaux préfixes au tableau de chaînes statiques _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 vous utilisez vS2k8, vous pouvez utiliser une méthode d'extension pour l'ajouter à la classe String:

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

Pour contourner certains des problèmes / problèmes qui ont été mis en évidence, je suggérerais de convertir d'abord la chaîne en minuscules, puis d'appeler la méthode ToTitleCase. Vous pouvez ensuite utiliser IndexOf ("Mc") ou IndexOf ("O \ '") pour déterminer les cas spéciaux qui nécessitent une attention plus spécifique.

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

J'aime cette façon:

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

Tiré de cet article MSDN .

J'espère que cela vous aide.

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;

        }

Comme indiqué par edg, vous aurez besoin d'un algorithme plus complexe pour gérer les noms spéciaux (c'est probablement pourquoi de nombreux endroits forcent tout en majuscules).

Quelque chose comme ce c # non testé devrait gérer le cas simple que vous avez demandé:

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