Enumerable.OfType<TResult>(IEnumerable) Méthode

Définition

Filtre les éléments d'un IEnumerable en fonction du type spécifié.

public:
generic <typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ OfType(System::Collections::IEnumerable ^ source);
public static System.Collections.Generic.IEnumerable<TResult> OfType<TResult> (this System.Collections.IEnumerable source);
static member OfType : System.Collections.IEnumerable -> seq<'Result>
<Extension()>
Public Function OfType(Of TResult) (source As IEnumerable) As IEnumerable(Of TResult)

Paramètres de type

TResult

Type en fonction duquel filtrer les éléments de la séquence.

Paramètres

source
IEnumerable

IEnumerable dont les éléments doivent être filtrés.

Retours

IEnumerable<TResult>

IEnumerable<T> qui contient des éléments de la séquence d'entrée de type TResult.

Exceptions

source a la valeur null.

Exemples

L’exemple de code suivant montre comment utiliser OfType pour filtrer les éléments d’un IEnumerable .

System.Collections.ArrayList fruits = new System.Collections.ArrayList(4);
fruits.Add("Mango");
fruits.Add("Orange");
fruits.Add("Apple");
fruits.Add(3.0);
fruits.Add("Banana");

// Apply OfType() to the ArrayList.
IEnumerable<string> query1 = fruits.OfType<string>();

Console.WriteLine("Elements of type 'string' are:");
foreach (string fruit in query1)
{
    Console.WriteLine(fruit);
}

// The following query shows that the standard query operators such as
// Where() can be applied to the ArrayList type after calling OfType().
IEnumerable<string> query2 =
    fruits.OfType<string>().Where(fruit => fruit.ToLower().Contains("n"));

Console.WriteLine("\nThe following strings contain 'n':");
foreach (string fruit in query2)
{
    Console.WriteLine(fruit);
}

// This code produces the following output:
//
// Elements of type 'string' are:
// Mango
// Orange
// Apple
// Banana
//
// The following strings contain 'n':
// Mango
// Orange
// Banana
' Create an ArrayList and add items to it.
Dim fruits As New System.Collections.ArrayList(4)
fruits.Add("Mango")
fruits.Add("Orange")
fruits.Add("Apple")
fruits.Add(3.0)
fruits.Add("Banana")

' Apply OfType(Of String)() to the ArrayList
' to filter out non-string items.
Dim query1 As IEnumerable(Of String) = fruits.OfType(Of String)()

' Print the results.
Dim output As New System.Text.StringBuilder("Elements of type 'string' are:" _
                                        & vbCrLf)
For Each fruit As String In query1
    output.AppendLine(fruit)
Next

' The following query shows that the standard query operators such as 
' Where() can be applied to the ArrayList type after calling OfType().
Dim query2 As IEnumerable(Of String) =
fruits.OfType(Of String)().Where(Function(fruit) _
                                     fruit.ToLower().Contains("n"))

output.AppendLine(vbCrLf & "The following strings contain 'n':")
For Each fruit As String In query2
    output.AppendLine(fruit)
Next

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

' This code produces the following output:
'
' Elements of type 'string' are:
' Mango
' Orange
' Apple
' Banana
'
' The following strings contain 'n':
' Mango
' Orange
' Banana

Remarques

Cette méthode est implémentée à l’aide de l’exécution différée. La valeur de retour immédiate est un objet qui stocke toutes les informations requises pour effectuer l’action. La requête représentée par cette méthode n’est pas exécutée tant que l’objet n’est pas énuméré soit en appelant sa GetEnumerator méthode directement, soit en utilisant foreach en Visual C# ou For Each dans Visual Basic.

La OfType<TResult>(IEnumerable) méthode retourne uniquement les éléments de source qui peuvent être castés en type TResult . Pour recevoir une exception à la place, si un élément ne peut pas être casté en type TResult , utilisez Cast<TResult>(IEnumerable) .

Cette méthode est l’une des quelques méthodes d’opérateur de requête standard qui peuvent être appliquées à une collection qui a un type non paramétrable, tel qu’un ArrayList . Cela est dû OfType au fait que étend le type IEnumerable . OfType ne peut pas être appliqué uniquement aux collections basées sur le type paramétré IEnumerable<T> , mais également aux collections basées sur le type non paramétrable IEnumerable .

En appliquant OfType à une collection qui implémente IEnumerable , vous pouvez interroger la collection à l’aide des opérateurs de requête standard. par exemple, la spécification d’un argument de type Object pour OfType retourne un objet de type IEnumerable<Object> en C# ou IEnumerable(Of Object) dans Visual Basic, auquel les opérateurs de requête standard peuvent être appliqués.

S’applique à