Array.FindLast<T>(T[], Predicate<T>) Méthode

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

Array.cs

Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne la dernière occurrence dans l’ensemble de la Array.

C#

public static T? FindLast<T>(T[] array, Predicate<T> match);

Paramètres de type

T

Type des éléments du tableau.

Paramètres

array

T[]

Les Array unidimensionnels basés sur zéro à rechercher.

match

Predicate<T>

La Predicate<T> qui définit les conditions de l’élément à rechercher.

Retours

T

Dernier élément qui correspond aux conditions définies par le prédicat spécifié, s’il est trouvé ; sinon, la valeur par défaut du type T.

Exceptions

ArgumentNullException

array est null.

-ou-

match est null.

Exemples

L’exemple de code suivant illustre les méthodes génériques Find, FindLastet FindAll. Un tableau de chaînes est créé, contenant 8 noms de dinosaures, dont deux (aux positions 1 et 5) se terminent par « saurus ». L’exemple de code définit également une méthode de prédicat de recherche nommée EndsWithSaurus, qui accepte un paramètre de chaîne et retourne une valeur booléenne indiquant si la chaîne d’entrée se termine par « saurus ».

La méthode générique Find traverse le tableau du début, en passant à son tour chaque élément à la méthode EndsWithSaurus. La recherche s’arrête lorsque la méthode EndsWithSaurus retourne true pour l’élément « Amargasaurus ».

Remarque

En C# et Visual Basic, il n’est pas nécessaire de créer explicitement le déléguéPredicate<string> (Predicate(Of String) en Visual Basic). Ces langages déduitnt le délégué approprié à partir du contexte et créez-le automatiquement.

La méthode générique FindLast est utilisée pour rechercher le tableau vers l’arrière à partir de la fin. Il trouve l’élément « Dilophosaurus » à la position 5. La méthode générique FindAll est utilisée pour retourner un tableau contenant tous les éléments qui se terminent par « saurus ». Les éléments sont affichés.

L’exemple de code illustre également les méthodes génériques Exists et TrueForAll.

C#

using System;

public class DinoDiscoverySet
{
    public static void Main()
    {
        string[] dinosaurs =
        {
            "Compsognathus", "Amargasaurus", "Oviraptor",
            "Velociraptor",  "Deinonychus",  "Dilophosaurus",
            "Gallimimus",    "Triceratops"
        };

        DinoDiscoverySet GoMesozoic = new DinoDiscoverySet(dinosaurs);

        GoMesozoic.DiscoverAll();
        GoMesozoic.DiscoverByEnding("saurus");
    }

    private string[] dinosaurs;

    public DinoDiscoverySet(string[] items)
    {
        dinosaurs = items;
    }

    public void DiscoverAll()
    {
        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }
    }

    public void DiscoverByEnding(string Ending)
    {
        Predicate<string> dinoType;

        switch (Ending.ToLower())
        {
            case "raptor":
                dinoType = EndsWithRaptor;
                break;
            case "tops":
                dinoType = EndsWithTops;
                break;
            case "saurus":
            default:
                dinoType = EndsWithSaurus;
                break;
        }
        Console.WriteLine(
            "\nArray.Exists(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.Exists(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.TrueForAll(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.TrueForAll(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.Find(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.Find(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.FindLast(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.FindLast(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.FindAll(dinosaurs, \"{0}\"):", Ending);

        string[] subArray =
            Array.FindAll(dinosaurs, dinoType);

        foreach(string dinosaur in subArray)
        {
            Console.WriteLine(dinosaur);
        }
    }

    // Search predicate returns true if a string ends in "saurus".
    private bool EndsWithSaurus(string s)
    {
        if ((s.Length > 5) &&
            (s.Substring(s.Length - 6).ToLower() == "saurus"))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    // Search predicate returns true if a string ends in "raptor".
    private bool EndsWithRaptor(String s)
    {
        if ((s.Length > 5) &&
            (s.Substring(s.Length - 6).ToLower() == "raptor"))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    // Search predicate returns true if a string ends in "tops".
    private bool EndsWithTops(String s)
    {
        if ((s.Length > 3) &&
            (s.Substring(s.Length - 4).ToLower() == "tops"))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

/* This code example produces the following output:

Compsognathus
Amargasaurus
Oviraptor
Velociraptor
Deinonychus
Dilophosaurus
Gallimimus
Triceratops

Array.Exists(dinosaurs, "saurus"): True

Array.TrueForAll(dinosaurs, "saurus"): False

Array.Find(dinosaurs, "saurus"): Amargasaurus

Array.FindLast(dinosaurs, "saurus"): Dilophosaurus

Array.FindAll(dinosaurs, "saurus"):
Amargasaurus
Dilophosaurus
*/

Remarques

Le Predicate<T> est un délégué à une méthode qui retourne true si l’objet passé à celui-ci correspond aux conditions définies dans le délégué. Les éléments de array sont transmis individuellement à l'Predicate<T>, se déplaçant vers l’arrière dans le Array, en commençant par le dernier élément et en se terminant par le premier élément. Le traitement est arrêté lorsqu’une correspondance est trouvée.

Cette méthode est une opération O(n), où n est la Length de array.

S’applique à

Voir aussi

• Exists<T>(T[], Predicate<T>)
• Find<T>(T[], Predicate<T>)
• FindAll<T>(T[], Predicate<T>)
• BinarySearch
• IndexOf
• LastIndexOf
• Predicate<T>