C# 为什么分组联接的结果重复2次？

我在2个集合之间编写一个分组联接 一年级学生 2-madrak 每个madrak有许多学生，每个学生有一个madrak 换句话说，和表之间存在一对多的关系

分组联接的结果为 ![组加入]：（）

重复2次。 我不明白为什么我们有4个小组

namespace ConsoleApp4{
class Program
{
   static void Main(string[] args)
    {
        IList<Student> studentList = new List<Student>()
                                {
                                new Student() { StudentID = 1, StudentName 
                                  = "davod zarei", MadrakID =1 },
                                new Student() { StudentID = 2, StudentName 
                                = "eshrat alipour", MadrakID =1 },
                                new Student() { StudentID = 3, StudentName 
                                = "hadi pournader", MadrakID =2 },
                                new Student() { StudentID = 4, StudentName 
                                = "mahdi chegini", MadrakID =2 },
                                new Student() { StudentID = 5, StudentName 
                                 = "Bozorg Mirzahoseini"}
                               };
        IList<Madrak> madrakList = new List<Madrak>()
                                {
                                new Madrak(){ MadrakID = 1, 
                                 MadrakName="lisance"},
                                new Madrak(){ MadrakID = 2, 
                                MadrakName="arshad"},
                                new Madrak(){ MadrakID = 3, 
                                MadrakName="phd"},
                                };
       var GroupJoinResult2 =
             from md in madrakList
             join  stu in studentList
             on md.MadrakID  equals stu.MadrakID into MachedStudent
             from item in MachedStudent
             select new { Key = md.MadrakID, Items = MachedStudent };
      Console.WriteLine("---------- group Join  Result ----------");
      foreach (var item in GroupJoinResult2)
        {
            Console.WriteLine(item.Key + ":");
            foreach (var element in item.Items)
            {
                Console.WriteLine("   " + element.StudentName);
            }
        }

        Console.ReadKey();
        }
    }
public class Student
{
    public int StudentID { get; set; }
    public string StudentName { get; set; }
    public int MadrakID { get; set; }
}

public class Madrak
{
    public int MadrakID { get; set; }
    public string MadrakName { get; set; }
}
}

名称空间控制台EAPP4{
班级计划
{
静态void Main（字符串[]参数）
{
IList studentList=新列表（）
{
new Student（）{StudentID=1，StudentName
=“davod zarei”，MadrakID=1}，
new Student（）{StudentID=2，StudentName
=“eshrat alipour”，MadrakID=1}，
new Student（）{StudentID=3，StudentName
=“哈迪·波尔纳德”，MadrakID=2}，
new Student（）{StudentID=4，StudentName
=“mahdi chegini”，MadrakID=2}，
new Student（）{StudentID=5，StudentName
=“博佐尔格·米尔扎霍塞尼”}
};
IList madrakList=新列表（）
{
新的Madrak（）{MadrakID=1，
MadrakName=“lisance”}，
新的Madrak（）{MadrakID=2，
MadrakName=“arshad”}，
新的Madrak（）{MadrakID=3，
MadrakName=“phd”}，
};
var GroupJoinResult2=
来自madrakList的md
加入斯图的学生名单
MadrakID博士等于stu.MadrakID成为MachedStudent
来自MachedStudent中的项目
选择新{Key=md.MadrakID，Items=machedstudion}；
Console.WriteLine（“------------组联接结果-----------------”；
foreach（GroupJoinResult2中的变量项）
{
Console.WriteLine（item.Key+“：”）；
foreach（item.Items中的var元素）
{
Console.WriteLine（“+element.StudentName”）；
}
}
Console.ReadKey（）；
}
}
公立班学生
{
公共int StudentID{get；set；}
公共字符串StudentName{get；set；}
公共整数MadrakID{get；set；}
}
公营马德拉克酒店
{
公共整数MadrakID{get；set；}
公共字符串MadrakName{get；set；}
}
}

我不明白为什么我们有4个小组

namespace ConsoleApp4{
class Program
{
   static void Main(string[] args)
    {
        IList<Student> studentList = new List<Student>()
                                {
                                new Student() { StudentID = 1, StudentName 
                                  = "davod zarei", MadrakID =1 },
                                new Student() { StudentID = 2, StudentName 
                                = "eshrat alipour", MadrakID =1 },
                                new Student() { StudentID = 3, StudentName 
                                = "hadi pournader", MadrakID =2 },
                                new Student() { StudentID = 4, StudentName 
                                = "mahdi chegini", MadrakID =2 },
                                new Student() { StudentID = 5, StudentName 
                                 = "Bozorg Mirzahoseini"}
                               };
        IList<Madrak> madrakList = new List<Madrak>()
                                {
                                new Madrak(){ MadrakID = 1, 
                                 MadrakName="lisance"},
                                new Madrak(){ MadrakID = 2, 
                                MadrakName="arshad"},
                                new Madrak(){ MadrakID = 3, 
                                MadrakName="phd"},
                                };
       var GroupJoinResult2 =
             from md in madrakList
             join  stu in studentList
             on md.MadrakID  equals stu.MadrakID into MachedStudent
             from item in MachedStudent
             select new { Key = md.MadrakID, Items = MachedStudent };
      Console.WriteLine("---------- group Join  Result ----------");
      foreach (var item in GroupJoinResult2)
        {
            Console.WriteLine(item.Key + ":");
            foreach (var element in item.Items)
            {
                Console.WriteLine("   " + element.StudentName);
            }
        }

        Console.ReadKey();
        }
    }
public class Student
{
    public int StudentID { get; set; }
    public string StudentName { get; set; }
    public int MadrakID { get; set; }
}

public class Madrak
{
    public int MadrakID { get; set; }
    public string MadrakName { get; set; }
}
}

你把一组学生和一个学生混为一谈，把团体加入和常规加入搞得很奇怪

让我们详细讨论一下

我将简化您的代码。让我们从简化学生类型开始：

public class Student
{
    public Student(string s, string m) 
    {
        StudentName = s;
        MadrakName = m;
    }
    public string StudentName { get; set; }
    public string MadrakName { get; set; }
    public override string ToString() { return StudentName; }
}

一所学校可以只是一根绳子。现在我们有四名学生和三所学校：

    var studentList = new List<Student>() {
        new Student("S1", "M1"),
        new Student("S2", "M1"),
        new Student("S3", "M2"),
        new Student("S4", "M2")
    };
    var madrakList = new List<string>() { "M1", "M2", "M3" };

现在，让我们打印出以下各项：

   foreach(var item in q)
       Console.WriteLine("{" + string.Join(",", item) + "}");

我们得到了我们想要的：

{S1,S2}
{S3,S4}
{}

有三所学校，所以你应该在你的小组中加入三行

现在，你为什么得到你的查询结果您已将您的群加入恢复为常规加入。让我们在您的查询上尝试一种变体：

         from m in madrakList
         join s in studentList
         on m equals s.MadrakName into MatchedStudent
         from item in MatchedStudent
         select new { Key = m, Items = item };

item

接受值S1、S2、S3、S4，这表示生成一个元组，其中键是学校，

m

，项是学生。你所做的只是一种非常复杂的写作方式

         from m in madrakList
         join s in studentList
         on m equals s.MadrakName 
         select new { Key = m, Items = s }

也就是说，正常连接，而不是组连接。显然，这有四行，因为它们是：

M1, S1
M1, S2
M2, S3
M2, S4

学校有四名学生，所以在你的正常连接中应该有四排

但那不是你写的。你写的

         from m in madrakList
         join s in studentList
         on m equals s.MadrakName into MatchedStudent
         from item in MatchedStudent
         select new { Key = m, Items = MatchedStudent }; 
         // MatchedStudent is a list of students!

那么现在你得到了什么？而不是

M1, S1
M1, S2
M2, S3
M2, S4

我们在列中有一个学生，而在列中有所有匹配的学生：

M1, {S1, S2} // From S1
M1, {S1, S2} // From S2
M2, {S3, S4} // From S3
M2, {S3, S4} // From S4

基本上，您已经编写了一个非常奇怪的常规连接和组连接的组合。该表采用常规联接的形式，有四行，每一行对应一个学校的学生，但行中的每个“学生”都是组中匹配学生的完整列表

看起来您很困惑，忘记了

MatchedStudent

是一个学生列表，因为它是一个组加入。你把它当学生看待，但那也是错误的

您打算编写的代码可能是：

    var q =
         from m in madrakList
         join s in studentList
         on m equals s.MadrakName into studentsInMadrak
         select new { Madrak = m, Students = studentsInMadrak };
   foreach(var item in q)
       Console.WriteLine(item.Madrak + "{" +  
         string.Join(",", item.Students) + "}");

打印出来的

M1{S1,S2}
M2{S3,S4}
M3{}

---

这些都有意义吗？

您的代码存在严重的格式问题。。。