Le moyen le plus propre de trouver une correspondance dans une liste

Question

Quelle est la meilleure façon de trouver quelque chose dans une liste ?Je sais que LINQ propose quelques astuces intéressantes, mais obtenons également des suggestions pour C# 2.0.Obtenons les meilleures refactorisations pour ce modèle de code courant.

Actuellement, j'utilise un code comme celui-ci :

// 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;
    }
}

Answer 1

@Konrad :Alors comment l'utiliser ?Disons que je veux faire correspondre mo.ID à magicNumber.

En C# 2.0, vous écririez :

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

3.0 connaît les lambdas :

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

Answer 2

À l'aide d'une expression Lambda :

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

// populate the list with objects..

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

Answer 3

Mettez le code dans une méthode et vous enregistrez un temporaire et un break (et vous recyclez le code, en 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.

Answer 4

De toute évidence, les performances des délégués anonymes sont assez significatives.

Code d'essai :

    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 de délégués anonymes est environ 100 % plus lente que l’inverse.