C# 如何在多对多关系实体框架linq lambda表达式中使用谓词方法？

我的问题很难解决。我需要你帮我解决这个问题。codefirst中存在多对多关系。但我无法解决这个问题。我想使用谓词func。但我不能解决它吗？如何使用“方法（谓词函数）”

public int方法（谓词func）
{
var s1=this.Uow.X.GetAll（）.Where（func）
.SelectMany（a=>a.OrganizationalUnits.Where（q=>Identity.Y.Contains（q.Z）））
.GroupBy（t=>t，（k，g）=>new
{
Tag=k，
Count=g.Count（）
})
.OrderByDescending（g=>g.Count）；
var s2=this.Uow.X.GetAll（）.Where（func）
.SelectMany（a=>a.Classes.Where（q=>Identity.Y.Contains（q.K）））
.GroupBy（t=>t，（k，g）=>new
{
Tag=k，
Count=g.Count（）
})
.OrderByDescending（g=>g.Count）；
var s3=this.Uow.X.GetAll（）.Where（func）
.SelectMany（a=>a.Courses.Where（q=>Identity.Y.Contains（q.L）））
.GroupBy（t=>t，（k，g）=>new
{
Tag=k，
Count=g.Count（）
})
.OrderByDescending（g=>g.Count）；
返回s1.ToString（）.Count（）+s2.ToString（）.Count（）+s3.ToString（）.Count（）；
}

以下是方法。我还删除了最后一行中的

ToString（）

s，因为不需要将对象作为字符串来计数

这样调用：

intresult=Method（p=>p==aValue）

代码：

公共静态int方法（此类型为me，表达式谓词）
{
var allOfEm=me.Uow.X.GetAll（）.Where（谓词）；
var s1=allOfEm
.SelectMany（a=>a.OrganizationalUnits.Where（q=>Identity.Y.Contains（q.Z）））
.Distinct（）；
var s2=allOfEm
.SelectMany（a=>a.Classes.Where（q=>Identity.Y.Contains（q.K）））
.Distinct（）；
var s3=allOfEm
.SelectMany（a=>a.Courses.Where（q=>Identity.Y.Contains（q.L）））
.Distinct（）；
返回s1.Count（）+s2.Count（）+s3.Count（）；
}
不清楚您在这里有什么以及您在问什么……您的方法GetAll是返回IEnumerable还是返回IQueryable？
     public int Method<T>(Predicate<T> func)
    {


        var s1 = this.Uow.X.GetAll().Where(func)
                       .SelectMany(a => a.OrganizationalUnits.Where(q => Identity.Y.Contains(q.Z)))
                      .GroupBy(t => t, (k, g) => new
                      {
                          Tag = k,
                          Count = g.Count()
                      })
                      .OrderByDescending(g => g.Count);


        var s2 = this.Uow.X.GetAll().Where(func)
                        .SelectMany(a => a.Classes.Where(q => Identity.Y.Contains(q.K)))
                        .GroupBy(t => t, (k, g) => new
                        {
                            Tag = k,
                            Count = g.Count()
                        })
                        .OrderByDescending(g => g.Count);


        var s3 = this.Uow.X.GetAll().Where(func)
                        .SelectMany(a => a.Courses.Where(q => Identity.Y.Contains(q.L)))
                        .GroupBy(t => t, (k, g) => new
                        {
                            Tag = k,
                            Count = g.Count()
                        })
                        .OrderByDescending(g => g.Count);



        return s1.ToString().Count() + s2.ToString().Count() + s3.ToString().Count();
    }

 public int Method<T>(Expression<Func<T, Boolean>> Predicate)
{


    var s1 = this.Uow.X.GetAll().Where(Predicate)
                   .SelectMany(a => a.OrganizationalUnits.Where(q => Identity.Y.Contains(q.Z)))
                  .GroupBy(t => t, (k, g) => new
                  {
                      Tag = k,
                      Count = g.Count()
                  })
                  .OrderByDescending(g => g.Count);


    var s2 = this.Uow.X.GetAll().Where(Predicate)
                    .SelectMany(a => a.Classes.Where(q => Identity.Y.Contains(q.K)))
                    .GroupBy(t => t, (k, g) => new
                    {
                        Tag = k,
                        Count = g.Count()
                    })
                    .OrderByDescending(g => g.Count);


    var s3 = this.Uow.X.GetAll().Where(Predicate)
                    .SelectMany(a => a.Courses.Where(q => Identity.Y.Contains(q.L)))
                    .GroupBy(t => t, (k, g) => new
                    {
                        Tag = k,
                        Count = g.Count()
                    })
                    .OrderByDescending(g => g.Count);

    return s1.Count() + s2.Count() + s3.Count();
}

thisType something = new something();
someType aValue = X; // don't know the type here.

// do stuff with something

int result = something.Method(p => p == aValue);

public static int Method(this thisType me, Expression<Func<someType, Boolean>> Predicate)
{
    var allOfEm = me.Uow.X.GetAll().Where(Predicate);

    var s1 = allOfEm
              .SelectMany(a => a.OrganizationalUnits.Where(q => Identity.Y.Contains(q.Z)))
              .Distinct();

    var s2 = allOfEm
              .SelectMany(a => a.Classes.Where(q => Identity.Y.Contains(q.K)))
              .Distinct();

    var s3 = allOfEm
              .SelectMany(a => a.Courses.Where(q => Identity.Y.Contains(q.L)))
              .Distinct();

    return s1.Count() + s2.Count() + s3.Count();
}