Enumerable.AsEnumerable<TSource>(IEnumerable<TSource>) Metoda

Definicja

Przestrzeń nazw:

System.Linq

Zestaw:

System.Linq.dll

Zestaw:

System.Core.dll

Zestaw:

netstandard.dll

Zwraca dane wejściowe wpisane jako IEnumerable<T>.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TSource> ^ AsEnumerable(System::Collections::Generic::IEnumerable<TSource> ^ source);

public static System.Collections.Generic.IEnumerable<TSource> AsEnumerable<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);

static member AsEnumerable : seq<'Source> -> seq<'Source>

<Extension()>
Public Function AsEnumerable(Of TSource) (source As IEnumerable(Of TSource)) As IEnumerable(Of TSource)

Parametry typu

TSource

Typ elementów elementu source.

Parametry

source

IEnumerable<TSource>

Sekwencja do wpisywania jako IEnumerable<T>.

Zwraca

IEnumerable<TSource>

Sekwencja wejściowa została wpisana jako IEnumerable<T>.

Przykłady

W poniższym przykładzie kodu pokazano, jak AsEnumerable<TSource>(IEnumerable<TSource>) ukryć metodę niestandardową Where typu, gdy wymagana jest standardowa implementacja operatora zapytania.

// Custom class.
class Clump<T> : List<T>
{
    // Custom implementation of Where().
    public IEnumerable<T> Where(Func<T, bool> predicate)
    {
        Console.WriteLine("In Clump's implementation of Where().");
        return Enumerable.Where(this, predicate);
    }
}

static void AsEnumerableEx1()
{
    // Create a new Clump<T> object.
    Clump<string> fruitClump =
        new Clump<string> { "apple", "passionfruit", "banana",
            "mango", "orange", "blueberry", "grape", "strawberry" };

    // First call to Where():
    // Call Clump's Where() method with a predicate.
    IEnumerable<string> query1 =
        fruitClump.Where(fruit => fruit.Contains("o"));

    Console.WriteLine("query1 has been created.\n");

    // Second call to Where():
    // First call AsEnumerable() to hide Clump's Where() method and thereby
    // force System.Linq.Enumerable's Where() method to be called.
    IEnumerable<string> query2 =
        fruitClump.AsEnumerable().Where(fruit => fruit.Contains("o"));

    // Display the output.
    Console.WriteLine("query2 has been created.");
}

// This code produces the following output:
//
// In Clump's implementation of Where().
// query1 has been created.
//
// query2 has been created.

Dim output As New System.Text.StringBuilder

' A custom class.
Class Clump(Of T)
    Inherits List(Of T)

    ' Constructor.
    Public Sub New(ByVal collection As IEnumerable(Of T))
        MyBase.New(collection)
    End Sub

    ' Custom implementation of Where().
    Function Where(ByVal predicate As Func(Of T, Boolean)) As IEnumerable(Of T)
        output.AppendLine("In Clump's implementation of Where().")
        Return Enumerable.Where(Me, predicate)
    End Function
End Class

Sub AsEnumerableEx1()
    ' Create a new Clump(Of T) object.
    Dim fruitClump As New Clump(Of String)(New String() _
                                       {"apple", "passionfruit", "banana",
                                        "mango", "orange", "blueberry",
                                        "grape", "strawberry"})

    ' First call to Where():
    ' Call Clump's Where() method with a predicate.
    Dim query1 As IEnumerable(Of String) =
    fruitClump.Where(Function(fruit) fruit.Contains("o"))
    output.AppendLine("query1 has been created." & vbCrLf)

    ' Second call to Where():
    ' First call AsEnumerable() to hide Clump's Where() method and thereby
    ' force System.Linq.Enumerable's Where() method to be called.
    Dim query2 As IEnumerable(Of String) =
    fruitClump.AsEnumerable().Where(Function(fruit) fruit.Contains("o"))
    output.AppendLine("query2 has been created.")

    ' Display the output.
    Console.WriteLine(output.ToString())
End Sub

' This code produces the following output:
'
' In Clump's implementation of Where().
' query1 has been created.
'
' query2 has been created.

Uwagi

Metoda AsEnumerable<TSource>(IEnumerable<TSource>) nie ma efektu innego niż zmiana typu source czasu kompilacji z typu implementowanego IEnumerable<T> do IEnumerable<T> samego siebie.

AsEnumerable<TSource>(IEnumerable<TSource>) Można użyć do wyboru między implementacjami zapytań, gdy sekwencja implementuje IEnumerable<T> , ale ma również inny zestaw dostępnych metod zapytań publicznych. Na przykład, biorąc pod uwagę klasę Table ogólną, która implementuje IEnumerable<T> i ma własne metody, takie jak Where, Selecti SelectMany, wywołanie metody wywołania Where metody publicznej Where .Table Table Typ reprezentujący tabelę bazy danych może mieć metodęWhere, która przyjmuje argument predykatu jako drzewo wyrażeń i konwertuje drzewo na SQL na potrzeby zdalnego wykonywania. Jeśli wykonanie zdalne nie jest pożądane, na przykład ponieważ predykat wywołuje metodę lokalną, AsEnumerable można użyć metody do ukrycia metod niestandardowych i zamiast tego udostępnić standardowe operatory zapytań.