it-swarm-eu.dev

Wie kann ich den ersten Buchstaben des Vor- und Nachnamens in C # groß schreiben?

Gibt es eine einfache Möglichkeit, den ersten Buchstaben einer Zeichenfolge in Großbuchstaben zu schreiben und den Rest abzusenken? Gibt es eine eingebaute Methode oder muss ich meine eigene erstellen?

139
Mike Roosa

TextInfo.ToTitleCase() aktiviert das erste Zeichen in jedem Token einer Zeichenfolge.
Wenn keine Akronym-Großbuchstaben erforderlich sind, sollten Sie ToLower() einschließen.

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

Wenn CurrentCulture nicht verfügbar ist, verwenden Sie:

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

Siehe MSDN Link für eine detaillierte Beschreibung.

257
ageektrapped
CultureInfo.CurrentCulture.TextInfo.ToTitleCase("hello world");
118
Nathan Baulch
String test = "HELLO HOW ARE YOU";
string s = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(test);

Der obige Code funktioniert nicht .....

setzen Sie den folgenden Code durch Konvertieren in einen niedrigeren Code und wenden Sie dann die Funktion an

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

Es gibt einige Fälle, die CultureInfo.CurrentCulture.TextInfo.ToTitleCase Nicht verarbeiten kann, z. B. das Apostroph '.

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

Ein Regex kann auch verwendet werden \b[a-zA-Z], Um das Startzeichen eines Wortes nach einer Wortgrenze \b Zu identifizieren Wir müssen nur die Übereinstimmung durch ihre Äquivalenz in Großbuchstaben ersetzen, dank der Regex.Replace(string input,string pattern,MatchEvaluator evaluator) -Methode:

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

Die Regex kann bei Bedarf angepasst werden, wenn wir beispielsweise die Fälle MacDonald und McFry behandeln möchten Regex wird zu: (?<=\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

Wenn wir mehr Präfixe verarbeiten müssen, müssen wir nur die Gruppe (?:mc|mac) Ändern, um beispielsweise französische Präfixe du, de Hinzuzufügen: (?:mc|mac|du|de).

Schließlich können wir feststellen, dass dieser reguläre Ausdruck auch mit dem Fall MacDonald'S Für den letzten 's Übereinstimmt, also müssen wir Behandle es in der Regex mit einem negativen Blick hinter (?<!'s\b). Am Ende haben wir:

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
14
polkduran

Mc und Mac sind in den USA gemeinsame Nachnamenpräfixe, und es gibt andere. TextInfo.ToTitleCase behandelt diese Fälle nicht und sollte für diesen Zweck nicht verwendet werden. So mache ich es:

    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;
    }
7
Jamie Ide

ToTitleCase () sollte für Sie funktionieren.

http://support.Microsoft.com/kb/31289

5
ckal

Die direkteste Option ist die Verwendung der in .NET verfügbaren Funktion ToTitleCase , die sich die meiste Zeit um den Namen kümmern sollte. Wie edg betonte, gibt es einige Namen, für die es nicht funktioniert, aber diese sind ziemlich selten. Wenn Sie also nicht auf eine Kultur abzielen, in der solche Namen häufig vorkommen, ist es nicht notwendig, dass Sie sich auch Sorgen machen viel über.

Wenn Sie jedoch nicht mit einer .NET-Sprache arbeiten, hängt dies davon ab, wie die Eingabe aussieht. Wenn Sie zwei separate Felder für den Vor- und Nachnamen haben, können Sie den ersten Buchstaben nur groß schreiben, während Sie den Rest verwenden Teilzeichenfolgen.

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

Wenn Sie jedoch mehrere Namen als Teil derselben Zeichenfolge angeben, müssen Sie wissen, wie Sie die Informationen erhalten, und aufteilen entsprechend. Wenn Sie also einen Namen wie "John Doe" erhalten, teilen Sie die Zeichenfolge anhand des Leerzeichens auf. Wenn es in einem Format wie "Doe, John" vorliegt, müssen Sie es basierend auf dem Komma aufteilen. Sobald Sie es jedoch aufgeteilt haben, wenden Sie einfach den zuvor gezeigten Code an.

4
rjzii

Ich benutze meine eigene Methode, um dieses Problem zu beheben:

Zum Beispiel der Satz: "Hallo Welt. Hallo, das ist die Stackoverflow-Welt." wird "Hello World. Hallo, das ist die Stackoverflow-Welt." lauten. Regex\b (Beginn eines Wortes)\w (erster Charakter des Wortes) erledigt den Trick.

/// <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;
}
3
Ton Snoei

CultureInfo.CurrentCulture.TextInfo.ToTitleCase ("my name");

gibt ~ My Name zurück

Das Problem besteht jedoch weiterhin bei Namen wie McFly, wie bereits erwähnt.

3
David C

Diese Klasse macht den Trick. Sie können dem statischen Zeichenfolgenarray _ prefixes neue Präfixe hinzufügen.

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

Die Vorschläge zur Verwendung von ToTitleCase funktionieren nicht für Zeichenfolgen, bei denen nur Großbuchstaben verwendet werden. Sie müssen also ToUpper für das erste Zeichen und ToLower für die verbleibenden Zeichen aufrufen.

2
Tundey

Wenn Sie vS2k8 verwenden, können Sie eine Erweiterungsmethode verwenden, um sie der String-Klasse hinzuzufügen:

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

Um einige der hervorgehobenen Probleme zu umgehen, empfehle ich, die Zeichenfolge zuerst in Kleinbuchstaben umzuwandeln und dann die ToTitleCase-Methode aufzurufen. Sie können dann IndexOf ("Mc") oder IndexOf ("O\'") verwenden, um Sonderfälle zu ermitteln, die eine genauere Betrachtung erfordern.

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);
}
0
Andy Rose
 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;

        }
0

Ich mag diesen Weg:

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

Aufgehoben von diesem MSDN-Artikel .

0
TrentVB

Hoffe das hilft dir.

String fName = "firstname";
String lName = "lastname";
String capitalizedFName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(fName);
String capitalizedLName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(lName);
0
Arun