Entity Framework [Foreignkey]

Question

Reading a tutorial on Entity framework, I came across a somewhat strange example for me. This example is about Dataannotation [ForeignKey]

public class Student
{
    public Student()
    { 

    }
    public int StudentID { get; set; }
    public string StudentName { get; set; }

    //Foreign key for Standard
    public int StandardId { get; set; }

    public Standard Standard { get; set; }
}

public class Standard
{
    public Standard()
    { 

    }
    public int StandardId { get; set; }
    public string StandardName { get; set; }

    public ICollection<Student> Students { get; set; }

    }

In a scenario without ORM, that is, dealing directly with ADO.net, I see no sense that Student has an attribute referring to Id of Standard, for Student already has a reference to Standard, where this reference already has the Id. Why does the RU work this way? Seems redundant to me.

Answer 1

Matheus, I believe you’re not taking one thing into account: LazyLoad.

Defido to Lazyload, to fetch one Student, only the data of Student are recovered from the Bank, only if you come to access the Navigation property Standard that the EF will fetch your data.

To make this load lazy, it is necessary that the navigation property has the modifier virtual, with this the EF can modify the behavior of the same.

Observe the mapping of your entities using Code First, maybe you can notice it better.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity;

public partial class Contexto : DbContext
{
    public Contexto() : base("name=Contexto")
    {
    }

    public virtual DbSet<Standard> Standards { get; set; }
    public virtual DbSet<Student> Students { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Standard>().Property(e => e.Name).IsUnicode(false);
        modelBuilder.Entity<Standard>().HasMany(e => e.Students).WithRequired(e => e.Standard).WillCascadeOnDelete(false);
        modelBuilder.Entity<Student>().Property(e => e.Name).IsUnicode(false);
    }
}

[Table("Student")]
public partial class Student
{
    public int StudentID { get; set; }

    [Required]
    [StringLength(50)]
    public string Name { get; set; }

    public int StandardID { get; set; }

    public virtual Standard Standard { get; set; }
}

[Table("Standard")]
public partial class Standard
{
    public Standard()
    {
        Students = new HashSet<Student>();
    }

    public int StandardID { get; set; }

    [Required]
    [StringLength(50)]
    public string Name { get; set; }

    public virtual ICollection<Student> Students { get; set; }
}

If you create a new entity Student, and set a value for StandardID that already exists in the database, and after this try to access the property Standard the RU retrieves the data from the Entity Standard in the Database.

But if you do not access the navigation property and only set the Property Value StandardID, the additional query will not be performed, but if you try to save the entity Student, EF will have no problem doing it.

Note that it is not always necessary to access a navigation property, sometimes knowing only the ID of the same is enough.

Answer 2

As stated in the comments by @Maniero, it is difficult to judge whether or not the mapping is correct without the context, what can be done is to analyze and explain what the code is doing.

This mapping is not wrong:

public class Student
{
    public Student()
    { 

    }
    public int StudentID { get; set; }
    public string StudentName { get; set; }

    //Não necessida da anotação [ForeignKey]
    public int StandardId { get; set; }

    public Standard Standard { get; set; }
}

public class Standard
{
    public Standard()
    { 

    }
    public int StandardId { get; set; }
    public string StandardName { get; set; }

    public ICollection<Student> Students { get; set; }

    }

In the code above, we have a mapping of 1:N, where a Standard has several Students , where the property StandardId is the foreing key of model Student. This is correct if the goal is this. Using the Entity Framework, you do not need to use the annotation [ForeignKey], for the name of foreing key is the name of the navigation property with the prefix id, that is to say, StandardId (Standard + Id).

On the contrary, the model Standard has a collection of Students, where it does not need to have a foreing key for Students, characterizing the connection of 1:N.

Answer 3

It’s very simple. Entity Framework will anyway create this Standardid in the database. What happens is, whether or not you have control of creating this column?

Another, you can perform queries in the table of Student without having to go to the Standard. Example: You need to select all Student of Standard 10.

_context.Students
    .Where(student => student.StandardId == 10)
    .ToList(); // Acessa apenas a entidade Student
// SELECT * FROM Student WHERE StandardId = 10

If you let implicit the StandardId, would have to do:

_contexto.Students
    .Where(student => student.Standard.Id == 10)
    .ToList(); // Acessa entidades Student e Standard
// SELECT Student.* FROM Student
//   JOIN Standard ON Standard.Id = Student.StandardId
//  WHERE Standard.Id = 10