如何在 linq 中编写此 C# 语句

Question

我正在尝试将相关表Adress和PlzOrt放入对象User中。 关系如下： 用户 1：1

地址

n：1 PlzOrt

从数据库搭建基架的实体

public partial class User
{
//No hash sets for Adress Scaffolded (probably unnecessary since the is 
//only ever one address per user
public int IdUser { get; set; }
public int? FidAdresse { get; set; }
public string Email { get; set; }
public string Vorname { get; set; }
public string Nachmname { get; set; }
[ForeignKey("FidAdresse")]
[InverseProperty("User")]
public virtual Adresse FidAdresseNavigation { get; set; }
}
public partial class Adresse
{
public Adresse()
{
User = new HashSet<User>();
}
public int IdAdresse { get; set; }
public int FidPlzOrt { get; set; }
public string Strasse { get; set; }
public string Hausnr { get; set; }
[ForeignKey("FidPlzOrt")]
[InverseProperty("Adresse")]
public virtual PlzOrt FidPlzOrtNavigation { get; set; }
[InverseProperty("FidAdresseNavigation")]
public virtual ICollection<User> User { get; set; }
}
public partial class PlzOrt
{
public PlzOrt()
{
Adresse = new HashSet<Adresse>();
}
public int IdPlzOrt { get; set; }
public string Plz { get; set; }
public string Ort { get; set; }
[InverseProperty("FidPlzOrtNavigation")]
public virtual ICollection<Adresse> Adresse { get; set; }
}

这是不起作用的 linq。

return _context.User
.Include(u => u.FidPermissionNavigation)
.Include(c => c.FidAdresseNavigation)
.ThenInclude(c => c.FidPlzOrtNavigation)
.FirstOrDefault(c => c.IdUser == id);

linq 在不包含"ThenInclude(c => c.FidPlzOrtNavigation)"语句时起作用，但我希望这些信息在我的对象中。

下面是为我提供预期结果的 C#：

public User GetUser(int id)
{
foreach (User user in _context.User)
{
if (user.IdUser == id)
{
foreach (Adresse adresse in _context.Adresse)
{
if (adresse.IdAdresse == user.FidAdresse)
{
user.FidAdresseNavigation = adresse;
foreach (PlzOrt plzOrt in _context.PlzOrt)
{
if (plzOrt.IdPlzOrt == adresse.FidPlzOrt)
{
user.FidAdresseNavigation.FidPlzOrtNavigation = plzOrt;
break;
}
}
break;
}
}
return user;
}
}
return null;
}

翻译此 linq 语句将有很大帮助。提前谢谢。

生成db_context代码，以防您感兴趣或有帮助

modelBuilder.Entity<User>(entity =>
{
entity.HasKey(e => e.IdUser)
.HasName("PRIMARY");
entity.HasIndex(e => e.FidAdresse)
.HasName("fk_User_Adresse1_idx");
entity.HasOne(d => d.FidAdresseNavigation)
.WithMany(p => p.User)
.HasForeignKey(d => d.FidAdresse)
.HasConstraintName("fk_User_Adresse1");
});
modelBuilder.Entity<Adresse>(entity =>
{
entity.HasKey(e => e.IdAdresse)
.HasName("PRIMARY");
entity.HasIndex(e => e.FidPlzOrt)
.HasName("fk_Adresse_plz_ort1_idx");
entity.HasOne(d => d.FidPlzOrtNavigation)
.WithMany(p => p.Adresse)
.HasForeignKey(d => d.FidPlzOrt)
.OnDelete(DeleteBehavior.ClientSetNull)
.HasConstraintName("fk_Adresse_plz_ort1");
});
modelBuilder.Entity<PlzOrt>(entity =>
{
entity.HasKey(e => e.IdPlzOrt)
.HasName("PRIMARY");
});

Answer 1

所以你有一个id，你想要唯一一个将此ID作为主键的用户，以及他的地址和他的PlzOrt。

每当查询时，请使用"选择"提取数据。仅当您要更新提取的数据时才使用"包含"。

选择的原因是您对选择的内容有更大的自由度。此外，您还可以限制获取的数据：如果您查询学校及其学生，您知道学校 10 的每个学生都有一个等于 10 的外键 SchoolId。那么，为什么要为每所学校的1000名学生获取这个外键呢？

我不熟悉 ef-core 的可能性。它是否知道，如果您选择其中一个虚拟属性需要(组)联接？在这种情况下，使用"选择"会更容易。

如果您必须自己执行联接：

var requestedUserWithAddresAndPlz = dbContext.Users.
// keep only the user with id
.Where(user => user.IdUser == id)
// every User has exactly one Address: use a normal join
.Join(dbContext.Addresses,
user => user.IdUser,              // from every User take IdUser
address => addres.IdAddress,      // from every Address take IdAddress
// result selector: take the user with its address to make one new
(user, address) => new
{
// Select only the User properties you plan to use
Id = user.IdUser,
Name = user.Name,
...
Address = new
{
// again: select only the properties you plan to use
// no need to select IdAddress, you know the value!
Street = address.Street,
HouseNumber = address.HouseNumber,
// to fetch the Plz: fetch the one-and-only PlzOrt with address.FidPlzOrt
Plz = dbContext.PlzOrts
.Where(plzOrt => plzOrt.PlzOrdIt == address.FidPlzOrt)
.FirstOrDefault(),
})
.FirstOrDefault();

注意：我使用匿名类型是为了在仅选择我实际计划使用的属性时有更大的自由度。我还可以为我的属性指定我想要的名称。

缺点：不能使用匿名类型作为返回值。如果你真的需要在函数之外使用它，请使用创建一个包含数据的类，并使用新的 SomeClass()。优点：如果您的数据库发生更改，SomeClass 不必更改，因此您的调用者不会注意到数据库中的更改。