Partage via


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()
{
    "Mango",
    "Orange",
    null,
    "Apple",
    3.0,
    "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.Contains('n', StringComparison.CurrentCultureIgnoreCase));

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 ArrayList() From {
    "Mango",
    "Orange",
    Nothing,
    "Apple",
    3.0,
    "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.Contains("n"c, StringComparison.CurrentCultureIgnoreCase))

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 d’une exécution différée. La valeur de retour immédiat est un objet qui stocke toutes les informations nécessaires à l’exécution de 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 directement sa GetEnumerator méthode, soit en utilisant foreach en C# ou For Each en Visual Basic.

La OfType<TResult>(IEnumerable) méthode retourne uniquement les éléments dans source qui sont non null et compatibles avec le type TResult. Pour recevoir une exception si un élément ne peut pas être casté 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 peut être appliquée à une collection qui a un type non paramétré, tel qu’un ArrayList. Cela est dû au fait que OfType étend le type IEnumerable. OfType non seulement être appliqué 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 obtenez la possibilité d’interroger la collection à l’aide des opérateurs de requête standard. Par exemple, la spécification d’un argument de type de Object à OfType renvoie 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 à