Enumerable.All<TSource> Méthode

Définition

Espace de noms:

System.Linq

Assembly:

System.Linq.dll

Détermine si tous les éléments d'une séquence satisfont à une condition.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static bool All(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, bool> ^ predicate);

public static bool All<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,bool> predicate);

static member All : seq<'Source> * Func<'Source, bool> -> bool

<Extension()>
Public Function All(Of TSource) (source As IEnumerable(Of TSource), predicate As Func(Of TSource, Boolean)) As Boolean

Paramètres de type

TSource

Le type des éléments de source.

Paramètres

source

IEnumerable<TSource>

IEnumerable<T> qui contient les éléments auxquels appliquer le prédicat.

predicate

Func<TSource,Boolean>

Fonction permettant de tester chaque élément par rapport à une condition.

Retours

Boolean

true si tous les éléments de la séquence source réussissent le test dans le prédicat spécifié ou si la séquence est vide ; sinon, false.

Exceptions

ArgumentNullException

source ou predicate est null.

Exemples

L’exemple de code suivant montre comment utiliser All pour déterminer si tous les éléments d’une séquence satisfont à une condition. La variable allStartWithB a la valeur true si tous les noms d’animaux commencent par « B » ou si le pets tableau est vide.

class Pet
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public static void AllEx()
{
    // Create an array of Pets.
    Pet[] pets = { new Pet { Name="Barley", Age=10 },
                   new Pet { Name="Boots", Age=4 },
                   new Pet { Name="Whiskers", Age=6 } };

    // Determine whether all pet names
    // in the array start with 'B'.
    bool allStartWithB = pets.All(pet =>
                                      pet.Name.StartsWith("B"));

    Console.WriteLine(
        "{0} pet names start with 'B'.",
        allStartWithB ? "All" : "Not all");
}

// This code produces the following output:
//
//  Not all pet names start with 'B'.

Structure Pet
    Public Name As String
    Public Age As Integer
End Structure

Sub AllEx()
    ' Create an array of Pets.
    Dim pets() As Pet =
{New Pet With {.Name = "Barley", .Age = 2},
 New Pet With {.Name = "Boots", .Age = 4},
 New Pet With {.Name = "Whiskers", .Age = 7}}

    ' Determine whether all pet names in the array start with "B".
    Dim allNames As Boolean =
pets.All(Function(ByVal pet) pet.Name.StartsWith("B"))

    ' Display the output.
    Dim text As String = IIf(allNames, "All", "Not all")
    Console.WriteLine($"{text} pet names start with 'B'.")
End Sub

' This code produces the following output:
'
' Not all pet names start with 'B'.

La valeur booléenne retournée par la All méthode est généralement utilisée dans le prédicat d’une where clause (Where clause en Visual Basic) ou dans un appel direct à la Where méthode. L’exemple suivant illustre cette utilisation de la All méthode.

class Pet
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Person
{
    public string LastName { get; set; }
    public Pet[] Pets { get; set; }
}

public static void AllEx2()
{
    List<Person> people = new List<Person>
        { new Person { LastName = "Haas",
                       Pets = new Pet[] { new Pet { Name="Barley", Age=10 },
                                          new Pet { Name="Boots", Age=14 },
                                          new Pet { Name="Whiskers", Age=6 }}},
          new Person { LastName = "Fakhouri",
                       Pets = new Pet[] { new Pet { Name = "Snowball", Age = 1}}},
          new Person { LastName = "Antebi",
                       Pets = new Pet[] { new Pet { Name = "Belle", Age = 8} }},
          new Person { LastName = "Philips",
                       Pets = new Pet[] { new Pet { Name = "Sweetie", Age = 2},
                                          new Pet { Name = "Rover", Age = 13}} }
        };

    // Determine which people have pets that are all older than 5.
    IEnumerable<string> names = from person in people
                                where person.Pets.All(pet => pet.Age > 5)
                                select person.LastName;

    foreach (string name in names)
    {
        Console.WriteLine(name);
    }

    /* This code produces the following output:
     *
     * Haas
     * Antebi
     */
}

Structure Pet
    Public Name As String
    Public Age As Integer
End Structure

Structure Person
    Public LastName As String
    Public Pets() As Pet
End Structure

Sub AllEx2()
    Dim people As New List(Of Person)(New Person() _
{New Person With {.LastName = "Haas",
                  .Pets = New Pet() {New Pet With {.Name = "Barley", .Age = 10},
                                     New Pet With {.Name = "Boots", .Age = 14},
                                     New Pet With {.Name = "Whiskers", .Age = 6}}},
  New Person With {.LastName = "Fakhouri",
                   .Pets = New Pet() {New Pet With {.Name = "Snowball", .Age = 1}}},
  New Person With {.LastName = "Antebi",
                   .Pets = New Pet() {New Pet With {.Name = "Belle", .Age = 8}}},
  New Person With {.LastName = "Philips",
                   .Pets = New Pet() {New Pet With {.Name = "Sweetie", .Age = 2},
                                      New Pet With {.Name = "Rover", .Age = 13}}}})

    ' Determine which people have pets that are all older than 5.
    Dim names = From person In people
                Where person.Pets.All(Function(pet) pet.Age > 5)
                Select person.LastName

    For Each name As String In names
        Console.WriteLine(name)
    Next

    ' This code produces the following output:
    '
    ' Haas
    ' Antebi

End Sub

Remarques

Notes

Cette méthode ne retourne pas tous les éléments d’une collection. Au lieu de cela, il détermine si tous les éléments d’une collection satisfont à une condition.

L’énumération de source est arrêtée dès que le résultat peut être déterminé.

Dans la syntaxe d’expression de requête Visual Basic, une Aggregate Into All() clause se traduit par un appel de All.

Voir aussi

• Aggregate, clause (Visual Basic)