Façon la plus propre pour Trouver une Correspondance Dans une Liste

Quel est le meilleur moyen de trouver quelque chose dans une liste? Je sais LINQ a quelques bons trucs, mais nous allons également obtenir des suggestions pour C# 2.0. Permet d'obtenir le meilleur refactorings pour cette commune du modèle de code.

Actuellement, je utiliser un code comme ceci:

//mObjList is a List<MyObject>
MyObject match = null;
foreach (MyObject mo in mObjList)
{
    if (Criteria(mo))
    {
        match = mo;
        break;
    }
}

ou

//mObjList is a List<MyObject>
bool foundIt = false;
foreach (MyObject mo in mObjList)
{
    if (Criteria(mo))
    {
        foundIt = true;
        break;
    }
}

OriginalL'auteur Nick | 2008-08-23

  1. 15

    @ Konrad: Alors, comment l'utilisez-vous? Disons que je veux correspondre mo.ID de magicNumber.

    En C# 2.0, vous devez écrire:

    result = mObjList.Find(delegate(int x) { return x.ID == magicNumber; });

    3.0 sait lambdas:

    result = mObjList.Find(x => x.ID == magicNumber);

    OriginalL'auteur Konrad Rudolph

  2. 4

    À l'aide d'une expression Lambda:

    List<MyObject> list = new List<MyObject>();

//populate the list with objects..

return list.Find(o => o.Id == myCriteria);

    OriginalL'auteur Todd

  3. 1

    Mettre le code dans une méthode et vous enregistrer temporaire et break (et de les recycler code, comme un bonus):

    T Find<T>(IEnumerable<T> items, Predicate<T> p) {
    foreach (T item in items)
        if (p(item))
            return item;

    return null;
}

    ... mais bien sûr, cette méthode existe déjà de toute façon pour les Listes, même dans .NET 2.0.

    OriginalL'auteur Konrad Rudolph

  4. 1

    Évidemment, les performances de délégués anonymes est assez significative.

    Code de Test:

        static void Main(string[] args)
    {
        for (int kk = 0; kk < 10; kk++)
        {
            List<int> tmp = new List<int>();
            for (int i = 0; i < 100; i++)
                tmp.Add(i);
            int sum = 0;
            long start = DateTime.Now.Ticks;
            for (int i = 0; i < 1000000; i++)
                sum += tmp.Find(delegate(int x) { return x == 3; });
            Console.WriteLine("Anonymous delegates: " + (DateTime.Now.Ticks - start));


            start = DateTime.Now.Ticks;
            sum = 0;
            for (int i = 0; i < 1000000; i++)
            {
                int match = 0;
                for (int j = 0; j < tmp.Count; j++)
                {
                    if (tmp[j] == 3)
                    {
                        match = tmp[j];
                        break;
                    }
                }
                sum += match;
            }
            Console.WriteLine("Classic C++ Style: " + (DateTime.Now.Ticks - start));
            Console.WriteLine();
        }
    }

    Résultats:

    Anonymous delegates: 710000
Classic C++ Style: 340000

Anonymous delegates: 630000
Classic C++ Style: 320000

Anonymous delegates: 630000
Classic C++ Style: 330000

Anonymous delegates: 630000
Classic C++ Style: 320000

Anonymous delegates: 610000
Classic C++ Style: 340000

Anonymous delegates: 630000
Classic C++ Style: 330000

Anonymous delegates: 650000
Classic C++ Style: 330000

Anonymous delegates: 620000
Classic C++ Style: 330000

Anonymous delegates: 620000
Classic C++ Style: 340000

Anonymous delegates: 620000
Classic C++ Style: 400000

    Dans tous les cas, l'utilisation anonyme des délégués est d'environ 100% plus lent que les autres.

    Non, le gain de performance n'est pas l'utilisation du délégué. Votre algorithmes fonction fondamentalement différentes, la première méthode a asymptotique d'exécution O(n^2) alors que la seconde dispose d'exécution O(n). Cela n'a pas eu quelque chose à voir avec les délégués, mais plutôt avec l'aide de la Find fonction dans ce contexte.

    OriginalL'auteur Nick