Löschen Sie das letzte Zeichen der Zeichenfolge

Ich rufe viele Informationen in einer Liste ab, die mit einer Datenbank verknüpft ist, und möchte eine Reihe von Gruppen für jemanden erstellen, der mit der Website verbunden ist.

Ich benutze dies zum Testen, aber das ist nicht dynamisch, also ist es wirklich schlecht:

string strgroupids = "6";

Ich möchte das jetzt nutzen. Aber die zurückgegebene Zeichenfolge ist so etwas wie1,2,3,4,5,

groupIds.ForEach((g) =>
{
    strgroupids = strgroupids  + g.ToString() + ",";
    strgroupids.TrimEnd(',');
});

strgroupids.TrimEnd(new char[] { ',' });

Ich möchte das ,nach dem löschen, 5aber es funktioniert definitiv nicht.

strgroupids = strgroupids.Remove(strgroupids.Length - 1);

MSDN:

String.Remove (Int32):

Löscht alle Zeichen aus dieser Zeichenfolge, beginnend an einer bestimmten Position und bis zur letzten Position

Was ist damit?

strgroupids = string.Join( ",", groupIds );

Ein viel sauberer.

Es werden alle Elemente im Inneren groupIdsmit einem ','Zwischenzeichen versehen, aber es wird kein ','am Ende gesetzt.

Zeichenfolgen in c # sind unveränderlich. Wenn Sie dies in Ihrem Code tun strgroupids.TrimEnd(',');oder strgroupids.TrimEnd(new char[] { ',' });die strgroupidsZeichenfolge nicht geändert wird .

Sie müssen strgroupids = strgroupids.TrimEnd(',');stattdessen so etwas tun .

Um von hier aus zu zitieren :

Zeichenfolgen sind unveränderlich - Der Inhalt eines Zeichenfolgenobjekts kann nach dem Erstellen des Objekts nicht mehr geändert werden, obwohl die Syntax den Anschein erweckt, als könnten Sie dies tun. Wenn Sie beispielsweise diesen Code schreiben, erstellt der Compiler tatsächlich ein neues Zeichenfolgenobjekt, das die neue Zeichenfolge enthält, und dieses neue Objekt wird b zugewiesen. Die Zeichenfolge "h" ist dann für die Speicherbereinigung berechtigt.

Fügen Sie eine Erweiterungsmethode hinzu.

public static string RemoveLast(this string text, string character)
{
    if(text.Length < 1) return text;
    return text.Remove(text.ToString().LastIndexOf(character), character.Length);
}

dann benutze:

yourString.RemoveLast(",");

Entfernt nachfolgende Kommas:

while (strgroupids.EndsWith(","))
    strgroupids = strgroupids.Substring(0, strgroupids.Length - 1);

Dies ist jedoch rückwärts, Sie haben den Code geschrieben, der das Komma an erster Stelle hinzufügt. Sie sollten string.Join(",",g)stattdessen verwenden, vorausgesetzt, es gist a string[]. Gib ihm einen besseren Namen als gauch!

Alternativ zum Hinzufügen eines Kommas für jedes Element können Sie auch String.Join verwenden:

var strgroupids = String.Join(",",  groupIds);

Dadurch wird der Trennzeichen (in diesem Fall ",") zwischen jedem Element im Array hinzugefügt .

string strgroupids = string.Empty;

groupIds.ForEach(g =>
{
    strgroupids = strgroupids + g.ToString() + ",";
});

strgroupids = strgroupids.Substring(0, strgroupids.Length - 1);

Beachten Sie, dass die Verwendung von ForEachhier normalerweise als "falsch" angesehen wird (lesen Sie beispielsweise http://blogs.msdn.com/b/ericlippert/archive/2009/05/18/foreach-vs-foreach.aspx ).

Verwenden von etwas LINQ:

string strgroupids = groupIds.Aggregate(string.Empty, (p, q) => p + q + ',');
strgroupids = strgroupids.Substring(0, str1.Length - 1);

Ohne End-Teilzeichenfolge:

string strgroupids = groupIds.Aggregate(string.Empty, (p, q) => (p != string.Empty ? p + "," + q : q.ToString()));

Zusätzlich zur Lösung von sll: Es ist besser, die Zeichenfolge zu kürzen, falls am Ende Leerzeichen vorhanden sind.

strgroupids = strgroupids.Remove(strgroupids.Trim().Length - 1);

string.Joinist besser, aber wenn Sie wirklich einen LINQ wollen ForEach:

var strgroupids = string.Empty;

groupIds.ForEach(g =>
{
    if(strgroupids != string.Empty){
        strgroupids += ",";
    }

    strgroupids += g;
});

Einige Notizen:

• string.Joinund foreachbeide sind besser als dieser, weitaus langsamere Ansatz
• Das letzte muss nicht entfernt werden, ,da es nie angehängt wird
• Der Inkrement-Operator ( +=) ist praktisch zum Anhängen an Zeichenfolgen
• .ToString() ist nicht erforderlich, da es beim Verketten von Nicht-Strings automatisch aufgerufen wird
• Beim Umgang mit großen Zeichenfolgen StringBuildersollte berücksichtigt werden, anstatt Zeichenfolgen zu verketten