Enumerable.AsEnumerable<TSource>(IEnumerable<TSource>) Méthode

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)

Paramètres de type

Paramètres

Retours

Séquence d'entrées typées comme IEnumerable<T>.

Exemples

L’exemple de code suivant montre comment utiliser AsEnumerable<TSource>(IEnumerable<TSource>) pour masquer la méthode personnalisée Where d’un type lorsque l’implémentation de l’opérateur de requête standard est souhaitée.

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

Remarques

La AsEnumerable<TSource>(IEnumerable<TSource>) méthode n’a pas d’autre effet que de changer le type au moment de la compilation d’un source type qui s’implémente IEnumerable<T> à IEnumerable<T> lui-même.

AsEnumerable<TSource>(IEnumerable<TSource>) peut être utilisé pour choisir entre des implémentations de requête lorsqu’une séquence implémente IEnumerable<T> , mais dispose également d’un ensemble différent de méthodes de requête publique disponibles. Par exemple, étant donné une classe Table générique qui implémente IEnumerable<T> et a ses propres méthodes telles que Where, Selectet SelectMany, un appel à Where appellerait la méthode publique Where de Table. Un Table type qui représente une table de base de données peut avoir une Where méthode qui prend l’argument de prédicat en tant qu’arborescence d’expressions et convertit l’arborescence en SQL pour une exécution à distance. Si l’exécution à distance n’est pas souhaitée, par exemple parce que le prédicat appelle une méthode locale, la AsEnumerable méthode peut être utilisée pour masquer les méthodes personnalisées et rendre les opérateurs de requête standard disponibles.

S’applique à