合并多个自定义对象列表的内容-C#

我有一个班级专题

public class Project 
{   public int ProjectId { get; set; }
    public string ProjectName { get; set; }
    public string Customer { get; set; }
    public string Address{ get; set; }
}

我有三张清单

List<Project> lst1; List<Project> lst2; List<Project> lst3;

列表lst1；清单2；清单lst3；

lst1

包含带有ProjectId和ProjectName的

Person

对象

ProjectId=1，ProjectName=“X”，客户=null，地址=null

ProjectId=2，ProjectName=“Y”，客户=null，地址=null

lst2

包含带有ProjectId和Customer的

Person

对象

ProjectId=1，ProjectName=null，Customer=“c1”，Address=null

ProjectId=2，ProjectName=null，Customer=“c2”，Address=null

，及

lst3

包含

Person

带有项目ID和地址的对象

ProjectId=1，ProjectName=null，Customer=null，Address=“a1”

ProjectId=2，ProjectName=null，Customer=null，Address=“a2”

考虑到每个列表中有多个这样的记录，并且每个项目的ProjectId都是Uniqe，我如何合并/组合这些列表以获得一个包含合并对象的列表

projectd=1，ProjectName=“X”，Customer=“c1”，address=“a1”

projectd=2，ProjectName=“Y”，Customer=“c2”，address=“a2”

我发现这些链接相似，并尝试使用它，但无法满足结果

---

谢谢。

我假设列表包含相同数量的项目，并按项目ID排序

List<Project> lst1; List<Project> lst2; List<Project> lst3

用于合并对象

List<Project> list4 = new List<Project>();
for(int i=1; i<list.Count; i++)
{ 
    list4.Add(new Project
    {
       ProjectId = list1[i].ProjectId;
       ProjectName = list1[i].ProjectName;
       Customer = list2[i].Customer;
       Address = list3[i].Address;
    });

}

List list4=新列表（）；
对于（inti=1；i我假设列表包含相同数量的项，并按ProjectId排序

List<Project> lst1; List<Project> lst2; List<Project> lst3

用于合并对象

List<Project> list4 = new List<Project>();
for(int i=1; i<list.Count; i++)
{ 
    list4.Add(new Project
    {
       ProjectId = list1[i].ProjectId;
       ProjectName = list1[i].ProjectName;
       Customer = list2[i].Customer;
       Address = list3[i].Address;
    });

}

List list4=新列表（）；
对于（inti=1；i我相信以下是LINQ
Join
的工作原理：

var mergedProjects =
    lst1
        .Join(lst2,
            proj1 => proj1.ProjectID,
            proj2 => proj2.ProjectID,
            (proj1, proj2) => new { Proj1 = proj1, Proj2 = proj2 })
        .Join(lst3,
            pair => pair.Proj1.ProjectID,
            proj3 => proj3.ProjectID,
            (pair, proj3) => new Project
            {
                ProjectID = proj3.ProjectID,
                ProjectName = pair.Proj1.ProjectName,
                Customer = pair.Proj2.Customer,
                Address = proj3.Address
            });

如果在所有三个列表中都找不到
ProjectID
，则不会返回任何结果

如果这是一个问题，我认为您最好手动执行此操作，而不是使用LINQ。
我相信以下是LINQ
Join
的工作原理：

var mergedProjects =
    lst1
        .Join(lst2,
            proj1 => proj1.ProjectID,
            proj2 => proj2.ProjectID,
            (proj1, proj2) => new { Proj1 = proj1, Proj2 = proj2 })
        .Join(lst3,
            pair => pair.Proj1.ProjectID,
            proj3 => proj3.ProjectID,
            (pair, proj3) => new Project
            {
                ProjectID = proj3.ProjectID,
                ProjectName = pair.Proj1.ProjectName,
                Customer = pair.Proj2.Customer,
                Address = proj3.Address
            });

如果在所有三个列表中都找不到
ProjectID
，则不会返回任何结果

如果这是一个问题，我认为您最好手动执行此操作，而不是使用LINQ。
尽管有些过分，但我还是尝试将其作为一种扩展方法：

public static List<T> MergeWith<T,TKey>(this List<T> list, List<T> other, Func<T,TKey> keySelector, Func<T,T,T> merge)
{
    var newList = new List<T>();
    foreach(var item in list)
    {
        var otherItem = other.SingleOrDefault((i) => keySelector(i).Equals(keySelector(item)));
        if(otherItem != null)
        {
            newList.Add(merge(item,otherItem));
        }
    }
    return newList;
}

活生生的例子：
尽管有些过分，我还是想把它作为一种扩展方法：

public static List<T> MergeWith<T,TKey>(this List<T> list, List<T> other, Func<T,TKey> keySelector, Func<T,T,T> merge)
{
    var newList = new List<T>();
    foreach(var item in list)
    {
        var otherItem = other.SingleOrDefault((i) => keySelector(i).Equals(keySelector(item)));
        if(otherItem != null)
        {
            newList.Add(merge(item,otherItem));
        }
    }
    return newList;
}

实时示例：
使用查找，您可以这样做：

        List<Project> lst = lst1.Union(lst2).Union(lst3).ToLookup(x => x.ProjectId).Select(x => new Project()
        {
            ProjectId = x.Key,
            ProjectName = x.Select(y => y.ProjectName).Aggregate((z1,z2) => z1 ?? z2),
            Customer = x.Select(y => y.Customer).Aggregate((z1, z2) => z1 ?? z2),
            Address = x.Select(y => y.Address).Aggregate((z1, z2) => z1 ?? z2)
        }).ToList();

List lst=lst1.Union（lst2）.Union（lst3）.ToLookup（x=>x.ProjectId）.选择（x=>newproject（））
{
projectd=x.Key，
ProjectName=x.Select（y=>y.ProjectName）.Aggregate（（z1，z2）=>z1？？z2），
客户=x.选择（y=>y.Customer）.聚合（（z1，z2）=>z1×z2），
地址=x.选择（y=>y.地址）.聚合（（z1，z2）=>z1？？z2）
}).ToList（）；
使用查找，您可以这样做：

        List<Project> lst = lst1.Union(lst2).Union(lst3).ToLookup(x => x.ProjectId).Select(x => new Project()
        {
            ProjectId = x.Key,
            ProjectName = x.Select(y => y.ProjectName).Aggregate((z1,z2) => z1 ?? z2),
            Customer = x.Select(y => y.Customer).Aggregate((z1, z2) => z1 ?? z2),
            Address = x.Select(y => y.Address).Aggregate((z1, z2) => z1 ?? z2)
        }).ToList();

List lst=lst1.Union（lst2）.Union（lst3）.ToLookup（x=>x.ProjectId）.选择（x=>newproject（））
{
projectd=x.Key，
ProjectName=x.Select（y=>y.ProjectName）.Aggregate（（z1，z2）=>z1？？z2），
客户=x.选择（y=>y.Customer）.聚合（（z1，z2）=>z1×z2），
地址=x.选择（y=>y.地址）.聚合（（z1，z2）=>z1？？z2）
}).ToList（）；
这是假设您希望获取第一个非空值，或者恢复为默认值—在本例中，字符串为空

private static IEnumerable<Project> GetMergedProjects(IEnumerable<List<Project>> projects)
{
    var projectGrouping = projects.SelectMany(p => p).GroupBy(p => p.ProjectId);
    foreach (var projectGroup in projectGrouping)
    {
        yield return new Project
                            {
                                ProjectId = projectGroup.Key,
                                ProjectName =
                                    projectGroup.Select(p => p.ProjectName).FirstOrDefault(
                                        p => !string.IsNullOrEmpty(p)),
                                Customer =
                                    projectGroup.Select(c => c.Customer).FirstOrDefault(
                                        c => !string.IsNullOrEmpty(c)),
                                Address =
                                    projectGroup.Select(a => a.Address).FirstOrDefault(
                                        a => !string.IsNullOrEmpty(a)),
                            };
    }
}

私有静态IEnumerable GetMergedProject（IEnumerable项目）
{
var projectGrouping=projects.SelectMany（p=>p）.GroupBy（p=>p.projectd）；
foreach（projectGrouping中的var projectGroup）
{
新项目收益率
{
ProjectId=projectGroup.Key，
项目名称=
projectGroup.Select（p=>p.ProjectName）.FirstOrDefault(
p=>！string.IsNullOrEmpty（p）），
顾客=
projectGroup.Select（c=>c.Customer）.FirstOrDefault(
c=>！string.IsNullOrEmpty（c）），
地址=
projectGroup.Select（a=>a.Address）.FirstOrDefault(
a=>！string.IsNullOrEmpty（a）），
};
}
}

如果需要，您也可以将其作为扩展方法。
这是假设您希望获取第一个非空值，或者恢复为默认值—在本例中，字符串为空

private static IEnumerable<Project> GetMergedProjects(IEnumerable<List<Project>> projects)
{
    var projectGrouping = projects.SelectMany(p => p).GroupBy(p => p.ProjectId);
    foreach (var projectGroup in projectGrouping)
    {
        yield return new Project
                            {
                                ProjectId = projectGroup.Key,
                                ProjectName =
                                    projectGroup.Select(p => p.ProjectName).FirstOrDefault(
                                        p => !string.IsNullOrEmpty(p)),
                                Customer =
                                    projectGroup.Select(c => c.Customer).FirstOrDefault(
                                        c => !string.IsNullOrEmpty(c)),
                                Address =
                                    projectGroup.Select(a => a.Address).FirstOrDefault(
                                        a => !string.IsNullOrEmpty(a)),
                            };
    }
}

私有静态IEnumerable GetMergedProject（IEnumerable项目）
{
var projectGrouping=projects.SelectMany（p=>p）.GroupBy（p=>p.projectd）；
foreach（projectGrouping中的var projectGroup）
{
新项目收益率
{
ProjectId=projectGroup.Key，
项目名称=
projectGroup.Select（p=>p.ProjectName）.FirstOrDefault(
p=>！string.IsNullOrEmpty（p）），
顾客=
projectGroup.Select（c=>c.Customer）.FirstOrDefault(
c=>！string.IsNullOrEmpty（c）），
地址=
projectGroup.Select（a=>a.Address）.FirstOrDefault(
a=>！string.IsNullOrEmpty（a）），
};
}
}

如果需要，您也可以将其作为扩展方法。
这可以通过一种非常简单的多步骤方法来完成。首先，定义一个
Func
来处理实际的记录合并。也就是说，您正在定义一个签名等效的方法