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

Definição

Namespace:

System.Linq

Assembly:

System.Linq.dll

Origem:

Cast.cs

Filtra os elementos de um IEnumerable com base em um tipo especificado.

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)

Parâmetros de tipo

TResult

O tipo no qual filtrar os elementos da sequência.

Parâmetros

source

IEnumerable

O IEnumerable cujos elementos serão filtrados.

Retornos

IEnumerable<TResult>

Um IEnumerable<T> que contém elementos da sequência de entrada de tipo TResult.

Exceções

ArgumentNullException

source é null.

Exemplos

O exemplo de código a seguir demonstra como usar OfType para filtrar os elementos de um 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

Comentários

Esse método é implementado usando a execução adiada. O valor retornado imediato é um objeto que armazena todas as informações necessárias para executar a ação. A consulta representada por esse método não é executada até que o objeto seja enumerado chamando seu GetEnumerator método diretamente ou usando foreach em C# ou For Each no Visual Basic.

O OfType<TResult>(IEnumerable) método retorna apenas os elementos no que podem ser convertidos no source tipo TResult. Para, em vez disso, receber uma exceção se um elemento não puder ser convertido no tipo TResult, use Cast<TResult>(IEnumerable).

Esse método é um dos poucos métodos de operador de consulta padrão que podem ser aplicados a uma coleção que tem um tipo não parametrizado, como um ArrayList. Isso ocorre porque OfType estende o tipo IEnumerable. OfType não pode ser aplicado somente a coleções baseadas no tipo parametrizado IEnumerable<T> , mas também coleções baseadas no tipo não parametrizado IEnumerable .

Aplicando-se OfType a uma coleção que implementa IEnumerable, você obtém a capacidade de consultar a coleção usando os operadores de consulta padrão. Por exemplo, especificar um argumento de tipo de Object para OfType retornaria um objeto do tipo IEnumerable<Object> em C# ou IEnumerable(Of Object) no Visual Basic, ao qual os operadores de consulta padrão podem ser aplicados.