混凝土浇筑IEnumerable界面

Question

我有这样的东西：

    public interface IThing
    {
        string Id { get; }
    }
    public class Ball : IThing
    {
        public string Id { get; }
    }

    public class Car : IThing
    {
        public string Id { get; }
    }

对于我的3-4函数，我想对Ball和Car进行同样的处理。我使用这个界面，所以我不需要做过载的方法(一种用于汽车，一种用于球)。

最后，在函数中，如果是Ball或Car，则有不同的逻辑。我得到一个IEnumerable<IThings>，我想将它转换为IEnumerable<Car>或IEnumerable<Ball>，这取决于它由什么组成。如果它是混合的，我希望它失败。必须是所有的汽车或所有的球。

我试过这样的方法：

        var things = (inputs is IEnumerable<Ball>) ? input.Locations.Cast<Ball>() : input.Locations.Cast<Car>()

但它不喜欢那样。什么是推荐的方法，我可以有一个变量？

编辑：

我之所以想把它放到一个变量中，是因为我将它发送到重载的方法中。所以我想这么做：

        var things = (inputs is IEnumerable<Ball>) ? input.Locations.Cast<Ball>() : input.Locations.Cast<Car>()

        for (var i = 0; i < numRequests; i++)
        {
            var thingsSet = things.Skip(i * 1000).Take(1000);
            var results = callOverLoadedFunction(thingsSet);
        }

而不是这样：

        if (inputs is IEnumerable<Ball>)
        {
            var things = input.Locations.Cast<Ball>();
            for (var i = 0; i < numRequests; i++)
            {
                var thingsSet = things.Skip(i * 1000).Take(1000);
                var results = callOverLoadedFunction(thingsSet);
            }
        }
        else
        {
            var things = input.Locations.Cast<Car>();
            for (var i = 0; i < numRequests; i++)
            {
                var thingsSet = things.Skip(i * 1000).Take(1000);
                var results = callOverLoadedFunction(thingsSet);
            }
        }

Answer 1

您的尝试中的问题是：

inputs is IEnumerable<Ball>

因为只包含Ball类型元素的Ball与IEnumerable<Ball>的类型不同。您真的别无选择，只能在集合中进行枚举，以确定每个项是否符合您所需的类型。您可以使用.Cast<...>()并处理InvalidCastException，但这有点麻烦。另一种方法是使用OfType<...>

var cars = inputs.OfType<Car>();
var balls = inputs.OfType<Ball>();

现在，您可以根据自己的意愿处理这些问题，例如：

if(balls.Any() && cars.Any())
{
    //You're not allowed to have balls and cars together
    throw new Exception(...);
}

然而，你真的打破了固体的开放/封闭原则在这里，它似乎你应该考虑在一个更高的层次，你正在努力实现什么。

Answer 2

您可以执行一个转换方法，但这仍然会破坏一些原则，因为您仍然需要放置一个if语句。我不确定，您正在使用的接口与您想要实现的正确的方式。

如果您希望car在特定情况下的行为与ball不同，那么car中的实现将执行而不是球中的实现。

不要试图从外部调整接口。实现必须这样做。

为什么不用DoMySpecialStuff在IThing中创建一个方法，然后在这个特殊的方法中迭代您的可枚举方法，该方法只对所有元素调用DoMySpecialStuff？这样你才能避免你的if-语句。

我刚看到你用overloadedMethod编辑

所以它可以这样工作：

for (var i = 0; i < numRequests; i++)
    {
        var thingsSet = things.Skip(i * 1000).Take(1000);
        var results = callOverLoadedFunction(thingsSet);
    }

void OverLoadedFunction(IThing thing)
{
    thing.DoSpecialStuff(); // This does different things in car/ball
}

Answer 3

您可以使用LINQ将球和汽车分开。

IEnumerable<Ball> balls = things.OfType<Ball>();
IEnumerable<Car> cars = things.OfType<Car>();

如果您希望它失败，并像一行解决方案一样，尝试这样的方法

IEnumerable<Ball> balls = things.OfType<Ball>().Count() == things.Count() ? things.OfType<Ball>() : null; //or whatever you want