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 filtrer OfType 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édiat 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é en appelant directement sa GetEnumerator méthode ou en l’utilisant foreach dans Visual C# ou For Each dans Visual Basic.

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

Cette méthode est l’une des rares 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û au fait que OfType le type IEnumerableest étendu . OfType ne peut être appliqué qu’aux collections basées sur le type paramétrable IEnumerable<T> , mais aussi aux collections basées sur le type non paramétrable IEnumerable .

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

S’applique à