List<T>.FindAll(Predicate<T>) Méthode

Définition

Espace de noms:

System.Collections.Generic

Assembly:

System.Collections.dll

Source:

List.cs

Récupère tous les éléments qui correspondent aux conditions définies par le prédicat spécifié.

C#

public System.Collections.Generic.List<T> FindAll (Predicate<T> match);

Paramètres

match

Predicate<T>

Délégué Predicate<T> qui définit les conditions des éléments à rechercher.

Retours

List<T>

List<T> contenant tous les éléments qui correspondent aux conditions définies par le prédicat spécifié, le cas échéant ; sinon, List<T> vide.

Exceptions

ArgumentNullException

match a la valeur null.

Exemples

L’exemple suivant illustre les méthodes de recherche pour la List<T> classe . L’exemple de la classe contient book des objets, de classe Book, à l’aide des données de l’exemple de fichier XML : livres (LINQ to XML) .List<T> La FillList méthode de l’exemple utilise LINQ to XML pour analyser les valeurs du XML vers les valeurs de propriété des book objets.

Le tableau suivant décrit les exemples fournis pour les méthodes de recherche.

Méthode	Exemple
Find(Predicate<T>)	Recherche un livre à l’aide d’un ID à l’aide du délégué de IDToFind prédicat. L’exemple C# utilise un délégué anonyme.
FindAll(Predicate<T>)	Recherchez tous les livres dont Genre la propriété est « Ordinateur » à l’aide du délégué de FindComputer prédicat.
FindLast(Predicate<T>)	Recherche le dernier livre de la collection dont la date de publication est antérieure à 2001, à l’aide du délégué de PubBefore2001 prédicat. L’exemple C# utilise un délégué anonyme.
FindIndex(Predicate<T>)	Recherche l’index du premier livre d’ordinateur à l’aide du délégué de FindComputer prédicat.
FindLastIndex(Predicate<T>)	Recherche l’index du dernier livre d’ordinateur à l’aide du délégué de FindComputer prédicat.
FindIndex(Int32, Int32, Predicate<T>)	Recherche l’index du premier livre d’ordinateur dans la deuxième moitié de la collection, à l’aide du délégué de FindComputer prédicat.
FindLastIndex(Int32, Int32, Predicate<T>)	Recherche l’index du dernier livre d’ordinateur dans la deuxième moitié de la collection, à l’aide du délégué de FindComputer prédicat.

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace Find
{
    class Program
    {
        private static string IDtoFind = "bk109";

        private static List<Book> Books = new List<Book>();
        public static void Main(string[] args)
        {
            FillList();

            // Find a book by its ID.
            Book result = Books.Find(
            delegate(Book bk)
            {
                return bk.ID == IDtoFind;
            }
            );
            if (result != null)
            {
                DisplayResult(result, "Find by ID: " + IDtoFind);
            }
            else
            {
                Console.WriteLine("\nNot found: {0}", IDtoFind);
            }

            // Find last book in collection published before 2001.
            result = Books.FindLast(
            delegate(Book bk)
            {
                DateTime year2001 = new DateTime(2001,01,01);
                return bk.Publish_date < year2001;
            });
            if (result != null)
            {
                DisplayResult(result, "Last book in collection published before 2001:");
            }
            else
            {
                Console.WriteLine("\nNot found: {0}", IDtoFind);
            }

            // Find all computer books.
            List<Book> results = Books.FindAll(FindComputer);
            if (results.Count != 0)
            {
                DisplayResults(results, "All computer:");
            }
            else
            {
                Console.WriteLine("\nNo books found.");
            }

            // Find all books under $10.00.
            results = Books.FindAll(
            delegate(Book bk)
            {
                return bk.Price < 10.00;
            }
            );
            if (results.Count != 0)
            {
                DisplayResults(results, "Books under $10:");
            }
            else
            {
                Console.WriteLine("\nNo books found.");
            }

            // Find index values.
            Console.WriteLine();
            int ndx = Books.FindIndex(FindComputer);
            Console.WriteLine("Index of first computer book: {0}", ndx);
            ndx = Books.FindLastIndex(FindComputer);
            Console.WriteLine("Index of last computer book: {0}", ndx);

            int mid = Books.Count / 2;
            ndx = Books.FindIndex(mid, mid, FindComputer);
            Console.WriteLine("Index of first computer book in the second half of the collection: {0}", ndx);

            ndx = Books.FindLastIndex(Books.Count - 1, mid, FindComputer);
            Console.WriteLine("Index of last computer book in the second half of the collection: {0}", ndx);
        }

        // Populates the list with sample data.
        private static void FillList()
        {

            // Create XML elements from a source file.
            XElement xTree = XElement.Load(@"c:\temp\books.xml");

            // Create an enumerable collection of the elements.
            IEnumerable<XElement> elements = xTree.Elements();

            // Evaluate each element and set set values in the book object.
            foreach (XElement el in elements)
            {
                Book book = new Book();
                book.ID = el.Attribute("id").Value;
                IEnumerable<XElement> props = el.Elements();
                foreach (XElement p in props)
                {

                    if (p.Name.ToString().ToLower() == "author")
                    {
                        book.Author = p.Value;
                    }
                    else if (p.Name.ToString().ToLower() == "title")
                    {
                        book.Title = p.Value;
                    }
                    else if (p.Name.ToString().ToLower() == "genre")
                    {
                        book.Genre = p.Value;
                    }
                    else if (p.Name.ToString().ToLower() == "price")
                    {
                        book.Price = Convert.ToDouble(p.Value);
                    }
                    else if (p.Name.ToString().ToLower() == "publish_date")
                    {
                        book.Publish_date = Convert.ToDateTime(p.Value);
                    }
                    else if (p.Name.ToString().ToLower() == "description")
                    {
                        book.Description = p.Value;
                    }
                }

                Books.Add(book);
            }

            DisplayResults(Books, "All books:");
        }

        // Explicit predicate delegate.
        private static bool FindComputer(Book bk)
        {

            if (bk.Genre == "Computer")
            {
                return true;
            }
        else
            {
                return false;
            }
        }

        private static void DisplayResult(Book result, string title)
        {
            Console.WriteLine();
            Console.WriteLine(title);
            Console.WriteLine("\n{0}\t{1}\t{2}\t{3}\t{4}\t{5}", result.ID,
                result.Author, result.Title, result.Genre, result.Price,
                result.Publish_date.ToShortDateString());
            Console.WriteLine();
        }

        private static void DisplayResults(List<Book> results, string title)
        {
            Console.WriteLine();
            Console.WriteLine(title);
            foreach (Book b in results)
            {

                Console.Write("\n{0}\t{1}\t{2}\t{3}\t{4}\t{5}", b.ID,
                    b.Author, b.Title, b.Genre, b.Price,
                    b.Publish_date.ToShortDateString());
            }
            Console.WriteLine();
        }
    }

    public class Book
    {
        public string ID { get; set; }
        public string Author { get; set; }
        public string Title { get; set; }
        public string Genre { get; set; }
        public double Price { get; set; }
        public DateTime Publish_date { get; set; }
        public string Description { get; set; }
    }
}

Remarques

est Predicate<T> un délégué à une méthode qui retourne true si l’objet qui lui est passé correspond aux conditions définies dans le délégué. Les éléments du actif List<T> sont transmis individuellement au Predicate<T> délégué, et les éléments qui correspondent aux conditions sont enregistrés dans le retourné List<T>.

Cette méthode effectue une recherche linéaire ; par conséquent, cette méthode est une opération O(n), où n est Count.

S’applique à

Voir aussi

• Exists(Predicate<T>)
• Find(Predicate<T>)
• FindLast(Predicate<T>)
• FindIndex
• FindLastIndex
• BinarySearch
• IndexOf
• LastIndexOf
• Predicate<T>