Queryable.All<TSource> Metoda

Definicja

Przestrzeń nazw:

System.Linq

Zestaw:

System.Linq.Queryable.dll

Źródło:

Queryable.cs

Określa, czy wszystkie elementy sekwencji spełniają warunek.

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

Parametry typu

TSource

Typ elementów elementu source.

Parametry

source

IQueryable<TSource>

Sekwencja, której elementy do przetestowania pod kątem warunku.

predicate

Expression<Func<TSource,Boolean>>

Funkcja testowania każdego elementu na stanie.

Zwraca

Boolean

true jeśli każdy element sekwencji źródłowej przejdzie test w określonym predykacie lub jeśli sekwencja jest pusta; w przeciwnym razie , false.

Wyjątki

ArgumentNullException

source lub predicate ma wartość null.

Przykłady

W poniższym przykładzie kodu pokazano, jak za pomocą All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) metody określić, czy wszystkie elementy w sekwencji spełniają warunek.

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'.

Wartość logiczna zwracana All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) przez metodę jest zwykle używana w predykacie where klauzuli (Where klauzuli w Visual Basic) lub bezpośrednim wywołaniu Where metody. W poniższym przykładzie pokazano użycie All metody .

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

Uwagi

Ta metoda ma co najmniej jeden parametr typu Expression<TDelegate> , którego argument type jest jednym z Func<T,TResult> typów. Dla tych parametrów można przekazać wyrażenie lambda i zostanie skompilowane do elementu Expression<TDelegate>.

Metoda All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) generuje obiekt MethodCallExpression , który reprezentuje wywołanie All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) siebie jako skonstruowaną metodę ogólną. Następnie przekazuje MethodCallExpression wartość do Execute<TResult>(Expression) metody IQueryProvider reprezentowanej przez Provider właściwość parametru source .

Zachowanie zapytania, które występuje w wyniku wykonania drzewa wyrażeń reprezentującego wywołanie All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) , zależy od implementacji source typu parametru. Oczekiwane zachowanie polega na tym, że określa, czy wszystkie elementy w source obiekcie spełniają warunek w elemecie predicate.