EF Core – One to One using Fluent API

Entity framework supports relationship of entities and provides different kinds of relationships conventions namely:

One to One relationship This translates to multiple entities being related to each other with a single Key. We will learn about this relationship using code in the below tutorial

One to Many relationship: Multiple entities is related to each other in a way that one key in entity can refer to multiple columns in the related entries.

Many to Many relationship: When One to Many relationship works for both the connected entities, many to many relationship is said to have occurred.

Fluent API:

Entity relationships are translated using Fluent API in the model class. Fluent API is a step by step approach to write code by defining entries in a particular order and setting the relationship accordingly.

In this tutorial we will learn to code with One to one relationship. In our project consider SQL tables BookAvailability and MyBookTable are connected to each other. Meaning, we are storing the availability of books in the market using the BookAvailability table. So we will use Book_ID as foreign key in the BookAvailability table and establish a one to one relationship between these 2 tables.

BooksDB

BookAvailablity.cs

    public class BookAvailability
    {
        [Key]
        public int AvailableID { get; set; }
        public int BookID { get; set; }

        public string WebsiteName { get; set; }

        public decimal Price { get; set; }

        public int Quantity { get; set; }

        public MyBookTable Book { get; set; }
    }

MyBookTable.cs

 public class MyBookTable
    {
        [Key]
        public int BookID { get; set; }
        public string BookName { get; set; }
        public string BookAuthor { get; set; }
        public BookAvailability Availability { get; set; }

        public MyBookTable()
        {
            BookAvailabilityModel bookModel = new BookAvailabilityModel();
            bookModel.Database.EnsureCreated();
        }
    }

We created both the above related entities accordingly using Database First approach.

BookAvailabilityModel.cs

public class BookAvailabilityModel : DbContext
    {
        public string connString = @"Data Source=DESKTOP-TAE8O0I\SQLEXPRESS;Initial Catalog=BooksDB;Integrated Security=True;Pooling=False";

        public DbSet<MyBookTable> MyBookTable { get; set; }
        public DbSet<BookAvailability> BookAvailability { get; set; }

        public BookAvailabilityModel()
        {

        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer(connString);
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<MyBookTable>().ToTable("MyBookTable");

            modelBuilder.Entity<BookAvailability>().ToTable("BookAvailability");

            modelBuilder.Entity<MyBookTable>().HasOne<BookAvailability>(a => a.Availability).WithOne(o => o.Book).HasForeignKey<BookAvailability>(f => f.BookID);
        }
    }

In the model class, we will define the relationship of MyBookTable and BookAvailability table in OnModelCreating method using Fluent API. Below is the syntax of FluentAPI defining the above relationship.

        modelBuilder.Entity<MyBookTable>().HasOne<BookAvailability>(a => a.Availability).WithOne(o => o.Book).HasForeignKey<BookAvailability>(f => f.BookID);

So using Fluent API, we are asking the compiler to create an entity for MyBookTable and create One relation with BookAvailability using navigation property availability mapped to One Book entity with foreign key as BookID.

HomeController.cs

Writing code to save an entry for MyBookTable and BookAvailability using MVC’s controller.

public IActionResult Index()
        {

            MyBookTable book = new MyBookTable();
            book.BookName = "Learn Node JS";
            book.BookAuthor = "Naved";

            BookAvailability bookAvailability = new BookAvailability();
            bookAvailability.AvailableID = 10;
            bookAvailability.WebsiteName = "BookStore";
            bookAvailability.Price = 10;
            bookAvailability.Quantity = 2;

            book.Availability = bookAvailability;

            BookAvailabilityModel model = new BookAvailabilityModel();
            model.Add(book);
            model.SaveChanges();

            return View();
        }

So to save changes we are adding the book entity in the context which will consist of BookAvailability records.

        model.Add(book);
        model.SaveChanges();

SQL Query:

select * from MyBookTable

select * from BookAvailability

Share this: