在变量中使用 C# Select

Question

我有一个 linq select 零件，我经常使用它，所以我想知道是否有办法“重用”它，即将它放在某种变量中。

我的 linq 语句看起来有点像这样：

var today = DateTime.Now;
var tmp = _context.Student
.Where(b => b.Semester > 10)
.Select(b => new {
    BName = b.Name,
    SuperList = b.Seminars.SelectMany(sem => sem.DateFrom <= today && ......) // this is a superfancy and long subquery that I wanna reuse
});

由于我还有其他一些 linq 查询将使用完全相同的子查询，因此我尝试创建一个 function 来为我提供此子查询部分以供重用。 但唉，它不起作用，查询不会引发错误，但看起来好像子查询被完全忽略了：

var today = DateTime.Now;
var f1 = GetFancySubquery(today);

var tmp = _context.Student.Where(b => b.Semester > 10)
   .Select(b => new {
        BName = b.Name,
        SuperList = f1.Invoke(b)
    });       

private Func<Student, List<SemesterSomethingDTO>> GetFancySubquery(DateTime tag)
{
    Func<Student, List<SemesterSomethingDTO>> condition = s => s.Seminars.SelectMany(sem => ....).ToList();
    return condition;
}

我觉得我很接近（或者可能不是） - 我做错了什么？ 我想要做的甚至可能吗？

Answer 1

我对你的实体一无所知。 但是你可以试试归属码

var today = DateTime.Now;
var tmp = _context.Student.Include(i=>i.SuperList).Where(b => b.Semester > 10)
.Select(b => new {
   BName = b.Name,
   SuperList = b.Seminars.Where(sem => sem.DateFrom <= today && ......) 
});

Answer 2

我觉得我很接近（或者可能不是） - 我做错了什么？ 我想要做的甚至可能吗？

你确实很接近，是的，这是可能的。

我认为最好的方法是为 IEnumerable<Student> （您要查询的列表）创建一个扩展方法，因为您将在多个部分中重复使用查询，这就是扩展方法可以帮助您的原因保留东西 D.R.Y.

它会是这样的：

class Program
{
    static void Main(string[] args)
    {
        var today = DateTime.Now;
        List<Student> students = new List<Student>();

        // Not quite the same code as yours since I don't have all the classes
        // but it's the same idea
        var tmp = students
            .Where(b => b.Name == "Student 1")
            .Select(b => new
            {
                BName = b.Name,
                SuperList = b.Courses.Select(course => course.Semester == 2).ToList()
            });

        // This is exactly the same query using and extension method
        var tmp2 = students.FancyQuery("Student 1", 2);
    }
}

public static class LinqExtension
{
    /// <summary>
    /// Extension method to query an IEnumerable<Student> by name and course semester
    /// </summary>
    /// <param name="query">Type that the method extends</param>
    /// <param name="name">Student name</param>
    /// <param name="semester">Course semester</param>
    /// <returns>IEnumerable<QuerySelectResult> after filtering by name and semester</student></returns>
    public static List<QuerySelectResult> FancyQuery(this IEnumerable<Student> query, string name, int semester)
    {
        return query.Where(b => b.Name == name)
                .Select(b => new QuerySelectResult
                {
                    BName = b.Name,
                    SuperList = b.Courses.Where(course => course.Semester == 2).ToList()
                }).ToList();
    }
}

public class Student
{
    public string Name { get; set; }
    public List<Course> Courses { get; set; }
}

public class Course
{
    public string Name { get; set; }
    public int Semester { get; set; }
}

public class QuerySelectResult
{
    public string BName { get; set; }
    public List<Course> SuperList { get; set; }
}

笔记：

1. 扩展类和方法必须是公共的 static 才能工作。 AFAIK。
2. LinqExtension 的 FancyQuery方法上的这个 IEnumerable<Student>参数是指扩展所针对的类型。 例如，您将无法将它与 IEnumerable<int> 一起使用。
3. 代码与您的代码不完全相同，但试图重现类似的情况。
4. LinqExtension 不应与我的代码示例在同一个 class 中。 例如应该在 Extension 或 Helper 命名空间（文件夹）中。 要在代码的任何地方使用它，您应该插入一个带有其命名空间的 using 语句，并且它可以用于扩展您正在扩展的类型

如果有不清楚的地方，请询问:)

希望它有用。

编辑 1：现在扩展方法没有整个查询（Where 和 Select 子句）。

非常感谢：这里的问题是。 fancyQuery 现在包含整个查询，而我只希望子查询可重用。 rest 看起来可能非常不同。 所以不幸的是，这对我没有帮助

如何？ 好像我在这里错过了一个重要的拼图 - 我该怎么做？

class Program
{
    static void Main(string[] args)
    {
        var today = DateTime.Now;
        List<Student> students = new List<Student>();

        // Not quite the same code as yours since I don't have all the classes
        // but it's the same idea
        var tmp = students
            .Where(b => b.Name == "Student 1")
            .Select(b => new
            {
                BName = b.Name,
                SuperList = b.Courses.Select(course => course.Semester == 2).ToList()
            });

        // As you can see "students.Where(b => b.Name == "Student 1")" it's still and IEnumerable after the Where()
        // clause is used, so the extension method can be used after it
        var tmp2 = students.Where(b => b.Name == "Student 1").FancyQuery(2);
    }
}

public static class LinqExtension
{
    /// <summary>
    /// Extension method to query an IEnumerable<Student> by name and course semester
    /// </summary>
    /// <param name="query">Type that the method extends</param>
    /// <param name="name">Student name</param>
    /// <param name="semester">Course semester</param>
    /// <returns>IEnumerable<QuerySelectResult> after filtering by name and semester</student></returns>
    public static List<QuerySelectResult> FancyQuery(this IEnumerable<Student> query, int semester)
    {
        // Took out the Where() clause from here, and left only the Select() one
        return query.Select(b => new QuerySelectResult
        {
            BName = b.Name,
            SuperList = b.Courses.Where(course => course.Semester == semester).ToList()
        }).ToList();

    }
}

编辑 2：仅适用于 SuperList 的扩展方法（IEnumerable<Course> 与我的类）

但是 fancyQuery 添加了整个 select - 我不想要。 也许下次我不需要 BName 但想查询别的东西 - 我唯一需要的是 SuperList

您可以扩展您想要的任何类型，只需更改扩展方法的返回和签名。 现在它只用于 SuperList，但可以与任何类型为 IEnumerable<Course> 的 object 一起使用（在这种情况下）

static void Main(string[] args)
    {
        var today = DateTime.Now;
        List<Student> students = new List<Student>();

        // Not quite the same code as yours since I don't have all the classes
        // but it's the same idea
        var tmp = students
            .Where(b => b.Name == "Student 1")
            .Select(b => new
            {
                BName = b.Name,
                SuperList = b.Courses.Select(course => course.Semester == 2).ToList()
            });

        // Now the extension method is used only on SuperList 
        var tmp2 = students
            .Where(b => b.Name == "Student 1")
            .Select(b => new
            {
                BName = b.Name,
                SuperList = b.Courses.FancyQuery(2)
            });
    }
}

public static class LinqExtension
{
    /// <summary>
    /// Extension method to query an IEnumerable<Student> by name and course semester
    /// </summary>
    /// <param name="query">Type that the method extends</param>
    /// <param name="name">Student name</param>
    /// <param name="semester">Course semester</param>
    /// <returns>IEnumerable<QuerySelectResult> after filtering by name and semester</student></returns>
    public static List<Course> FancyQuery(this IEnumerable<Course> query, int semester)
    {
        // Took out the Where() clause from here, and left only the Select() one
        return query.Where(course => course.Semester == semester).ToList();

    }
}

Answer 3

此类辅助函数需要扩展为生成的表达式树。 vanilla EF 任何版本都不支持它。 我建议使用LINQKit来完成这样的任务：

public static class DTOExtensions
{
    [Expandable(nameof(GetFancySubqueryImpl))]
    public static List<SemesterSomethingDTO> GetFancySubquery(this Student student, DateTime tag)
    {
        throw new InvalidOperationException();
    }

    private static Expression<Student, DateTime, List<SemesterSomethingDTO>> GetFancySubqueryImpl()
    {
        return (student, tag) => student.Seminars.SelectMany(sem => ....).ToList();
    }
}

和用法：

var today = DateTime.Now;
var tmp = _context.Student
    .Where(b => b.Semester > 10)
    .AsExpandable() // activating LINQKit
    .Select(b => new {
        BName = b.Name,
        SuperList = b.GetFancySubquery(today)
    });

Answer 4

看起来您缺少 .Include 语句以确保已加载研讨会数据。

如果你尝试它是否有效：

_context.Student.Include(s => s.Seminars)... // continue your query here

您可以阅读更多关于。包括在此处。

此外，您可以将 Func 委托声明为变量，而不是从 function 中返回它。 考虑微软文档中的这个例子：

// Declare a Func variable and assign a lambda expression to the
// variable. The method takes a string and converts it to uppercase.
Func<string, string> selector = str => str.ToUpper();

// Create an array of strings.
string[] words = { "orange", "apple", "Article", "elephant" };
// Query the array and select strings according to the selector method.
IEnumerable<String> aWords = words.Select(selector);