Konvertieren Sie alle Anfangsbuchstaben in Großbuchstaben und ruhen Sie für jedes Wort in Kleinbuchstaben

Ich habe eine Textfolge (meistens ca. 5-6 Wörter), die ich konvertieren muss.

Derzeit sieht der Text so aus:

THIS IS MY TEXT RIGHT NOW

Ich möchte es konvertieren in:

This Is My Text Right Now

Ich kann meine Sammlung von Zeichenfolgen durchlaufen, bin mir aber nicht sicher, wie ich diese Textänderung durchführen soll.

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

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

Ich ziehe es wahrscheinlich vor, ToTitleCase von CultureInfo ( System.Globalization ) aus aufzurufen als Thread.CurrentThread ( System.Threading )

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

aber es sollte das gleiche sein wie jspcal Lösung

BEARBEITEN

Eigentlich sind diese Lösungen nicht die gleichen : 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

Verweise:

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

Es gibt verschiedene Möglichkeiten, das erste Zeichen eines Strings in Großbuchstaben umzuwandeln.

Die erste Möglichkeit besteht darin, eine Methode zu erstellen, die einfach das erste Zeichen begrenzt und den Rest der Zeichenfolge mithilfe eines Teilstrings anfügt:

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

Die zweite Möglichkeit (die etwas schneller ist) besteht darin, die Zeichenfolge in ein char-Array aufzuteilen und die Zeichenfolge dann neu zu erstellen:

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

Ungetestet, aber so etwas sollte funktionieren:

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

Im Wesentlichen heißt es: "Führen Sie eine Regex-Übereinstimmung für alle Vorkommen eines alphanumerischen Zeichens durch, das auf ein anderes alphanumerisches Zeichen folgt, und ersetzen Sie es dann durch eine Kleinbuchstabenversion von sich selbst."

Wenn Sie auf einer Webseite verwenden, können Sie auch CSS verwenden:

style="text-transform:capitalize;"

Beim Erstellen großer Tische ist Geschwindigkeit ein Problem, daher ist Jamie Dixons zweite Funktion am besten, aber sie funktioniert nicht vollständig wie sie ist ...

Es werden nicht alle Buchstaben in Kleinbuchstaben geschrieben, und es wird nur der erste Buchstabe der Zeichenfolge großgeschrieben, nicht der erste Buchstabe jedes Wortes in der Zeichenfolge. Die folgende Option behebt beide Probleme:

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

Obwohl zu diesem Zeitpunkt ungewiss ist, ob dies immer noch die schnellste Option ist, könnte die Regexvon George Mauer bereitgestellte Lösung schneller sein ... jemand, der sich genug darum kümmert, sollte sie testen.

Ich weiß nicht, ob die unten stehende Lösung mehr oder weniger effizient ist als die Antwort von jspcal, aber ich bin mir ziemlich sicher, dass sie weniger Objekterstellung erfordert als die von Jamie und 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();

Denken Sie zusätzlich zur ersten Antwort daran, den Startindex für die Zeichenfolgenauswahl an das Ende des Wortes zu ändern. Andernfalls wird die Reihenfolge der Buchstaben in der Zeichenfolge in umgekehrter Reihenfolge angezeigt.

s.SelectionStart=s.Length;

Versuchen Sie diese Technik; Es gibt das gewünschte Ergebnis zurück

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

Und vergessen Sie nicht zu verwenden System.Globalization.

Eine der möglichen Lösungen, an denen Sie interessiert sein könnten. Durchlaufen einer Reihe von Zeichen von rechts nach links und umgekehrt in einer Schleife.

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

Die Antwort von jspcal als String-Erweiterung.

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