Konvertieren einer Zeichenfolge in Groß- und Kleinschreibung

Ich habe eine Zeichenfolge, die Wörter in einer Mischung aus Groß- und Kleinbuchstaben enthält.

Zum Beispiel: string myData = "a Simple string";

Ich muss das erste Zeichen jedes Wortes (durch Leerzeichen getrennt) in Großbuchstaben umwandeln. Also möchte ich das Ergebnis wie folgt:string myData ="A Simple String";

Gibt es eine einfache Möglichkeit, dies zu tun? Ich möchte den String nicht teilen und die Konvertierung durchführen (das wird mein letzter Ausweg sein). Es ist auch garantiert, dass die Zeichenfolgen in Englisch sind.

MSDN: TextInfo.ToTitleCase

Stellen Sie sicher, dass Sie Folgendes angeben: using System.Globalization

string title = "war and peace";

TextInfo textInfo = new CultureInfo("en-US", false).TextInfo;

title = textInfo.ToTitleCase(title); 
Console.WriteLine(title) ; //War And Peace

//When text is ALL UPPERCASE...
title = "WAR AND PEACE" ;

title = textInfo.ToTitleCase(title); 
Console.WriteLine(title) ; //WAR AND PEACE

//You need to call ToLower to make it work
title = textInfo.ToTitleCase(title.ToLower()); 
Console.WriteLine(title) ; //War And Peace

Versuche dies:

string myText = "a Simple string";

string asTitleCase =
    System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.
    ToTitleCase(myText.ToLower());

Wie bereits erwähnt, liefert die Verwendung von TextInfo.ToTitleCase möglicherweise nicht genau die gewünschten Ergebnisse. Wenn Sie mehr Kontrolle über die Ausgabe benötigen, können Sie Folgendes tun:

IEnumerable<char> CharsToTitleCase(string s)
{
    bool newWord = true;
    foreach(char c in s)
    {
        if(newWord) { yield return Char.ToUpper(c); newWord = false; }
        else yield return Char.ToLower(c);
        if(c==' ') newWord = true;
    }
}

Und dann benutze es so:

var asTitleCase = new string( CharsToTitleCase(myText).ToArray() );

Noch eine Variation. Basierend auf mehreren Tipps hier habe ich es auf diese Erweiterungsmethode reduziert, die für meine Zwecke hervorragend funktioniert:

public static string ToTitleCase(this string s) =>
    CultureInfo.InvariantCulture.TextInfo.ToTitleCase(s.ToLower());

Persönlich habe ich die TextInfo.ToTitleCaseMethode ausprobiert , aber ich verstehe nicht, warum sie nicht funktioniert, wenn alle Zeichen in Großbuchstaben geschrieben sind.

Obwohl mir die von Winston Smith bereitgestellte util-Funktion gefällt, möchte ich die Funktion bereitstellen, die ich derzeit verwende:

public static String TitleCaseString(String s)
{
    if (s == null) return s;

    String[] words = s.Split(' ');
    for (int i = 0; i < words.Length; i++)
    {
        if (words[i].Length == 0) continue;

        Char firstChar = Char.ToUpper(words[i][0]); 
        String rest = "";
        if (words[i].Length > 1)
        {
            rest = words[i].Substring(1).ToLower();
        }
        words[i] = firstChar + rest;
    }
    return String.Join(" ", words);
}

Das Spiel mit einigen Tests Strings:

String ts1 = "Converting string to title case in C#";
String ts2 = "C";
String ts3 = "";
String ts4 = "   ";
String ts5 = null;

Console.Out.WriteLine(String.Format("|{0}|", TitleCaseString(ts1)));
Console.Out.WriteLine(String.Format("|{0}|", TitleCaseString(ts2)));
Console.Out.WriteLine(String.Format("|{0}|", TitleCaseString(ts3)));
Console.Out.WriteLine(String.Format("|{0}|", TitleCaseString(ts4)));
Console.Out.WriteLine(String.Format("|{0}|", TitleCaseString(ts5)));

Geben Ausgabe :

|Converting String To Title Case In C#|
|C|
||
|   |
||

Kürzlich habe ich eine bessere Lösung gefunden.

Wenn Ihr Text jeden Buchstaben in Großbuchstaben enthält, konvertiert TextInfo ihn nicht in die richtige Groß- und Kleinschreibung. Wir können das beheben, indem wir die darin enthaltene Kleinbuchstabenfunktion folgendermaßen verwenden:

public static string ConvertTo_ProperCase(string text)
{
    TextInfo myTI = new CultureInfo("en-US", false).TextInfo;
    return myTI.ToTitleCase(text.ToLower());
}

Dies konvertiert nun alles, was in Propercase eingeht.

public static string PropCase(string strText)
{
    return new CultureInfo("en").TextInfo.ToTitleCase(strText.ToLower());
}

Wenn jemand an der Lösung für Compact Framework interessiert ist:

return String.Join(" ", thestring.Split(' ').Select(i => i.Substring(0, 1).ToUpper() + i.Substring(1).ToLower()).ToArray());

Hier ist die Lösung für dieses Problem ...

CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture;
TextInfo textInfo = cultureInfo.TextInfo;
string txt = textInfo.ToTitleCase(txt);

Verwenden Sie ToLower()zuerst als CultureInfo.CurrentCulture.TextInfo.ToTitleCasefür das Ergebnis, um die richtige Ausgabe zu erhalten.

    //---------------------------------------------------------------
    // Get title case of a string (every word with leading upper case,
    //                             the rest is lower case)
    //    i.e: ABCD EFG -> Abcd Efg,
    //         john doe -> John Doe,
    //         miXEd CaSING - > Mixed Casing
    //---------------------------------------------------------------
    public static string ToTitleCase(string str)
    {
        return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str.ToLower());
    }

Ich brauchte einen Weg, um mit allen Großbuchstaben umzugehen, und ich mochte die Lösung von Ricky AH, aber ich ging noch einen Schritt weiter, um sie als Erweiterungsmethode zu implementieren. Dies vermeidet den Schritt, dass Sie Ihr Zeichenarray erstellen und dann jedes Mal explizit ToArray darauf aufrufen müssen. Sie können es also einfach in der Zeichenfolge aufrufen, wie folgt:

Verwendung:

string newString = oldString.ToProper();

Code:

public static class StringExtensions
{
    public static string ToProper(this string s)
    {
        return new string(s.CharsToTitleCase().ToArray());
    }

    public static IEnumerable<char> CharsToTitleCase(this string s)
    {
        bool newWord = true;
        foreach (char c in s)
        {
            if (newWord) { yield return Char.ToUpper(c); newWord = false; }
            else yield return Char.ToLower(c);
            if (c == ' ') newWord = true;
        }
    }

}

Es ist besser zu verstehen, indem Sie Ihren eigenen Code ausprobieren ...

Weiterlesen

http://www.stupidcodes.com/2014/04/convert-string-to-uppercase-proper-case.html

1) Konvertieren Sie einen String in Großbuchstaben

string lower = "converted from lowercase";
Console.WriteLine(lower.ToUpper());

2) Konvertieren Sie eine Zeichenfolge in Kleinbuchstaben

string upper = "CONVERTED FROM UPPERCASE";
Console.WriteLine(upper.ToLower());

3) Konvertieren Sie einen String in TitleCase

    CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture;
    TextInfo textInfo = cultureInfo.TextInfo;
    string txt = textInfo.ToTitleCase(TextBox1.Text());

Hier ist eine Implementierung, Zeichen für Zeichen. Sollte mit "(One Two Three)" funktionieren

public static string ToInitcap(this string str)
{
    if (string.IsNullOrEmpty(str))
        return str;
    char[] charArray = new char[str.Length];
    bool newWord = true;
    for (int i = 0; i < str.Length; ++i)
    {
        Char currentChar = str[i];
        if (Char.IsLetter(currentChar))
        {
            if (newWord)
            {
                newWord = false;
                currentChar = Char.ToUpper(currentChar);
            }
            else
            {
                currentChar = Char.ToLower(currentChar);
            }
        }
        else if (Char.IsWhiteSpace(currentChar))
        {
            newWord = true;
        }
        charArray[i] = currentChar;
    }
    return new string(charArray);
}

String TitleCaseString(String s)
{
    if (s == null || s.Length == 0) return s;

    string[] splits = s.Split(' ');

    for (int i = 0; i < splits.Length; i++)
    {
        switch (splits[i].Length)
        {
            case 1:
                break;

            default:
                splits[i] = Char.ToUpper(splits[i][0]) + splits[i].Substring(1);
                break;
        }
    }

    return String.Join(" ", splits);
}

Mit dieser einfachen Methode können Sie Text oder Zeichenfolge direkt in die richtige ändern, nachdem Sie nach null oder leeren Zeichenfolgenwerten gesucht haben, um Fehler zu vermeiden:

public string textToProper(string text)
{
    string ProperText = string.Empty;
    if (!string.IsNullOrEmpty(text))
    {
        ProperText = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text);
    }
    else
    {
        ProperText = string.Empty;
    }
    return ProperText;
}

Versuche dies:

using System.Globalization;
using System.Threading;
public void ToTitleCase(TextBox TextBoxName)
        {
            int TextLength = TextBoxName.Text.Length;
            if (TextLength == 1)
            {
                CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture;
                TextInfo textInfo = cultureInfo.TextInfo;
                TextBoxName.Text = textInfo.ToTitleCase(TextBoxName.Text);
                TextBoxName.SelectionStart = 1;
            }
            else if (TextLength > 1 && TextBoxName.SelectionStart < TextLength)
            {
                int x = TextBoxName.SelectionStart;
                CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture;
                TextInfo textInfo = cultureInfo.TextInfo;
                TextBoxName.Text = textInfo.ToTitleCase(TextBoxName.Text);
                TextBoxName.SelectionStart = x;
            }
            else if (TextLength > 1 && TextBoxName.SelectionStart >= TextLength)
            {
                CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture;
                TextInfo textInfo = cultureInfo.TextInfo;
                TextBoxName.Text = textInfo.ToTitleCase(TextBoxName.Text);
                TextBoxName.SelectionStart = TextLength;
            }
        }

Rufen Sie diese Methode im TextChanged-Ereignis der TextBox auf.

Ich habe die obigen Referenzen verwendet und die vollständige Lösung lautet: -

Use Namespace System.Globalization;
string str="INFOA2Z means all information";

// Benötige ein Ergebnis wie "Infoa2z bedeutet alle Informationen"
// Wir müssen den String auch in Kleinbuchstaben konvertieren, sonst funktioniert er nicht richtig.

TextInfo ProperCase= new CultureInfo("en-US", false).TextInfo;

str= ProperCase.ToTitleCase(str.toLower());

http://www.infoa2z.com/asp.net/change-string-to-proper-case-in-an-asp.net-using-c#

Dies ist, was ich benutze und es funktioniert in den meisten Fällen, es sei denn, der Benutzer beschließt, es durch Drücken von Shift oder Feststelltaste zu überschreiben. Wie auf Android- und iOS-Tastaturen.

Private Class ProperCaseHandler
    Private Const wordbreak As String = " ,.1234567890;/\-()#$%^&*€!~+=@"
    Private txtProperCase As TextBox

    Sub New(txt As TextBox)
        txtProperCase = txt
        AddHandler txt.KeyPress, AddressOf txtTextKeyDownProperCase
    End Sub

    Private Sub txtTextKeyDownProperCase(ByVal sender As System.Object, ByVal e As Windows.Forms.KeyPressEventArgs)
        Try
            If Control.IsKeyLocked(Keys.CapsLock) Or Control.ModifierKeys = Keys.Shift Then
                Exit Sub
            Else
                If txtProperCase.TextLength = 0 Then
                    e.KeyChar = e.KeyChar.ToString.ToUpper()
                    e.Handled = False
                Else
                    Dim lastChar As String = txtProperCase.Text.Substring(txtProperCase.SelectionStart - 1, 1)

                    If wordbreak.Contains(lastChar) = True Then
                        e.KeyChar = e.KeyChar.ToString.ToUpper()
                        e.Handled = False
                    End If
                End If

            End If

        Catch ex As Exception
            Exit Sub
        End Try
    End Sub
End Class

Für diejenigen, die es automatisch per Tastendruck tun möchten, habe ich es mit folgendem Code in vb.net auf einem benutzerdefinierten Textfeld-Steuerelement gemacht - Sie können es natürlich auch mit einem normalen Textfeld tun -, aber ich mag die Möglichkeit, wiederkehrenden Code für bestimmte Steuerelemente hinzuzufügen Über benutzerdefinierte Steuerelemente passt es zum Konzept von OOP.

Imports System.Windows.Forms
Imports System.Drawing
Imports System.ComponentModel

Public Class MyTextBox
    Inherits System.Windows.Forms.TextBox
    Private LastKeyIsNotAlpha As Boolean = True
    Protected Overrides Sub OnKeyPress(e As KeyPressEventArgs)
        If _ProperCasing Then
            Dim c As Char = e.KeyChar
            If Char.IsLetter(c) Then
                If LastKeyIsNotAlpha Then
                    e.KeyChar = Char.ToUpper(c)
                    LastKeyIsNotAlpha = False
                End If
            Else
                LastKeyIsNotAlpha = True
            End If
        End If
        MyBase.OnKeyPress(e)
End Sub
    Private _ProperCasing As Boolean = False
    <Category("Behavior"), Description("When Enabled ensures for automatic proper casing of string"), Browsable(True)>
    Public Property ProperCasing As Boolean
        Get
            Return _ProperCasing
        End Get
        Set(value As Boolean)
            _ProperCasing = value
        End Set
    End Property
End Class

Funktioniert auch mit Kamelhülle: 'someText in YourPage'

public static class StringExtensions
{
    /// <summary>
    /// Title case example: 'Some Text In Your Page'.
    /// </summary>
    /// <param name="text">Support camel and title cases combinations: 'someText in YourPage'</param>
    public static string ToTitleCase(this string text)
    {
        if (string.IsNullOrEmpty(text))
        {
            return text;
        }
        var result = string.Empty;
        var splitedBySpace = text.Split(new[]{ ' ' }, StringSplitOptions.RemoveEmptyEntries);
        foreach (var sequence in splitedBySpace)
        {
            // let's check the letters. Sequence can contain even 2 words in camel case
            for (var i = 0; i < sequence.Length; i++)
            {
                var letter = sequence[i].ToString();
                // if the letter is Big or it was spaced so this is a start of another word
                if (letter == letter.ToUpper() || i == 0)
                {
                    // add a space between words
                    result += ' ';
                }
                result += i == 0 ? letter.ToUpper() : letter;
            }
        }            
        return result.Trim();
    }
}

Als Erweiterungsmethode:

/// <summary>
//     Returns a copy of this string converted to `Title Case`.
/// </summary>
/// <param name="value">The string to convert.</param>
/// <returns>The `Title Case` equivalent of the current string.</returns>
public static string ToTitleCase(this string value)
{
    string result = string.Empty;

    for (int i = 0; i < value.Length; i++)
    {
        char p = i == 0 ? char.MinValue : value[i - 1];
        char c = value[i];

        result += char.IsLetter(c) && ((p is ' ') || p is char.MinValue) ? $"{char.ToUpper(c)}" : $"{char.ToLower(c)}";
    }

    return result;
}

Verwendungszweck:

"kebab is DELICIOU's   ;d  c...".ToTitleCase();

Ergebnis:

Kebab Is Deliciou's ;d C...

Alternative in Bezug auf Microsoft.VisualBasic(behandelt auch Großbuchstaben):

string properCase = Strings.StrConv(str, VbStrConv.ProperCase);

Ohne zu verwenden TextInfo:

public static string TitleCase(this string text, char seperator = ' ') =>
  string.Join(seperator, text.Split(seperator).Select(word => new string(
    word.Select((letter, i) => i == 0 ? char.ToUpper(letter) : char.ToLower(letter)).ToArray())));

Es durchläuft jeden Buchstaben in jedem Wort und wandelt ihn in Großbuchstaben um, wenn es der erste Buchstabe ist, andernfalls wird er in Kleinbuchstaben umgewandelt.

Ich weiß, dass dies eine alte Frage ist, aber ich habe nach dem gleichen Thema für C gesucht und es herausgefunden, also dachte ich, ich würde es posten, wenn jemand anderes nach einem Weg in C sucht:

char proper(char string[]){  

int i = 0;

for(i=0; i<=25; i++)
{
    string[i] = tolower(string[i]);  //converts all character to lower case
    if(string[i-1] == ' ') //if character before is a space 
    {
        string[i] = toupper(string[i]); //converts characters after spaces to upper case
    }

}
    string[0] = toupper(string[0]); //converts first character to upper case


    return 0;
}