Question

我正在尝试为IQueryable<T>创建通用扩展方法。 T是抽象Player，IQueryable可以包含具体类型Goalkeeper和Striker。

public abstract class Player
{
    public string Name { get; set; }
    public string Fouls { get; set; }
}

public class Goalkeeper : Player
{
    public int Saves { get; set; }

}

public class Striker : Player
{
    public int Goals { get; set; }
}

正在运行的扩展方法（简单的方法）如下所示：

public static IQueryable<Goalkeeper> NotPerforming(this IQueryable<Goalkeeper> goalkeepers)
{
    return goalkeepers.Where(g => g.Saves < goalkeepers.Average(x => x.Saves));
}

public static IQueryable<Striker> NotPerforming(this IQueryable<Striker> strikers)
{
    return strikers.Where(g => g.Goals < strikers.Average(x => x.Goals));
}

我可以这样使用：

var badGoalies = players.OfType<Goalkeeper>().NotPerforming();
var badStrikers = players.OfType<Striker>().NotPerforming();

所以现在我想查询表现不佳的所有的。

var badPlayers = players.NotPerforming();

我似乎无法正常工作。

public static IQueryable<T> NotPerforming<T>(this IQueryable<T> players) where T : Player { // what to do here? }

我尝试过像......

return players.OfType<Striker>().NotPerforming() .Union( players.OfType<Goalkeeper>().NotPerforming() );

哪个不起作用。

这样做的最佳实践方法是什么 - 并且不必离开LINQ-to-SQL，因为我希望继续使用链接扩展方法 - 并保持良好的性能？

Answer 1

您可以创建另一个扩展方法并输入逻辑：

public static IQueryable<Player> NotPerforming(this IQueryable<Player> players)
{
    var notPerformingGoalKeepers = players.NotPerformingGoalkeepers();
    var notPerformingStrikers = players.NotPerformingStrikers();

    return notPerformingGoalKeepers.Cast<Player>()
        .Concat(notPerformingStrikers);
}

public static IQueryable<Goalkeeper> NotPerformingGoalkeepers(this IQueryable<Player> players)
{
    var goalkeepers = players.OfType<Goalkeeper>();
    return goalkeepers.Where(g => g.Saves < goalkeepers.Average(x => x.Saves));
}

public static IQueryable<Striker> NotPerformingStrikers(this IQueryable<Player> players)
{
    var strikers = players.OfType<Striker>();
    return strikers.Where(g => g.Goals < strikers.Average(x => x.Goals));
}

并使用：

var badPlayers = players.NotPerforming();

或其他方法：

public static IQueryable<Player> NotPerforming<T>(this IQueryable<Player> players) where T : Player
{
    if (typeof(T) == typeof(Goalkeeper))
    {
        return players.OfType<Goalkeeper>().NotPerforming();
    }

    if (typeof(T) == typeof(Striker))
    {
        return players.OfType<Striker>().NotPerforming();
    }

    return null;
}

private static IQueryable<Goalkeeper> NotPerforming(this IQueryable<Goalkeeper> goalkeepers)
{
    return goalkeepers.Where(g => g.Saves < goalkeepers.Average(x => x.Saves));
}

private static IQueryable<Striker> NotPerforming(this IQueryable<Striker> strikers)
{
    return strikers.Where(g => g.Goals < strikers.Average(x => x.Goals));
}

并使用：

var badStrikers = players.NotPerforming<Striker>();
var badGoalkeepers = players.NotPerforming<Goalkeeper>();

var badPlayers = players.NotPerforming<Striker>()
    .Concat(players.NotPerforming<Goalkeeper>());

关于各种派生类型集合的通用LINQ to SQL扩展方法

1 个答案: