Den ersten Buchstaben einer Zeichenkette groß schreiben (mit maximaler Leistung)

Question

Ich habe eine DetailsView mit einer TextBox und ich möchte die Eingangsdaten sein immer gespeichert mit dem erster Buchstabe in Großbuchstaben .

Exemple :

"red" --> "Red"
"red house" --> " Red house"

Wie kann ich das erreichen? Leistungsmaximierung ?

---

Hinweis :

Ausgehend von den Antworten und den Kommentaren unter den Antworten denken viele, dass es hier um die Kapitalisierung geht alle Wörter in der Zeichenkette. z.B. => Red House Ist es nicht, aber wenn es das ist, was Sie suchen suchen Sie nach einer der Antworten, in der TextInfo 's ToTitleCase Methode. (Anmerkung: Diese Antworten sind falsch für die tatsächlich gestellte Frage). Siehe TextInfo.ToTitleCase Dokumentation für Vorbehalte (berührt keine Wörter in Großbuchstaben - sie werden als Akronyme betrachtet; kann Buchstaben in der Mitte von Wörtern kleinschreiben, die nicht kleingeschrieben werden sollten, z. B. "McDonald" "Mcdonald"; nicht garantiert, dass alle kulturspezifischen Feinheiten in Bezug auf Großschreibregeln berücksichtigt werden).

---

Hinweis :

Die Frage lautet zweideutig die Frage, ob die Buchstaben nach dem ersten Buchstaben gezwungen a Kleinschreibung . Die akzeptierte Antwort geht davon aus, dass nur der erste Buchstabe sollte geändert werden . Wenn Sie Folgendes erzwingen wollen alle Buchstaben der Zeichenkette außer dem ersten klein geschrieben werden soll, suchen Sie nach einer Antwort, die ToLower y die nicht ToTitleCase enthalten .

Answer 1

Ich habe etwas gefunden in C# Großbuchstaben Anfangsbuchstabe - Dot Net Perls :

static string UppercaseFirst(string s)
{
    // Check for empty string.
    if (string.IsNullOrEmpty(s))
    {
        return string.Empty;
    }

    // Return char and concat substring.
    return char.ToUpper(s[0]) + s.Substring(1);
}

Answer 2

Hier ist eine Möglichkeit, dies als Erweiterungsmethode zu tun:

static public string UpperCaseFirstCharacter(this string text)
{
    if (!string.IsNullOrEmpty(text))
    {
        return string.Format(
            "{0}{1}",
            text.Substring(0, 1).ToUpper(),
            text.Substring(1));
    }

    return text;
}

Sie kann dann wie folgt aufgerufen werden:

//yields "This is Brian's test.":
"this is Brian's test.".UpperCaseFirstCharacter();

Und hier sind einige Unit-Tests für sie:

[Test]
public void UpperCaseFirstCharacter_ZeroLength_ReturnsOriginal()
{
    string orig = "";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual(orig, result);
}

[Test]
public void UpperCaseFirstCharacter_SingleCharacter_ReturnsCapital()
{
    string orig = "c";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("C", result);
}

[Test]
public void UpperCaseFirstCharacter_StandardInput_CapitalizeOnlyFirstLetter()
{
    string orig = "this is Brian's test.";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("This is Brian's test.", result);
}

Answer 3

Das genügt, wobei auch sichergestellt wird, dass keine Großbuchstaben fehlen, die nicht am Anfang des Wortes stehen.

public string(string s)
{
    System.Globalization.CultureInfo c = new System.Globalization.CultureInfo("en-us", false)
    System.Globalization.TextInfo t = c.TextInfo;

    return t.ToTitleCase(s);
}

Answer 4

Wir können dies tun (C# 8.0, .NET 5):

input?.Length > 0 ? char.ToUpperInvariant(input[0]) + input[1..] : input

Ich glaube, das ist kurz genug, um es inline zu machen.

---

Si input eine leere Zeichenfolge ist, erhalten wir eine leere Zeichenfolge. Wenn input es null erhalten wir null .

Andernfalls nimmt der Code das erste Zeichen input[0] und konvertieren es in Großbuchstaben mit char.ToUpperInvariant . Und den Rest verketten input[1..] .

Der Compiler wandelt den Bereichszugriff in einen Aufruf von Substring Außerdem kann es sich die Tatsache zunutze machen, dass wir die Länge bereits haben.

_Dies hat gegenüber der akzeptierten Antwort den Vorteil, dass keine LINQ . Einige andere Antworten konvertieren die Zeichenkette in ein Array, nur um das erste Zeichen zu übernehmen. Dieser Code tut das auch nicht._

---

Wenn Sie eine Erweiterungsmethode bevorzugen, können Sie dies tun:

public static string FirstCharToUpper(this string input) =>
        input?.Length > 0 ? char.ToUpperInvariant(input[0]) + input[1..] : input;

Was, wenn Sie lieber werfen wollen? OK, lass ihn werfen:

public static string FirstCharToUpper(this string input) =>
        input switch
        {
            null => throw new ArgumentNullException(nameof(input)),
            _ => input.Length > 0 ? char.ToUpperInvariant(input[0]) + input[1..] : input
        };

Hier ein ungefähr gleichwertiger Code (da wir eine Erweiterungsmethode erstellen, können wir etwas ausführlicher sein):

public static string FirstCharToUpperEquivalent(this string input)
{
    if (input == null)
    {
        throw new ArgumentNullException(nameof(input));
    }

    var length = input.Length;
    if (length == 0)
    {
        return input;
    }

    string firstCharacter = char.ToUpperInvariant(input[0]).ToString();
    return string.Concat(firstCharacter, input.Substring(1, length - 1));
}

---

Ich habe einen Benchmark mit 1000 Runden von 155 Wörtern durchgeführt (sie wurden also 155000 Mal aufgerufen), und das ist das Ergebnis:

Benchmarking type Tests
  TestAccepted         00:00:00.0465979
  TestProposalNoThrow  00:00:00.0092839
  TestProposalDoThrow  00:00:00.0092938
  TestProposalEquival  00:00:00.0091463

_Ich habe es unter Windows 10, Intel Kern i3 unter Verwendung des Codes aus Einfaches Microbenchmarking in C# von Jon Skeet._

Answer 5

Dies ist der schnellste Weg:

public static unsafe void ToUpperFirst(this string str)
{
    if (str == null)
        return;
    fixed (char* ptr = str)
        *ptr = char.ToUpper(*ptr);
}

Ohne die ursprüngliche Zeichenfolge zu ändern:

public static unsafe string ToUpperFirst(this string str)
{
    if (str == null)
        return null;
    string ret = string.Copy(str);
    fixed (char* ptr = ret)
        *ptr = char.ToUpper(*ptr);
    return ret;
}