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; }
}

这是行不通的。

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

当我不包含“ ThenInclude（c => c.FidPlzOrtNavigation）”语句时，linq可以工作，但是我希望此信息包含在对象中。

这是给我预期结果的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的可能性不熟悉。它是否知道，如果您选择一个虚拟属性，则需要一个（组）连接？在这种情况下，使用Select会更容易。

如果您必须自己加入：

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，因此您的呼叫者将不会注意到数据库中的更改。

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

1 个答案: