Comment remplacer un élément de liste de la meilleure façon

Question

if (listofelements.Contains(valueFieldValue.ToString()))
{
    listofelements[listofelements.IndexOf(valueFieldValue.ToString())] = value.ToString();
}

J'ai remplacé comme ci-dessus. Y a-t-il une autre façon de placer la comparaison que celle-ci ?

Answer 1

Utilisez Lambda pour trouver l'index dans la liste et utilisez cet index pour remplacer l'élément de la liste.

List<string> listOfStrings = new List<string> { "abc", "123", "ghi" };

int index = listOfStrings.FindIndex(s => s == "123");

if (index != -1)
    listOfStrings[index] =  "def";

Answer 2

Vous pourriez le rendre plus lisible et plus efficace :

string oldValue = valueFieldValue.ToString();
string newValue = value.ToString();
int index = listofelements.IndexOf(oldValue);
if(index != -1)
    listofelements[index] = newValue;

L'index est demandé une seule fois. Votre approche utilise Contains d'abord qui doit boucler tous les éléments (dans le pire des cas), alors vous utilisez IndexOf qui doit à nouveau énumérer les éléments.

Answer 3

Pourquoi ne pas utiliser les méthodes d'extension ?

Considérons le code suivant :

        var intArray = new int[] { 0, 1, 1, 2, 3, 4 };
        // Replaces the first occurance and returns the index
        var index = intArray.Replace(1, 0);
        // {0, 0, 1, 2, 3, 4}; index=1

        var stringList = new List<string> { "a", "a", "c", "d"};
        stringList.ReplaceAll("a", "b");
        // {"b", "b", "c", "d"};

        var intEnum = intArray.Select(x => x);
        intEnum = intEnum.Replace(0, 1);
        // {0, 0, 1, 2, 3, 4} => {1, 1, 1, 2, 3, 4}

• Pas de duplication de code
• Il n'est pas nécessaire de saisir de longues expressions linq.
• Il n'est pas nécessaire de procéder à des utilisations supplémentaires

Le code source :

namespace System.Collections.Generic
{
    public static class Extensions
    {
        public static int Replace<T>(this IList<T> source, T oldValue, T newValue)
        {
            if (source == null)
                throw new ArgumentNullException(nameof(source));

            var index = source.IndexOf(oldValue);
            if (index != -1)
                source[index] = newValue;
            return index;
        }

        public static void ReplaceAll<T>(this IList<T> source, T oldValue, T newValue)
        {
            if (source == null)
                throw new ArgumentNullException(nameof(source));

            int index = -1;
            do
            {
                index = source.IndexOf(oldValue);
                if (index != -1)
                    source[index] = newValue;
            } while (index != -1);
        }

        public static IEnumerable<T> Replace<T>(this IEnumerable<T> source, T oldValue, T newValue)
        {
            if (source == null)
                throw new ArgumentNullException(nameof(source));

            return source.Select(x => EqualityComparer<T>.Default.Equals(x, oldValue) ? newValue : x);
        }
    }
}

Les deux premières méthodes ont été ajoutées pour modifier les objets des types de référence en place. Bien entendu, vous pouvez utiliser uniquement la troisième méthode pour tous les types.

P.S. Merci à l'observation de mike J'ai ajouté la méthode ReplaceAll.

Answer 4

Vous accédez deux fois à votre liste pour remplacer un élément. Je pense que c'est simple for La boucle devrait suffire :

var key = valueFieldValue.ToString();
for (int i = 0; i < listofelements.Count; i++)
{
    if (listofelements[i] == key)
    {
        listofelements[i] = value.ToString();
        break;
    }
}

Answer 5

Suite à la réponse de rokkuchan, juste une petite mise à jour :

List<string> listOfStrings = new List<string> {"abc", "123", "ghi"};

int index = listOfStrings.FindIndex(ind => ind.Equals("123"));
if (index > -1)
    listOfStrings[index] =  "def";