Convertissez toutes les premières lettres en majuscules, restez en bas pour chaque mot

J'ai une chaîne de texte (environ 5 à 6 mots principalement) que je dois convertir.

Actuellement, le texte ressemble à:

THIS IS MY TEXT RIGHT NOW

Je veux le convertir en:

This Is My Text Right Now

Je peux parcourir ma collection de chaînes, mais je ne sais pas comment procéder pour effectuer cette modification de texte.

string s = "THIS IS MY TEXT RIGHT NOW";

s = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(s.ToLower());

Je préfère probablement appeler le ToTitleCase de CultureInfo ( System.Globalization ) que Thread.CurrentThread ( System.Threading )

string s = "THIS IS MY TEXT RIGHT NOW";
s = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(s.ToLower());

mais cela devrait être la même chose que la solution jspcal

ÉDITER

En fait, ces solutions ne sont pas les mêmes : CurrentThread--calls -> CultureInfo!

System.Threading.Thread.CurrentThread.CurrentCulture

string s = "THIS IS MY TEXT RIGHT NOW";
s = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(s.ToLower());

IL_0000:  ldstr       "THIS IS MY TEXT RIGHT NOW"
IL_0005:  stloc.0     // s
IL_0006:  call        System.Threading.Thread.get_CurrentThread
IL_000B:  callvirt    System.Threading.Thread.get_CurrentCulture
IL_0010:  callvirt    System.Globalization.CultureInfo.get_TextInfo
IL_0015:  ldloc.0     // s
IL_0016:  callvirt    System.String.ToLower
IL_001B:  callvirt    System.Globalization.TextInfo.ToTitleCase
IL_0020:  stloc.0     // s

System.Globalization.CultureInfo.CurrentCulture

string s = "THIS IS MY TEXT RIGHT NOW";
s = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(s.ToLower());

IL_0000:  ldstr       "THIS IS MY TEXT RIGHT NOW"
IL_0005:  stloc.0     // s
IL_0006:  call        System.Globalization.CultureInfo.get_CurrentCulture
IL_000B:  callvirt    System.Globalization.CultureInfo.get_TextInfo
IL_0010:  ldloc.0     // s
IL_0011:  callvirt    System.String.ToLower
IL_0016:  callvirt    System.Globalization.TextInfo.ToTitleCase
IL_001B:  stloc.0     // s

Références:

• http://msdn.microsoft.com/library/kx54z3k7(v=VS.80).aspx
• http://msdn.microsoft.com/library/66w76es3(v=VS.80).aspx

Il existe plusieurs façons de convertir le premier caractère d'une chaîne en majuscules.

La première méthode consiste à créer une méthode qui met simplement le premier caractère en majuscule et ajoute le reste de la chaîne à l'aide d'une sous-chaîne:

public string UppercaseFirst(string s)
    {
        return char.ToUpper(s[0]) + s.Substring(1);
    }

La deuxième méthode (qui est légèrement plus rapide) consiste à diviser la chaîne en un tableau de caractères, puis à reconstruire la chaîne:

public string UppercaseFirst(string s)
    {
        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
    }

Non testé mais quelque chose comme ça devrait fonctionner:

var phrase = "THIS IS MY TEXT RIGHT NOW";
var rx = new System.Text.RegularExpressions.Regex(@"(?<=\w)\w");
var newString = rx.Replace(phrase,new MatchEvaluator(m=>m.Value.ToLowerInvariant()));

Essentiellement, il dit "préformer une correspondance regex sur toutes les occurrences d'un caractère alphanumérique qui suit un autre caractère alphanumérique, puis le remplacer par une version minuscule de lui-même"

Si vous utilisez sur une page Web, vous pouvez également utiliser CSS:

style="text-transform:capitalize;"

Lorsque la construction de grandes tables est un problème, la deuxième fonction de Jamie Dixon est la meilleure, mais elle ne fonctionne pas complètement telle quelle ...

Il ne parvient pas à mettre toutes les lettres en minuscules et ne met en majuscule que la première lettre de la chaîne, pas la première lettre de chaque mot de la chaîne ... l'option ci-dessous résout les deux problèmes:

    public string UppercaseFirstEach(string s)
    {
        char[] a = s.ToLower().ToCharArray();

        for (int i = 0; i < a.Count(); i++ )
        {
            a[i] = i == 0 || a[i-1] == ' ' ? char.ToUpper(a[i]) : a[i];

        }

        return new string(a);
    }

Bien qu'à ce stade, il n'est pas certain que ce soit toujours l'option la plus rapide, la Regexsolution fournie par George Mauer pourrait être plus rapide ... quelqu'un qui s'en soucie suffisamment devrait la tester.

Je ne sais pas si la solution ci-dessous est plus ou moins efficace que la réponse de jspcal, mais je suis presque sûr qu'elle nécessite moins de création d'objet que celle de Jamie et George.

string s = "THIS IS MY TEXT RIGHT NOW";
StringBuilder sb = new StringBuilder(s.Length);
bool capitalize = true;
foreach (char c in s) {
    sb.Append(capitalize ? Char.ToUpper(c) : Char.ToLower(c));
    capitalize = !Char.IsLetter(c);
}
return sb.ToString();

En plus de la première réponse, n'oubliez pas de modifier l'index de démarrage de la sélection de chaîne à la fin du mot ou vous obtiendrez l'ordre inverse des lettres dans la chaîne.

s.SelectionStart=s.Length;

Essayez cette technique; Il renvoie le résultat souhaité

CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str.ToLower());

Et n'oubliez pas de l'utiliser System.Globalization.

Une des solutions possibles qui pourrait vous intéresser. Traverser un tableau de caractères de droite à gauche et vice versa dans une boucle.

public static string WordsToCapitalLetter(string value)
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            throw new ArgumentException("value");
        }

        int inputValueCharLength = value.Length;
        var valueAsCharArray = value.ToCharArray();

        int min = 0;
        int max = inputValueCharLength - 1;

        while (max > min)
        {
            char left = value[min];
            char previousLeft = (min == 0) ? left : value[min - 1];

            char right = value[max];
            char nextRight = (max == inputValueCharLength - 1) ? right : value[max - 1];

            if (char.IsLetter(left) && !char.IsUpper(left) && char.IsWhiteSpace(previousLeft))
            {
                valueAsCharArray[min] = char.ToUpper(left);
            }

            if (char.IsLetter(right) && !char.IsUpper(right) && char.IsWhiteSpace(nextRight))
            {
                valueAsCharArray[max] = char.ToUpper(right);
            }

            min++;
            max--;
        }

        return new string(valueAsCharArray);
    }

réponse de jspcal comme extension de chaîne.

Program.cs

class Program
{
    static void Main(string[] args)
    {
        var myText = "MYTEXT";
        Console.WriteLine(myText.ToTitleCase()); //Mytext
    }
}

StringExtensions.cs

using System;
public static class StringExtensions
{

    public static string ToTitleCase(this string str)
    {
        if (str == null)
            return null;

        return System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(str.ToLower());
    }
}