Question

我有以下Application类型的对象的列表，如下所示：

public class Application
    {
        public int AppId { get; set; }
        public List<Question> Questions { get; set; }
    }

我想要做的是将它们映射为Section类型的对象，如下所示：

public class Section
       {
            public List<int> AppIds { get; set; }
            public List<Question> Questions { get; set; }
        }

通过按照以下规则将它们分组：在包含这些问题的AppId列表下收集所有相同的问题。示例输入和输出：

Input: A1(Q1,Q2,Q3), A2(Q1,Q2), A3(Q1,Q3), A4(Q1). 
Output: A1,A2,A3,A4(Q1), A1,A2(Q2), A1,A3(Q3)

有可能在LINQ中做到吗？还是我必须自己编写逻辑？

Answer 1

也许有一种更简单的方法，但这是我编写的第一个LINQ查询，至少应该足以使您入门。首先，我将您的问题和appid弄平，然后按问题重新分组，然后按问题列出您的appid。请注意，在运行之前，您必须填充List个应用程序。

List<Application> app = new List<Application>();
var output = (from a in app.SelectMany(p => p.Questions.Select(z => new {z, p.AppId})
group a.AppId by new 
{
a.Questions
} into combined
select new 
{
combined.Key.Questions,
combined.ToList()
});

Answer 2

我认为这个问题被略微描述了。每个应用程序应具有不同的AppId，因此基本上没有任何分组依据，因为所有AppId都不同。相反，我们应该按问题分组，因为每个应用程序都可能有相同的问题。

这就是我所拥有的（就样式而言，它与确切的输出不匹配，因为您的示例输出基于AppId的分组而不是问题，但预期结果是相同的）：

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {       
        // create Questions

        var questionOne = new Question(){QuestionId = 1, ActualQuestion = "Who"};
        var questionTwo = new Question(){QuestionId = 2, ActualQuestion = "What"};
        var questionThree = new Question(){QuestionId = 3, ActualQuestion = "Where"};

        // Assign questions to the specified list of questions

        var applicationOneQuestions = new List<Question>(){questionOne, questionTwo, questionThree};
        var applicationTwoQuestions = new List<Question>() {questionOne, questionTwo};
        var applicationThreeQuestions = new List<Question>() {questionOne, questionThree};
        var applicationFourQuestions = new List<Question>() {questionOne};

        // Create Applications

        var applicationOne = new Application(){AppId = 1, Questions = applicationOneQuestions};
        var applicationTwo = new Application(){AppId = 2, Questions = applicationTwoQuestions};
        var applicationThree = new Application() {AppId = 3, Questions = applicationThreeQuestions};
        var applicationFour = new Application() {AppId = 4, Questions = applicationFourQuestions};

        // Create List of Applications

        var lstApplications = new List<Application>(){applicationOne, applicationTwo, applicationThree, applicationFour};

        // Group Applications based on Questions and cast to Section Object

        var groupApplications = lstApplications.GroupBy(x => x.Questions).Select(t => new Section { AppIds = t.Select(z => z.AppId).ToList() , Questions = t.Key}).ToList();

        foreach(var item in groupApplications)
        {
            foreach(var appId in item.AppIds)
            {
                Console.WriteLine(appId);

            }

            foreach(var question in item.Questions)
            {
                Console.WriteLine(question.ActualQuestion);
            }

            Console.WriteLine("\n");
        }
    }
}

public class Application
    {
        public int AppId { get; set; }
        public List<Question> Questions { get; set; }
    }

public class Section
       {
            public List<int> AppIds { get; set; }
            public List<Question> Questions { get; set; }
        }

public class Question
{
    public int QuestionId {get;set;}
    public string ActualQuestion {get;set;} 
}

输出

// 1
// Who
// What
// Where

// 2
// Who
// What

// 3
// Who
// Where

// 4
// Who

应用程序1、2、3、4都包含一个问题
应用程序1、2包含第二个问题
应用程序1、3包含问题3

请告诉我这是否有帮助。我也为您创建了一个DotNetFiddle，供您自己进行测试并提供反馈。

根据列表中的元素对同一对象进行分组

2 个答案: