Queryable.All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) Méthode

Définition

Détermine si tous les éléments d'une séquence satisfont à une condition.Determines whether all the elements of a sequence satisfy a condition.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static bool All(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, bool> ^> ^ predicate);
public static bool All<TSource> (this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,bool>> predicate);
static member All : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, bool>> -> bool
<Extension()>
Public Function All(Of TSource) (source As IQueryable(Of TSource), predicate As Expression(Of Func(Of TSource, Boolean))) As Boolean

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

Paramètres

source
IQueryable<TSource>

Séquence dont les éléments doivent être testés par rapport à une condition.A sequence whose elements to test for a condition.

predicate
Expression<Func<TSource,Boolean>>

Fonction permettant de tester chaque élément par rapport à une condition.A function to test each element for a 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.true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.

Exceptions

source ou predicate est null.source or predicate is null.

Exemples

L’exemple de code suivant montre comment utiliser All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) pour déterminer si tous les éléments d’une séquence satisfont à une condition.The following code example demonstrates how to use All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) to determine whether all the elements in a sequence satisfy a condition.

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

public static void AllEx1()
{
    // 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.AsQueryable().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'.

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

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

    MsgBox(String.Format( _
        "{0} pet names start with 'B'.", _
        IIf(allStartWithB, "All", "Not all")))
End Sub

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

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

La valeur booléenne All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) retournée par la méthode est généralement utilisée dans le prédicat d’une where clause ( Where clause dans Visual Basic) ou d’un appel direct à la Where méthode.The Boolean value that the All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) method returns is typically used in the predicate of a where clause (Where clause in Visual Basic) or a direct call to the Where method. L’exemple suivant illustre cette utilisation de la All méthode.The following example demonstrates this use of the All method.

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.AsQueryable().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.AsQueryable().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

Cette méthode a au moins un paramètre de type Expression<TDelegate> dont l’argument de type est l’un des Func<T,TResult> types.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Pour ces paramètres, vous pouvez passer une expression lambda et elle sera compilée dans un Expression<TDelegate> .For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

La All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) méthode génère un MethodCallExpression qui représente l’appel de All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) lui-même comme une méthode générique construite.The All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) method generates a MethodCallExpression that represents calling All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) itself as a constructed generic method. Il passe ensuite MethodCallExpression à la Execute<TResult>(Expression) méthode de IQueryProvider représenté par la Provider propriété du source paramètre.It then passes the MethodCallExpression to the Execute<TResult>(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Le comportement de requête qui se produit suite à l’exécution d’une arborescence d’expression qui représente l’appel de All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) dépend de l’implémentation du source type du paramètre.The query behavior that occurs as a result of executing an expression tree that represents calling All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depends on the implementation of the source parameter's type. Le comportement attendu est qu’il détermine si tous les éléments de source satisfont à la condition dans predicate .The expected behavior is that it determines if all the elements in source satisfy the condition in predicate.

S’applique à