¿Cómo puedo implementar NotOfType <T> en LINQ que tiene una buena sintaxis de llamadas?

Question

Estoy intentando crear una implementación para NotOfType, que tiene una sintaxis de llamada legible. NotOfType debe ser el complemento a OfType<T> y sería por lo tanto producir todos los elementos que son no de tipo T

Mi objetivo era poner en práctica un método que se llama igual que OfType<T>, al igual que en la última línea de este fragmento:

public abstract class Animal {} 
public class Monkey : Animal {} 
public class Giraffe : Animal {} 
public class Lion : Animal {} 

var monkey = new Monkey(); 
var giraffe = new Giraffe(); 
var lion = new Lion(); 

IEnumerable<Animal> animals = new Animal[] { monkey, giraffe, lion }; 

IEnumerable<Animal> fewerAnimals = animals.NotOfType<Giraffe>(); 

Sin embargo, no puedo encontrar una implementación que admita esa sintaxis de llamada específica.

Esto es lo que he probado hasta ahora:

public static class EnumerableExtensions 
{ 
    public static IEnumerable<T> NotOfType<T>(this IEnumerable<T> sequence, Type type) 
    { 
     return sequence.Where(x => x.GetType() != type); 
    } 

    public static IEnumerable<T> NotOfType<T, TExclude>(this IEnumerable<T> sequence) 
    { 
     return sequence.Where(x => !(x is TExclude)); 
    } 
} 

llamar a estos métodos se vería así:

// Animal is inferred 
IEnumerable<Animal> fewerAnimals = animals.NotOfType(typeof(Giraffe)); 

y

// Not all types could be inferred, so I have to state all types explicitly 
IEnumerable<Animal> fewerAnimals = animals.NotOfType<Animal, Giraffe>(); 

Creo que hay grandes inconvenientes con el estilo de ambas llamadas. El primero sufre de una construcción redundante de "tipo/tipo de", y el segundo simplemente no tiene sentido (¿quiero una lista de animales que no son ni animales ni jirafas?).

Entonces, ¿hay alguna manera de lograr lo que quiero? Si no, ¿podría ser posible en futuras versiones del lenguaje? (Estoy pensando que tal vez algún día tengamos argumentos de tipo con nombre, o que solo necesitemos proporcionar explícitamente argumentos de tipo que no se puedan inferir?)

¿O solo estoy siendo tonto?

Answer 1

¿Qué tal

animals.NotOf(typeof(Giraffe)); 

Alternativamente, you can split the generic parameters across two methods:

animals.NotOf().Type<Giraffe>(); 

public static NotOfHolder<TSource> NotOf<TSource>(this IEnumerable<TSource> source); 

public class NotOfHolder<TSource> : IHideObjectMembers { 
    public IEnumerable<TSource> NotOf<TNot>(); 
} 

---

Además, es necesario decidir si también se excluye tipos heredados.

Answer 2

Esto podría parecer una sugerencia extraña, pero ¿qué pasa con un método de extensión en el antiguo IEnumerable? Esto reflejaría la firma de OfType<T>, y también eliminaría el problema de los parámetros de tipo redundante <T, TExclude>.

También argumentaría que si ya tiene una secuencia fuertemente tipada, hay muy pocas razones para un método especial NotOfType<T>; parece mucho más útil (en mi opinión) excluir un tipo específico de una secuencia de tipo arbitrario ... o déjenme decirlo de esta manera: si se trata de un IEnumerable<T>, es trivial llamar al Where(x => !(x is T)) ; la utilidad de un método como NotOfType<T> se vuelve más cuestionable en este caso.

Answer 3

No estoy seguro de por qué no acaba de decir:

animals.Where(x => !(x is Giraffe)); 

esto parece perfectamente legible para mí.Ciertamente, es más directo para mí que animals.NotOfType<Animal, Giraffe>(), lo que me confundiría si lo descubriera ... el primero nunca me confundiría, ya que es inmediatamente legible.

Si querías una interfaz fluida, supongo que también podría hacer algo como esto con un método predicado extensión en Object:

animals.Where(x => x.NotOfType<Giraffe>()) 

Answer 4

Si va a realizar un método para la inferencia, que desea inferir todo el camino. Eso requiere un ejemplo de cada tipo:

public static class ExtMethods 
{ 
    public static IEnumerable<T> NotOfType<T, U>(this IEnumerable<T> source) 
    { 
     return source.Where(t => !(t is U)); 
    } 
     // helper method for type inference by example 
    public static IEnumerable<T> NotOfSameType<T, U>(
     this IEnumerable<T> source, 
     U example) 
    { 
     return source.NotOfType<T, U>(); 
    } 
} 

llamado por

List<ValueType> items = new List<ValueType>() { 1, 1.0m, 1.0 }; 
IEnumerable<ValueType> result = items.NotOfSameType(2); 

Answer 5

He intentado esto y funciona ...

public static IEnumerable<TResult> NotOfType<TExclude, TResult>(this IEnumerable<TResult> sequence) 
    => sequence.Where(x => !(x is TExclude)); 

Me estoy perdiendo algo?

Answer 6

Considere esta

public static IEnumerable NotOfType<TResult>(this IEnumerable source) 
{ 
    Type type = typeof(Type); 

    foreach (var item in source) 
    { 
     if (type != item.GetType()) 
     { 
      yield return item; 
     } 
    } 
} 

Answer 7

tuve un problema similar, y me encontré con esta pregunta, mientras que en busca de una respuesta.

Yo en cambio se conformaron con la siguiente sintaxis llamando:

var fewerAnimals = animals.Except(animals.OfType<Giraffe>()); 

tiene la desventaja de que enumera la colección dos veces (por lo que no se puede utilizar con una serie infinita), pero la ventaja de que ninguna nueva función auxiliar es requerido, y el significado es claro.

En mi caso uso real, también terminó la adición de un .Where(...) después de los .OfType<Giraffe>() (jirafas también incluidos a menos que cumplan una condición particular exclusión que sólo tiene sentido para las jirafas)