le meilleur moyen de convertir la collecte à la chaîne

J'ai besoin de convertir une collection de <string,string> à une seule chaîne de caractères contenant toutes les valeurs dans la collection comme KeyValueKeyValue... Mais Comment puis-je le faire efficacement?

Je l'ai fait de cette façon en ce moment:

parameters = string.Join("", requestParameters.Select(x => string.Concat(x.Key, x.Value)));

Mais pas sûr que c'est la meilleure façon de le faire, ne serait qu'un générateur de chaîne de mieux? Je suppose que la collection comportera un maximum de 10 paires.

Votre chemin a l'air assez sympa et compact.

OriginalL'auteur Rasmus Christensen | 2010-09-04

  1. 5

    Avec une petite collection, il n'y a pas beaucoup d'un souci de performances, mais je serais probablement utiliser un StringBuilder pour Ajouter toutes les valeurs.

    Comme ceci:

    var sb = new Text.StringBuilder;
foreach (var item in requestParameters)
{
    sb.AppendFormat("{0}{1}", item.Key, item.Value);
}
var parameters = sb.ToString();
    Mais c'est un peu double emploi avec ce que string.Join n'en interne (l'OP semble être sur .NET 4.0, ainsi, il a accès à la surcharge qui accepte un IEnumerable<string>).

    OriginalL'auteur davisoa

  2. 5

    string.Join utilisé pour ne pas être vraiment la meilleure option, car elle n'acceptait string[] ou object[] paramètres, exigeant que tous les selectde style requêtes nécessaires pour être complètement évalués et les mettre dans un tableau en premier.

    .NET 4.0 apporté avec elle une surcharge qui accepte IEnumerable<string> -- qui est ce que vous utilisez -- et même une surcharge qui accepte toutes les IEnumerable<T>. Ce sont certainement votre meilleur pari, car ils font désormais partie de la BCL.

    D'ailleurs, la fissuration ouvrir la source pour la première surcharge en Réflecteur montre le code qui suit d'assez près à ce davisoa suggéré:

    public static string Join(string separator, IEnumerable<string> values)
{
    if (values == null)
    {
        throw new ArgumentNullException("values");
    }
    if (separator == null)
    {
        separator = Empty;
    }
    using (IEnumerator<string> enumerator = values.GetEnumerator())
    {
        if (!enumerator.MoveNext())
        {
            return Empty;
        }
        StringBuilder builder = new StringBuilder();
        if (enumerator.Current != null)
        {
            builder.Append(enumerator.Current);
        }
        while (enumerator.MoveNext())
        {
            builder.Append(separator);
            if (enumerator.Current != null)
            {
                builder.Append(enumerator.Current);
            }
        }
        return builder.ToString();
    }
}

    Donc, en d'autres termes, si vous étiez à modifier ce code pour utiliser un StringBuilder, vous devriez juste être la réécriture de ce que MS a déjà écrit pour vous.

    OriginalL'auteur Dan Tao

  3. 0

    Générateur de chaîne serait bien. Ajouter utiliser pour ajouter chaque chaîne à la chaîne de constructeur.

    Fondamentalement, la seule raison pour laquelle concat, de remplacer, de le rejoindre, chaîne+chaîne , etc ne sont pas considérés comme les meilleurs, car ils ont tous tendance à détruire l'actuel string & en recréer un nouveau.

    Ainsi, lorsque vous avez ajout de chaînes de caractères comme jusqu'à 10-12 fois il vraiment signifie que vous allez détruire & recréer une chaîne de nombreuses fois.

    OriginalL'auteur loxxy