Comment capitaliser la première lettre du nom et de prénom en C#?
Est-il un moyen facile de mettre en majuscule la première lettre d'une chaîne et d'abaisser le reste? Y a-t-il une méthode intégrée ou dois-je faire la mienne?
17 réponses
TextInfo.ToTitleCase() capitalise le premier caractère dans chaque jeton d'une chaîne.
S'il n'est pas nécessaire de maintenir L'Majuscule des acronymes, vous devez inclure ToLower() .
string s = "JOHN DOE";
s = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(s.ToLower());
// Produces "John Doe"
si la culture actuelle n'est pas disponible, utiliser:
string s = "JOHN DOE";
s = new System.Globalization.CultureInfo("en-US", false).TextInfo.ToTitleCase(s.ToLower());
voir la 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 .....
donc mettez le code ci-dessous par convert en bas puis appliquer la fonction
String test = "HELLO HOW ARE YOU";
string s = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(test.ToLower());
il y a des cas que CultureInfo.CurrentCulture.TextInfo.ToTitleCase ne peut pas traiter, par exemple : l'apostrophe ' .
string input = CultureInfo.CurrentCulture.TextInfo.ToTitleCase("o'reilly, m'grego, d'angelo");
// input = O'reilly, M'grego, D'angelo
A regex peut également être utilisé \b[a-zA-Z] pour identifier le caractère de départ d'un mot après une limite de mot \b , alors nous avons juste besoin de remplacer le match par son équivalent en majuscules grâce à la Regex.Replace(string input,string pattern,MatchEvaluator evaluator) 1519240920" 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 accordé si nécessaire, par exemple, si nous voulons Gérer les cas MacDonald et 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 manipuler plus de préfixes , nous n'avons qu'à modifier le groupe (?:mc|mac) , par exemple pour ajouter les préfixes Français du, de : (?:mc|mac|du|de) .
enfin, nous pouvons nous rendre compte que ce regex va également correspondre au cas MacDonald'S pour le dernier 's nous avons donc besoin de le gérer dans le regex avec un négatif regarder 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 communs aux États-Unis, et il y en a d'autres. TextInfo.ToTitleCase ne gère pas ces cas et ne devrait pas être utilisé à cette fin. Voici comment je le 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;
}
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 GDE a souligné qu'il y a certains noms pour lesquels cela ne fonctionnera pas, mais ceux-ci sont assez rares donc à moins que vous cibliez une culture où de tels noms sont communs, il n'est pas nécessaire quelque chose que vous devez vous inquiéter trop.
cependant si vous n'êtes pas en travaillant avec un langauge.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 de famille, alors vous pouvez simplement capitaliser la première lettre en dessous du reste en utilisant des substrats.
firstName = firstName.Substring(0, 1).ToUpper() + firstName.Substring(1).ToLower();
lastName = lastName.Substring(0, 1).ToUpper() + lastName.Substring(1).ToLower();
cependant, si vous avez plusieurs noms dans la même chaîne de caractères, vous devez savoir comment vous obtenez l'information et la diviser en conséquence. Si vous obtenez un nom comme "John Doe" vous avez une scission de la chaîne basée sur le caractère espace. S'il est dans un format tel que "Doe, John" vous allez avoir besoin de le diviser sur la base de la virgule. Cependant, une fois que vous l'avez divisé, vous n'avez qu'à appliquer le code indiqué précédemment.
CultureInfo.CurrentCulture.TextInfo.ToTitleCase ("mon nom");
retourne ~ 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 obtenir ce fixe:
par exemple la phrase:" hello world. bonjour c'est la stackoverflow monde."Bonjour tout le Monde. Bonjour C'Est La Stackoverflow Monde.". 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 pour utiliser ToTitleCase ne fonctionneront pas pour les chaînes qui sont toutes en majuscules. Donc vous allez devoir appeler ToUpper sur le premier char et ToLower sur les personnages restants.
cette classe fait l'affaire. Vous pouvez ajouter de nouveaux préfixes au tableau de chaînes de caractères 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 quelques-uns des problèmes que ben a mis en évidence, je suggère de convertir la chaîne en minuscules d'abord, puis d'appeler la méthode ToTitleCase. Vous pouvez alors 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());
supprimé de cet article MSDN .
J'espère que cela vous aidera.
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 GDE indiqué, vous aurez besoin d'un algorithme plus complexe pour traiter les noms spéciaux (c'est probablement pourquoi de nombreux endroits forcent tout à la majuscule).
quelque chose comme CE c non testé devrait traiter le cas simple que vous avez demandé:
public string SentenceCase(string input)
{
return input(0, 1).ToUpper + input.Substring(1).ToLower;
}