如何实现 NotOfType在 LINQ 中有一个很好的调用语法吗？

Question

我正在尝试提出 NotOfType 的实现，它具有可读的调用语法。 NotOfType 应该是 OfType 的补充，因此会产生所有不类型为 T 的元素

我的目标是实现一个像 OfType 一样被调用的方法，就像这个片段的最后一行一样：

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>();

但是，我无法提出支持该特定调用语法的实现。

这是我到目前为止所尝试过的：

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));
    }
}

调用这些方法将如下所示：

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

我

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

认为这两种调用的风格都存在重大缺陷。第一个存在冗余的“类型/类型”结构，而第二个则没有意义（我想要一个既不是动物也不是长颈鹿的动物列表吗？）。

那么，有没有办法实现我想要的呢？如果没有，在该语言的未来版本中可能吗？ （我在想也许有一天我们会有命名类型参数，或者我们只需要显式提供无法推断的类型参数？）

或者我只是在愚蠢？

Answer 1

我刚刚尝试过这个并且有效...

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

我错过了什么吗？

Answer 2

你可能会考虑这个

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 3

我不知道你为什么不直接说：

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

这对我来说似乎完全可读。对我来说，它肯定比 animals.NotOfType() 更直接，如果我遇到它，它会让我感到困惑......第一个永远不会让我困惑，因为它可以立即读取。

如果您想要一个流畅的界面，我想您也可以使用 Object 上的扩展方法谓词执行类似的操作：

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

Answer 4

或者

animals.NotOf(typeof(Giraffe));

，您可以将通用参数拆分为两种方法：

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

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

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

---

此外，您还需要决定是否也排除继承的类型。

Answer 5

这似乎是一个奇怪的建议，但是在普通的旧 IEnumerable 上使用扩展方法怎么样？这将镜像 OfType 的签名，并且还将消除冗余 类型参数的问题。

我还认为，如果您已经有一个强类型序列，则几乎没有理由使用特殊的 NotOfType 方法；从任意类型序列中排除特定类型似乎更有用（在我看来）......或者让我这样说：如果您正在处理IEnumerable，调用 Where(x => !(x is T)); 很简单；在这种情况下，像 NotOfType 这样的方法的有用性变得更加值得怀疑。

Answer 6

我遇到了类似的问题，在寻找答案时遇到了这个问题。

相反，我选择了以下调用语法：

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

它的缺点是它枚举了两次集合（因此不能与无限系列或枚举具有不应重复的副作用的集合一起使用），但优点是没有新的需要辅助函数，并且含义很明确。

在我的实际用例中，我最终还在 .OfType() 之后添加了 .Where(...) （长颈鹿也包括在内，除非它们满足仅对长颈鹿有意义的特殊排除条件）

Answer 7

如果你要制定一种推理方法，你想一路推理。 的示例：

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>();
    }
}

这需要每种类型

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