Meilleur moyen de supprimer le dernier caractère d'une chaîne construite avec stringbuilder

J'ai ce qui suit

data.AppendFormat("{0},",dataToAppend);

Le problème avec ceci est que je l'utilise en boucle et qu'il y aura une virgule d'essai. Quelle est la meilleure façon de supprimer la virgule de fin?

Dois-je changer les données en une chaîne de la sous-chaîne?

Le moyen le plus simple et le plus efficace consiste à exécuter cette commande:

data.Length--;

en faisant cela, vous déplacez le pointeur (c'est-à-dire le dernier index) en arrière d'un caractère mais vous ne changez pas la mutabilité de l'objet. En fait, il StringBuildervaut mieux effacer a Lengthaussi (mais utilisez plutôt la Clear()méthode pour plus de clarté car c'est à cela que ressemble son implémentation):

data.Length = 0;

encore une fois, car cela ne change pas la table d'allocation. Pensez-y comme si vous disiez que je ne veux plus reconnaître ces octets. Maintenant, même en appelant ToString(), il ne reconnaîtra rien après son Length, eh bien, il ne le peut pas. C'est un objet mutable qui alloue plus d'espace que ce que vous lui fournissez, il est simplement construit de cette façon.

Juste utiliser

string.Join(",", yourCollection)

De cette façon, vous n'avez pas besoin de StringBuilderla boucle et.

Ajout long sur le cas asynchrone. À partir de 2019, ce n'est pas une configuration rare lorsque les données arrivent de manière asynchrone.

Dans le cas où vos données sont dans une collection asynchrone, il n'y a pas de string.Joinprise de surcharge IAsyncEnumerable<T>. Mais il est facile d'en créer un manuellement, en piratant le code à partir destring.Join :

public static class StringEx
{
    public static async Task<string> JoinAsync<T>(string separator, IAsyncEnumerable<T> seq)
    {
        if (seq == null)
            throw new ArgumentNullException(nameof(seq));

        await using (var en = seq.GetAsyncEnumerator())
        {
            if (!await en.MoveNextAsync())
                return string.Empty;

            string firstString = en.Current?.ToString();

            if (!await en.MoveNextAsync())
                return firstString ?? string.Empty;

            // Null separator and values are handled by the StringBuilder
            var sb = new StringBuilder(256);
            sb.Append(firstString);

            do
            {
                var currentValue = en.Current;
                sb.Append(separator);
                if (currentValue != null)
                    sb.Append(currentValue);
            }
            while (await en.MoveNextAsync());
            return sb.ToString();
        }
    }
}

Si les données arrivent de manière asynchrone mais que l'interface IAsyncEnumerable<T>n'est pas prise en charge (comme mentionné dans les commentaires SqlDataReader), il est relativement facile d'encapsuler les données dans un IAsyncEnumerable<T>:

async IAsyncEnumerable<(object first, object second, object product)> ExtractData(
        SqlDataReader reader)
{
    while (await reader.ReadAsync())
        yield return (reader[0], reader[1], reader[2]);
}

et utilisez-le:

Task<string> Stringify(SqlDataReader reader) =>
    StringEx.JoinAsync(
        ", ",
        ExtractData(reader).Select(x => $"{x.first} * {x.second} = {x.product}"));

Pour l'utiliser Select, vous devrez utiliser le package nuget System.Interactive.Async. Ici vous pouvez trouver un exemple compilable.

Utilisez ce qui suit après la boucle.

.TrimEnd(',')

ou simplement changer pour

string commaSeparatedList = input.Aggregate((a, x) => a + ", " + x)

Que dis-tu de ça..

string str = "The quick brown fox jumps over the lazy dog,";
StringBuilder sb = new StringBuilder(str);
sb.Remove(str.Length - 1, 1);

Je préfère manipuler la longueur du stringbuilder:

data.Length = data.Length - 1;

Je recommande, vous changez votre algorithme de boucle:

• Ajoutez la virgule non APRÈS l'élément, mais AVANT
• Utilisez une variable booléenne, qui commence par false, supprimez la première virgule
• Définissez cette variable booléenne sur true après l'avoir testée

Vous devez utiliser la string.Joinméthode pour transformer une collection d'éléments en une chaîne délimitée par des virgules. Cela garantira qu'il n'y a pas de virgule de début ou de fin, ainsi que la construction efficace de la chaîne (sans chaînes intermédiaires inutiles).

Oui, convertissez-le en chaîne une fois la boucle terminée:

String str = data.ToString().TrimEnd(',');

Vous avez deux options. La première est une Removeméthode d' utilisation très facile , elle est assez efficace. La deuxième méthode consiste à utiliser ToStringavec l'index de début et l'index de fin ( documentation MSDN )

Question SO similaire ici.

J'ai aimé l'utilisation d'une méthode d'extension StringBuilder.

RemoveLast, méthode

Le moyen le plus simple serait d'utiliser la méthode Join ():

public static void Trail()
{
    var list = new List<string> { "lala", "lulu", "lele" };
    var data = string.Join(",", list);
}

Si vous avez vraiment besoin de StringBuilder, coupez la virgule de fin après la boucle:

data.ToString().TrimEnd(',');