C# 合并来自多个源的不同类

我有2个用户对象（都来自不同的数据源）

现在，用户X可能存在于两个数据源中（或者可能仅存在于其中一个数据源中）。在这种情况下，字段

upn

将是相同的。理论上，

firstname

和

lastname

也应该相同。因此，如果只使用第一个，这是很好的（在不同的情况下）

现在，我想将这些对象合并在一起，以便得到一个唯一用户的列表。但是这两个对象的所有字段（因此我可以将其作为JSON返回）

因此，最终的对象（如果用户同时存在于两个源中，则看起来像）

---

LINQ Join语句是合并这两个列表的最佳方法，它可以从每个匹配对创建一个新对象

List<UserA> first = ...
List<UserB> second = ...

from a in first
join b in second on a.Upn equals b.Upn
select new UserC 
       { 
         Upn = a.Upn, 
         FirstName = a.FirstName, 
         Id = a.Id, 
         SamAccountName = b.SamAccountName
       }

List first=。。。
第二个列表=。。。
从一开始
在a上的第二个位置连接b。Upn等于b.Upn
选择newuserc
{ 
Upn=a.Upn，
FirstName=a.FirstName，
Id=a.Id，
SamAccountName=b.SamAccountName
}

（为了简洁起见，我删除了一些字段）

---

这里可以看到的是一个JOIN语句，它将第一个用户列表与第二个用户列表进行匹配，其中Upn字段作为关键字段，然后为每对UserA/UserB创建一个新的UserC，从两个实体中选择属性。

LINQ JOIN语句是合并这两个列表的最佳方法，从每个匹配对创建新对象

List<UserA> first = ...
List<UserB> second = ...

from a in first
join b in second on a.Upn equals b.Upn
select new UserC 
       { 
         Upn = a.Upn, 
         FirstName = a.FirstName, 
         Id = a.Id, 
         SamAccountName = b.SamAccountName
       }

List first=。。。
第二个列表=。。。
从一开始
在a上的第二个位置连接b。Upn等于b.Upn
选择newuserc
{ 
Upn=a.Upn，
FirstName=a.FirstName，
Id=a.Id，
SamAccountName=b.SamAccountName
}

（为了简洁起见，我删除了一些字段）

这里可以看到一个JOIN语句，它将第一个用户列表与第二个用户列表相匹配，其中Upn字段作为关键字段，然后为每对UserA/UserB创建一个新的UserC，从两个实体中选择属性。

您也可以尝试：

• 将列表转换为包含类型

  UserC

• concat

  列表

• groupBy

  连接的列表

具体如下：

var aUsers = new List<UserA>();
var bUsers = new List<UserB>();
// Initialize aUsers and bUsers here

var aUsersAsCUsers = aUsers.Select(a => new UserC{
  Upn = a.Upn, 
  Firstname = a.Firstname, 
  Lastname = a.Lastname,
  Id = a.Id
});

var bUsersAsCUsers = bUsers.Select(b => new UserC{
  Upn = b.Upn, 
  Firstname = b.Firstname, 
  Lastname = b.Lastname,
  MemberOf = b.MemberOf,
  SamAccountName = b.SamAccountName
});

var cUsers = aUsersAsCUsers.Concat(bUsersAsCUsers)
  .GroupBy(u => u.Upn)
  .Select(c => new UserC() 
  { 
    Upn = c.Upn, 
    Firstname = c.Firstname, 
    Lastname = c.Lastname,
    Id = c.Id,
    MemberOf = c.MemberOf,
    SamAccountName = c.SamAccountName
});

var aUsers=newlist（）；
var bUsers=新列表（）；
//在这里初始化aUsers和bUsers
var aUsersAsCUsers=aUsers.Select（a=>newuserc{
Upn=a.Upn，
Firstname=a.Firstname，
Lastname=a.Lastname，
Id=a.Id
});
var bUsersAsCUsers=bUsers.Select（b=>newuserc{
Upn=b.Upn，
Firstname=b.Firstname，
Lastname=b.Lastname，
MemberOf=b.MemberOf，
SamAccountName=b.SamAccountName
});
var cUsers=ausersacusers.Concat（busersacusers）
.GroupBy（u=>u.Upn）
.Select（c=>newuserc（）
{ 
Upn=c.Upn，
Firstname=c.Firstname，
Lastname=c.Lastname，
Id=c.Id，
MemberOf=c.MemberOf，
SamAccountName=c.SamAccountName
});

如果

Upn

s相同，

Firstname

和

Lastname

属性也应该相同。

您也可以尝试：

• 将列表转换为包含类型

  UserC

• concat

  列表

• groupBy

  连接的列表

具体如下：

var aUsers = new List<UserA>();
var bUsers = new List<UserB>();
// Initialize aUsers and bUsers here

var aUsersAsCUsers = aUsers.Select(a => new UserC{
  Upn = a.Upn, 
  Firstname = a.Firstname, 
  Lastname = a.Lastname,
  Id = a.Id
});

var bUsersAsCUsers = bUsers.Select(b => new UserC{
  Upn = b.Upn, 
  Firstname = b.Firstname, 
  Lastname = b.Lastname,
  MemberOf = b.MemberOf,
  SamAccountName = b.SamAccountName
});

var cUsers = aUsersAsCUsers.Concat(bUsersAsCUsers)
  .GroupBy(u => u.Upn)
  .Select(c => new UserC() 
  { 
    Upn = c.Upn, 
    Firstname = c.Firstname, 
    Lastname = c.Lastname,
    Id = c.Id,
    MemberOf = c.MemberOf,
    SamAccountName = c.SamAccountName
});

var aUsers=newlist（）；
var bUsers=新列表（）；
//在这里初始化aUsers和bUsers
var aUsersAsCUsers=aUsers.Select（a=>newuserc{
Upn=a.Upn，
Firstname=a.Firstname，
Lastname=a.Lastname，
Id=a.Id
});
var bUsersAsCUsers=bUsers.Select（b=>newuserc{
Upn=b.Upn，
Firstname=b.Firstname，
Lastname=b.Lastname，
MemberOf=b.MemberOf，
SamAccountName=b.SamAccountName
});
var cUsers=ausersacusers.Concat（busersacusers）
.GroupBy（u=>u.Upn）
.Select（c=>newuserc（）
{ 
Upn=c.Upn，
Firstname=c.Firstname，
Lastname=c.Lastname，
Id=c.Id，
MemberOf=c.MemberOf，
SamAccountName=c.SamAccountName
});

---

如果

Upn

s相同，

Firstname

和

Lastname

属性也应该相同。

这里有一种方法。您可以选择如何处理一个列表中不在另一个列表中的项目

字典用于提高性能

List<UserA> listA;
List<UserB> listB;

var dictA = listA.ToDictionary(x => x.Upn, x => x);
var dictB = listB.ToDictionary(x => x.Upn, x => x);

foreach(var upn in dictA.Keys.Union(dictB.Keys))
{
   UserC user = new UserC();
   if(dictA.ContainsKey(upn)) //Fill in fields
   if(dictB.ContainsKey(upn)) //Fill in fields     
} 

列表列表a；
名单b；
var dictA=listA.ToDictionary（x=>x.Upn，x=>x）；
var dictB=listB.ToDictionary（x=>x.Upn，x=>x）；
foreach（dictA.Keys.Union（dictB.Keys）中的var upn）
{
UserC user=new UserC（）；
if（dictA.ContainsKey（upn））//填写字段
if（dictB.ContainsKey（upn））//填写字段
} 

这里有一种方法。您可以选择如何处理一个列表中不在另一个列表中的项目

字典用于提高性能

List<UserA> listA;
List<UserB> listB;

var dictA = listA.ToDictionary(x => x.Upn, x => x);
var dictB = listB.ToDictionary(x => x.Upn, x => x);

foreach(var upn in dictA.Keys.Union(dictB.Keys))
{
   UserC user = new UserC();
   if(dictA.ContainsKey(upn)) //Fill in fields
   if(dictB.ContainsKey(upn)) //Fill in fields     
} 

列表列表a；
名单b；
var dictA=listA.ToDictionary（x=>x.Upn，x=>x）；
var dictB=listB.ToDictionary（x=>x.Upn，x=>x）；
foreach（dictA.Keys.Union（dictB.Keys）中的var upn）
{
UserC user=new UserC（）；
if（dictA.ContainsKey（upn））//填写字段
if（dictB.ContainsKey（upn））//填写字段
} 

要从这两个对象中获得唯一列表，您需要这样做。又快又短

        var uniquelist = (from aa in ListA
                        join ba in ListB on aa.Upn equals ba.Upn into all
                        from avail in all.DefaultIfEmpty()
                        where avail == null
                        select new UserC
                        {
                            Firstname = aa.Firstname,
                            Lastname = aa.Lastname,
                            Upn = aa.Upn,
                        }).ToList();
        uniquelist.AddRange(from ba in ListB
                          select new UserC
                          {
                              Firstname = ba.Firstname,
                              Lastname = ba.Lastname,
                              Upn = ba.Upn,

                          });

您可以像这样添加您的join

join ba in b on new { aa.Upn, aa.Firstname } equals new { ba.Upn, ba.Firstname } into all

---

然后，您可以使用json序列化程序将其转换为

json

，以从两个对象中获得一个唯一的列表，这样做需要这样做。又快又短

        var uniquelist = (from aa in ListA
                        join ba in ListB on aa.Upn equals ba.Upn into all
                        from avail in all.DefaultIfEmpty()
                        where avail == null
                        select new UserC
                        {
                            Firstname = aa.Firstname,
                            Lastname = aa.Lastname,
                            Upn = aa.Upn,
                        }).ToList();
        uniquelist.AddRange(from ba in ListB
                          select new UserC
                          {
                              Firstname = ba.Firstname,
                              Lastname = ba.Lastname,
                              Upn = ba.Upn,

                          });

您可以像这样添加您的join

join ba in b on new { aa.Upn, aa.Firstname } equals new { ba.Upn, ba.Firstname } into all

---

然后，您可以使用json序列化程序将其转换为

json

，因此，如果

Firstname

和/或

Lastname

文件对多个用户相同，则会发生什么情况。它们应该连接起来吗？第一个将只使用？还是什么？@vahdet理论上他们应该是一样的。那么，如果

upn

是sa，那么

Firstname

和/或

Lastname

文件会发生什么情况呢